X86 assembly language
x86 Assembly Language is a family of backward-compatible assembly languages, which provide some level of compatibility all the way back to the Intel 8008 introduced in April 1972. x86 assembly languages are used to produce object code for the x86 class of processors. Like all assembly languages, it uses short mnemonics to represent the fundamental instructions that the CPU in a computer can understand and follow. Compilers sometimes produce assembly code as an intermediate step when translating a high level program into machine code. Regarded as a programming language, assembly coding is machine-specific and low level. Assembly languages are more typically used for detailed and time critical applications such as small real-time embedded systems or operating system kernels and device drivers.
Mnemonics and opcodes
Each x86 assembly instruction is represented by a mnemonic which, often combined with one or more operands, translates to one or more bytes called an opcode; the NOP instruction translates to 0x90, for instance and the HLT instruction translates to 0xF4. There are potential opcodes with no documented mnemonic which different processors may interpret differently, making a program using them behave inconsistently or even generate an exception on some processors. These opcodes often turn up in code writing competitions as a way to make the code smaller, faster, more elegant or just show off the author's prowess.Syntax
x86 assembly language has two main syntax branches: Intel syntax, originally used for documentation of the x86 platform, and AT&T syntax. Intel syntax is dominant in the DOS and Windows world, and AT&T syntax is dominant in the Unix world, since Unix was created at AT&T Bell Labs.Here is a summary of the main differences between Intel syntax and AT&T syntax:
| AT&T | Intel | |
| Parameter order | Source before the destination. | Destination before source. |
| Parameter size | Mnemonics are suffixed with a letter indicating the size of the operands: q for qword, l for long, w for word, and b for byte. | Derived from the name of the register that is used. |
| Sigils | Immediate values prefixed with a "$", registers prefixed with a "%". | The assembler automatically detects the type of symbols; i.e., whether they are registers, constants or something else. |
| Effective addresses | General syntax of DISP. Example: | Arithmetic expressions in square brackets; additionally, size keywords like byte, word, or dword have to be used if the size cannot be determined from the operands. Example: |
Many x86 assemblers use Intel syntax, including NASM, FASM, MASM, TASM, and YASM. GAS, which originally used AT&T syntax, has supported both syntaxes since version 2.10 via the .intel_syntax directive. A quirk in the AT&T syntax for x86 is that x87 operands are reversed, an inherited bug from the original AT&T assembler.
Registers
x86 processors have a collection of registers available to be used as stores for binary data. Collectively the data and address registers are called the general registers. Each register has a special purpose in addition to what they can all do:- AX multiply/divide, string load & store
- BX index register for MOVE
- CX count for string operations & shifts
- DX port address for IN and OUT
- SP points to top of the stack
- BP points to base of the stack frame
- SI points to a source in stream operations
- DI points to a destination in stream operations
- IP instruction pointer
- FLAGS
- segment registers which determine where a 64k segment starts
- extra extension registers .
The x86 registers can be used by using the MOV instructions. For example, in Intel syntax:
Segmented addressing
The x86 architecture in real and virtual 8086 mode uses a process known as segmentation to address memory, not the flat memory model used in many other environments. Segmentation involves composing a memory address from two parts, a segment and an offset; the segment points to the beginning of a 64 KB group of addresses and the offset determines how far from this beginning address the desired address is. In segmented addressing, two registers are required for a complete memory address. One to hold the segment, the other to hold the offset. In order to translate back into a flat address, the segment value is shifted four bits left then added to the offset to form the full address, which allows breaking the 64k barrier through clever choice of addresses, though it makes programming considerably more complex.In real mode/protected only, for example, if DS contains the hexadecimal number 0xDEAD and DX contains the number 0xCAFE they would together point to the memory address 0xDEAD * 0x10 + 0xCAFE = 0xEB5CE. Therefore, the CPU can address up to 1,048,576 bytes in real mode. By combining segment and offset values we find a 20-bit address.
The original IBM PC restricted programs to 640 KB but an expanded memory specification was used to implement a bank switching scheme that fell out of use when later operating systems, such as Windows, used the larger address ranges of newer processors and implemented their own virtual memory schemes.
Protected mode, starting with the Intel 80286, was utilized by OS/2. Several shortcomings, such as the inability to access the BIOS and the inability to switch back to real mode without resetting the processor, prevented widespread usage. The 80286 was also still limited to addressing memory in 16-bit segments, meaning only 216 bytes could be accessed at a time.
To access the extended functionality of the 80286, the operating system would set the processor into protected mode, enabling 24-bit addressing and thus 224 bytes of memory.
In protected mode, the segment selector can be broken down into three parts: a 13-bit index, a Table Indicator bit that determines whether the entry is in the GDT or LDT and a 2-bit Requested Privilege Level; see x86 memory segmentation.
When referring to an address with a segment and an offset the notation of segment:offset is used, so in the above example the flat address 0xEB5CE can be written as 0xDEAD:0xCAFE or as a segment and offset register pair; DS:DX.
There are some special combinations of segment registers and general registers that point to important addresses:
- CS:IP points to the address where the processor will fetch the next byte of code.
- SS:SP points to the address of the top of the stack, i.e. the most recently pushed byte.
- DS:SI is often used to point to string data that is about to be copied to ES:DI.
- ES:DI is typically used to point to the destination for a string copy, as mentioned above.
The 32-bit flat memory model of the 80386's extended protected mode may be the most important feature change for the x86 processor family until AMD released x86-64 in 2003, as it helped drive large scale adoption of Windows 3.1 since Windows could now run many applications at once, including DOS applications, by using virtual memory and simple multitasking.
Execution modes
The x86 processors support five modes of operation for x86 code, Real Mode, Protected Mode, Long Mode, Virtual 86 Mode, and System Management Mode, in which some instructions are available and others are not. A 16-bit subset of instructions are available on the 16-bit x86 processors, which are the 8086, 8088, 80186, 80188, and 80286. These instructions are available in real mode on all x86 processors, and in 16-bit protected mode, additional instructions relating to protected mode are available. On the 80386 and later, 32-bit instructions are also available in all modes, including real mode; on these CPUs, V86 mode and 32-bit protected mode are added, with additional instructions provided in these modes to manage their features. SMM, with some of its own special instructions, is available on some Intel i386SL, i486 and later CPUs. Finally, in long mode, 64-bit instructions, and more registers, are also available. The instruction set is similar in each mode but memory addressing and word size vary, requiring different programming strategies.The modes in which x86 code can be executed in are:
- Real mode
- Protected mode
- Long mode
- Virtual 8086 mode
- System Management Mode
Switching modes
Instruction types
In general, the features of the modern x86 instruction set are:- A compact encoding
- * Variable length and alignment independent
- * Mainly one-address and two-address instructions, that is to say, the first operand is also the destination.
- * Memory operands as both source and destination are supported.
- * Both general and implicit register usage; although all seven general registers in 32-bit mode, and all fifteen general registers in 64-bit mode, can be freely used as accumulators or for addressing, most of them are also implicitly used by certain special instructions; affected registers must therefore be temporarily preserved, if active during such instruction sequences.
- Produces conditional flags implicitly through most integer ALU instructions.
- Supports various addressing modes including immediate, offset, and scaled index but not PC-relative, except jumps.
- Includes floating point to a stack of registers.
- Contains special support for atomic read-modify-write instructions
- SIMD instructions.
Stack instructions
push, pop, call and ret are used with the properly set up stack to pass parameters, to allocate space for local data, and to save and restore call-return points. The ret size instruction is very useful for implementing space efficient calling conventions where the callee is responsible for reclaiming stack space occupied by parameters.When setting up a stack frame to hold local data of a recursive procedure there are several choices; the high level
enter instruction takes a procedure-nesting-depth argument as well as a local size argument, and may be faster than more explicit manipulation of the registers. Whether it is faster or slower depends on the particular x86-processor implementation as well as the calling convention used by the compiler, programmer or particular program code; most x86 code is intended to run on x86-processors from several manufacturers and on different technological generations of processors, which implies highly varying microarchitectures and microcode solutions as well as varying gate- and transistor-level design choices.The full range of addressing modes even for instructions such as
push and pop, makes direct usage of the stack for integer, floating point and address data simple, as well as keeping the ABI specifications and mechanisms relatively simple compared to some RISC architectures.Integer ALU instructions
x86 assembly has the standard mathematical operations,add, sub, mul, with idiv; the logical operators and, or, xor, neg; bitshift arithmetic and logical, sal/sar, shl/shr; rotate with and without carry, rcl/rcr, rol/ror, a complement of BCD arithmetic instructions, aaa, aad, daa and others.Floating-point instructions
x86 assembly language includes instructions for a stack-based floating-point unit. The FPU was an optional separate coprocessor for the 8086 through the 80386, it was an on-chip option for the 80486 series, and it is a standard feature in every Intel x86 CPU since the 80486, starting with the Pentium. The FPU instructions include addition, subtraction, negation, multiplication, division, remainder, square roots, integer truncation, fraction truncation, and scale by power of two. The operations also include conversion instructions, which can load or store a value from memory in any of the following formats: binary-coded decimal, 32-bit integer, 64-bit integer, 32-bit floating-point, 64-bit floating-point or 80-bit floating-point. x86 also includes a number of transcendental functions, including sine, cosine, tangent, arctangent, exponentiation with the base 2 and logarithms to bases 2, 10, or e.The stack register to stack register format of the instructions is usually
fop st, st or fop st, st, where st is equivalent to st, and st is one of the 8 stack registers , st,..., st. Like the integers, the first operand is both the first source operand and the destination operand. fsubr and fdivr should be singled out as first swapping the source operands before performing the subtraction or division. The addition, subtraction, multiplication, division, store and comparison instructions include instruction modes that pop the top of the stack after their operation is complete. So, for example, faddp st, st performs the calculation st = st + st, then removes st from the top of stack, thus making what was the result in st the top of the stack in st.SIMD instructions
Modern x86 CPUs contain SIMD instructions, which largely perform the same operation in parallel on many values encoded in a wide SIMD register. Various instruction technologies support different operations on different register sets, but taken as complete whole they include general computations on integer or floating point arithmetic. So for example, paddw mm0, mm1 performs 4 parallel 16-bit integer adds of mm0 values to mm1 and stores the result in mm0. Streaming SIMD Extensions or SSE also includes a floating point mode in which only the very first value of the registers is actually modified. Some other unusual instructions have been added including a sum of absolute differences and a 16-bit multiply accumulation instruction. SSE and 3DNow! extensions include addition and subtraction instructions for treating paired floating point values like complex numbers.
These instruction sets also include numerous fixed sub-word instructions for shuffling, inserting and extracting the values around within the registers. In addition there are instructions for moving data between the integer registers and XMM /FPU registers.Data manipulation instructions
The x86 processor also includes complex addressing modes for addressing memory with an immediate offset, a register, a register with an offset, a scaled register with or without an offset, and a register with an optional offset and another scaled register. So for example, one can encode mov eax, as a single instruction which loads 32 bits of data from the address computed as ds selector, and stores it to the eax register. In general x86 processors can load and use memory matched to the size of any register it is operating on.
The x86 instruction set includes string load, store, move, scan and compare instructions which perform each operation to a specified size then increments/decrements the implicit address register. For the load, store and scan operations, the implicit target/source/comparison register is in the al, ax or eax register. The implicit segment registers used are ds for si and es for di. The cx or ecx register is used as a decrementing counter, and the operation stops when the counter reaches zero or when inequality is detected.
The stack is implemented with an implicitly decrementing and incrementing stack pointer. In 16-bit mode, this implicit stack pointer is addressed as SS:, in 32-bit mode it is SS:, and in 64-bit mode it is . The stack pointer actually points to the last value that was stored, under the assumption that its size will match the operating mode of the processor to match the default width of the push/pop/call/ret instructions. Also included are the instructions enter and leave which reserve and remove data from the top of the stack while setting up a stack frame pointer in bp/ebp/rbp. However, direct setting, or addition and subtraction to the sp/esp/rsp register is also supported, so the enter/leave instructions are generally unnecessary.
This code in the beginning of a function:
push ebp ; save calling function's stack frame
mov ebp, esp ; make a new stack frame on top of our caller's stack
sub esp, 4 ; allocate 4 bytes of stack space for this function's local variables
...is functionally equivalent to just:
enter 4, 0
Other instructions for manipulating the stack include pushf/popf for storing and retrieving the FLAGS register. The pusha/popa instructions will store and retrieve the entire integer register state to and from the stack.
Values for a SIMD load or store are assumed to be packed in adjacent positions for the SIMD register and will align them in sequential little-endian order. Some SSE load and store instructions require 16-byte alignment to function properly. The SIMD instruction sets also include "prefetch" instructions which perform the load but do not target any register, used for cache loading. The SSE instruction sets also include non-temporal store instructions which will perform stores straight to memory without performing a cache allocate if the destination is not already cached
Most generic integer and floating point instructions can use one parameter as a complex address as the second source parameter. Integer instructions can also accept one memory parameter as a destination operand.Program flow
The x86 assembly has an unconditional jump operation, jmp, which can take an immediate address, a register or an indirect address as a parameter.
Also supported are several conditional jumps, including jz, jnz, jg, jl, ja, jb. These conditional operations are based on the state of specific bits in the FLAGS register. Many arithmetic and logic operations set, clear or complement these flags depending on their result. The comparison cmp and test instructions set the flags as if they had performed a subtraction or a bitwise AND operation, respectively, without altering the values of the operands. There are also instructions such as clc and cmc which work on the flags directly. Floating point comparisons are performed via fcom or ficom instructions which eventually have to be converted to integer flags.
Each jump operation has three different forms, depending on the size of the operand. A short jump uses an 8-bit signed operand, which is a relative offset from the current instruction. A near jump is similar to a short jump but uses a 16-bit signed operand or a 32-bit signed operand. A far jump is one that uses the full segment base:offset value as an absolute address. There are also indirect and indexed forms of each of these.
In addition to the simple jump operations, there are the call and ret instructions. Before transferring control to the subroutine, call pushes the segment offset address of the instruction following the call onto the stack; ret pops this value off the stack, and jumps to it, effectively returning the flow of control to that part of the program. In the case of a far call, the segment base is pushed following the offset; far ret pops the offset and then the segment base to return.
There are also two similar instructions, int, which saves the current FLAGS register value on the stack, then performs a far call, except that instead of an address, it uses an interrupt vector, an index into a table of interrupt handler addresses. Typically, the interrupt handler saves all other CPU registers it uses, unless they are used to return the result of an operation to the calling program. The matching return from interrupt instruction is iret, which restores the flags after returning. Soft Interrupts of the type described above are used by some operating systems for system calls, and can also be used in debugging hard interrupt handlers. Hard interrupts are triggered by external hardware events, and must preserve all register values as the state of the currently executing program is unknown. In Protected Mode, interrupts may be set up by the OS to trigger a task switch, which will automatically save all registers of the active task.Examples
"Hello world!" program for DOS in MASM style assembly
Using interrupt 21h for output – other samples use libc's printf to print to stdout.
.model small
.stack 100h
.data
msg db 'Hello world!$'
.code
start:
mov ah, 09h ; Display the message
lea dx, msg
int 21h
mov ax, 4C00h ; Terminate the executable
int 21h
end start
"Hello world!" program for Windows in MASM style assembly
; requires /coff switch on 6.15 and earlier versions
.386
.model small,c
.stack 1000h
.data
msg db "Hello world!",0
.code
includelib libcmt.lib
includelib libvcruntime.lib
includelib libucrt.lib
includelib legacy_stdio_definitions.lib
extrn printf:near
extrn exit:near
public main
main proc
push offset msg
call printf
push 0
call exit
main endp
end
"Hello world!" program for Windows in NASM style assembly
; Image base = 0x00400000
%define RVA
section.text
push dword hello
call dword
push byte +0
call dword
ret
section.data
hello db "Hello world!"
section.idata
dd RVA
dd -1
dd 0
dd RVA
dd RVA
times 5 dd 0 ; ends the descriptor table
msvcrt_string dd "msvcrt.dll", 0
msvcrt_LookupTable:
dd RVA
dd RVA
dd 0
msvcrt_imports:
printf dd RVA
exit dd RVA
dd 0
msvcrt_printf:
dw 1
dw "printf", 0
msvcrt_exit:
dw 2
dw "exit", 0
dd 0
"Hello world!" program for Linux in NASM style assembly
; This program runs in 32-bit protected mode.
; build: nasm -f elf -F stabs name.asm
; link: ld -o name name.o
; In 64-bit long mode you can use 64-bit registers
; Also change "-f elf " for "-f elf64" in build command.
section.data ; section for initialized data
str: db 'Hello world!', 0Ah ; message string with new-line char at the end
str_len: equ $ - str ; calcs length of string by subtracting the str's start address
; from this address
section.text ; this is the code section
global _start ; _start is the entry point and needs global scope to be 'seen' by the
; linker --equivalent to main in C/C++
_start: ; definition of _start procedure begins here
mov eax, 4 ; specify the sys_write function code
mov ebx, 1 ; specify file descriptor stdout --in gnu/linux, everything's treated as a file,
; even hardware devices
mov ecx, str ; move start _address_ of string message to ecx register
mov edx, str_len ; move length of message
int 80h ; interrupt kernel to perform the system call we just set up -
; in gnu/linux services are requested through the kernel
mov eax, 1 ; specify sys_exit function code
mov ebx, 0 ; specify return code for OS
int 80h ; interrupt kernel to perform system call
"Hello world!" program for Linux in NASM style assembly using the C standard library">Libc">C standard library
; This program runs in 32-bit protected mode.
; gcc links the standard-C library by default
; build: nasm -f elf -F stabs name.asm
; link: gcc -o name name.o
; In 64-bit long mode you can use 64-bit registers
; Also change "-f elf " for "-f elf64" in build command.
global main ;main must be defined as it being compiled against the C-Standard Library
extern printf ;declares use of external symbol as printf is declared in a different object-module.
;Linker resolves this symbol later.
segment.data ;section for initialized data
string db 'Hello world!', 0Ah, 0h ;message string with new-line char and the NULL terminator
;string now refers to the starting address at which 'Hello, World' is stored.
segment.text
main:
push string ;push the address of first character of string onto stack. This will be argument to printf
call printf ;calls printf
add esp, 4 ;advances stack-pointer by 4 flushing out the pushed string argument
ret ;return
"Hello world!" program for 64-bit mode Linux in NASM style assembly
; build: nasm -f elf64 -F dwarf hello.asm
; link: ld -o hello hello.o
DEFAULT REL ; use RIP-relative addressing modes by default, so =
SECTION.rodata ; read-only data can go in the.rodata section on GNU/Linux, like.rdata on Windows
Hello: db "Hello world!",10 ; 10 = `\n`.
len_Hello: equ $-Hello ; get NASM to calculate the length as an assemble-time constant
;; write takes a length so a 0-terminated C-style string isn't needed. It would be for puts
SECTION.text
global _start
_start:
mov eax, 1 ; __NR_write syscall number from Linux asm/unistd_64.h
mov edi, 1 ; int fd = STDOUT_FILENO
lea rsi, ; x86-64 uses RIP-relative LEA to put static addresses into regs
mov rdx, len_Hello ; size_t count = len_Hello
syscall ; write; call into the kernel to actually do the system call
;; return value in RAX. RCX and R11 are also overwritten by syscall
mov eax, 60 ; __NR_exit call number
xor edi, edi ; status = 0
syscall ; _exit
Running it under strace verifies that no extra system calls are made in the process. The printf version would make many more system calls to initialize libc and do dynamic linking. But this is a static executable because we linked using ld without -pie or any shared libraries; the only instructions that run in user-space are the ones you provide.
$ strace./hello > /dev/null # without a redirect, your program's stdout is mixed strace's logging on stderr. Which is normally fine
execve = 0
write = 13
exit = ?
+++ exited with 0 +++
Using the flags register
Flags are heavily used for comparisons in the x86 architecture. When a comparison is made between two data, the CPU sets the relevant flag or flags. Following this, conditional jump instructions can be used to check the flags and branch to code that should run, e.g.:
cmp eax, ebx
jne do_something
;...
do_something:
; do something here
Flags are also used in the x86 architecture to turn on and off certain features or execution modes. For example, to disable all maskable interrupts, you can use the instruction:
cli
The flags register can also be directly accessed. The low 8 bits of the flag register can be loaded into ah using the lahf instruction. The entire flags register can also be moved on and off the stack using the instructions pushf, popf, int and iret.Using the instruction pointer register
The instruction pointer is called ip in 16-bit mode, eip in 32-bit mode, and rip in 64-bit mode. The instruction pointer register points to the memory address which the processor will next attempt to execute; it cannot be directly accessed in 16-bit or 32-bit mode, but a sequence like the following can be written to put the address of next_line into eax:
call next_line
next_line:
pop eax
This sequence of instructions generates position-independent code because call takes an instruction-pointer-relative immediate operand describing the offset in bytes of the target instruction from the next instruction.
Writing to the instruction pointer is simple — a jmp instruction sets the instruction pointer to the target address, so, for example, a sequence like the following will put the contents of eax into eip:
jmp eax
In 64-bit mode, instructions can reference data relative to the instruction pointer, so there is less need to copy the value of the instruction pointer to another register.Manuals
-
-
Books
- Dennis Yurichev: