---

A skeletal example on storing parameters and local variables in the program stack

---

• Introduction
  • Previously, I have shown you that due to the event sequence in a function call with parameters:

    The caller will use this sequence of instructions to pass parameters to a function: How to pass parameters using the stack to a function: (1) push params (in reverse order) (2) bl function (3) clean up parameters on stack The called function will use these sequences of instructions to build its stack frame and break down its stack frame: /* --------------------------------- Prelude code: build stack frame --------------------------------- */ push {lr} // Save return address push {fp} // Save old FP mov fp, sp // Initial function's own FP sub sp, sp, #N // Allocate N bytes on stack for local vars /* ------------------------------------------- Postlude code: break down the stack frame and return to caller ------------------------------------------- */ mov sp, fp // De-allocate stack space of local vars pop {fp} // Restore old FP pop {pc} // Return to caller

    In this webpage, I want to show you the effect of these sequence of instructions and their effect on the program stack with 3 examples

  ---

  ---

  ---

  ---

• Example 1: one function call
  • In example 1, I will show you what happens inside the computer system when:

    main( ) { Calls a function A and passes 2 parameters to A. In Java, this would be written as: A(1111,2222) } A( int a, int b ) { A( ) has 3 local variables. In Java, you would write: int x, y, z; // Define 3 local vars return(9999); // A( ) always returns 9999 }

    I will only show you how the parameters and local variables are stored in the program stack

    The assembler code is as follows:

    main: mov r0, #2222 // Pass 2222 as parameter 2 on stack push {r0} mov r0, #1111 // Pass 1111 as parameter 1 on stack push {r0} bl A // Call function A add sp, sp, #8 // Clean up parameters on the stack // When A returns, you will see the return value in r0 = 9999 nop nop Stop: nop /* ============================================== Function A: param and locals in stack ============================================== */ A: // When run in EGTAPI - you will see {1111, 2222} on stack /* **************************************** Prelude: build stack frame **************************************** */ push {lr} // Save return address in LR push {fp} // Save Frame Pointer in FP mov fp, sp // Initialize my own FP sub sp, sp, #12 // I create 3 local variable in stack nop // These instructions in A( ) can use stack nop // to access parameters and local variables /* ==================================================== We can use a register to return the return value ==================================================== */ mov r0, #9999 // Pass return value in register r0 /* ************************************************ Postlude: break down stack frame ************************************************ */ mov sp, fp // De-allocate the local variables pop {fp} // Restore old FP pop {pc} // Return

    I will show this example in class and also highlight the effect of the instructions

    What you should notice is:

    Before main( ) calls A( ), the program stack is empty After A( ) finishes building the stack frame, the stack frame has this structure: During the execution of method A( ), we can access the parameters and local variable in the program stack using an offset from the base address in register FP !!! (We will learn how to do this below) Before main( ) has clean up the parameters in the program stack, the program stack is empty again !!! (That's what we want !!! We do not want to leave any garbage on the program stack !!!)

    ---

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

    How to run the program:

    To compile:   as255 skel-stack          To run: use EGTAPI

  ---

  ---

  ---

  ---

• Example 2: back-to-back function calls
  • In example 2, I will show you what happens inside the computer system when main( ) calls A( ) and then A( ) calls B( ) -- both calls use the program stack:

    main( ) { A(1111,2222) } A( int a, int b ) { int x, y, z; // Define 3 local vars B(3333,4444,5555); return(9999); } B( int a, int b, int c ) { int x, y; // Define 2 local vars return(8888); }

    I will only show you how the parameters and local variables are stored in the program stack

    The assembler code is as follows:

    main: mov r0, #2222 // Pass 2222 as parameter 2 on stack push {r0} mov r0, #1111 // Pass 1111 as parameter 1 on stack push {r0} bl A // Call function A add sp, sp, #8 // Clean up parameters on the stack // When A returns, you will see the return value in r0 = 9999 nop nop Stop: nop /* ============================================== Function A: param and locals in stack ============================================== */ A: // When run in EGTAPI - you will see {1111, 2222} on stack /* **************************************** Prelude: build stack frame **************************************** */ push {lr} // Save return address in LR push {fp} // Save Frame Pointer in FP mov fp, sp // Initialize my own FP sub sp, sp, #12 // I create 3 local variable in stack nop // These instructions in A( ) can use stack nop // to access parameters and local variables /* ========================================= Call B( ) with 3 parameters ========================================= */ mov r0, #5555 // Pass 5555 as parameter 3 on stack push {r0} mov r0, #4444 // Pass 4444 as parameter 2 on stack push {r0} mov r0, #3333 // Pass 3333 as parameter 1 on stack push {r0} bl B // Call function B add sp, sp, #12 // Clean up parameters on the stack nop // We are back in A( ) nop // We will now return to main( ) /* ==================================================== We can use a register to return the return value ==================================================== */ mov r0, #9999 // Pass return value in register r0 /* ************************************************ Postlude: break down stack frame ************************************************ */ mov sp, fp // De-allocate the local variables pop {fp} // Restore old FP pop {pc} // Return

    I will show this example in class and also highlight the effect of the instructions

    What you should notice is:

    Before main( ) calls A( ), the program stack is empty After A( ) finishes building the stack frame, the stack frame has this structure: During the execution of method A( ), we can access the A( )'s parameters and A( )'s local variable in the program stack using an offset from the base address in register FP !!! (We will learn how to do this below) After B( ) finishes building the stack frame, the stack frame has this structure: During the execution of method A( ), we can access the B( )'s parameters and B( )'s local variable in the program stack using an offset from the base address in register FP !!! (We will learn how to do this below) After B( ) has returned and A( ) has cleaned up the parameters in the program stack, the program stack is restored back to: When method A( ) continues, we can access the A( )'s parameters and A( )'s local variable in the program stack using an offset from the base address in register FP !!! (That's what we want !!! We must be able to continue with the execution of A( ) after the method call B( ) completes !!! After main( ) has clean up the parameters in the program stack, the program stack is empty again !!! (That's what we want !!! We do not want to leave any garbage on the program stack !!!)

    ---

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

    How to run the program:

    To compile:   as255 skel-stack2          To run: use EGTAPI

  ---

  ---

  ---

  ---

• Example 3: shows you how to access the parameters and local variables using an offset from the FP register
  • If you realize that throughout the execution of the A( ) method (even when A( ) calls another method B( ), the stack frame always has this structure:

    Then you can easily understand that you access the parameters and local variables with these offsets:

    ---

    ---

  • Here is a demo program that show you how to set:

    localVar1 = param1; localVar2 = param2; localVar3 = param1 + param2;

    Example:

    main: mov r0, #2222 // Pass 2222 as parameter 2 on stack push {r0} mov r0, #1111 // Pass 1111 as parameter 1 on stack push {r0} bl A // Call function A add sp, sp, #8 // Clean up parameters on the stack // When A returns, you will see the return value in r0 = 9999 nop nop Stop: nop A: // When run in EGTAPI - you will see {1111, 2222} on stack /* **************************************** Prelude: build stack frame **************************************** */ push {lr} // Save return address in LR push {fp} // Save Frame Pointer in FP mov fp, sp // Initialize my own FP sub sp, sp, #12 // I create 3 local variable in stack // How to to access parameters and local variables // stored in the program stack ldr r0, [fp, #8] // Get parameter 1 = 1111 str r0, [fp, #-12] // Store in local variable 1 ldr r1, [fp, #12] // Get parameter 2 = 2222 str r1, [fp, #-8] // Store in local variable 2 add r0, r0, r1 str r0, [fp, #-4] // Store sum in local variable 3 /* ================================================= We can use a register to return the return value ================================================= */ mov r0, #9999 // Pass return value in register r0 /* ************************************************ Postlude: break down stack frame ************************************************ */ mov sp, fp pop {fp} pop {pc} // Return

    ---

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

    How to run the program:

    To compile:   as255 skel-stack-access          To run: use EGTAPI