Wednesday, November 15, 2017

Transcription

1 Wednesday, November 15, 2017 Topics for today Code generation Synthesis Algorithm 5: tree to code Optimizations Code generation Algorithm 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); A 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. A "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. Comp 162 Notes Page 1 of 10 November 15, 2017

2 Preorder: Inorder: Postorder: root, left, right left, root, right left, right, root. 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 A preorder traversal visits the nodes in this order: t w h b x a r j m An inorder traversal visits the nodes in this order: h w b t a x j r m A postorder traversal visits the nodes in this order: h b w a j m r x t Comp 162 Notes Page 2 of 10 November 15, 2017

3 Algorithm 5 Consider the binary expression tree that we have constructed by processing an arithmetic expression with Algorithm 4. We can traverse this tree and output appropriate instruction sequences for our target machine (in this case Pep/9). 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/9 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 ldwa X,d ; next three lines from leaf Y ldwa Y,d ; next four lines from operator + adda 2,s When this sequence is executed on the Pep/9 machine we end up with the value of the expression as the top item on the Pep/9 stack. You can see from this example that the traversal we need is postorder (left, right, root). Because the same ordering is used within subtrees, tree traversal algorithms are often recursive. This is illustrated in the following C function generate that outputs assembly language from a given expression tree. It assumes that nodetype is 1 for operator, 2 for an identifier and 3 for a constant subroutines MUL, DIV and EXP can be called to perform multiplication, division and exponentiation operations. Comp 162 Notes Page 3 of 10 November 15, 2017

4 void generate (TREENODE *T) if (T!= NULL) if ( T->left==NULL) // leaf printf("\n"); if (T->nodetype==2) printf("ldwa %c,d\n",t->id); else printf("ldwa %d,i\n",t->number); printf("sta 0,s\n"); else generate(t->left); generate(t->right); if (T->nodetype==1 && (T->operatorsymbol == '+' T->operatorsymbol == '-')) printf("\n"); if (T->operatorsymbol == '+') printf("\n"); if (T->operatorsymbol == '-') printf("suba 2,s\n"); printf("\n"); printf("\n"); else if (T->nodetype==1 && (T->operatorsymbol == '*' T->operatorsymbol == '/' T->operatorsymbol == '^')) if (T->operatorsymbol == '*') printf("call MUL\n"); if (T->operatorsymbol == '/') printf("call DIV\n"); if (T->operatorsymbol == '^') printf("call EXP\n"); printf("\n"); The tree generated from assignment X = A + ( B + C ) * ( D + E ) Comp 162 Notes Page 4 of 10 November 15, 2017

5 is = X + A * + + B C D E In our implementation, because of the way that pointers in nodes are actually assigned, the code generated begins ldwa e,d ldwa d,d 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 5 of 10 November 15, 2017

6 Optimization There is clearly scope for an optimizer to improve the code generated from Algorithm 5. Some possibilities are: (1) Removing redundant LOAD instructions (2) Combining (eliminating) consecutive SP changes (3) Taking a wider view of stack operations (4) Performing arithmetic at tree-build time (1) Removing redundant load instructions. Sometimes our code generator will output a LOAD from a location to which we have just issued a STORE (see line 7 in the example above). The LOAD can be eliminated. (2) Combining/eliminating consecutive SP changes The translation of x=a*b+c*d includes the following 5-line fragment call MUL ldwa b,d Both 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). By looking at larger sections, further savings might be possible. For example, the beginning of the translation of x=a*b+c*d is ldwa d,d ldwa c,d which can be simplified to subsp 4,i ldwa d,d ldwa c,d Comp 162 Notes Page 6 of 10 November 15, 2017

7 (4) When we build the tree, there may be instances in which we apply an operator to two constants. We can perform the arithmetic operation at tree build time and replace the subtree by a node containing the value. Optimizations (1) and (2) have been implemented as shown in the following example. $ codegen "x=a+5*b+7" $ codegen " x=a+5*b+7" optimizer ldwa 7,i ldwa b,d ldwa 5,i call MUL ldwa a,d stwa x,d ldwa 7,i ldwa b,d ldwa 5,i call MUL ldwa a,d stwa x,d Comp 162 Notes Page 7 of 10 November 15, 2017

8 Optimization (4) has been built in as a o option in the code-generating program 1 codegen x=y+4*6 codegen o x=y+4*6 codegen-o x=y+4*6 optimizer ldwa 6,i ldwa 4,i call MUL ldwa y,d stwa x,d ldwa 24,i ldwa y,d stwa x,d ldwa 24,i ldwa y,d stwa x,d Reading Next we will look at topics in Chapter 8. 1 int main(int argc, char* argv[]) char buffer[50], expression[50]; int idx, optimization = FALSE, goodbuild; // check for presence of optimization flag "-o" for (idx=1; idx<argc; idx++) if (strcmp(argv[idx],"-o")==0) optimization=true; Comp 162 Notes Page 8 of 10 November 15, 2017

9 Review Questions 1. Consider an expression tree and the code generated from it. What is the upper bound on the size of the stack as the code runs? 2. Consider an expression tree and the code generated from it. How can you calculate the actual maximum size of the stack when the code is run? 3. Consider an expression tree. How can we determine if the code (and the stack when it runs) will fit in memory? 4. How could you use the answer to Question 2 to, possibly, reduce further the number of instructions in the generated code? 5. What checks should be added to the section of the code generator when it performs arithmetic during tree-build and why? Comp 162 Notes Page 9 of 10 November 15, 2017

10 Review Answers 1. Count the number of operands in the tree and multiply by 2 (bytes). The highest stack would result when all operands are pushed first then the operators applied. 2. Set variable stack-height to 0. Traverse the tree in the same order as the code generator. At each operand, increase stack-height by 2 and at each operator decrease stack-height by 2. Remember highest value. 3. Calculate maximum stack as in Question 2. Code size can be summed during the tree traversal. Code-size initially 0 At each operand add 9 bytes (3 3-byte instructions). At each operator, add 12 bytes (4 3-byte instructions). Code-size plus stack-height should be less than Allocate all needed stack space at the beginning of the code and deallocate at the end. Make appropriate adjustments to the stack addressing. 5. Pep/9 is a 16-bit machine; the code generator may be running on a system with a longer word length so add checks for results outside the 16-bit range ( to 32767). Also for division by zero. Comp 162 Notes Page 10 of 10 November 15, 2017