Assembly Language Instructions Cheat Sheet

Introduction

Assembly language is a low-level programming language that has a strong correspondence between the language’s instructions and the processor’s machine code instructions. This cheat sheet focuses primarily on x86 assembly with notes on other architectures where relevant.

Common Terminology

• Register: CPU’s internal storage locations
• Instruction: A single operation the CPU can perform
• Operand: Data that an instruction operates on
• Addressing Mode: How memory locations are specified
• Mnemonic: Human-readable instruction name

Register Sets

x86 (32-bit) Registers

General Purpose Registers

• EAX: Accumulator (arithmetic operations, function return values)
• EBX: Base (pointer to data in memory)
• ECX: Counter (loop counter)
• EDX: Data (arithmetic operations)
• ESI: Source Index (string operations source)
• EDI: Destination Index (string operations destination)
• ESP: Stack Pointer (points to top of stack)
• EBP: Base Pointer (points to base of stack frame)

Segment Registers

• CS: Code Segment
• DS: Data Segment
• SS: Stack Segment
• ES, FS, GS: Extra Segments

Status Flags (EFLAGS)

• CF: Carry Flag
• ZF: Zero Flag
• SF: Sign Flag
• OF: Overflow Flag
• PF: Parity Flag
• AF: Auxiliary Carry Flag

x86-64 (64-bit) Additional Registers

• RAX, RBX, RCX, RDX, RSI, RDI, RSP, RBP: 64-bit extensions of 32-bit registers
• R8-R15: Additional 64-bit registers
• XMM0-XMM15: 128-bit SIMD registers

ARM Registers

• R0-R12: General purpose registers
• R13 (SP): Stack pointer
• R14 (LR): Link register (return address)
• R15 (PC): Program counter

MIPS Registers

• $0: Constant zero
• $1: Reserved for assembler
• $2-$3: Function results
• $4-$7: Function arguments
• $8-$15, $24-$25: Temporaries
• $16-$23: Saved registers
• $26-$27: Reserved for OS
• $28 (GP): Global pointer
• $29 (SP): Stack pointer
• $30 (FP): Frame pointer
• $31 (RA): Return address

Data Movement Instructions

x86/x64

ARM

MIPS

Arithmetic Instructions

x86/x64

ARM

MIPS

Logical Instructions

x86/x64

ARM

MIPS

Control Flow Instructions

x86/x64

Unconditional Jumps

Conditional Jumps

ARM

MIPS

Memory Addressing Modes

x86/x64

ARM

MIPS

SIMD Instructions (x86/x64)

SSE/AVX Registers

• XMM0-XMM15: 128-bit registers
• YMM0-YMM15: 256-bit registers (AVX)
• ZMM0-ZMM31: 512-bit registers (AVX-512)

Common SSE Instructions

Common AVX Instructions

System Instructions

x86/x64

String Operations (x86/x64)

Common x86/x64 Calling Conventions

cdecl (C Declaration)

• Arguments pushed on stack from right to left
• Caller cleans the stack
• EAX, ECX, EDX are caller-saved
• Other registers are callee-saved
• Return value in EAX

stdcall (Standard Call)

• Arguments pushed on stack from right to left
• Callee cleans the stack
• Return value in EAX

fastcall

• First two arguments in ECX and EDX
• Remaining arguments pushed on stack from right to left
• Callee cleans the stack
• Return value in EAX

x64 (Microsoft)

• First four arguments in RCX, RDX, R8, R9
• Additional arguments pushed on stack from right to left
• 32 bytes of shadow space on stack
• Return value in RAX

x64 (System V – Linux, macOS)

• First six integer/pointer arguments in RDI, RSI, RDX, RCX, R8, R9
• First eight floating-point arguments in XMM0-XMM7
• Additional arguments pushed on stack from right to left
• Return value in RAX (integer) or XMM0 (floating-point)

Common Assembler Directives

General Directives

Data Definition Directives

Common Assembly Tasks (x86/x64)

Function Prologue (x86)

function:
    push ebp            ; Save old base pointer
    mov ebp, esp        ; Set new base pointer
    sub esp, X          ; Allocate X bytes of local variables
    push ebx            ; Save callee-saved registers
    push esi
    push edi
    ; Function body

Function Epilogue (x86)

    pop edi             ; Restore callee-saved registers
    pop esi
    pop ebx
    mov esp, ebp        ; Deallocate local variables
    pop ebp             ; Restore old base pointer
    ret                 ; Return to caller

Function Prologue (x64, Microsoft)

function:
    push rbp            ; Save old base pointer
    mov rbp, rsp        ; Set new base pointer
    sub rsp, X          ; Allocate X bytes of local variables (X must be multiple of 16)
    ; Save non-volatile registers if used
    ; Function body

Function Epilogue (x64, Microsoft)

    ; Restore non-volatile registers if saved
    mov rsp, rbp        ; Deallocate local variables
    pop rbp             ; Restore old base pointer
    ret                 ; Return to caller

Memory Access Examples (x86)

; Accessing function parameters (cdecl)
mov eax, [ebp+8]    ; First parameter
mov ecx, [ebp+12]   ; Second parameter

; Accessing local variables
mov [ebp-4], eax    ; First local variable
mov [ebp-8], ecx    ; Second local variable

; Array indexing (array of 4-byte elements)
mov eax, [ebx+ecx*4]    ; array[ecx]

Memory Access Examples (x64, Microsoft)

; Parameters already in registers: RCX, RDX, R8, R9
; Accessing parameters beyond the first four
mov rax, [rbp+16]   ; Fifth parameter

; Accessing local variables
mov [rbp-8], rax    ; First local variable
mov [rbp-16], rcx   ; Second local variable

C-Style Array Access (x86)

; Accessing array[i] where each element is 4 bytes
; Assume:
;   - EBX points to the array (array base address)
;   - ECX contains i (the index)

; Method 1: Use scaled indexed addressing
mov eax, [ebx+ecx*4]    ; Load array[i] into EAX

; Method 2: Calculate address manually
mov eax, ecx            ; Copy i to EAX
shl eax, 2              ; Multiply by 4 (size of each element)
add eax, ebx            ; Add to base address
mov eax, [eax]          ; Load array[i] into EAX

Loop Structure (x86)

    mov ecx, 10         ; Initialize counter
loop_start:
    ; Loop body
    
    dec ecx             ; Decrement counter
    jnz loop_start      ; Jump if not zero

Loop Structure with array (x86)

    mov ecx, 10         ; Array length
    mov eax, 0          ; Sum
    mov esi, array      ; Array pointer
loop_start:
    add eax, [esi]      ; Add current element to sum
    add esi, 4          ; Move to next element
    dec ecx             ; Decrement counter
    jnz loop_start      ; Jump if not zero

Floating-Point Operations (x87 FPU)

Tips and Best Practices

1. Comment your code: Assembly is difficult to read and understand
2. Use meaningful labels: Makes the code more readable
3. Be consistent with naming conventions: Helps with maintenance
4. Save/restore registers: Especially in functions and interrupts
5. Align your data: For performance and to avoid bus errors
6. Use macros for repetitive tasks: Reduces code duplication
7. Avoid self-modifying code: Hard to maintain and may not work on modern systems
8. Use higher-level constructs when available: Many assemblers support structured programming
9. Be careful with overflow and boundary conditions: Assembly provides minimal protection
10. Test thoroughly: Assembly errors can be subtle and difficult to find

Resources and References

• Intel® 64 and IA-32 Architectures Software Developer Manuals
• ARM Architecture Reference Manual
• MIPS Architecture Reference Manual
• AMD64 Architecture Programmer’s Manual
• “Assembly Language for x86 Processors” by Kip Irvine
• “Programming from the Ground Up” by Jonathan Bartlett
• “Art of Assembly Language” by Randall Hyde