---

Introduction: (1) how to pass parameters to functions, (2) how to create local variables and (3) how to pass return values back

---

• Introduction
  • Just like in the discussion of the if (if-else) and the while (for) statements where:

    We learn 2 new assembler instructions: The compare (cmp) instruction The conditional and unconditional branch instruction(s)         and use them to construct the if (if-else) and while (for) statement program flow

    I can tell you that:

    You have learned everything in ARM assembler to write subroutines/functions/methods

    Here a summary of what you have learned about subroutine call/return:

    The caller uses bl to call a subroutine The bl instruction will store the return address in the Link Register lr. A non-leaf subroutine must use: push {lr} to save its return address on the system stack pop {pc} to return to the caller A leaf subroutine may use: push {lr} to save its return address on the system stack pop {pc} to return to the caller or: Don't save the return address (in lr) Use mov pc,lr to return to the caller

  ---

  ---

  ---

  ---

• Other things that are available in a function call in a high level programming language
  • There are 3 things that are available in a method/function written in a high level programming language.

    I will illustrate them with a commonly used method definition:

    /* ---------------------------------------------------------- sumRange(A,a,b): returns (A[a] + A[a+1] + ... + A[b-1]) ---------------------------------------------------------- */ int sumRange(int[] A, int a, int b ) { int i, s; s = 0; for (i = a, i < b; i++) s = s + A[i]; return(s); }

    You can see that besides the function/method name (which translates to a label) and the statements inside the method (which will translate into assembler instructions - just like in the main program that we have seen in so many prior examples), you find these new features:

    Parameters Return value Local variables that are created when the method starts running and that are destroyed when method finishes So far, we have only use permanent variables (defined with .byte, .2byte, .4byte or .skip that exist throughout the entire execution of the program

    ---

    ---

  • And just like in the discussion of if (if-else) and while (for) statements, the realization of these new features is not achieve with new assembler instructions, but throught:

    Organize your assembler program

    In the next discussions, we will organize the memory cells in the CPU and in the computer memory to store parameters, return values and local variables

    So pay attention to how we organize !!!

  ---

  ---

  ---

  ---

• Terminology: caller and callee
  • Caller (= calling method)

    Caller = the method that calls another method The caller may pass one or more parameter(s) to a called method

    ---

  • Callee (= called method)

    Callee = the method that got called (by another method) (The main( ) program is also a method !!!) The callee may pass a return value back to its caller

  ---

  ---

  ---

  ---

• How to pass parameters
  • Principle of passing parameters:

    Parameter passing is an agreement between The calling method             and        The called method on: Where to pass (= store) the value of each parameter               How to pass the value of each parameter

  ---

  ---

  ---

  ---

• How to pass return values
  • Principle of passing return values:

    Passing return values is also an agreement between The calling method             and        The called method on: Where to pass (= store) the value of each parameter               How to pass the value of each parameter

    ---

  • Important note about return values:

    When a method returns its return value, the method has completed execution !!! Therefore: all parameters and all local variables in the method are no longer needed The return value is (usually) one simple value that can (always) be stored in one CPU register)

  ---

  ---

  ---

  ---

• The common theme of (1) how to pass parameters to functions, (2) how to create local variables and (3) how to pass return values back
  • Passing parameters, creating local variables and passing return values has the following theme in common:

    They all involves storing information (or data): Parameters are passed using "things" that store parameter values Local variables are stored using "things" that store values Return value are also passed using "things" that store values 🙂

  ---

  ---

  ---

  ---

• "Things" that store values inside the computer system
  • Recall that the computer system consists of:

    The CPU The computer memory (RAM)

    ---

    ---

  • "Things" in the CPU that can be used to store values are:

    The general purpose registers !!!

    ---

    ---

  • "Things" in the RAM (computer memory) that can be used to store values are:

    Every memory cell in the RAM can be used to store values... However: Due to the FILO ordering of function calls/returns: Therefore: The most suitable data structure to store the parameters and local variables in function calls is the stack (because the stack is a FILO data structure) So the parameters and local variables are placed in the system stack when they are store in the memory

  ---

  ---

  ---

  ---

• Commonly used "things" (= storage location) to put parameters
  • Commonly used "things" (= places) to store parameters:

    Parameters can be passed by copying the value of the parameters in a pre-agreed register in the CPU Parameters can be passed by pushing the value of the parameters on the system stack

    I will discuss method 1 next

    Method 2 will be discussed later.

  ---

  ---

  ---

  ---

• Technique used to pass return values
  • Because return values of methods are simple values that can be stored in a CPU register:

    The return value of methods are always passed back to its caller in a CPU register

  ---

  ---

  ---

  ---

• Commonly used techniques to create (= reserve) local variables
  • Local variables have the same lifetime as parameter variables in a method.

    Therefore:

    We can use the same techniques to allocate memory for local varaibles as for parameter variables

    ---

    ---

  • Commonly used techniques to reserve (memory) for local variables:

    Method reserves (= designate) a specific register to "represent" a specific local variable This method will only work when there are a few simple (= non-arrays or objets) local variables This method does not work when there are too many local variables or for arrays or objects as local variables Method reserves (= allocate) memory on the system stack to store the value of a specific local variable This method will always work !!!

    I will discuss method 1 next

    Method 2 will be discussed after later.