Department of Electrical Engineering and Computer Science MASSACHUSETTS INSTITUTE OF TECHNOLOGY Fall Test I Solutions

Transcription

1 Department of Eletrial Engineering and Computer iene MAACHUETT INTITUTE OF TECHNOLOGY Fall 2016 Test I olutions 1

2 I Regular Expressions and Finite-tate Automata For Questions 1, 2, and 3, let the alphabet Σ = {a, b}. Let language L be the language of all strings over Σ that ontains the substring aa or bb. 1. [5 points]: Write a regular expression that reognizes language L. olution: (a b) (aa bb)(a b) 2. [5 points]: Draw a state diagram of a nondeterministi finite-state automaton (NFA) that reognizes language L. Remember to indiate starting and aepting states. olution: ee Problem 3. All DFA are NFA. Alternative solution: a,b a q 1 a,b a start q 0 b b q 3 q 2 3. [10 points]: Draw a state diagram of a deterministi finite-state automaton (DFA) that reognizes language L. Note that you an either build a DFA diretly from the English desription or onvert your NFA into a DFA. Remember to indiate starting and aepting states. olution: a q 1 a,b a start q 0 a b b b q 3 q 2 2

3 II Ambiguous Grammar For eah of the following grammars, state if it is ambiguous. If the grammar is ambiguous, find a sentene in the language with two (or more) parse trees, and show the two parse trees. Every lowerase letter indiates a terminal, and every upperase letter indiates a non-terminal. Parsing starts at. 4. [5 points]: d olution: Ambiguous. Example: d d d 5. [5 points]: F + F F F ( ) olution: Not ambiguous. 3

4 6. [5 points]: + F F F ( ) olution: Ambiguous. Example: F F + F F F F 7. [5 points]:? : olution: Not Ambiguous. 4

5 III Left Reursion Consider the following grammar: T $ T T A T ɛ A v = The following is an implementation (in a C-like language) of a reursive desent parser. Note that a parse funtion returns true if it suessfully parses a rule given the input stream, false otherwise. Assume all input ends with exatly one dollar sign $. 1 bool parse() { 2 if (parset()) { 3 if (isdollarign()) { 4 return true; 5 } 6 } 7 return false; 8 } 9 10 bool parset() { 11 if (isv(token)) { 12 if (parset()) { 13 if (parsea()) { 14 return true; 15 } 16 } 17 return false; 18 } else { 19 return true; 20 } 21 } bool parsea() { 24 if (isv(token)) { 25 token = nexttoken(); 26 if (isequal(token)) { 27 token = nexttoken(); 28 if (isc(token)) { 29 token = nexttoken(); 30 return true; 31 } 32 } 33 } 34 return false; 35 } 5

6 8. [6 points]: The reursive desent parser enters infinite reursion beause is left reursive. Redesign the grammar of this language to eliminate left reursion. olution: T $ T A T T ɛ A v = 9. [14 points]: Write the new ode for the reursive desent parser for the new grammar. olution: Both parse() and parsea() are unhanged. bool parset() { if (isv(token)) { if (parsea()) { if (parset()) { return true; } } return false; } else { return true; } } 6

7 IV Control Flow and hort-ciruiting Consider a programming language that inludes a ontrol flow onstrut alled the repeat-until loop. A repeat-until loop is written as follows: repeat { // body statements } until (ondition) The repeat-until loop runs the ode in the loop body, and then heks the ondition. If the ondition evaluates to true, the loop ends; otherwise, the loop repeats. Note that even if the ondition is always true, the loop body will still run one. 10. [10 points]: The semantis of the programming language says that a ompiled program should exeute only as muh as required to determine the value of a boolean ondition. The program evaluates a ompound ondition from left to right. Complete the flowhart on the next page that illustrates the ontrol flow for evaluating the following statements, inluding short-iruit logi for onditionals, assuming the ompiler is not performing any optimizations: int i = 0; int j = 12; repeat { i += j; j = j * 2; } until (i == 36 (i >= 0 && j > 10)) (Hint: after this ode runs, your final values should be i = 12 and j = 24.) 7

8 olution: i = 0; j = 12; i += j; j = j * 2; i == 36 false i >= 0 false true true j > 10 false true end 8

9 11. [10 points]: In the leture, we disussed the implementation of proedures alled shortiruit and destrut. The proedure shortiruit(, t, f) generates the short-iruit ontrol-flow representation for a onditional. This proedure makes the ontrol flow to node t if is true and flow to node f if is false. The proedure returns the begin node for evaluating ondition. The proedure destrut(n) generates the ontrol-flow representation for strutured ode represented by n. This proedure reates a ontrol flow graph for n and returns the begin and end nodes of the graph. Reall that the pseudoode of destrut(n) for an if-else statement is as follows: If n is of the form if () { x1 } else { x2 } then e = new nop; (b1, e1) = destrut(x1); (b2, e2) = destrut(x2); b = shortiruit(, b1, b2); next(e1) = e; next(e2) = e; return (b, e); Implement the pseudoode of destrut(n) for a repeat-until loop: If n is of the form repeat { x } until () then olution: e = new nop; (b, e1) = destrut(x); b = shortiruit(, e, b); next(e1) = b; return (b, e); 9

10 V Code Generation for Proedures Consider the following funtion in C and its orresponding assembly ode generated by a ompliler. Note that long is a 64-bit integer. long bar(long x) { return x+x; } 1 pushq %rbp // push the value of %rbp to the stak 2 movq %rsp, %rbp // opy the value of %rsp to %rbp 3 movq %rdi, -8(%rbp) // opy the value of %rdi to the stak 4 movq -8(%rbp), %rdi // opy the value on the stak to %rdi 5 addq -8(%rbp), %rdi // add the value on the stak to %rdi 6 movq %rdi, %rax // opy the value of %rdi to %rax 7 popq %rbp // pop the top value from the stak to %rbp 8 ret // return from the funtion The ompiler follows the standard Linux x86-64 alling onvention: A aller proedure/funtion passes the first 6 arguments, from left to right, in %rdi, %rsi, %rdx, %rx, %r8, %r9. Any remaining arguments are passed on the stak, from right to left. The aller owns registers %rsp, %rbp, %rbx, and %r12-%r15. The allee proedure/funtion is responsible for ensuring that these registers have the same value after the all as before the all. Note that %rsp and %rbp are the stak and base registers. Registers %rsp, %rbp, %rbx, and %r12-%r15 are the allee-save registers. The allee owns the remaining registers %rax, %rx, %rdx, %rsi, %rdi, and %r8-%r11. These registers an have different values after the all as before the all. These registers are the aller-save registers. The allee plaes its return value in %rax. 10

11 Whih of the following possible generated ode sequenes for bar are orret in the sense that 1) they ompute the orret return value for bar and 2) they follow the the standard Linux x86-64 alling onvention? Provide your answer by irling either Corret or Inorret below eah ode sequene. 12. [5 points]: 1 pushq %rbp // push the value of %rbp to the stak 2 movq %rsp, %rbp // opy the value of %rsp to %rbp 3 movq %rdi, -8(%rbp) // opy the value of %rdi to the stak 4 addq %rdi, %rdi // add the value of %rdi to %rdi 5 movq %rdi, %rax // opy the value of %rdi to %rax 6 popq %rbp // pop the top value from the stak to %rbp 7 retq // return from the funtion Corret Inorret olution: Corret 13. [5 points]: 1 movq %rdi, -8(%rsp) // opy the value of %rdi to the stak 2 addq -8(%rsp), %rdi // add the value on the stak to %rdi 3 movq %rdi, %rax // opy the value of %rdi to %rax 4 retq // return from the funtion Corret Inorret olution: Corret 11

12 The ode in the next two questions is also ompiled by a ompiler that adheres to the Linux x86-64 alling onvention, whih is repeated below for your onveniene. A aller proedure/funtion passes the first 6 arguments, from left to right, in %rdi, %rsi, %rdx, %rx, %r8, %r9. Any remaining arguments are passed on the stak, from right to left. The aller owns registers %rsp, %rbp, %rbx, and %r12-%r15. The allee proedure/funtion is responsible for ensuring that these registers have the same value after the all as before the all. Note that %rsp and %rbp are the stak and base registers. Registers %rsp, %rbp, %rbx, and %r12-%r15 are the allee-save registers. The allee owns the remaining registers %rax, %rx, %rdx, %rsi, %rdi, and %r8-%r11. These registers an have different values after the all as before the all. These registers are the aller-save registers. The allee plaes its return value in %rax. The ompiler will try to alloate variables in registers to minimize movement between memory and registers. In other words, it will deide that the value of a speifi variable should be stored in a speifi register, then aess that value from that register diretly. The goal is to ensure that as many values are aessed from registers as possible and to minimize any need to save and restore registers to and from memory. 12

13 14. [6 points]: Into what registers should the ompiler alloate n, i, x, when it ompiles the proedure g() below? If there are multiple equivalent register assignments, you only need to write one. Assume that funtions g() and f() are ompiled separately. 1 long g() { 2 long n = 100; 3 long i = 0; 4 long x = 0; 5 while (i < n) { 6 x = x + f(i); 7 i = i + 1; 8 } 9 return x; 10 } Alloate n in register: olution: %r12 Alloate i in register: olution: %r13 Alloate x in register: olution: %r14 Note: Any 3 different registers from the following list are OK: %rbx, %r12, %r13, %r14, and %r15. 13

14 15. [4 points]: Into what registers should the ompiler alloate j and y, when it ompiles the proedure f() below? 1 long f(long j) { 2 long y = j * j; 3 y = j + 10; 4 return y; 5 } Alloate j in register: olution: %rdi Alloate y in register: olution: %rax Note: Any 2 different aller saved registers are OK. 14