Wednesday, October 17, 2012

Size: px

Start display at page:

Download "Wednesday, October 17, 2012"

Magdalene Foster
6 years ago
Views:

1 Wednesday, October 17, 2012 Topics for today Arrays and Indexed Addressing Arrays as parameters of functions Multi-dimensional arrays Indexed branching Implementation of switch statement Arrays as parameters of functions We need to be able to translate functions that have arrays as parameters. This is not such a big leap because we already know how to pass scalars by reference and we can think of a scalar as being an array of size 1. When we pass an array as parameter we pass its address on the stack. Separately, we typically have to pass its size (or at least the number of elements we need to process). This is what we have to do in most high-level languages also. For example, here is a C function for adding up the first N elements of an array. int sum (int V[], int N) { int j,temp = 0; for (j=0; j<n; j++) temp += V[j]; } return temp; If we have int T[320]; global array then the following are typical calls of sum total = sum(t,60); // address of array and number of elements to process all = sum(t,320); first = sum(t,1); Comp 162 Notes Page 1 of 14 October 17, 2012

2 Here is the call sum(t,60) in Pep/8 subsp 2,i ; for returned value subsp 4,i ; for parameters; lda T,i ; address of array sta 0,s ; is the first parameter lda 60,i ; count of elements sta 2,s ; is the second parameter call sum After sum creates space for local variables j and temp, the stack looks like j temp Return Address For return value To access the elements of the array parameter combines two ideas we have already seen - deferred addressing (we saw this when looking at "pass by reference") and indexing (we saw this when accessing global arrays). The body of our function is for (j=0; j<n; j++) temp += V[j]; The assignment to temp translates to ldx 0,s ; the local variable j in index register lda 2,s ; temp in Reg. A aslx ; index converted to byte offset adda 6,sxf ; add V[j] sta 2,s ; update temp The new mode (,sxf) is stack-indexed deferred. The operand is memory[ memory [operand + SP] + register X ] Comp 162 Notes Page 2 of 14 October 17, 2012

3 It is used when the stack contains a pointer to an array. The operand indicates how far down the stack the pointer to the array is. The contents of Register X are used (as usual) to index within the array. Thus in the case of adda 6,sxf We are accessing the array that is pointed to from the word 6 bytes down from the top of the stack (below the local variables and return address) and using register X to select a particular element within the array, that is memory[ memory [6 + SP] + register X ] As far as our function sum is concerned it makes no difference whether the array being passed is global or local as long as the stack contains a pointer to the place where the array is stored. In the former case the array is stored in the global area in the latter case it is stored on the stack but in each case we are just passing an address. More on arrays as parameters Here is an example of a call where the parameter is a local array void A() { int numbers[10]; int X,Y,Z; } X = sum(numbers,10); The only difference between this and the previous example is the calling environment and how the pointer to the array is figured out. Here is this call of sum in Pep/8 movspa ; save address of top of stack subsp 2,i ; for returned value subsp 4,i ; for parameters adda 6,i ; address of array numbers is 6 greater than old top of ; stack i.e. beyond space for X, Y and Z sta 0,s ; array parameter lda 10,i sta 2,s ; size parameter call sum Comp 162 Notes Page 3 of 14 October 17, 2012

4 Pictorially: Pointer to numbers (2 bytes) 10 (2 bytes) 00 0A Space for returned value (2 bytes) Z (2 bytes) Saved SP value Y (2 bytes) X (2 bytes) Array numbers (not all shown) (20 bytes) Finally, here are two examples of C array-processing functions translated into Pep/8. Example 1: copies N elements from one array to another. C void copy (int ar[1], int ar2[], int N) { int i; for (i=0; i<n; i++) ar2[i] = ar1[i]; } Comp 162 Notes Page 4 of 14 October 17, 2012

5 Pep/8 Local: i Ret. Addr.... N... The same value of register X is used to access both arrays so the Pep/8 is relatively straightforward copy: subsp 2,i ; for i ldx 0,i stx 0,s ; initialized to 0 top: cpx 8,s ; i<n? brge done ; no, we are finished aslx ; convert to byte offset lda 4,sxf ; ar1[i] sta 6,sxf ; ar2[i] = ar1[i] asrx ; convert back to index addx 1,i br top done: ret2 Example 2: partial sort of an N-element array. The function partsort makes a pass through the array exchanging out-of-order neighbors. C void partsort(int ar[], int N) { int i,temp; } for (i=0; i<n-1; i++) if (ar[i]>ar[i+1]) { temp = ar[i]; ar[i]=ar[i+1]; ar[i+1]=temp; } Comp 162 Notes Page 5 of 14 October 17, 2012

6 Pep/8 Version 1 Local: temp Local: i Ret. Addr N... The relevant part of our example is the if statement which, given the stack above, translates to ldx 2,s aslx lda 6,sxf addx 2,i cpa 6,sxf brle skip sta 0,s lda 6,sxf subx 2,i sta 6,sxf lda 0,s addx 2,i sta 6,sxf skip: ; i ; as byte offset ; ar[i] ; compare with ar[i+1] ; skip if no swap ; temp = ar[i] ; ar[i+1] ; ar[i] = ar[i+1] ; temp ; ar[i+1] = temp Note that three instructions just change the value in Register X. (This is a consequence of Pep/8 having only a single index register.) One way to eliminate these changes (and thus make the program run faster) is to have a second pointer to the array. The pointer is stored in the scratch space above the top of the stack and points not to the first element of the array but to the second thus: Comp 162 Notes Page 6 of 14 October 17, 2012

7 Pep/8 Version 2 Local: temp.local: i Ret. Addr N... Setting up the pointer is straightforward: lda 6,s adda 2,i sta -2,s Now the code for the if statement is shorter skip: ldx 2,s ; i aslx ; as byte offset lda 6,sxf ; ar[i] cpa -2,sxf ; compare with ar[i+1] brle skip ; skip if no swap sta 0,s ; temp = ar[i] lda -2,sxf ; ar[i+1] sta 6,sxf ; ar[i] = ar[i+1] lda 0,s ; temp sta -2,sxf ; ar[i+1] = temp We have added three instructions at the top of the subroutine to set up the pointer but shorted the then part of the if statement by three instructions. So the space required by this version of the subroutine is the same as the earlier one. However, if the array is large and many swaps are made we would expect our new version to run faster. Comp 162 Notes Page 7 of 14 October 17, 2012

8 Storage and manipulation of multi-dimensional arrays We need multi-dimensional arrays for representing matrices, chessboards, spreadsheets, timetables and so on. There are two main ways in which we can organize their storage. There is somewhat of a trade-off between space and time Option A: single contiguous block Store the array elements systematically in a single block either row-by-row or column-by-column. Suppose our array is declared as follows Values: array[1..3, 2..5] of integer; [ Some languages, e.g., Pascal, let us have non-zero lower bounds.] The contents are Row-by-row it is stored Column-by-column it is stored What is the address of element Values[i,j] (given that both i and j are in bounds)? For our example: Row-by-row mapping: the element is found at Values + 2 * ( (i-1) * 4 + (j-2)) [ In general at : Base-address + element-size * ((row_number row_lower_bound) * row_size + column_number - column_lower_bound) ] Column-by-column mapping: the element is found at Values + 2 * ((j-2) * 3 + (i-1)) For example, Values[3,4] is at M+20 in a row-by-row mapping and at M+16 in a column-bycolumn mapping. Comp 162 Notes Page 8 of 14 October 17, 2012

9 Many systems will store and access multi-dimensional arrays in this way because a MULTIPLY instruction is usually available to compute element addresses. But MULTIPLY is often a timeconsuming operation and some machines (e.g. Pep/8) may not have a multiply instruction so we need to look at another way to store and access multi-dimensional arrays. Option B: using Iliffe vectors We can devise a storage scheme that uses pointers instead of multiplication. Access may be faster than the multiply method although requiring more space (another example of trading time for space). Assume we store the array row by row (ideas are similar if it is stored column by column). Our method works by using an array of pointers to the array. This array of pointers is called an Iliffe vector (after J. K. Iliffe who proposed its use). Each pointer in the Iliffe vector points to the beginning of a row of the actual array. We label the Iliffe vector with the name of the array. In the following depiction of our array Values stored in this way we assume that the actual array starts at location 600 and the Iliffe vector starts at location 300. Note that there is no requirement for the rows to be adjacent in memory or even the same size. Values Comp 162 Notes Page 9 of 14 October 17, 2012

10 Now the Pep/8 code to implement is K = Values[Row,Col] ldx Row,d ; the row number sbx 1,i ; the row lower bound aslx ; make a byte offset ldx Values,x ; get element from array of pointers and put in Reg. X ; this is pointer to row Row addx Col,d ; add 2 times addx Col,d ; Col subx 4,i ; and subtract 2* column lower bound ; so reg X now has address of element we need lda 0,x ; get the element sta K,d ; and assign to K Here is a trace of Register X values for Row=3, Col=4 Reg. X 3 ldx Row,d ; the row number 2 sbx 1,i ; the row lower bound 4 aslx ; as byte offset 616 ldx Values,x ; get element from array of pointers and put in Reg. X ; this is pointer to row Row 620 addx Col,d ; add 2 times 624 addx Col,d ; Col 620 subx 4,i ; and subtract 2* column lower bound ; so reg X now has address of element we need 30 ldx 0,x ; get the element stx K,d ; and assign to K C uses this method to store arrays. Advantages of the pointer method compared with the multiplication method include: (1) may be faster (2) storage for different rows of the actual array need not be adjacent (3) rows need not be the same length! Can have triangular and irregular arrays. We can extend the technique to higher number of dimensions with additional Iliffe vectors. Comp 162 Notes Page 10 of 14 October 17, 2012

11 Array bound checking Adding bound checking to either the multiplication method or the pointer-based method typically adds three or more instructions per dimension for each array access. The Option B code with checking added in bold is ldx Row,d ; the row number cpx MinRow ; the row lower bound brlt Error cpx MaxRow ; the row upper bound brgt Error sbx 1,i ; the row lower bound aslx ; as byte offset ldx M,x ; get element from array of pointers and put in Reg. X ; this is pointer to row Row lda Col,d cpa MinCol ; column lower bound brlt Error ; if Col < lower bound cpa MaxCol brgt Error ; if Col > upper bound addx Col,d ; add 2 times addx Col,d ; subx 4,i ; subtract twice lower bound ; so reg X now has address of element we need lda 0,x ; get the element sta K,d ; and assign to K Because it makes the program larger and slower, perhaps bound checking should be a compiler option. Indexed branching It turns out that arrays are useful in translating other language constructs, the case/switch statement for example. Note that when we write BR LAB we mean BR LAB,i (the assembler lets us omit the,i for readability). From the table of Pep/8 instructions (e.g., inside front cover) we see that it is also possible to write branches using indexing as in BR tab,x Q: What it the effect and why is it useful? A: The effect is to jump to whatever address is stored in Mem[tab+register X]. This means we can set up a table of addresses then branch quickly to any one of them based on the Comp 162 Notes Page 11 of 14 October 17, 2012

12 value in Register X. This is one way to implement a multi-way branch, e.g. a switch/case statement. Warford has an example of a switch statement translation (Fig. 6.40)), here is a more general one: switch(w) { case 13: case 16: < action 1 > break; case 14: < action 2 > break; case 11: < action 3 > break; default: < action 4 > } The implementation of a switch statement in Pep/8 has three components (1) implementations of the actions, with labels. Each action should end with a branch to take program control to whatever statement follows the end of the switch statement. (2) A table containing the labels of the action sections. Table[k] contains the label of the action we should take when the switch variable has value k or, more generally, k+constant. (3) A driver section to implement the branch. Here is an implementation of the example above. Part 1 - the actions action1:... ; code for whatever action 1 does goes here... br endsw ; this branch to stop us falling into action 2 action2:... ; other actions are similar... br endsw action3: br endsw action4: br endsw Comp 162 Notes Page 12 of 14 October 17, 2012

13 Part 2 - the table The.addrss directive in Pep/8 is similar to.word. Both have the effect of initializing a two-byte location with a value known at assembly time. Since we are storing addresses, we choose to use.addrss. In our example, if the switch variable has value 12 or 15 we go to the default case. swtab:.addrss action3 ; case 11.addrss action4 ; case 12.addrss action1 ; case 13.addrss action2 ; case 14.addrss action4 ; case 15.addrss action1 ; case 16 Part 3 - the driver section ldx w,d ; the switch variable cpx 11,i ; less than the lowest switch case? brlt action4 ; yes do the default case cpx 16,i ; greater then the highest switch case? brgt action4 ; yes do the default case subx 11,i ; to get X in range of array indexes: 0.. aslx ; to make into offset for table of (2-byte) addresses br swtab,x ; jump to one of the actions endsw:... ; go here after each case Clearly this approach would not be a good one in all instances. What if the switch statement were switch(w) { case 1: < action 1 > case 100: < action 2 > case 1000: < action 3 > default: < action 4 > } The array in this case would be very large and almost all the entries would point to the default case. In this instance it would be better to implement the switch statement as a sequence of test-andbranch statements. A compiler will apply some internal check to the case labels to decide which implementation to use. Comp 162 Notes Page 13 of 14 October 17, 2012

14 Indexed subroutine calls Note that CALL tab,x is also legal so we can set up a table of subroutine addresses and jump to one depending on the value on register X then return to the instruction following the CALL. This might be a good way to implement a menu-driven program. Something like the following perhaps main: stro prompt,d ; output a prompt deci choice,d ; get user selection brne act ; assume entering zero means stop stop ; act: ldx choice,d ; action number aslx ; subroutine addresses are 2 bytes call options,x ; use table of subroutine addresses br main ; then get next choice ; options:.word 0 ; never executed corresponds to option 0 = stop.address sub1 ; sub1 to be called if user enters 1.address sub2 ; sub2 to be called if user enters 2 and so on Reading We have reached p We will look at section 6.5 and implementation of structures next.. Comp 162 Notes Page 14 of 14 October 17, 2012

Monday, October 24, 2016

Monday, October 24, 2016 Topics for today Arrays and Indexed Addressing Arrays as parameters of functions Multi-dimensional arrays Option A: Space-minimal solution Option B: Iliffe vectors Array bound