CSCI565 Compiler Design

Transcription

1 CSCI565 Compiler Design Fall 2015 Homework 2 - Solution Problem 1: Attributive Grammar and Syntax-Directed Translation [30 points] In this problem you ned to develop a grammar for array variable expressions and perform checking of the type and number of indexing expressions of an array variable. You may assume that a given variable array has been previously declared along with the number of dimensions of the array. For example, if a variable a is declared as a twodimensional array of double values the array expression a[i] and a[i,j,k] are both incorrect. Your solution should also check that the type of the indexing expressions (in this case using the variables i, j and k are all integer. Show your work by indicating the order in which the attributes need to be evaluated and present two sample cases, one correctly typed and another incorrectly typed. A possible grammar for array expression is given below which is obviously incomplete. ArrayExpression ArrayIdentifier [ ExpressionList ']' ExpressionList Expression, ExpressionList ExpressionList Expression Expression... ArrayIdentifier Given these non-terminals we can define the following attributes and their types, Here the enumerated value used for the type attribute associated with the Expression is a simple unique entifier (possibly the index into a symbol table) that corresponds to the type of the corresponding expression. ArrayExpression: typechecked (boolean, synthesized) ArrayIdentifier: (string, synthesized) ExpressionList: length (integer, synthesized) ExpressionList: typelist (list of enumerated values, synthesized) Expression: type (enumerated, synthesized) Given these attributes, we can develop a set of rules as follows: ArrayExpression ArrayIdentifier [ ExpressionList ']' { decl = lookuparraydeclaration(arrayidentifier.); ArrayExpression.typechecked = true; if (decl.numberdimensions!= ExpressionList.length) ArrayExpression.typechecked = false; for all values v in ExpressionList.typelist { if (v!= integer){ ArrayExpression.typechecked = false; break; ExpressionList Expression, ExpressionList 1 { ExpressionList.typelist = AppendToList(ExpressionList 1.typelist,Expression.type); ExpressionList.length = ExpressionList 1.length + 1 ExpressionList Expression { ExpressionList.typelist = CreateList(Expression.type); ExpressionList.length = 1; Expression... { Expression.type = <cdode that determines the type> ; ArrayIdentifier { ArrayIdentifier. =.string; 1 of 7

2 University of Southern California CSCI565 Compiler Design Homework 2 - Solution Problem 2: Static-Single Assignment Representation [10 points] For the sequence of instructions shown below depict an SSA-form representation (as there could be more than one). Comment on the need to save all the values at the end of the loop and how the SSA representation helps you in your evaluation of the code. Do not forget to include the φ-functions. b = 0; d = 1; a =...; i =...; L1: if(i > 0) { d = 0; b = b + 1; d = 1; i = i - 1; if(i < 0) goto Lbreak; goto L1; Lbreak: x = a; y = b; A possible representation in SSA is as shown below where each value associated with each variable is denoted by a subscripted index. b 1 = 0 d 1 = 1 a 1 =... i 1 =... L1: i 2 = φ(i 1,i 3 ) b 2 = φ(b 1,b 3 ) if (i 2 <= 0) then goto Lbreak d 2 = 0 b 3 = b d 3 = 1 i 3 = i 2-1 if (i 3 < 0) then goto Lbreak goto L1 Lbreak: b 3 = φ(b 2,b 3 ) d 4 = φ(d 1,d 3 ) x 1 = a 1 y 1 = b 3 An important aspect of this representation is that it makes explicit the flow of values that reach a given point. In particular and for this case the value for the d variable is defined by two assignments denoted by d 4 = φ(d 1,d 3 ). Where and despite the intermediate assignment of the value 0 to the variable d, the surviving value is 1 and hence we can be guaranteed at the exit of this loop that the variable d has the 1 value. This is a form of data-flow analysis that is done via the SSA representation. 2 of 7

3 Problem 3: Symbol Table Organization [10 points] For the PASCAL code below answer the following questions: 01: procedure main 02: integer a, b, c; 03: procedure f1(w,x); 04: integer w, x; 05: f2(w,x); 06: end; 07: procedure f2(y,z); 08: integer a, y, z; 09: procedure f3(m,n); 10: integer b, m, n; 11: c = a * b + f4(m+1); 12: b = a * (x + 1); 13: end; 14: f3(c,z); 15: end; 16: function f4(k): integer; 17: integer k; 18: f4 := (k + 1); 19: end; 20:... 21: f1(a,b); 22: end; a) [05 points] Draw the symbol tables for each of the procedures in this code (including main) and show their nesting relationship by linking them via a pointer reference in the structure (or record) used to implement them in memory. Include the entries or s for the local variables, arguments and any other information you find relevant for the purposes of code generation, such as its type and location at run-time. b) [05 points] For the statement in line 18 what are the specific instance of the variables used in this statement the compiler needs to locate? Explain how the compiler obtains the data corresponding to each of these variables table at compile time. a) The figure below depicts the hierarchical structure of the procedure in this PASCAL program. main kind symbol type size var a integer 4 var b integer 4 var c integer 4 kind param param f1 symbol w x type size integer 4 integer 4 f2 kind symbol type size var a integer 4 param y integer 4 param z integer 4 f4 kind symbol type size param k integer 4 f3 kind symbol type size var b integer 4 param m integer 4 param n integer 4 b) For the statement in line 18 we simply follow the symbol table entries to find out the specific instance of each of the symbols. Given than the statement is located lexically inse the body of procedure f4 the search for symbols always begins in the symbol table for f4. In this statement "f4 := (k+1);" the symbol k refers to the local variable of procedure f4, so trivially, this will be accessible from the f4 s own activation record (AR) accessible via the ARP or stack pointer (SP) used in many processor architectures. 3 of 7

4 University of Southern California CSCI565 Compiler Design Homework 2 - Solution Problem 4: Intermediate Code Generation [25 points] Conser the code generation scheme for expressions described in class. Assume that the grammar does allow for referencing of union expressions and its s to consists of a simple entifier such as a.u1.f or b.u2.g where the symbol a refers to a reference or address of a C struct and b for a location of a struct in C. Assume for the purpose of this exercise that during a semantic analysis phase you have computed the offset of the first byte of each of the unions u1 and u2 being referenced in these expressions. In this context answer the following: a) [20 points] Derived a SDT code generation scheme that handles simple union references such as the ones above as well as more complicated ones with multiple nested union references, e.g., a.u1.f1. You need to include as part of your answer relevant productions of the grammar. b) [10 points] Show your code generation scheme for the simple expression c = a.u.f1 + b.u.f2 assuming that b and c are declared in the C programming language as shown below. typedef struct { union { int f1;; u;; int xa;; A;; typedef struct { int xb;; union { int f2;; u;; B;; int A B c;; a;; b;; a) Below is a possible parse tree that will help us structure the grammar and corresponding productions, attributes and semantic rules for this problem for a simple assignment b = a.u.f1. All the attributes should be synthesized as that helps the integration with a bottom-up parser and also with a single bottom-up traversal of the tree. type: pointer: place: code: symbol to be used with the symbol table boolean (true if this is a pointer ) temporary name list of instructions '=' Using these attributes, we also defined a set of simple auxiliary functions, namely: b '.' type :: getoffset(user-defined type, _name);; symboltable :: gettype(symbol_name);; symboltable :: gettypeof Field(type_name, _name);; '.' f1 u a 4 of 7

5 As to the semantic rules we can define them as follows: assign '=' exp 1 exp 1 exp 2 '+' exp 3 { t4 = newtemp();; assign.place = t4;; assign.code = append(exp 1.code, gen('t4 = exp 1';;));; assign.pointer = exp 1.pointer;; assign.type = igettype(.symbol);; { t3 = newtemp();; exp 1.place = t3;; exp 1.code = append(exp 2.code, exp 3.code,gen(t3 = exp 2.place + exp 3.place));; exp 1.pointer = exp 2.pointer;; exp 1.type = exp 2.type;; exp { exp.code =.code;; exp.type =.type;; exp.pointer =.pointer;; exp.place =.place;; 1 2 '->' 1 2 '.' 1 { offset = getfieldoffset( 2.type,.symbol);; t2 = newtemp();; 1.place = t2;; 1.type = gettypeoffield( 2.type,.symbol);; if( ispointertype( 2.type) ){ 1.code = append( 2.code,{ gen('t2 = 2.place + offset';; 't2 = *t2;;));; 1.pointer = true;; else { error { offset = getfieldoffset( 2.type,.symbol);; t2 = newtemp();; 1.place = t2;; 1.type = gettypeoffield( 2.type,.symbol);; if( ispointertype( 2.type) ){ error;; else { 1.code = append( 2.code,{ gen('t2 = 2.place + offset';; 't2 = *t2;;));; 1.pointer = ispointertype( 1.type);; { 1.type = gettype(.symbol);; 1.pointer = ispointertype(.symbol));; t1 = newtemp();; 1.place = t1;; 1.code = { gen('t1 =.symbol;;');; b) Nested unions behave the same as nested structure with the only difference that the offsets are computed in a different fashion. Once you have determined the offsets of each, the code generation scheme is entical. 5 of 7

6 University of Southern California CSCI565 Compiler Design Homework 2 - Solution '=' place= c code= t1 = a; t2=t1+0; t2 = *t2; t3 = b; t4=t3+4; t4 = *t4; t5 = t3 + t4; c = t5; place= a code= null '+' place= t5 code= t1 = b; t2=t1+0; t2 = *t2; t3 = c; t4=t3+4; t4 = *t4; t5 = t3 + t4; c exp place= t2 code= t1 = b; t2=t1+0; t2 = *t2; place= t2 code= t1 = b; t2=t1+0; t2 = *t2; exp place= t4 code= t3 = c; t4=t3+4; t4 = *t4; place= t4 code= t3 = c; t4=t3+4; t4 = *t4; '.' '->' '.' type= B place= t1 code= 't1 = a' u f1 '->' type= B place= t3 code= 't3 = b' u f2 a b 6 of 7

7 Problem 5: Back-patching of Loop Constructs [25 points] We have covered in class an SDT scheme to generated code using the back-patching technique for a while loop construct. In this exercise you will develop a similar scheme for the FORTRAN do-loop construct using the production below and also taking into account next and stop statements (these are similar to the continue and break statement in the C language. Further assume that the expression exp 1 and exp 2 have a place attribute and a specific code generation attribute where the code to evaluate them has been deposited. A further complication in FORTRAN is that the expressions that define the bounds of the loop are evaluated once on loop entry and temporaries are used instead to retain their values. The exp 1 and exp 2 are thus only evaluated on loop entry. Your solution needs to account for this by including temporary variables as part of the generated code. (1) S do var = exp 1, exp 2 L enddo (2) S next; (3) S stop; (4) L S \n L (4) L S Do not forget to show the augmented production with the marker non-terminal symbols, M and possibly N along with the corresponding rules for the additional symbols and productions. Argue for the correctness of your solution without necessarily having to show an example. This solution is further complicated by the fact that the code starts its execution with the evaluation of the expressions Exp 1 and Exp 2 that correspond to the bounds of the loop and these expressions need only and must only be evaluated once. The code generated as part of the main production starts at the address M 3.address. In order to control the execution of the loop, however, the production for M 1 inserts a jump to the code at the bottom of the loop where the test for execution will be made. It is thus assumed that the execution, when it reaches the code generated by production M 1 has already executed the code generated for the evaluation of Exp 1 and Exp 2. As such the correct values for these expression are already in the corresponding location attribute. The code jumps to the address denoted by M 3.address where the test fir the condition of execution of the loop is located and then jumps back to the body of the loop. (1) S do M 1 var = Exp 1, Exp 2 M 2 L M 3 enddo { t1 = newtemp(); t2 = newtemp(); gen( t 1 = Exp 1.place ); gen( t 2 = Exp 2.place ); gen( var. = t1 ); emit( goto M 2.address ); emit( t1 = t1 + 1; ); emit( var. = t1; ); gen( if t1 > t2 goto ); emit( goto M 2.address ); backpatch(newlist({m 1.address, M 3.address); backpatch(l.nextlist,m 3.address); backpatch(l.skiplist,m 3. address); S.nextlist = merge(makelist({m 1.address+6,L.breaklist)); S.breaklist = nil; (2) S continue; { S.skiplist = newlist(nextaddr()); emit( goto ); S.breaklist = nil; S.nextlist = nil; (3) S break; { S.breaklist = newlist(nextaddr()); emit( goto ); S.nextlist = nil; S.skiplist = nil; (4) L 1 S ; M 2 L 2 { backpatch(s.nextlist, M 2.quad); L 1.nextlist = L 2.nextlist; L 1.breaklist = merge(s.breaklist,l 2.breaklist); L 1.skiplist = merge(s.skiplist,l 2.skiplist); (5) L S { L.breaklist = S.breaklist; L.nextlist = S.nextlist; L.skiplist = S.skiplist; (6) M 1 ε { M 1.address = nextaddr; emit( goto ); (7) M 2 ε { M 2.address = nextaddr; emit( goto ); (8) M 3 ε { M 3.address = nextaddr; 7 of 7