x86_64 Assembly Quick Reference ("Cheat Sheet")

Instructions (identical to x86)

Mnemonic
Purpose
Examples
mov src,dest
Move data between registers, load immediate data into registers, move data between registers and memory.
mov $4,%eax  # Load constant into eax
mov %eax,%ebx  # Copy eax into ebx
mov %ebx,123  # Copy ebx to memory address 123
push src
Insert a value onto the stack.  Useful for passing arguments, saving registers, etc.
push %ebp
pop dest
Remove topmost value from the stack.  Equivalent to "mov (%esp),dest; add $4,%esp"
pop %ebp
call func
Push the address of the next instruction and start executing func.
call print_int
ret
Pop the return program counter, and jump there.  Ends a subroutine.
ret
add src,dest
dest=dest+src
add %ebx,%eax # Add ebx to eax
mul src
Multiply eax and src as unsigned integers, and put the result in eax.  High 32 bits of product go into eax.
mul %ebx #Multiply eax by ebx
jmp label Goto the instruction label:.  Skips anything else in the way. jmp post_mem
mov %eax,0 # Write to NULL!
post_mem: # OK here...
cmp a,b

Compare two values.  Sets flags that are used by the conditional jumps (below).  WARNING: compare is relative to *last* argument, so "jl" jumps if b<a!
cmp $10,%eax  
jl label Goto label if previous comparison came out as less-than.  Other conditionals available are: jle (<=), jeq (==), jge (>=), jg (>), jne (!=), and many others. jl loop_start  # Jump if eax<10

Stack Frame

(Normally not needed)


Constants, Registers, Memory

Constants MUST be preceeded with "$".  "$12" means decimal 12; "$0xF0" is hex.  "$some_function" is the address of the first instruction of the function.  WARNING: a bare "12", "0xF0", or "some_function" dereferences the expression like it was a pointer!
Registers MUST be preceeded with "%".  "%eax" means register eax.
Memory access (use register as pointer): "(%esp)".  Same as C "*esp".
Memory access with offset (use register + offset as pointer): "4(%esp)".  Same as C "*(esp+4)".
Memory access with scaled index (register + another register * scale): "(%eax, %ebx, 4)".  Same as C "*(eax+ebx*4)".

Registers

64-bit: %rax, %r8
32-bit: %eax, %r8d  (plus zero extension)
16-bit: %ax, %r8w
8-bit: %al, %r8b
%rsp is the stack pointer
The stack frame pointer isn't used very often.
Return value in %rax (or %eax)
Arguments are in %rdi, %rsi,%rdx, %rcx,%r8d,%r9d, and then on the stack (in the usual order)


See sandpile.org for an opcode map.


O. Lawlor, ffosl@uaf.edu
Up to: Class Site, CS, UAF