X86 Registers

• This is Jorgensen Chapter 2.3.1 CPU Registers
• The current X86 family has 16 general purpose registers.
  • The can be addressed as 8,16, 32 and 64 bit registers.
  • The table on page 10, recreated here

    64 Bit	Lowest 32 Bit	Lowest 16 bit	Lowest 8 Bit
    rax	eax	ax	al
    rbx	ebx	bx	bl
    rcx	ecx	cx	cl
    rdx	edx	dx	dl
    rsi	esi	si	sil
    rdi	edi	di	dil
    rbp	ebp	bp	bpl
    rsp	esp	sp	spl
    r8	r8d	r8w	r8b
    r9	r9d	r9w	r9b
    r10	r10d	r10w	r10b
    r11	r11d	r11w	r11b
    r12	r12d	r12w	r12b
    r13	r13d	r13w	r13b
    r14	r14d	r14w	r14b
    r15	r15d	r15w	r15b

  • These are all general purpose.
  • But some have a specific intended purpose.
• We will be using NASM, and it has the following register reference
  • NASM Registers
  • This quick reference is good.
• The registers are configured as follows
  • (From the book)
  • Note that a-d also have *h (ie ah) which is the second lowest 8-bits in the register.
    • He notes that we will only use ah.
• An Example
  • Here is some simple NASM code

  •           global    _start
    
              section   .text
    _start:
              ; store a big number in the entire register
              mov       rax, 01111111111111111h
              ; store a smaller number in the lower 1/2
              mov       eax, 022222222h
              ; store a smaller number in the lower 1/4
              mov       ax, 03333h
              ; store a small number in the lower 1/8
              mov       al, 044h
    
              mov       al, -1
              mov       rax, -1
    
              ; exit the program properly
              mov       rax, 60           ; system call for exit
              xor       rdi, rdi          ; exit code 0
              syscall                     ; invoke operating system to exit

  • You would enter this code with your text editor (vi, VSC, ...)
  • Spacing is and is not important.
    • The assembler is line oriented.
    • It needs space between commands.
    • But indents and such are for our readability.
    • AND THIS IS IMPORTANT!
  • The assembler is line oriented.
    • We can continue lines with a \ if needed, but this is not likely.
  • The general layout of a line is

    • label: instruction operands      ;comment 

    • The comments are in general VERY IMPORTANT
    • Ok, so I didn't put them on the first 8 lines, but this really does nothing.
  • The C++ program is essentially

    • int main() {
         rax = 0x1111111111111111;
         eax =0x22222222;
         ax = 0x3333;
         al = 0x44;
      
         al = -1
         rax = -1
      
         return 0;
      } 

    • I am NOT an assembler programmer, I try to always write c/c++ like code before I write the assembly code.
  • The move command
    • Carter 1.3.4, page 12 discusses the move instruction.
    • mov dest, src
    • Move the data from the source location to the destination.
    • In this case, the destinations are all registers.
    • In this case, the source is a numeric constant
      • NASM reference
    • We will discuss this in real detail later.
  • The exit code
    • Move a 60 into rax to indicate we want to call exit.
    • Move a 0 into rdi to indicate our return code.
    • These two are really just parameters.
    • The OS expects to find them in these two registers.
    • Call the exit code.
    • We will discuss this in real detail later.
  • I compile this with

    • nasm -f elf64 -g regDemo.asm -o regDemo.o
      ld -g  regDemo.o -o regDemo 

    • But I can't remember this, so I use make.
    • We will discuss this in real detail later.
  • This code does not I/O so we need to use gdb to examine the registers.
    • gdb regDemo
    • list will list the next few lines of code.
    • l will list the next few lines of code.
    • l start,end Will list from start to end.
    • help list
    • break 7 will set a breakpoint at line 7
    • b 7 will set a breakpoint at line 7
    • run will run the program
    • step or s will step to the next instruction.
    • print or p will print.
    • $regname prints the value of a register.
    • \x prints the value in hex
    • p \x $rax
    • info registers prints the registers
    • i r
    • quit
  • Changing eax or rax changes the entire register
  • Changing ax, or al, it does not change the top bits.
• regDemo.asm
• Makefile