Wednesday, February 19, 2014

Transcription

1 Wednesda, Februar 19, 2014 Topics for toda Solutions to HW #2 Topics for Eam #1 Chapter 6: Mapping High-level to assembl-level The Pep/8 run-time stack Stack-relative addressing (,s) SP manipulation Stack as scratch space Global variables and local variables Parameter passing and return values Solutions to Homework #2 1. (a) 360 * 10 * 180 * 10 = Need 23 bits 2 23 = (b) ( 23 * 2 12 * 24 ) / 8 = btes/da.. So, 1 megabte? 2. (a) Smbol Code A ** B ** C *** D *** F *** WU **** I **** (b) (i) 2.57 * 20,000 = 51,400 (ii) 3 * 20,000 = 60,000 Comp 162 Notes Page 1 of 9 Februar 19, 2014

2 3. Machine Code Instruction (he) E C Opcode (binar) Uses register? If so, which Includes addressing mode? If so, which 1110 Yes, X 001 = direct No 000 = immediate Yes, A No F1F2F3 06FC Yes, A 001 = direct No 0 = immediate btes for program (from chapter 4) = btes available for instructions X * X * 3 = X = Largest X is No. Onl if the base is even. Possible topics for Eam #1 include: Simple C programming arras, loops Logical and arithmetic operations Headecimal and octal representation Encoding (including Huffman codes) Number conversion Pep/8 instructions Comp 162 Notes Page 2 of 9 Februar 19, 2014

3 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.39). This is to minimize 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 3 Push 7 Pop Push 4 Push 9 Pop 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 function is called - passing parameters into functions - 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: Comp 162 Notes Page 3 of 9 Februar 19, 2014

4 Direct addressing: E.g. lda 3,d ; load contents of address 3 (and 4) into register A Immediate addressing: E.g. lda 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 eample of the main program function). Stack-relative addressing E.g. lda 3,s loads into register A the word that begins at memor[ SP + 3] that is, loads the word that starts three btes down from the top of the stack If the stack contents are A7 SP E 4C then after the load instruction, register A contains 7E4C. Similarl, loads 1355 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. Note that the Pep/8 stack grows upwards towards address zero 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 Comp 162 Notes Page 4 of 9 Februar 19, 2014

5 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 size of the stack Some instructions (see later) change the size of the stack 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 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/8 does not reall need two instructions. For eample, ] SUBSP 6,i ADDSP -6,i Stack trace question. What does the stack look like after. subsp 5,i lda 09876,i ld 01234,i sta 2,s st 3,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. Comp 162 Notes Page 5 of 9 Februar 19, 2014

6 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. 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 z) 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,,z; test(); //, and z 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. Comp 162 Notes Page 6 of 9 Februar 19, 2014

7 z RA z r q p RA z Initiall Main starts Main calls test Test running Test finishes Main resumes End RA z z 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 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 spacee 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. Comp 162 Notes Page 7 of 9 Februar 19, 2014

8 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 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 Comp 162 Notes Page 8 of 9 Februar 19, 2014

9 (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.3 is trick so read slowl. Comp 162 Notes Page 9 of 9 Februar 19, 2014