Wednesday, April 16, 2014

Size: px

Start display at page:

Download "Wednesday, April 16, 2014"

Julius Grant
5 years ago
Views:

1 Wednesday, pril 16, 2014 Topics for today Homework #5 solutions Code generation nalysis lgorithm 4: infix to tree Synthesis lgorithm 5: tree to code Optimization HW #5 solutions 1. lda 0,i ; for sum of elements ldx 510,I ; index of last element L: adda CMRIN,x ; add current element to total subx 2,i brge L ; branch if more to add asra asra asra asra asra asra asra asra ; divide total by 256 to get average sta av,d ldx 510,I ; second pass to get count L2: lda CMRIN,x cpa av,d brle skip ; branch if not greater than average lda count,d adda 1,i sta count,d ; count is incremented Skip:subx 2,i brge L2 ; branch if more to look at deco count,d stop av:.block 2 count:.word 0.end Comp 162 Notes Page 1 of 16 pril 16, 2014

2 2. ; exor ; precondition: stack,,? ; postcondition: stack,,exor(,) ; exor(,) = ( or ) and not ( and ) ; exor: ; for local sta -2,s ; save current value of Reg stx -4,s ; save current value of RegX lda 4,s ; ora 6,s ; or ; saved for later lda 4,s anda 6,s ; and nota ; not ( and ) anda 0,s ; ( or ) and not ( and ) sta 8,s ; is exor(,) = result lda -2,s ; restore register ldx -4,s ; restore register X ret2 3. Q3: lda 0,i Sta 0,s ; result initialized to zero ldx 4,s ; N aslx ; byte offset of Nth element L: lda 2,sxf ; element from array cpa 9999,i brgt add ; branch if larger than 9999 cpa -999,i brgt next ; branch if no need to bump count add: lda 6,s adda 2,i sta 6,s ; result is incremented next:subx 2,i brge L ; branch of more elements to look at ret0 Comp 162 Notes Page 2 of 16 pril 16, 2014

3 4. (a) void Q4 (int R[]) int i=15; while (i>=0 && R[i]==0) i--; if (i>=0) i--; while (i>=0) R[i]= 1-R[i]; i--; (b) negates the number Comp 162 Notes Page 3 of 16 pril 16, 2014

4 lgorithm 4: building a tree from an infix expression This algorithm is a variation on algorithm 3. It uses two stacks, one of operators and one of pointers to tree nodes. Here are the actions for the four types of symbol: Symbol ( ction put it on the operator stack with lowest possible priority ) Unstack and apply operators until "(" reached. Unstack but do not apply the "(" operand create a binary tree node with the operand as the data item and nil in the two pointer fields. Push a pointer to this node onto the operand stack operator while ( priority(top-of-operator-stack) priority(input) ) unstack and apply the top-of-operator-stack. push the input onto the operator stack t the end: unstack and apply any operators remaining on the operator stack What does "apply" an operator mean in this algorithm? It means create a binary tree node with the operator as the data item and left and right pointers containing the pointer values in the top items on the operand stack. Then pop those two items and push a pointer to the new node. For example, efore fter * 9 * Operator Operand Operator Operand Comp 162 Notes Page 4 of 16 pril 16, 2014

5 fter the expression has been read, we should get a binary expression tree pointed to from the only item left on the operand stack. Example: Expression * C D Input: Operator Stack <empty> Input: Operator Stack Comp 162 Notes Page 5 of 16 pril 16, 2014

6 Input: Operator Stack Input: * Operator Stack * Comp 162 Notes Page 6 of 16 pril 16, 2014

7 Input: C Operator Stack * C Input: Operator Stack * C Comp 162 Notes Page 7 of 16 pril 16, 2014

8 Input: D Operator Stack D * C t the end of input we unstack and apply the operators on the operator stack resulting in first. Comp 162 Notes Page 8 of 16 pril 16, 2014

9 Operator Stack D * C and finally, Operator Stack <empty> D * C Comp 162 Notes Page 9 of 16 pril 16, 2014

10 Error checking Here are some simple error checks we can add to lgorithm 4 to make it more robust 1. llowable sequences of symbols in the input Previous Symbol Current Symbol ( ) Operator Operand ( OK Error Error OK ) Error OK OK Error Operator OK Error Error OK Operand Error OK OK Error 2. Parentheses. We can maintain a counter, initially zero, that is incremented whenever we read an opening parenthesis and decremented when we read a closing one. The counter should never go negative and must be zero at the end of the input. 3. Operator. In general an operator requires n operands. In our case we just have n=2. There should be at least n items on the operand stack when we apply the operator. Next we will see how to generate assembly code from the binary tree. Comp 162 Notes Page 10 of 16 pril 16, 2014

11 Code generation lgorithm 5: generating assembly code Visiting all the nodes in a linked list is easy. We start at the beginning and move node-by-node to the end. Note that a list can be viewed as a recursive structure because it is made up of a head (the first node) and tail the rest of the list. The tail is also a list. Thus we could write a function to print a list recursively as follows: void printlist (listnode *L) if (L!= NULL) output (L->data); printlist(l->next); If we want to print the list backwards, it is quite tricky to do with iteration but a recursive solution is simple: void printlistbackwards (listnode *L) if (L!= NULL) printlistbackwards(l->next); output (L->data); binary tree can also be regarded as a recursive structure. It consists of a root node and (possibly empty) left and right sub-trees each of which in turn is a binary tree. "tree traversal" is a systematic visiting of all the nodes in a tree. Three common traversals are characterized by the order in which they visit the left and right sub-trees and the root node. Preorder: Inorder: Postorder: root, left, right left, root, right left, right, root. Comp 162 Notes Page 11 of 16 pril 16, 2014

12 The ordering is applied recursively to the sub-trees of the tree. For example if the tree is t / \ / \ w x / \ / \ / \ / \ h b a r / \ / \ j m preorder traversal visits the nodes in this order: t w h b x a r j m n inorder traversal visits the nodes in this order: h w b t a x j r m postorder traversal visits the nodes in this order: h b w a j m r x t lgorithm 5 Consider the binary expression tree that we have constructed by processing an arithmetic expression with lgorithm 4. We can traverse this tree and output appropriate instruction sequences for our target machine (in this case Pep/8). In the example that follows we assume that there is a MUL and a DIV instruction for * and / respectively. The sequence of instructions uses the Pep/8 user stack to evaluate the expression because, unlike the set of registers, this is virtually unlimited in size. For example, if the binary expression tree is X / \ / \ Y We generate ; next three lines from leaf X lda X,d ; next three lines from leaf Y lda Y,d ; next four lines from operator lda 0,s adda 2,s sta 2,s Comp 162 Notes Page 12 of 16 pril 16, 2014

13 When this sequence is executed on the Pep/8 machine we end up with the value of the expression as the top item on the Pep/8 stack. You can see from this example that the traversal we need is postorder (left, right, root). ecause the same ordering is used within subtrees, tree traversal algorithms are often recursive. This is illustrated in the following C/pseudocode function generate that outputs assembly language from a given expression tree. It assumes that the operands in the expression tree are names of global variables so it uses direct mode to reference them. void generate (treenode* T) if (T!= null) if ( T->left==NULL) /* true if node is a leaf */ printf("\n"); printf("lda %s,d\n",t->data);/* ssume T->data is name of a global */ printf("\n"); else generate(t->left); generate(t->right); printf("lda 0,s\n"); if (T->data == ) printf( DDa 2,s\n ); if (T->data == - ) printf( SUa 2,s\n ); if (T->data == * ) printf( MULa 2,s\n ); if (T->data == / ) printf( DIVa 2,s\n ); printf("sta 2,s\n"); printf("\n"); ) The tree generated from assignment X = ( C ) * ( D E ) Comp 162 Notes Page 13 of 16 pril 16, 2014

14 is = X * C D E In our implementation, because of the way that pointers in nodes are actually assigned, the code generated begins lda e,d lda d,d lda 0,s DDa 2,s sta 2,s If we substitute a call to a MUL subroutine in place of the MULr instruction then the complete sequence contains 32 instructions: 3 generated from each of the 5 leaves/operands 4 generated from each of the 3 operators 2 generated from the * operator ( call to MUL) 3 for the assignment and tidy up of stack Comp 162 Notes Page 14 of 16 pril 16, 2014

15 Optimization There is clearly scope for an optimizer to improve the code generated from lgorithm 5. Some possibilities are: (1) Removing redundant load instructions. See line 7 in the example above. (2) Combining/eliminating consecutive SP changes The translation of x=a*bc*d includes call MUL lda b,d oth changes to SP can be removed. In general, changes to SP on consecutive lines can be combined and if the net change is zero, they can be eliminated. (3) Combining SP operations with a wider view Example optimization (1) and (2) only require the optimizer to look at small sections of assembly code (perhaps two or three lines). y looking at larger sections, further savings might be possible. For example, the beginning of the translation of x=a*bc*d is lda d,d lda c,d which can be simplified to subsp 4,i lda d,d sta 2,s lda c,d Optimizations (1) and (2) have been implemented as shown in the following example. Comp 162 Notes Page 15 of 16 pril 16, 2014

16 $ codegen "x=a5*b7" $ codegen " x=a5*b7" optimizer lda 7,i lda b,d lda 5,i call MUL lda a,d lda 0,s DDa 2,s sta 2,s lda 0,s DDa 2,s sta 2,s lda 0,s sta x,d lda 7,i lda b,d lda 5,i call MUL lda a,d DDa 2,s sta 2,s lda 0,s DDa 2,s sta 2,s lda 0,s sta x,d Reading We have reached the end of Chapter 7 and will begin Chapter 8 next week. Comp 162 Notes Page 16 of 16 pril 16, 2014

Monday, April 15, We will lead up to the Analysis and Synthesis algorithms involved by first looking at three simpler ones.

Monday, April 15, We will lead up to the Analysis and Synthesis algorithms involved by first looking at three simpler ones. Monday, pril 15, 2013 Topics for today Code generation nalysis lgorithm 1: evaluation of postfix lgorithm 2: infix to postfix lgorithm 3: evaluation of infix lgorithm 4: infix to tree Synthesis lgorithm