Machine code or machine language is a system of instructions and data executed directly by a computer's central processing unit. Machine code may be regarded as a primitive (and cumbersome) programming language or as the lowest-level representation of a compiled and/or assembled computer program. Programs in interpreted languages are not represented by machine code however, although their interpreter (which may be seen as a processor executing the higher level program) often is. Machine code is sometimes called native code when referring to platform-dependent parts of language features or libraries. Machine code should not be confused with so called "bytecode", which is executed by an interpreter.
Machine code instructions
Main article: Instruction (computer science)
Every processor or processor family has its own machine code instruction set. Instructions are patterns of bits
that by physical design correspond to different commands to the
machine. The instruction set is thus specific to a class of processors
using (much) the same architecture. Successor or derivative processor
designs often include all the instructions of a predecessor and may add
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 nearly completely compatible processors may show
slightly different behaviour for some instructions but this is seldom 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 machine code instruction set may have all instructions of the same
length, or it may have variable-length instructions. How the patterns
are organized varies strongly with the particular architecture and
often also with the type of instruction. Most instructions have one or
more opcode
fields which specifies the basic instruction type (such as arithmetic,
logical, jump, etc) and the actual 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 actual value itself (such
constant operands contained in an instruction are called immediates).
[edit] Programs
A computer program is a sequence of instructions that are executed
by a CPU. While simple processors execute instructions one after the
other, superscalar processors are capable of executing several instructions at once.
Program flow may be influenced by special 'jump' instructions that transfer execution to an instruction other than the following one. Conditional jumps
are taken (execution continues at another address) or not (execution
continues at the next instruction) depending on some condition.
[edit] Assembly languages
Main article: Assembly language
A much more readable rendition of machine language, called assembly language, uses mnemonic codes to refer to machine code instructions, rather than simply using the instructions' numeric values. For example, on the Zilog Z80 processor, the machine code 00000101, which causes the CPU to decrement the B processor register, would be represented in assembly language as DEC B.
[edit] Example
The MIPS architecture
provides a specific example for a machine code whose instructions are
always 32 bits long. 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.
For example adding the registers 1 and 2 and placing the result in register 6 is encoded:
[ 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:
[ op | rs | rt | address/immediate]
35 3 8 68 decimal
100011 00011 01000 00000 00001 000100 binary
Jumping to the address 1024:
[ op | target address ]
2 1024 decimal
000010 00000 00000 00000 00100 000000 binary
[edit] Relationship to microcode
In some computer architectures, the machine code is implemented by a more fundamental underlying layer of programs called microprograms,
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 a microcode layer 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.
