Parameters and Local Variables

• Here is a useful Quick Reference
• Registers RBX, R12, R13, R14, R15 are called preserved or Saved registers.
  • If you use these in a function, you should restore their value before you return.
  • After you have the stack established, push the value of any of these you wish to save.
  • Once you are done, pop these BEFORE you return.
• RAX, RCX, RDX, RSI, RDI, R8, R9, R10, R11 are scratch registers.
  • This means that a function may change the value without preserving it.
  • Some of these are used in parameter passing/value return.
  • But if you are using them in your code, and you call a function you should save them BEFORE you call the function and restore them AFTER the function call.
  • You do this on the stack BEFORE you call the function.
• We have already stated that
  • Pass variables to functions in RDI, RSI, RDX, RCX, R8, R9
  • Return a value in RAX
  • So if you are using any of these for other purposes they will need to be preserved.
  • RBP and RSP should be used to manage the stack.
  • RIP will be changed by call and ret.
• What about additional parameters (beyond 6?).
  • These are pushed on the stack, in reverse order, BEFORE you call the function.
  • It is probably best to follow the C/C++ convention and only have a single return value in RAX.
  • Other architectures use the stack, but stack management is different.
  • We could agree that the caller provide space for additional return arguments.
• Local function variables
  • Finally, if you need local variables for your function, you put those on the stack in your activation record.
• The activation record then...
  • Assume that the calling function wishes to
    • preserve registers R10 and R11
    • pass nine parameters (6 in the registers and 3 on the stack)

    • push r10
      push r11
      push arg9
      push arg8
      push arg7
      call function 

  • The callee wants
    • Does preamble (save bp and sp)

    • push rbp
      mov rbp, rsp 

    • To save registers r14 and r15 so it can use them in computation.

      push r14
      push r15 

    • "Declare" three local 64 bit words for local storage.

      add rsp, 24  ; 8 byte word x 3
                  

    Address (decimal)	Value	Pointer
    400000	r10
    399992 (removed 8 bytes)	r11
    399984 (removed 8 bytes)	argument 9
    399976 (removed 8 bytes)	argument 8
    399968 (removed 8 bytes)	argument 7
    399960 (removed 8 bytes)	ripcaller
    399952 (removed 8 bytes)	rbpold	rspold, rbpnew
    399944 (removed 8 bytes)	R14
    399936 (removed 8 bytes)	R15
    399928 (removed 8 bytes)	local 1
    399920 (removed 8 bytes)	local 2
    399912 (removed 8 bytes)	local 3	rspnew

• To access values, we should probably use the bp.
  • Remember previous frame is rbp + offset
    • So argument 9 is rbp + 32
    • So argument 8 is rbp + 24
    • So argument 7 is rbp + 16
  • This frame is RBP - offest.
    • So the first local variable is RBP - 24
    • So the second local variable is RBP - 32
    • So the third local variable is RBP - 40
• How do we clean up the stack and exit from this function?
• What do we need to do when we return to the caller?
• How do we do a pass by value?
• How do we do a pass by reference (pointer)?
• Why are all arrays pass by reference (pointer)?