Monday, September 28, 2015

Transcription

1 Monda, September 28, 2015 Topics for toda Chapter 6: Mapping High-level to assembl-level The Pep/8 run-time stack (6.1) Stack-relative addressing (,s) SP manipulation Stack as scratch space Global variables and local variables Parameter passing and return values The Pep/8 run-time stack (Section 6.1) The Pep/8 run-time stack is at the high end of the memor allocated to the user (see e.g., Fig. 4.9). This is to minimie the possibilit that the stack runs into the user program as it grows. The stack pointer register (SP) holds the address of the top item of the stack. Stacks in general The stack data structure is sometimes referred to as a Last-in First-out queue (or First-In, Lastout) meaning that the last item put into the stack is the first one to be removed. Think of a stack of books or a stack of plates. The push operation adds an item to the stack (at the top) and the pop operation removes the top item Push Push 7 Pop Push 4 Push 9 Pop Comp 162 Notes Page 1 of 7 September 28, 2015

2 Stack in Pep/8 The Pep/8 stack plas a large part in non-trivial assembl code programs - those with function/subroutine calls. The Pep/8 stack is used for: - storing local variables - remembering a return address when a subroutine is called - passing parameters into - returning values from functions - scratch space We do not (usuall) need to know the actual memor address of an item in the stack because we can access them using stack-relative addressing. So far, we have seen two of Pep/8 s eight addressing modes: Direct addressing: E.g. lda,d ; load contents of address (and 4) into register A Immediate addressing: E.g. lda,i ; load the number into register A In section 6.1, Warford introduces the third addressing mode (stack-relative addressing) and shows how the stack is used in providing space for local variables (he uses the eample of the locals in the main program function). Stack-relative addressing E.g. lda,s loads into register A the word that begins at memor[ SP + ] that is, loads the word that starts three btes down from the top of the stack If the btes of the stack (in he) are Comp 162 Notes Page 2 of 7 September 28, 2015

3 A7 SP E 4C then after the load instruction, register A contains 7E4C. Similarl, loads 155 into Register X. ld 1,s The number before,s can be negative allowing us to access locations above the stack pointer. There are various reasons wh we might want to do that see later. Note that the Pep/8 stack grows upwards towards address ero so items that are in the middle of the stack have larger addresses than the item at the top of the stack. You ma have encountered the stack Abstract Data Tpe (ADT) in a data structures class. In the case of the stack ADT we are onl permitted to access the top of the stack using POP and PUSH operations to remove or add items respectivel. At the assembl language level we ma need to be able to quickl access items stored within the stack and stack relative addressing lets us do that. Changing the sie of the stack Some instructions (see later) change the sie of the stack, and the value in SP, as a side effect of their actions (think pop and push). In addition, there are two instructions that let us directl manipulate the SP register. Using these two instructions is how we allocate and deallocate space on the stack. ADDSP - add to SP, i.e. move SP awa from ero so make the stack smaller SUBSP - subtract from SP, i.e. move the SP towards ero so make the stack bigger. [Note that Pep/8 does not reall need two different instructions. For eample, ] SUBSP 6,i ADDSP -6,i Comp 162 Notes Page of 7 September 28, 2015

4 Stack trace question. What does the stack look like after. subsp 5,i lda 09876,i ld 0124,i sta 2,s st,s adda 1,i addsp 4,i stbtea -4,s Answer 77?? Preview of stack operations During the course of Chapter 6 we will look at the various was in which the stack is used but here is a preview of some of them don t worr about the details. Stack as scratch space We can use the stack as temporar space without changing SP. In the following code we input three numbers then output them in the reverse order deci -2,s deci -4,s deci -6,s deco -6,s deco -4,s deco -2,s Technicall we are not using the stack but the area above it. This is usuall a prett safe thing to do. This avoids having to declare variables to hold the numbers. Comp 162 Notes Page 4 of 7 September 28, 2015

5 Local variables In the following eample C program there are global variables (a,b and c) that can be accessed anwhere variables local to test (p,q and r) that can accessed onl from inside test variables local to main (, and ) that can be accessed onl from inside main. #include <stdio.h> int a,b,c; test() int p,q,r; // these are globals // p, q and r are local to test main () int,,; test(); //, and are local to main // calling test When a function is called, we have to allocate btes on the stack for its local variables (if an) and adopt some convention about which location corresponds to which variable. For eample, here is how the stack might look as the program runs. On entr to a function (main or test) we allocate space for the local variables. When we eit from the call of a function we deallocate this space. In addition, we have the space for the return address (RA) that lets us return to the correct location in main when we have finished the call of test. RA r q p RA Initiall Main starts Main calls test Test running Test finishes Main resumes End RA Comp 162 Notes Page 5 of 7 September 28, 2015

6 Consider the following C program #include <stdio.h> int A,B; int main() int C,D,E; A = C+D; Ignoring for the moment the fact that main is reall a function, this might be translated into Pep/8 assembl code as br main A:.block 2 B:.block 2 main: subsp 6,i ; allocate stack space for C, D and E lda 4,s ; C adda 2,s ; D sta A,d addsp 6,i stop.end ; end of main so finished with C, D and E At the end of the "main" function it does not reall matter if we deallocate the stack space allocated at the beginning of main because the program is about to terminate. However, in the case of all other functions it is normall criticall important that we tid up the stack before eiting - more later. Here is a summar of the differences between local variables and global variables. Globals Locals Declaration using.block,.word,.bte allocated space on the stack dnamicall Accessibilit anwhere in the program. In theor, onl while appropriate function is active (space goes awa on eit from the function) Referenced b identifier stack-relative addressing Comp 162 Notes Page 6 of 7 September 28, 2015

7 Parameter passing and returning values Suppose we have the Pep/8 equivalent of the following C function int functionname (int B, int C) int D, E; *** and it is being called as follows W = functionname(p,q) then during the eecution of function A (e.g. at the point marked ***) the topmost locations on the stack can be depicted Space for local variable D Space for local variable E Address to return to when function terminates Value of parameter P Value of parameter Q Space for the value returned b functionname (P and Q could be the other wa round; D and E could be the other wa round). We will look later at man eamples of translations of C functions into Pep/8 (including recursive ones!). The stack is a shared memor location that lets information (parameter values) be passed from main program to subprogram and information (returned value) be passed from subprogram to main program Reading. Section 6.1. We will begin looking at functions (C) and subroutines (Pep/8) net week but Section 6. is trick so read slowl. Comp 162 Notes Page 7 of 7 September 28, 2015