Theory of Function Calls

• I am starting in Jorgensen chapter 12.
• Leaf vs non-leaf functions
  • Functions can be classified as either leaf or non-leaf
  • A leaf function is called, does its work and returns.
  • A non-leaf function is called, but will call other functions.
• A function
  • Can be called from anywhere
  • Thus it can return to anywhere.
  • This means that the function must "know" where to return to.
  • A simple jmp will not do.
• Functions must be able to interact with other functions
  • Thus there must be a standard way to do things like parameters and return values.
  • This is called the calling convention.
  • We will be using the System V AMD64 ABI calling convention.
    • This is a linux calling convention.
    • Our procedures should work with c/c++ on linux
    • It is not the windows calling convention.
• The calling convention describes things like
  • Register usage (what must be saved and what need not be)
  • Parameter passing (where we put parameters)
  • Return values (and where we do this)
  • Stack usage
• Local variables and the stack.
  • We will see that we need the stack for various reasons.
  • A big one is local variables.
  • If we have a recursive function, we can not use the global variable store for this.
  • Consider

    int pow(float base, int power) {
       int rv;
       if (power <= 0) {
          rv = 1
       } else if (power == 1) {
          rv = base
       } else {
          rv = base * pow( base,  power-1)
       }
       return rv;
    } 

  • Trace pow(10,3) on the stack.
  • An activation record or stack frame is created for each function call.
    • These are placed on the stack.
    • They contain, among other things, the local variables.
    • When the function exits, they are popped off the stack.
  • This is convenient as we can save other values we need as well.
• Linkage
  • This is the name for getting to and returning from a function.
  • Where do we return to when we call a function?
  • What will hold this information?
  • call function_name
    • Transfers rip to the stack (and decrements rsp)
    • jumps to the named address.
  • ret
    • Pops the stack and sets the rip to the value removed. (increments the rsp)
  • The implication is that the stack is in the proper "configuration"
    • The return address is at the top of the stack.
    • Or if the programmer has done anything to the stack in the function, they undo it before the return.
  • Note that there are special instructions/hardware to do a function call
    • rsp, rip
    • call, ret
• A smple.asm simple, bad function
• Passing parameters on the stack
  • rax is used for the return value of a function.
  • The arguments should be placed in
    1. rdi
    2. rsi
    3. rdx
    4. rcx
    5. r8
    6. r9
  • Any additional argument shold be stored on the stack in reverse order.
  • More on this to come.
• Saving Registers
  • We saw this sheet before.
  • In a function
    • If you used a preserved register
      • You need to save it before you use it.
      • You need to restore it before you return.
    • If you use a scratch register and call a function
      • You need to save it before you call the function
      • You need to put it back after the function returns.
    • We do this on the stack.
• Local variables
  • Sorry if this is duplicate.
  • We will save local variables on the stack.