---

Problem with using registers to pass parameters and to store local variables

---

• The problem with registers
  • Limitations of CPU registers:

    The number of CPU registers is limited Consequences: You can only pass a limited number of parameters           and        You can only have a limited number of local variables in a method The CPU registers are shared resources where different methods do not know each others reservations Consequences: Only a leaf function/method (that does not call other methods can claim exclusive use of the registers (Because a leaf method does not call other methods, it can claim the use of the registers without having to worry that other methods will destroy the value in the registers. A non-leaf method will/can not claim/use any register for parameter or local variable because when it calls another method, that method can use any registers !!!) I will illustrate this important fact with an example next

  ---

  ---

  ---

  ---

• What can go wrong if you have an important value in a register and calls a method
  • Suppose I have a method called square that computes the square of a value passed in register r0

    The square returns the square in register r0

    ---

  • Suppose we write the following program in assembler:

    result = square(3);

    The assembler code is:

    // result = square(3) /* ------------------------------------------------- Call square(3) ------------------------------------------------- */ mov r0, #3 bl square /* ------------------------------------------------- Store in result ------------------------------------------------- */ movw r1, #:lower16:result movt r1, #:upper16:result str r0, [r1]

    You can see for yourself in this demo that it works.

    ---

  • Example Program: (Demo above code)                                                
    • Prog file: /home/cs255001/demo/asm/8-sub/reg-problem.s

    How to run the program:

    To compile:   as255 reg-problem          To run: use EGTAPI

    ---

    ---

    ---

  • Now, suppose we want to write the following statement:

    result = square(3) + square(4);

    Can you tell what's wrong with this naive code:

    // result = square(3) /* ------------------------------------------------- Call square(3) ------------------------------------------------- */ mov r0, #3 bl square mov r1, r0 // Save 32 in r1 /* ------------------------------------------------- Call square(4) ------------------------------------------------- */ mov r0, #4 bl square add r0, r0, r1 // Computes 32+ 42 /* ------------------------------------------------- Store in result ------------------------------------------------- */ movw r1, #:lower16:result movt r1, #:upper16:result str r0, [r1]

    Answer:

    This naive code assumes that the square subroutine will preserve the saved value in register r1 !!! Consequently: This code will not work if the square subroutine uses register r1 in its computation

    In fact, I have written the square subroutine that it will zero out every register in ARM.

    I will change the reg-problem.s in class and run this demo to show you that this program does not compute 3²+ 4²

    ---

    We cannot solve this problem right now.... you have not learn enough techniques to do so.

    I will revisit this problem after I have discussed how to use the program stack to store parameters and local variables

  ---

  ---

  ---

  ---

• Interrupted computations
  • So when do you find that:

    You hold an important value in some register And you must make a call to a function ???

    This is always the case when you perform a computation that contain multiple function calls.

    When you perform a computation that contain multiple function calls, you must interrupt the computation process and make a function call

    ---

    ---

  • As a rule, when you have multiple function calls in an expression, such as:

    result = square(3) + square(4); ^^^^^^^^^ ^^^^^^^^^ 2 function calls in this expression

    the computation of the expression is always interrupted by a function call.

    This is because when you computes an expression that contains multiple function calls, you must:

    Make the first function call (e.g. square(3)) This function call will return a value (e.g.: square(3) = 9 in some register But: you cannot use this value (9) yet, because the other operand (e.g.: square(4) must still need to be computed with a function call You must interrupt the computation (e.g.: add) by making a function call (e.g.: square(4)) This interrupted computation can cause a big problem because The function call (e.g.: square(4)) may overwrite a value stored in any register !

    As I said, we can't solve this problem yet.

    We must first learn how to use the program stack to store things first.

    If you can't wait, the webpage that explain how to solve this problem is: click here

  ---

  ---

  ---

  ---

• Summary
  • When a non-leaf function (say: f( )) calls another function (say: g( )) :

    The function g( ) can use any register And therefore: the function g( ) can overwrite any register used by function f( )

  ---

  ---

  ---

  ---

• A better (perfectly safe) place to store parameters and local variables
  • Because the calling and return sequence of methods/functions is LIFO (Last Called function will Return First, a better (= more general) place (memory) to pass parameters and store local variables is:

    The system stack

    We will discuss this next.