nasm x86 assembly quick reference

nasm x86 Assembly Quick Reference ("Cheat Sheet")

Instructions Mnemonic Purpose Examples movdest,src Move data between registers, load immediate data into registers, move data between registers and memory. mov eax,4  ; Load constant into eax mov ebx,eax  ; Copy eax into ebx mov [123],ebx ;  Copy ebx to memory address 123 callfunc Push the address of the next instruction and start executing func.  For local functions, you don't have to say anything special.  For functions defined in C/C++, say "extern func" first. call print_int ret Pop the return program counter, and jump there.  Ends a subroutine. ret adddest,src dest=dest+src add eax,ebx ; 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 edx. mul ebx ; Multiply eax by ebx imuldest,src dest=dest*src imul ecx,3 idiv bot Divide eax by bot.  Treats edx as high bits above eax, so set them to zero first!   top = eax+(edx<<32)   eax = top/bot   edx = top%bot mov eax,73; top mov ecx,10; bot mov edx,0 idiv ecx jmplabel Goto the instruction label:.  Skips anything else in the way. jmp post_mem  ... post_mem: cmp a,b Compare two values.  Sets flags that are used by the conditional jumps (below).   cmp eax,10   jl label Goto label if previous comparison came out as less-than.  Other conditionals available are: jle (<=), je (==), jge (>=), jg (>), jne (!=), and many others.  Declare your label with a semicolon beforehand, just like in C/C++: "label:". jl loop_start  ; Jump if eax<10 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 "movdest,[esp]     add esp,4" pop ebp

Stack Frame (example without ebp or local variables) Contents off esp caller's variables [esp+12] Argument 2 [esp+8] Argument 1 [esp+4] Caller Return Address [esp] my_sub: # Returns first argument   mov eax,[esp+4]   ret (example when using ebp and two local variables) Contents off ebp off esp caller's variables [ebp+16] [esp+24] Argument 2 [ebp+12] [esp+20] Argument 1 [ebp+8] [esp+16] Caller Return Address [ebp+4] [esp+12] Saved ebp [ebp] [esp+8] Local variable 1 [ebp-4] [esp+4] Local variable 2 [ebp-8] [esp] my_sub2: # Returns first argument   push ebp  # Prologue   mov ebp, esp   mov eax, [ebp+8]   mov esp, ebp  # Epilogue   pop ebp   ret

Constants, Registers, Memory "12" means decimal 12; "0xF0" is hex.  "some_function" is the address of the first instruction of a label. Memory access (use register as pointer): "[esp]".  Same as C "*esp". Memory access with offset (use register + offset as pointer): "[esp+4]".  Same as C "*(esp+4)". Memory access with scaled index (register + another register * scale): "[eax + 4*ebx]".  Same as C "*(eax+ebx*4)". Subroutines are basically just labels.  Here's how you declare labels for the linker: "extern some_function;" declares some_function as being outside the current file.  You'll get a "symbol undefined" compile error if you call or jump to a label you never declare.  In C++, be sure to declare the corresponding function as being 'extern "C"'! "global my_function;" exposes the label my_function so it can be called from outside.  (In MASM, it's "PUBLIC my_function").  Again, your C++ prototype better be 'extern "C"'! Differences with C: "010" means decimal ten in NASM, but *octal* eight in C/C++!  Write octal by ending with letter 'o', like "10o". In NASM, you can write binary constants by ending with the letter 'b', like "mov eax,00101111b;". "1+(7<<13)/15" is evaluated at compile time, and it's a constant.  "3+eax" can't be evaluated in NASM--it's not a constant.

Registers esp is the stack pointer ebp is the stack frame pointer Return value in eax Arguments are on the stack Free for use (no save needed):    eax, ecx, edx Must be saved:    ebp, esp, esi, edi ebx must be saved in a shared library, but is otherwise free for use. 8 bit: ah (high 8 bits) and al (low 8 bits) 16 bit: ax 32 bit: eax 64 bit: rax

Pretty much this same syntax is used by  NASM  (portable x86 assembler for Windows/Linux/whatever),  YASM  (adds 64-bit support to NASM),  MASM (the Microsoft/Macro Assembler), and the official Intel documentation below.  See the  NASM documentation  or  MASM documentation  for details on constants, labels and macros.  Paul Carter has a  good x86 assembly tutorial  using the Intel syntax.  The other, nastier syntax out there is the  AT&T/GNU syntax , which I can't recommend.  The machine code in all cases is identical.

The Intel  Software Developer's Manuals  are incredibly long, boring, and complete--they give all the nitty-gritty details.  Volume 1  lists the processor registers in Section 3.4.1.  Volume 2  lists all the x86 instructions in Section 3.2.   Volume 3  gives the performance monitoring registers in Section. For Linux, the  System V ABI  gives the calling convention on page 39. Also see the Intel  hall of fame  for historical info.   Sandpile.org  has a good opcode table.

  Ralph Brown's Interrupt List  is the aging but definitive reference for all PC software interrupt functions.  See just the  BIOS interrupts for interrupt-time code.