Wednesday, September 27, 2017

Transcription

1 Wednesday, September 27, 2017 Topics for today Chapter 6: Mapping High-level to assembly-level The Pep/9 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/9 run-time stack (Section 6.1) The Pep/9 run-time stack is at the high end of the memory allocated to the user (see e.g., Fig. 4.41). This is to minimize the possibility that when the stack grows it runs into the user program. 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 3 Push 7 Pop Push 4 Push 9 Pop Comp 162 Notes Page 1 of 10 September 27, 2017

2 Stack in Pep/9 The Pep/9 stack plays a large part in non-trivial assembly code programs - those with subroutine calls. The Pep/9 stack is used for: - storing local variables - remembering a return address when a subroutine is called - passing parameters into subroutines - returning values from subroutines - scratch space We do not (usually) need to know the actual memory address of any item in the stack because we can access them using stack-relative addressing. So far, we have seen two of Pep/9 s eight addressing modes: Direct addressing: E.g. ldwa 3,d ; load contents of address 3 (and 4) into register A Immediate addressing: E.g. ldwa 3,i ; load the number 3 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 example of the locals in the main program function). Stack-relative addressing E.g. ldwa 3,s loads into register A the word that begins at memory[ SP + 3] that is, loads the word that starts three bytes down from the top of the stack If the bytes of the stack (in hex) are Comp 162 Notes Page 2 of 10 September 27, 2017

3 A7 SP E 4C then after the load instruction, register A contains 7E4C. Similarly, loads 1355 into Register X. ldwx 1,s The number before,s can be negative allowing us to access locations above the stack pointer. There are various reasons why we might want to do that see later. Note that the Pep/9 stack grows upwards towards address zero (000016) so items that are in the middle of the stack have larger addresses than the item at the top of the stack. You may have encountered the stack Abstract Data Type (ADT) in a data structures class. In the case of the stack ADT we are only permitted to access the top of the stack using POP and PUSH operations to remove or add items respectively. At the assembly language level we may need to be able to quickly access items stored within the stack; stack relative addressing lets us do that. Changing the size of the stack Some instructions (see later) change the size of the stack (the value in SP) as a side effect of their actions (think pop and push). In addition, there are two instructions that let us directly manipulate the SP register. We use these two instructions to allocate and deallocate space on the stack. ADDSP - add to SP, i.e. move SP away from zero so make the stack smaller SUBSP - subtract from SP, i.e. move the SP towards zero so make the stack bigger. [Note that Pep/9 does not really need two different instructions. For example, ] SUBSP 6,i ADDSP -6,i Comp 162 Notes Page 3 of 10 September 27, 2017

4 Stack trace question. What does the stack look like after the following sequence? subsp 5,i ldwa 0x9876,i ldwx 0x1234,i stwa 2,s stwx 3,s adda 1,i addsp 4,i stba -4,s Answer 77?? Preview of stack operations During the course of Chapter 6 we will look at the various ways in which the stack is used. Here is a preview of some of them don t worry yet about the details. (1) Stack used as scratch space We can use the stack as temporary space without changing SP. In the following code we input three numbers then output them in reverse order. deci -2,s deci -4,s deci -6,s deco -6,s deco -4,s deco -2,s Technically we are not using the stack but the area above it. This is usually a safe thing to do and avoids having to declare variables to hold temporary values. Comp 162 Notes Page 4 of 10 September 27, 2017

5 (2) Stack contains local variables In the following example C program there are global variables (a,b and c) that can be accessed anywhere variables local to test (p,q and r) that can accessed only from inside test variables local to main (x, y and z) that can be accessed only 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 x,y,z; test(); // x, y and z are local to main // calling test When a function is called, we have to allocate bytes on the stack for its local variables (if any) and adopt some convention about which location corresponds to which variable. For example, here is how the stack might look as the program runs. On entry to a function (main or test) we allocate space for the local variables. When we exit 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. z y x RA z y x r q p RA z y x Initially Main starts Main calls test Test running Test finishes Main resumes End RA z y x z y x Comp 162 Notes Page 5 of 10 September 27, 2017

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 really a function, this might be translated into Pep/9 assembly code as br main A:.block 2 B:.block 2 main: subsp 6,i ; allocate stack space for C, D and E ldwa 4,s ; C adda 2,s ; D stwa 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 really 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 normally critically important that we tidy up the stack before exiting - more later. The following run of a C program illustrates that in at least one environment, when we allocate space for local variables we get whatever values are in those locations last time they were used. If no other function calls intervene then we might find values left over from the previous call of one of our functions. #include <stdio.h> void test() int A,B,C; printf("%d %d %d\n",a,b,c); // print initial contents of locals A=1; B=2; C=3; printf("%d %d %d\n",a,b,c); int main() test(); test(); Comp 162 Notes Page 6 of 10 September 27, 2017

7 The program output shows that the first time test was called, the initial values of the local variables were garbage but the second time, the space still had the numbers left there by the first call. ~$./a.out Here is a summary of some differences between local variables and global variables as commonly implemented in Pep/9. Globals Locals Declaration using.block,.word,.byte allocated space on the stack dynamically Accessibility anywhere in the program. In theory, only while appropriate function is active (space goes away on exit from the function) Referenced by identifier stack-relative addressing Initialization by.word,.byte,.ascii at load time. by assignment of values at run-time (3) Return addresses, passed parameters and return values Suppose we have the Pep/9 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) Comp 162 Notes Page 7 of 10 September 27, 2017

8 then during the execution of the function, 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 by functionname (P and Q could be the other way round; D and E could be the other way round). We will look later at many examples of translations of C functions into Pep/9 (including recursive ones!). The stack is a shared memory 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/9) next week but Section 6.3 is tricky so read slowly. Comp 162 Notes Page 8 of 10 September 27, 2017

9 Review Questions 1. If this diagram represents the top of the stack 32 4F E What number does the following instruction put in Register A? ldwa 1,s 2. If register A contains ABCD 16 which byte in the stack of Q1 changes and what is the new value when the following instruction is executed? stba 3,s 3. Consider the following two sequences of instructions subsp 4,i deci -4,s deci 0,s deci -2,s deci 2,s subsp 4,i Do they have the same net effect on memory and the SP register? 4. Consider the diagram from earlier 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 by functionname Which of these 6 spaces is always the same size and how big is it? 5. If E and Q are char and D and P are int and the function returns a char, how much total space is needed for the 6 items in the diagram? Comp 162 Notes Page 9 of 10 September 27, 2017

10 Review Answers 1. 4F is changed to CD 3. Yes. 4. The return address is always 2 bytes bytes ( ) Comp 162 Notes Page 10 of 10 September 27, 2017