CSE443 Compilers. Dr. Carl Alphonce 343 Davis Hall

Transcription

1 CSE443 Compilers Dr. Carl Alphonce 343 Davis Hall

2 Announcements Weekly team meetings starting today Wednesday (4/4) will be a workshop Wednesday - Post questions you'd like addressed in Piazza by Sunday (4/1) evening (no questions posted as of this AM) - Post

3 Phases of a compiler Intermediate Representation (IR): specification and generation Figure 1.6, page 5 of text

4 Control flow Booleans to control flow Booleans as values

5 Boolean expressions! X X & Y X Y We will do short-circuit evaluation if (X Y & Z) then { A } else { B } is translated as if X goto LA iffalse Y goto LB iffalse Z goto LB LA: A goto END LB: B END: (next instruction)

6 Boolean expressions A more concrete example: if ( r < s r = s & 0 < s) then { A } else { B } is translated as if r < s goto LA iffalse r = s goto LB iffalse 0 < s goto LB LA: A goto END LB: B END: (next instruction)

7 Flow-of-Control (6.3.3) if ( B ) then S1 else S2 B.true = newlabel() B.false = newlabel() S.next = S1.next = S2.next S.code = B.code label(b.true) S1.code gen('goto' S.next) label(b.false) S2.code LS1 LS2 B.code S1.code goto END S2.code iftrue: goto LS1 iffalse: goto LS2 END

8 Flow-of-Control (6.3.3) S -> if ( B ) then S1 B.true = newlabel() B.false = S.next = S1.next S.code = B.code label(b.true) S1.code LS1 B.code S1.code iftrue: goto LS1 iffalse: goto END END

9 Flow-of-Control (6.3.3) while ( B ) then S1 BEGIN B.code iftrue: goto LS1 iffalse: begin = newlabel() LS1 goto END B.true = newlabel() B.false = S.next S1.code S1.next = begin S.code = label(begin) B.code label(b.true) S1.code gen('goto' begin) END goto BEGIN

10 6.6.6 Boolean values and jumping code "S -> id = E; if (E) S while (E) S S S Nonterminal E governs the flow on control in S -> while (E) S1. The same nonterminal E denotes a value in S -> id = E [ ]" [p. 408]

11 6.6.6 Boolean values and jumping code "Suppose that attribute E.n denotes the syntax-tree node for an expression E and that nodes are objects. Let method jump generate jumping code at an expression node, and let method rvalue generate code to compute the value of the node into a temporary." [p. 408]

12 Value of Boolean expression "When E appears in S -> while (E) S1, method jump is called at node E.n [ ] When E appears in S -> id = E;, method rvalue is called at node E.n" [p. 408]

13 Figure 6.42 [p. 409] "If E has the form E1 + E2, the method call E.n.rvalue() generates code as discussed in section 6.4." [p. 408] "E-> E1 + E2 E.addr = new Temp() E.code = E1.code E2.code gen(e.addr '=' E1.addr '+' E2.addr)" [p. 379] "If E has the form E1 && E2 we first generate jumping code for E and then assign true or false to a new temporary t at the true and false exits, respectively, from the jumping code." [p. 408] Translation of: x = a<b && c<d iffalse a < b goto L1 iffalse c < d goto L1 t = true goto L2 L1: t = false L2: x = t

14 How to deal with jumps

15 6.6.4 Control-flow translation of Boolean Expressions B -> B1 B2 B1.true = B.true B1.false = newlabel() B2.true = B.true B2.false = B.false B.code = B1.code label(b1.false) B2.code true true B.true B1 B1.false B2 false false B.false

16 6.6.4 Control-flow translation of Boolean Expressions B -> B1 B2 B1.true = B.true B1.false = newlabel() B2.true = B.true B2.false = B.false B.code = B1.code label(b1.false) B2.code B -> B1 && B2 B1.true = newlabel() B1.false = B.false B2.true = B.true B2.false = B.false B.code = B1.code label(b1.true) B2.code

17 Backpatching Allows jump targets to be filled in during a one-pass parse. When (forward) jumps are needed, keep a list of where the addresses need to be inserted. Once address is known, go back and fill in the address ("backpatching").

18 6.7 Backpatching "For specificity, we generate instructions into an instruction array, and labels will be indices into this array." [p. 410] We have an instruction pointer (the first available index in the array), called nextinstr.

19 6.7 Backpatching page 410 makelist(i) creates a new list containing only i, an index into the array of instructions; makelist returns a pointer to the newly created list. merge(p1,p2) concatenates the lists pointed to by p1 and p2, and returns a pointer to the concatenated list. backpatch(p,i) inserts i as the target label for each of the instructions on the list pointed to by p

20 6.7.1 Backpatching for Boolean Expressions B -> B1 B2 B1.true = B.true B1.false = newlabel() B2.true = B.true B2.false = B.false B.code = B1.code label(b1.false) B2.code B -> B1 M B2 backpatch(b1.falselist, M.instr) B.truelist = merge(b1.truelist, B2.truelist) B.falselist = B2.falselist

21 6.7.1 Backpatching for Boolean Expressions B -> B1 B2 B1.true = B.true B1.false = newlabel() B2.true = B.true B2.false = B.false B.code = B1.code label(b1.false) B2.code B -> B1 M B2 Assume that B1 and B2 generate store code backpatch(b1.falselist, as attributes of the parse M.instr) tree B.truelist = merge(b1.truelist, nodes. B2.truelist) B.falselist = B2.falselist Actions happen at reduction step of rule B -> B1 B2

22 6.7.1 Backpatching for Boolean Expressions Assume that B1 B1.true and B2 = generate B.true code directly, rather B1.false than = storing newlabel() it in the B -> B1 B2 tree. B2.true = B.true B2.false = B.false Actions B.code happen = B1.code at reduction label(b1.false) step of rule B2.code B -> B1 M B2 B -> B1 M B2 backpatch(b1.falselist, M.instr) B.truelist = merge(b1.truelist, B2.truelist) B.falselist = B2.falselist

23 6.7.1 Backpatching for Boolean Expressions B -> B1 && B2 B1.true = newlabel() B1.false = B.false B2.true = B.true B2.false = B.false B.code = B1.code label(b1.true) B2.code B -> B1 && M B2 backpatch(b1.truelist, M.instr) B.truelist = B2.truelist B.falselist = merge(b1.falselist, B2.falselist)

24 6.7.1 Backpatching for Boolean Expressions B ->! B1 B1.true = B.false B1.false = B.true B.code = B1.code B ->! B1 B.truelist = B1.falselist B.falselist = B1.truelist

25 6.7.1 Backpatching for Boolean Expressions B -> ( B1 ) B1.true = B.true B1.false = B.false B.code = B1.code B -> ( B1 ) B.truelist = B1.truelist B.falselist = B1.falselist

26 6.7.1 Backpatching for Boolean Expressions B -> E1 rel E2 B.code = E1.code E2.code gen ('if' E1.addr rel.op E2.addr 'goto B.true') gen('goto' B.false) B -> E1 rel E2 B.truelist = makelist(nextinstr) B.falselist = makelist(nextinstr + 1) gen('if' E1.addr rel.op E2.addr 'goto _') gen('goto _')

27 6.7.1 Backpatching for Boolean Expressions B -> true B.code = gen('goto' B.true) B -> false B.code = gen('goto' B.false) B -> true B.truelist = makelist(nextinstr) gen('goto _') B -> false B.falselist = makelist(nextinstr) gen('goto _')

28 6.7.1 Backpatching for Boolean Expressions M -> ε M.instr = nextinstr

29 Example 6.24 x < 100 x > 200 && x!= y x < : if x < 100 goto 101: goto truelist = {100} falselist = {101}

30 Example 6.24 x < 100 x > 200 && x!= y x < : if x < 100 goto 101: goto truelist = {100} falselist = {101} M M.instr = 102

31 Example 6.24 x < 100 x > 200 && x!= y x < : if x < 100 goto 101: goto truelist = {100} falselist = {101} M M.instr = 102 x > : if x > 200 goto 103: goto truelist = {102} falselist = {103}

32 Example 6.24 x < 100 x > 200 && x!= y x < : if x < 100 goto 101: goto truelist = {100} falselist = {101} M M.instr = 102 x > : if x > 200 goto 103: goto truelist = {102} falselist = {103} M M.instr = 104

33 Example 6.24 x < 100 x > 200 && x!= y x < : if x < 100 goto 101: goto truelist = {100} falselist = {101} M M.instr = 102 x > : if x > 200 goto 103: goto truelist = {102} falselist = {103} M M.instr = 104 x!= y 104: if x!= y goto 105: goto truelist = {104} falselist = {105}

34 Example 6.24 x < 100 x > 200 && x!= y x < : if x < 100 goto 101: goto truelist = {100} falselist = {101} M M.instr = 102 x > : if x > 200 goto 103: goto truelist = {102} falselist = {103} M M.instr = 104 x!= y 104: if x!= y goto 105: goto truelist = {104} falselist = {105} x>200 && x!=y backpatch({102},104) 102: if x > 200 goto : goto truelist = {104} falselist = {103,105}

35 Example 6.24 x < 100 x > 200 && x!= y x < : if x < 100 goto truelist = {100} B -> B1 && B2 101: goto falselist = {101} B -> x > 200 && x!= y M M.instr = 102 x > : if x > 200 goto truelist = {102} 103: goto falselist = {103} M M.instr = : if x!= y goto x!= y 105: goto truelist = {104} falselist = {105} x>200 && x!=y backpatch({102},104) 102: if x > 200 goto : goto truelist = {104} falselist = {103,105} backpatch(b1.truelist, M.instr) B.truelist = B2.truelist B.falselist = merge(b1.falselist, B2.falselist)

36 Example 6.24 x < 100 x > 200 && x!= y x < : if x < 100 goto 101: goto truelist = {100} falselist = {101} M M.instr = 102 x > : if x > 200 goto 103: goto truelist = {102} falselist = {103} M M.instr = 104 x!= y 104: if x!= y goto 105: goto truelist = {104} falselist = {105} x>200 && x!=y backpatch({102},104) 102: if x > 200 goto : goto truelist = {104} falselist = {103,105} x < 100 x > 200 && x!= y backpatch({101},102) 100: if x < 100 goto 101: goto 102 truelist = {100,104} falselist = {103,105}

37 How does this play out during parse in array

38 Example 6.24 x < 100 x > 200 && x!= y 100: if x < 100 goto 101: goto truelist = {100} falselist = {101}

39 Example 6.24 x < 100 x > 200 && x!= y 100: if x < 100 goto 101: goto 102: if x > 200 goto 103: goto truelist = {100} falselist = {101} truelist = {102} falselist = {103}

40 Example 6.24 x < 100 x > 200 && x!= y 100: if x < 100 goto 101: goto 102: if x > 200 goto 103: goto 104: if x!= y goto 105: goto truelist = {100} falselist = {101} truelist = {102} falselist = {103} truelist = {104} falselist = {105}

41 Example 6.24 x < 100 x > 200 && x!= y 100: if x < 100 goto 101: goto 102: if x > 200 goto : goto 104: if x!= y goto 105: goto truelist = {100} falselist = {101} truelist = {104} falselist = {103,105}

42 Example 6.24 x < 100 x > 200 && x!= y 100: if x < 100 goto 101: goto : if x > 200 goto : goto 104: if x!= y goto 105: goto truelist = {100,104} falselist = {103,105}

43 Example 6.24 x < 100 x > 200 && x!= y 100: if x < 100 goto 101: goto : if x > 200 goto : goto 104: if x!= y goto 105: goto truelist = {100,102} falselist = {103,105} The remaining open jumps will be backpatched by other instructions, outside this expression

44 6.7.3 Backpatching Flow-of-Control statements S -> if (B) S1 else S2 B.true = newlabel() B.false = newlabel() S1.next = S2.next = S.next S.code = B.code label(b.true) S1.code gen('goto',s.next) label(b.false) S2.code S -> if (B) M1 S1 N else M2 S2 backpatch(b.truelist, M1.instr) backpatch(b.falselist, M2.instr) temp = merge(s1.nextlist, N.nextlist) S.nextlist = merge(temp, S2.nextlist)

45 6.7.3 Backpatching Flow-of-Control statements S -> while (B) S1 begin = newlabel() B.true = newlabel() B.false = S.next() S1.next = begin S.code = label(begin) B.code label(b.true) S1.code gen('goto' begin) S -> while M1 (B) M2 S1 backpatch(s1.nextlist, M1.instr) backpatch(b.truelist, M2.instr) S.nextlist = B.falselist gen('goto' M1.instr)