Machine code

Short description: Set of instructions executed by a computer

Program execution

General concepts

* Code
* Translation
* Compiler
* Compile-time
* Optimizing compiler
* Intermediate representation (IR)
* Execution
* Runtime system
* Runtime
* Executable
* Interpreter
* Virtual machine

Types of code

* Source code
* Object code
* Bytecode
* Machine code
* Microcode

Compilation strategies

* Just-in-time (JIT)
* Tracing just-in-time
* Ahead-of-time (AOT)
* Transcompilation
* Recompilation

Notable runtimes

* Android Runtime (ART)
* Common Language Runtime (CLR) & Mono
* crt0
* HHVM
* Java virtual machine (JVM)
* Objective-C
* V8
* Node.js
* PyPy
* Zend Engine

Notable compilers & toolchains

* GNU Compiler Collection (GCC)
* LLVM
* Clang

* v
* t
* e

Machine language monitor in a W65C816S single-board computer, displaying code disassembly, as well as processor register and memory dumps

In computer programming, machine code is computer code consisting of machine language instructions, which are used to control a computer's central processing unit (CPU). Although decimal computers were once common, the contemporary marketplace is dominated by binary computers; for those computers, machine code is "the binary representation of a computer program which is actually read and interpreted by the computer. A program in machine code consists of a sequence of machine instructions (possibly interspersed with data)."[1]

Each instruction causes the CPU to perform a very specific task, such as a load, a store, a jump, or an arithmetic logic unit (ALU) operation on one or more units of data in the CPU's registers or memory.

Early CPUs had specific machine code that might break backward compatibility with each new CPU released. The notion of an instruction set architecture (ISA) defines and specifies the behavior and encoding in memory of the instruction set of the system, without specifying its exact implementation. This acts as an abstraction layer, enabling compatibility within the same family of CPUs, so that machine code written or generated according to the ISA for the family will run on all CPUs in the family, including future CPUs.

In general, each architecture family (e.g. x86, ARM) has its own ISA, and hence its own specific machine code language. There are exceptions, such as the VAX architecture, which included optional support of the PDP-11 instruction set and IA-64, which included optional support of the IA-32 instruction set. Another example is the PowerPC 615, a processor designed to natively process both PowerPC and x86 instructions.

Machine code is a strictly numerical language, and is the lowest-level interface to the CPU intended for a programmer. Assembly language provides a direct mapping between the numerical machine code and a human-readable version where numerical opcodes and operands are replaced by readable strings (e.g. 0x90 is the NOP instruction on x86). While it is possible to write programs directly in machine code, managing individual bits and calculating numerical addresses and constants manually is tedious and error-prone. For this reason, programs are very rarely written directly in machine code in modern contexts, but may be done for low-level debugging, program patching (especially when assembler source is not available) and assembly language disassembly.

The majority of practical programs today are written in higher-level languages. Those programs are either translated into machine code by a compiler, or are interpreted by an interpreter, usually after being translated into an intermediate code, such as a bytecode, that is then interpreted.[nb 1]

Machine code is by definition the lowest level of programming detail visible to the programmer, but internally many processors use microcode or optimize and transform machine code instructions into sequences of micro-ops. Microcode and micro-ops are not generally considered to be machine code; except on some machines, the user cannot write microcode or micro-ops, and the operation of microcode and the transformation of machine-code instructions into micro-ops happens transparently to the programmer except for performance related side effects.

## Contents

* 1 Instruction set
* 2 Programs
* 3 Assembly languages
* 4 Example
* 5 Overlapping instructions
* 6 Relationship to microcode
* 7 Relationship to bytecode
* 8 Storing in memory
* 9 Readability by humans
* 10 See also
* 11 Notes
* 12 References
* 13 Further reading

## Instruction set

Every processor or processor family has its own instruction set. Instructions are patterns of bits, digits, or characters that correspond to machine commands. Thus, the instruction set is specific to a class of processors using (mostly) the same architecture. Successor or derivative processor designs often include instructions of a predecessor and may add new additional instructions. Occasionally, a successor design will discontinue or alter the meaning of some instruction code (typically because it is needed for new purposes), affecting code compatibility to some extent; even compatible processors may show slightly different behavior for some instructions, but this is rarely a problem. Systems may also differ in other details, such as memory arrangement, operating systems, or peripheral devices. Because a program normally relies on such factors, different systems will typically not run the same machine code, even when the same type of processor is used.

A processor's instruction set may have fixed-length or variable-length instructions. How the patterns are organized varies with the particular architecture and type of instruction. Most instructions have one or more opcode fields that specify the basic instruction type (such as arithmetic, logical, jump, etc.), the operation (such as add or compare), and other fields that may give the type of the operand(s), the addressing mode(s), the addressing offset(s) or index, or the operand value itself (such constant operands contained in an instruction are called immediate).[2]

Not all machines or individual instructions have explicit operands. On a machine with a single accumulator, the accumulator is implicitly both the left operand and result of most arithmetic instructions. Some other architectures, such as the x86 architecture, have accumulator versions of common instructions, with the accumulator regarded as one of the general registers by longer instructions. A stack machine has most or all of its operands on an implicit stack. Special purpose instructions also often lack explicit operands; for example, CPUID in the x86 architecture writes values into four implicit destination registers. This distinction between explicit and implicit operands is important in code generators, especially in the register allocation and live range tracking parts. A good code optimizer can track implicit as well as explicit operands which may allow more frequent constant propagation, constant folding of registers (a register assigned the result of a constant expression freed up by replacing it by that constant) and other code enhancements.

## Programs

A computer program is a list of instructions that can be executed by a central processing unit (CPU). A program's execution is done in order for the CPU that is executing it to solve a problem and thus accomplish a result. While simple processors are able to execute instructions one after another, superscalar processors are able under certain circumstances (when the pipeline is full) of executing two or more instructions simultaneously. As an example, the original Intel Pentium from 1993 can execute at most two instructions per clock cycle when its pipeline is full.

Program flow may be influenced by special 'jump' instructions that transfer execution to an address (and hence instruction) other than the next numerically sequential address. Whether these conditional jumps occur is dependent upon a condition such as a value being greater than, less than, or equal to another value.

## Assembly languages

Main article: Assembly language

A much more human friendly rendition of machine language, called assembly language, uses mnemonic codes to refer to machine code instructions, rather than using the instructions' numeric values directly, and uses symbolic names to refer to storage locations and sometimes registers.[3] For example, on the Zilog Z80 processor, the machine code `00000101`, which causes the CPU to decrement the `B` general-purpose register, would be represented in assembly language as `DEC B`.[4]

## Example

The MIPS architecture provides a specific example for a machine code whose instructions are always 32 bits long.[5]: 299 The general type of instruction is given by the op (operation) field, the highest 6 bits. J-type (jump) and I-type (immediate) instructions are fully specified by op. R-type (register) instructions include an additional field funct to determine the exact operation. The fields used in these types are:

6      5     5     5     5      6 bits
[  op  |  rs |  rt |  rd |shamt| funct]  R-type
[  op  |  rs |  rt | address/immediate]  I-type
[  op  |        target address        ]  J-type

rs, rt, and rd indicate register operands; shamt gives a shift amount; and the address or immediate fields contain an operand directly.[5]: 299–301

For example, adding the registers 1 and 2 and placing the result in register 6 is encoded:[5]: 554

[  op  |  rs |  rt |  rd |shamt| funct]
0     1     2     6     0     32     decimal
000000 00001 00010 00110 00000 100000   binary

Load a value into register 8, taken from the memory cell 68 cells after the location listed in register 3:[5]: 552

[  op  |  rs |  rt | address/immediate]
35     3     8           68           decimal
100011 00011 01000 00000 00001 000100   binary

Jumping to the address 1024:[5]: 552

[  op  |        target address        ]
2                 1024               decimal
000010 00000 00000 00000 10000 000000   binary

## Overlapping instructions

On processor architectures with variable-length instruction sets[6] (such as Intel's x86 processor family) it is, within the limits of the control-flow resynchronizing phenomenon known as the Kruskal count,[7][6][8][9][10] sometimes possible through opcode-level programming to deliberately arrange the resulting code so that two code paths share a common fragment of opcode sequences.[nb 2] These are called overlapping instructions, overlapping opcodes, overlapping code, overlapped code, instruction scission, or jump into the middle of an instruction, and represent a form of superposition.[11][12][13]

In the 1970s and 1980s, overlapping instructions were sometimes used to preserve memory space. One example were in the implementation of error tables in Microsoft's Altair BASIC, where interleaved instructions mutually shared their instruction bytes.[14][6][11] The technique is rarely used today, but might still be necessary to resort to in areas where extreme optimization for size is necessary on byte-level such as in the implementation of boot loaders which have to fit into boot sectors.[nb 3]

It is also sometimes used as a code obfuscation technique as a measure against disassembly and tampering.[6][9]

The principle is also utilized in shared code sequences of fat binaries which must run on multiple instruction-set-incompatible processor platforms.[nb 2]

This property is also used to find unintended instructions called gadgets in existing code repositories and is utilized in return-oriented programming as alternative to code injection for exploits such as return-to-libc attacks.[15][6]

## Relationship to microcode

In some computers, the machine code of the architecture is implemented by an even more fundamental underlying layer called microcode, providing a common machine language interface across a line or family of different models of computer with widely different underlying dataflows. This is done to facilitate porting of machine language programs between different models. An example of this use is the IBM System/360 family of computers and their successors. With dataflow path widths of 8 bits to 64 bits and beyond, they nevertheless present a common architecture at the machine language level across the entire line.

Using microcode to implement an emulator enables the computer to present the architecture of an entirely different computer. The System/360 line used this to allow porting programs from earlier IBM machines to the new family of computers, e.g. an IBM 1401/1440/1460 emulator on the IBM S/360 model 40.

## Relationship to bytecode

Machine code is generally different from bytecode (also known as p-code), which is either executed by an interpreter or itself compiled into machine code for faster (direct) execution. An exception is when a processor is designed to use a particular bytecode directly as its machine code, such as is the case with Java processors.

Machine code and assembly code are sometimes called native code when referring to platform-dependent parts of language features or libraries.[16]

## Storing in memory

From the point of view of the CPU, machine code is stored in RAM, but is typically also kept in a set of caches for performance reasons. There may be different caches for instructions and data, depending on the architecture.

The CPU knows what machine code to execute, based on its internal program counter. The program counter points to a memory address and is changed based on special instructions which may cause programmatic branches. The program counter is typically set to a hard coded value when the CPU is first powered on, and will hence execute whatever machine code happens to be at this address.

Similarly, the program counter can be set to execute whatever machine code is at some arbitrary address, even if this is not valid machine code. This will typically trigger an architecture specific protection fault.

The CPU is oftentimes told, by page permissions in a paging based system, if the current page actually holds machine code by an execute bit — pages have multiple such permission bits (readable, writable, etc.) for various housekeeping functionality. E.g. on Unix-like systems memory pages can be toggled to be executable with the `mprotect()` system call, and on Windows, `VirtualProtect()` can be used to achieve a similar result. If an attempt is made to execute machine code on a non-executable page, an architecture specific fault will typically occur. Treating data as machine code, or finding new ways to use existing machine code, by various techniques, is the basis of some security vulnerabilities.

Similarly, in a segment based system, segment descriptors can indicate whether a segment can contain executable code and in what rings that code can run.

From the point of view of a process, the code space is the part of its address space where the code in execution is stored. In multitasking systems this comprises the program's code segment and usually shared libraries. In multi-threading environment, different threads of one process share code space along with data space, which reduces the overhead of context switching considerably as compared to process switching.

## Readability by humans

Pamela Samuelson wrote that machine code is so unreadable that the United States Copyright Office cannot identify whether a particular encoded program is an original work of authorship;[17] however, the US Copyright Office does allow for copyright registration of computer programs[18] and a program's machine code can sometimes be decompiled in order to make its functioning more easily understandable to humans.[19] However, the output of a decompiler or disassembler will be missing the comments and symbolic references, so while the output may be easier to read than the object code, it will still be more difficult than the original source code. This problem does not exist for object-code formats like SQUOZE, where the source code is included in the file.

Cognitive science professor Douglas Hofstadter has compared machine code to genetic code, saying that "Looking at a program written in machine language is vaguely comparable to looking at a DNA molecule atom by atom."[20]

## See also

* Assembly language
* Endianness
* List of machine languages
* Machine code monitor
* Overhead code
* P-code machine
* Reduced instruction set computing (RISC)
* Very long instruction word
* Teaching Machine Code: Micro-Professor MPF-I

## Notes

1. ↑ Such as many versions of BASIC, especially early ones, as well as Smalltalk, MATLAB, Perl, Python, Ruby and other special purpose or scripting languages.
2. ↑ 2.0 2.1 While overlapping instructions on processor architectures with variable-length instruction sets can sometimes be arranged to merge different code paths back into one through control-flow resynchronization, overlapping code for different processor architectures can sometimes also be crafted to cause execution paths to branch into different directions depending on the underlying processor, as is sometimes utilized in fat binaries.
3. ↑ As an example, the DR-DOS MBRs and boot sectors (which also hold the partition table and BIOS Parameter Block, leaving less than 446 respectively 423 bytes for the code) were traditionally able to locate the boot file in the FAT12 or FAT16 file system by themselves and load it into memory as a whole, in contrast to their counterparts in MS-DOS/PC DOS, which instead relied on the system files to occupy the first two directory entries in the file system and the first three sectors of IBMBIO.COM to be stored at the start of the data area in contiguous sectors containing a secondary loader to load the remainder of the file into memory (requiring SYS to take care of all these conditions). When FAT32 and LBA support was added, Microsoft even switched to require 386 instructions and split the boot code over two sectors for code size reasons, which was no option to follow for DR-DOS as it would have broken backward\- and cross-compatibility with other operating systems in multi-boot and chain load scenarios, as well as with older PCs. Instead, the DR-DOS 7.07 boot sectors resorted to self-modifying code, opcode-level programming in machine language, controlled utilization of (documented) side effects, multi-level data/code overlapping and algorithmic folding techniques to still fit everything into a physical sector of only 512 bytes without giving up any of their extended functionality.

## References

1. ↑ Stallings, William. Computer Organization and Architecture 10th edition. p. 776. ISBN 9789332570405.
2. ↑ "Immediate Operand". http://programmedlessons.org/AssemblyTutorial/Chapter-11/ass11_2.html.
3. ↑ Where the Action is: The Foundations of Embodied Interaction. MIT Press. 2004. p. 7. ISBN 0-262-54178-5. https://books.google.com/books?id=DCIy2zxrCqcC&pg=PA7. Retrieved 2023-03-05.
4. ↑ Programming the Z80 (Third Revised ed.). Sybex. 1982. pp. 67, 120, 609. ISBN 0-89588-094-6. https://archive.org/details/ProgrammingTheZ80. Retrieved 2023-03-05.
5. ↑ 5.0 5.1 5.2 5.3 5.4 Digital Design and Computer Architecture. Morgan Kaufmann Publishers. 2007. ISBN 978-0-12-370497-9. https://books.google.com/books?id=5X7JV5-n0FIC. Retrieved 2023-03-05.
6. ↑ 6.0 6.1 6.2 6.3 6.4 "Towards Integral Binary Execution: Implementing Oblivious Hashing Using Overlapped Instruction Encodings". Proceedings of the 9th workshop on Multimedia & Security (MM&Sec '07). Dallas, Texas, USA: Association for Computing Machinery. 20–21 September 2007. pp. 129–140. doi:10.1145/1288869.1288887. ISBN 978-1-59593-857-2. https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/jacob07overlap.pdf. Retrieved 2021-12-25. (12 pages)
7. ↑ "The Kruskal Count". The Mathematics of Preference, Choice and Order. Essays in Honor of Peter J. Fishburn (Berlin / Heidelberg, Germany: Springer-Verlag): 371–391. 2009. ISBN 978-3-540-79127-0. (22 pages)
8. ↑ Dietrich, Sven, ed (2014-07-10). "Instruction-Level Steganography for Covert Trigger-Based Malware". written at Vrije Universiteit Amsterdam, Amsterdam, Netherlands. 11th International Conference on Detection of Intrusions and Malware, and Vulnerability Assessment (DIMVA). Egham, UK; Switzerland: Springer International Publishing. pp. 41–50 [45]. doi:10.1007/978-3-319-08509-8_3. LNCS 8550. ISBN 978-3-31908508-1. https://www.cs.vu.nl/~herbertb/papers/stega_dimva14.pdf. Retrieved 2023-08-26. (10 pages)
9. ↑ 9.0 9.1 "Graph Based Model for Software Tamper Protection". Microsoft. February 2016. https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/mariuszj-jacob07overlap.ppt.
10. ↑ "On Offensive and Defensive Methods in Software Security". Department of Electrical and Information Technology, Lund University. November 2016. p. 96. https://lucris.lub.lu.se/ws/portalfiles/portal/15764406/dissertation.pdf. (1+xvii+1+152 pages)
11. ↑ 11.0 11.1 "Unintended Instructions on x86". Hacker News. 2021. https://news.ycombinator.com/item?id=27113890.
12. ↑ Static Analysis of x86 Executables (Dissertation). Munich, Germany: Technische Universität Darmstadt. 2010-09-24. D17. http://infoscience.epfl.ch/record/167546/files/thesis.pdf. Retrieved 2021-12-25. (199 pages)
13. ↑ "What is "overlapping instructions" obfuscation?". Reverse Engineering Stack Exchange. 2013-04-07. https://reverseengineering.stackexchange.com/questions/1531/what-is-overlapping-instructions-obfuscation.
14. ↑ Personal communication (NB. According to Jacob et al.)
15. ↑ "The Geometry of Innocent Flesh on the Bone: Return-into-libc without Function Calls (on the x86)". Proceedings of the ACM, CCS 2007. ACM Press. 2007. https://hovav.net/ucsd/dist/geometry.pdf. Retrieved 2021-12-24.
16. ↑ "Managed, Unmanaged, Native: What Kind of Code Is This?". 28 April 2003. http://www.developer.com/net/cplus/article.php/2197621/Managed-Unmanaged-Native-What-Kind-of-Code-Is-This.htm.
17. ↑ "CONTU Revisited: The Case against Copyright Protection for Computer Programs in Machine-Readable Form". Duke Law Journal 1984 (4): 663–769. September 1984. doi:10.2307/1372418. PMID 10268940. https://scholarship.law.berkeley.edu/facpubs/333.
18. ↑ "Copyright Registration for Computer Programs". US Copyright Office. August 2008. http://www.copyright.gov/circs/circ61.pdf.
19. ↑ "What is decompile? - Definition from WhatIs.com" (in en-US). WhatIs.com. http://whatis.techtarget.com/definition/decompile.
20. ↑ Gödel, Escher, Bach: An Eternal Golden Braid. 1980. p. 290.

## Further reading

* Computer Organization and Design. The Hardware/Software Interface.. Morgan Kaufmann Publishers. 1994. ISBN 1-55860-281-X. https://archive.org/details/computerorganiza00henn.
* Structured Computer Organization. Prentice Hall. 1999. ISBN 0-13-020435-8.
* Computer Science: An Overview. Addison Wesley. 2007. ISBN 978-0-321-38701-1.

* v
* t
* e

Application binary interface (ABI)

Parts and
conventions|

* Alignment
* Calling convention
* Call stack
* Library
* static
* Machine code
* Memory segmentation
* Name mangling
* Object code
* Opaque pointer
* Position-independent code
* Relocation
* System call
* Virtual method table

Related topics|

* Binary code compatibility
* Foreign function interface
* Language binding
* Linker
* dynamic
* Loader
* Year 2038 problem

* v
* t
* e

Types of programming languages

* Actor-based
* Array
* Aspect-oriented
* Class-based
* Concatenative
* Concurrent
* Dataflow
* Declarative
* Domain-specific
* Dynamic
* Esoteric
* Event-driven
* Extensible
* Functional
* Imperative
* Logic
* Macro
* Metaprogramming
* Multi-paradigm
* Object-based
* Object-oriented
* Pipeline
* Procedural
* Prototype-based
* Reflective
* Rule-based
* Scripting
* Stack based
* Synchronous
* Tactile
* Templating

* Assembly
* Compiled
* Interpreted
* Machine

* Low-level
* High-level
* Very high-level

* First generation
* Second generation
* Third generation
* Fourth generation
* Fifth generation

* Non-English-based
* Visual

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Machine code. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Machine_code&oldid=203006"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template