Register Usage in x86-64 Linux

Register Usage in x86-64 Linux

• Caller-Saved Registers:

  • %rax: Holds return value and can be modified by the procedure.
  • %rdi, %rsi, %rdx, %rcx, %r8, %r9: Used to pass arguments, and can be modified by the procedure.
  • %r10, %r11: Used as caller-saved temporaries and can be modified by the procedure.

• Callee-Saved Registers:

  • %rbx, %r12, %r13, %r14: Callee must save and restore these registers before and after using them.
  • %rbp: Acts as a frame pointer:
    • The callee must save and restore it.
    • Can be used to access local variables.
  • %rsp:
    • Acts as a stack pointer.
    • Restored to its original value upon exiting the procedure.

• Register Usage Roles:

  • Caller-Saved: The responsibility of saving and restoring these registers lies with the caller of the function.
  • Callee-Saved: The responsibility of saving and restoring these registers lies with the function itself.

Procedures

• A procedure is a named sequence of instructions that perform a specific function.
• A procedure can execute multiple times with different sets of arguments.
• Procedures pass control and data to other parts of the program.
• Procedures manage memory by allocating and deallocating space during execution.

x86-64 Stack

• The x86-64 stack is a region of memory managed using the last-in, first-out (LIFO) principle.
• The stack grows towards lower memory addresses.
• The stack pointer register %rsp points to the top of the stack.
• The pushq instruction decrements the stack pointer and writes the value to the stack.
• The popq instruction reads a value from the stack, increments the stack pointer, and stores the value in a register.

Procedure Data Flow

• The first six arguments are passed to a procedure through registers %rdi, %rsi, %rdx, %rcx, %r8, and %r9.
• The return value is passed through register %rax.
• The stack is used to store arguments beyond the first six and local variables.

Stack-Based Languages

• Stack-based languages, such as C, Pascal, and Java, support recursion and require code to be reentrant.
• Reentrant code allows multiple simultaneous instantiations of a procedure without interfering with each other.
• The stack stores local variables, arguments, and return pointers for each instantiation.
• Stack frames are used to allocate space for a single procedure instantiation.

x86-64/Linux Stack Frame

• The x86-64/Linux stack frame consists of:
  • The caller's frame pointer (%rbp)
  • The return address
  • Arguments passed to the called procedure
  • Local variables of the called procedure
  • Saved registers
• The stack pointer (%rsp) points to the top of the current stack frame.
• The stack frame is managed using push and pop instructions.

Example: incr

• The incr function takes a pointer to a long integer (p) and a long integer (val) as arguments.
• The function increments the value pointed to by p by val.
• The function returns the original value pointed to by p.
• The function uses registers for all arguments and local variables.
• The value of p is stored in %rdi, val is stored in %rsi, and the return value is stored in %rax.

Call Stack

• The code snippet demonstrates a function call stack. This call stack is used to store information required for subsequent function calls.
• The "call_incr" function calls the "incr" function.
• When a function is called, its return address is added to the call stack.
• In the case of "call_incr", the address "18213" is added to the call stack as it is used as the return address when the "incr" function is executed.
• When a function is called, local variables are allocated in the space allocated to the function on the stack.
• In the case of "call_incr" the value of variable "v1" is allocated space on the stack at address "%rsp+8".
• The function "call_incr" pushes 16 bytes onto the stack to create space for these values.
• The instruction "addq $16, %rsp" pops the values from the stack, removing the temporary space occupied by the variables.
• The instruction "ret" returns control flow to the instruction following the "call" instruction.
• The function "call_incr" takes the return value of "incr" (which is placed in %rax) adds it to the value of "v1" on the stack, then adds the two together.
• The value "v1" is taken from the call stack at the address "%rsp+8".
• The value of variable "v1" is located at address "%rsp+8".
• The function "call_incr" places its return value into the %rax register.

Increment Function ("incr")

• The function "incr" increments the value of the pointer "v1" and stores the new value in the register %rax.
• The "incr" function requires two parameters: a pointer to a variable and a value to add to the variable.
• The "incr" function is called from within the function "call_incr".
• This code illustrates how functions are called and how data is stored in the stack.
• The values passed as arguments to the "incr" function are passed in the %rdi and %rsi registers.
• The value of "v1" is taken from the call stack and addressed using the %rdi register and the value "3000" is stored in the %rsi register.
• The function "incr" first adds the value of the register %rsi (3000) to the value of the memory address stored in %rdi.
• The function "incr" finally returns the incremented value in the %rax register.