Universitetet i Oslo

Institutt for Informatikk

PMA, PSE
Krogdahl, Møller-Pedersen, Steffen

INF 5110: Compiler construction

Spring 2016 Collection of exam questions 12. 05. 2016

Issued: 12. 05. 2016

Abstract
This is a collection of exams from earlier years. They are not the originals but translated
to English (but I more or less tried to keep true to the formulations). Additionally, there are
hints for solutions, also taken from those earlier exams.
In the solutions, there is often more text than is expected when answering an exam, such
as explaining what is generally expected in such a question, about the background,1 or how
to approach it. In contrast, in an exam, one is very much encouraged to keep explanations
more to the point of the actual question at hand.
Disclaimer: Care has been taken to keep it error-free here; I do not, however, give guar-
antees for 100% correctness, and an error here can not be taken as argument when defending
own errors.
Also: it’s unclear whether throughout the years, exactly the same pensum was required.
The pensum of 2016 corresponds roughly (but not 100%) to the one from 2015, but I have
no overview over earlier semesters. Thus, earlier exams may cover more/different material
or left out some material, which has been added to the pensum later on. The text here is
just a “matter-of-fact” repository of earlier exams. Peruse at your leisure.

1 2005
Exercise 1 (Regular expressions and automata (0%))

(a) Use Thompson’s construction to construct a NFA for the following regular expression
(aa ∣ b)∗ (a ∣ cc)∗

(b) Write the following NFA as regular expression.

a a a


start 1 3

v b b

1
Especially in the footnotes.
Collection of exam questions 12. 05. 2016

(c) Turn the NFA from the previous sub-problem into a DFA.

Exercise 2 (CFGs and Parsing (0%))

Consider the following grammar G1 :

E → S E ∣ num
S → − S ∣ +S ∣ 

E and S are non-terminals, +, −, and num are terminals (with the usual interpretation).
The start symbol is E (not S).

(a) Describe short how sentences generated by G1 look like, and give one example of a sentence
consisting of 4 terminal symbols

(b) Give a regular expression representing the same sentences as G1 .

(c) Give a short argument determining which of the following 5 groups the the grammar belongs
to (more than one may apply):

(i) LR(0)
(ii) SLR(1)
(iii) LALR(1)
(iv) LR(1)
(v) none of the above.

Consider next a different grammar G2 :

F → + F ∣ − F ∣ num

Here, F is a non-terminal (and, obviously, the start symbol). The terminals are unchanged:
+, −, and num

(d) Give a LR(0)-DFA for G2 , where the grammar has been extended by a new producion
F ′ → F and where F ′ is taken as the start symbol of the extended grammar. Give a
number to each state of your DFA for identification.

(e) Given the DFA thus constructed: which type(s) of grammar is G2 , again with a short
explanation. (Cf. question (c) from above for the classification).

(f) Give the parsing table for G2 , fitting to the type of grammar

(g) How will the sentence following sentence be parsed

−−9

Give your answer by showing the stack-content and input (as done in the book) for each
of the shift- or reduce-steps done while parsing the sentence.

Exercise 3 (Attribute grammars and type checking (0%))

2
Collection of exam questions 12. 05. 2016

(a) The following is a (fragment of a) grammar for a language with classes.

class → class name superclass { decls }

decls → decls;decl ∣ decl
decl → variable-decl
decl → method -decl
method -decl → type name ( params ) body
type → int ∣ bool ∣ void
superclass → name

Words in italics are meta-symbols, words or symbols in boldface are terminal symbols
(and name represents a name the scanner hands over. You can assume that name has
an attribute name.
Methods with the same name as the class are constructors, and, as a rule, constructors
must have the type void.
The task now is: formulate semantic rules for each production in the following fragment of
an attribute grammar. Start by deciding which attributes you need.
Hint: the solution does not require a symbol table.

productions/grammar rules semantic rules

1 class → class name superclass { decls }
2 decls → decls;decl
3 decls → decl
4 decl → variable-decl Not to be filled out
5 decl → method -decl
6 method -decl → type name ( params ) body
7 type → int
8 type → bool
9 type → void
10 superclass → name

(b) Assume we are dealing with a language with classes and subclasses. All methods are virtual
(such that they can be overwritten). Assume the following class definitions:
1 class A {
2 int i ;
3 void P { . . . AP . . . };
4 void Q { . . . AQ . . . };
5 }
6
7 c l a s s B extends A {
8 int j ;
9 void Q { . . . BQ . . . } ;
10 void R { . . . BR . . . } ;
11 }
12
13 c l a s s C1 extends B {
14 void P { . . . C1P . . . } ;
15 void S { . . . C1S . . . } ;
16 }
17
18 c l a s s C2 extends B {
19 int k
20 void R { . . . C2R . . . } ;
21 void T { . . . C2T . . . } ;
22 }

3
Collection of exam questions 12. 05. 2016

Show how objects of classes C1 and C2 are structure (show their layout) and draw the
virtual function table2 for each of the classes. Use the “names” shown in the above method
bodies to indicate elements in the virtual function tables.
(c) We introduce an instanceof operator as in Java. The boolean expression
refExpr instanceof class
is “true” if the object pointed at by refExpr is of a class which is not “null”, and which is
class class or a subclass of class. Otherwise, the value of the expression is “false”.
To implement this operation, we extend the virtual function table with a pointer to class
descriptors; there is one class descriptor for each class in the program. Each class descriptor
contain a variable “super” pointing to the class descriptor of its superclass. Classes without
an explictly given superclass have the specific class Object as superclass. The example
figure below illustrates the concept for an object of class B.

Sketch an algorithm which calculates the value of refExpr instanceof class

(d) To make the test of instanceof more efficient and inspired by the concept of display/context
vector for nested blocks, we instroduce a table “super” which, for a given class, contains
all superclasses including the class itself. This table uses as index the “subclass-level”, with
0 for Object, with 1 for the programs root class, etc. In our example, class A has level 1,
B has 2, and C1 and C3 both level 3. In our example, the class descriptors which includes
the “super”-tables look as follows:

Explain how this representation can make the implementation of the instanceof -operator.
To illustrate that, we introduce two more classes:
2
name

4
Collection of exam questions 12. 05. 2016

1 c l a s s C11 extends C1 { . . . }
2 c l a s s C21 extends C1 { . . . }

Give the class descriptors for those two new classes C11 and C21 and show how the following
tests are done.
1 rC11 = new C1 ( ) ;
2 rC11 i n s t a n c e o f C1 ; // ( 1 )
3 rC11 i n s t a n c e o f C2 ; // ( 2 )

2 2006
Exercise 4 (Parameter passing and attribute grammars (0%))
The following is a fragment of a grammar for a language with procedures (uninteresting
parts are omitted for the current problem set). All procedures have one parameter that
this parameter is either “by-value”, “by-reference”.(indicated by they keyword ref ), or
“by-value-result” (indicated by the keyword result).

procedure → proc id ( param ) stmt

param → type id ∣ ref type id ∣ result type id
call → id ( exp )
exp → id
exp → id [ exp ]
exp → exp aritop exp

The following 2 programs declare a variable i and a procedure change; afterwards, 1 is

assigned to i, the procedure is called with i as argument and finally prints the content of
i. The difference between the first and the second version of the program is the parameter-
passing mode: the first uses call-by-reference, the second call-by-value-result. We assume
standard scoping rules apply.
1 {
2 int i ;
3 proc change ( r e f i n t p ) {
4 p = 2; i = 0;
5 };
6 i = 1;
7 change ( i ) ;
8 write ( i ) ;
9 }

1 {
2 int i ;
3 proc change ( r e s u l t i n t p ) {
4 p = 2; i = 0;
5 };
6 i = 1;
7 change ( i ) ;
8 write ( i ) ;
9 }

(a) Assume that the semantics for “call-by-value-result” is such that the address (location) of
the actual parameter is determined at the time of the procedure call (procedure entry).
What is the output of program 1 and program 2 upon execution?

5
Collection of exam questions 12. 05. 2016

(b) Assume that the semantics for “call-by-value-result” is such that the address (location) of
the actual parameter is determined a the time of the procedure return (procedure exit).
(c) The easy rule governing procedure calls in this language “by-reference” or “by-value-result”
is as follows: such procedures can be called only where the expression is either a simple
variable (id ) or an indexed variable (id [ exp ]).
Fill out the missing entries in the following attribute grammars such that the attribute ok
for call is true the call is done following the given rule and false, otherwise.
The symbol table is set up targeted towards this language rule such that the names of
procedures are associated with a value which indicates whether the given procedure uses
its parameter “by-value”, “by-reference”, or “by-value-result” (with values value, ref , or
result, respectively). A call lookupkind (id .name) gives in which way the procedure with
the name id .name is defined.
It’s not required here to check whether the procedure name id in a call-expression is
actually declared.

productions/grammar rules semantic rules

procedure → proc id ( param ) stmt insert(id .name, param.kind)
param → type id
param → ref type id
param → result type id
call → id ( exp ) call .ok =
exp → id
exp 1 → id [ exp 2 ]
exp 1 → exp 2 aritop exp 3

Exercise 5 (CFGs and Parsing (0%))

Consider the following grammar G. In the grammar, S and T are nonterminals, # and a
are terminals, and S is the start symbol.

S → TS
S → T
T → #T
T → a

(a) Determine the First- and Follow -sets for S and T . Use $, as usual, to represent the
“end-of-file”.
(b) Forumalate in your own words which sequences of terminal symbols are generated starting
from S.
(c) Is it possible to represent the language of G (consisting of # and a symbols) by a regular
expression. Explain, if the answer is “no”, resp. give a corresponding regular expression if
the answer is “yes”.
(d) Introduce a new start symbol S ′ with a production S ′ → S. Give the LR(0)-DFA for G
right for that grammar. Give numbers to the states of the DFA.
(e) Give a short argument determining which of the following 5 groups the grammar belongs
to; more than one answer is possible:

6
Collection of exam questions 12. 05. 2016

(i) LR(1)
(ii) LALR(1)
(iii) SLR(1)
(iv) LR(0)
(v) none of the above

Hint: determine possible conflicts in the constructed DFA and/or if the grammar is unam-
biguous.

(f) Give the parsing table for G, fitting the grammar type.

(g) Show how the sentence “a # a” is being parsed. Do that, as done in the book, by writing
the stack-contents and input for each shift- or reduce-operation executed during the parsing.
Indicate also the numbers of the states on the stack (as in the book).

Exercise 6 (Classes and virtual tables (0%))

(a) Assume a language with classes and subclasses. All methods are virtual, such that they
can be redefined in subclasses.
The class Graph, together with classes Node and Edge, defines graphs, which consist of
Node-objects which are connected via Edge-objected. An instance of class Graph represents
graphs. All nodes of the graph are assumed to be reachable from a node represented by
the attribute startNode, which contains a references to a Node-object.
Parts of the class definitions irrelevant for the problem are indicated by “...”.
1 c l a s s Node { . . . }
2 c l a s s Edge { . . . }
3
4 c l a s s Graph {
5 Node s t a r t N o d e ;
6 void c o n n e c t ( Node n1 , n2 ) {
7 . . . // c o n n e c t s two Nodes by c r e a t i n g an Edge− o b j e c t ...
8 };
9 }

The following classes define subclasses (City and Road) of Node and Edge, respectively. Fur-
thermore given is a subclass RoadAndCityGraph of Graph, and a subclass TravelingSalesmanGraph
of RoadAndCityGraph. The method display will draw the graph with startNode as start-
ing point.
1 c l a s s C i t y extends Node {
2 S t r i n g name ;
3 ...
4 }
5
6 c l a s s Road extends Edge {
7 S t r i n g name ;
8 int d i s t a n c e ;
9 ...
10 }
11
12
13 c l a s s RoadAndCityGraph extends Graph {
14 String country ;
15 void c o n n e c t ( Node n1 , n2 ) {
16 . . . // c o n n e c t s t o c i t y o b j e c t s t r e a t e s as Nodes ,
17 // by c r e a t i n g a Road o b j e c t
18 };
19 void d i s p l a y ( ) {

7
Collection of exam questions 12. 05. 2016

20 . . . // d i s p l a y Roads and C i t y w i t h names

21 }
22 }
23
24 c l a s s T ra v el i ng S a le s ma n Gr a ph extends RoadAndCityGraph {
25 void d i s p l a y ( ) {
26 . . . // d i s p l a y c i t i e s w i t h names and r o a d s
27 // w i t h name and d i s t a n c e
28 };
29 }

Show how objects of the classes Graph, RoadAndCityGraph, and TravelingSalesmanGraph

are structured (show their layout) and draw the virtual table for each of the objects. Use
names of the form ⟨classname⟩ ∶∶ ⟨methodname⟩ to indicate which definition is associated
with each object.

(b) Assume that classes Node and Edge are defines as inner classes of Graph and furthermore
that inner classes can be redefined in subclasses in the same way that virtual methods
can. One may well speak of virtual classes then. Redefined classes automatically become
subclasses for the corresponding virtual classes. For example, class RoadAndCityGraph is
a subclass of class Node in Graph.
1 c l a s s Node { . . . }
2 c l a s s Edge { . . . }
3
4 c l a s s Graph {
5 Node s t a r t N o d e ;
6 void c o n n e c t ( Node n1 , n2 ) {
7 . . . // c o n n e c t s two Nodes by c r e a t i n g an Edge− o b j e c t ...
8 };
9 }
10
11
12
13 c l a s s RoadAndCityGraph extends Graph {
14 class City {
15 S t r i n g name ;
16 ...
17 }
18
19 c l a s s Road {
20 S t r i n g name ;
21 int d i s t a n c e ;
22 ...
23 }
24
25 String country ;
26 void c o n n e c t ( Node n1 , n2 ) {
27 . . . // c o n n e c t s t o c i t y o b j e c t s t r e a t e s as Nodes ,
28 // by c r e a t i n g a Road o b j e c t
29 };
30 void d i s p l a y ( ) {
31 . . . // d i s p l a y Roads and C i t y w i t h names
32 }
33 }
34
35
36
37
38
39
40 c l a s s T ra v el i ng S a le s ma n Gr a ph extends RoadAndCityGraph {
41 void d i s p l a y ( ) {
42 . . . // d i s p l a y c i t i e s w i t h names and r o a d s
43 // w i t h name and d i s t a n c e
44 };
45 }

8
Collection of exam questions 12. 05. 2016

In the same way as the virtual table for virtual methods is used when calling a virtual
method, we now also make use of an additional virtual table for the instantiation of objects
from virtual classes. For instance, the method connect of class Graph contains code to
generate a new Edge-object. If this method therefore is called on a RoadAndCityGraph-
object, it is supposed to generate an Edge-object as it is defined in class RoadAndCityGraph.
Show how such a virtual table for virtual classes can look like. Don’t include in the
representation the virtual table from subproblem (a).
Explain how this new virtual table is used when executing new Edge() in method connect
in the class Graph.

3 Exam 2007
Exercise 7 (Code generation (-%))

(a) Given is the program from Listing 1. The code is basically three-address code, except that
we also allowed ourselves in the code two-armed conditionals and a while-construct (with
the conventional meaning). The input and output instructions in the first two lines resp.
the last two lines are considered as standard three-address instruction, which the obvious
meaning of “inputting” a value into the mentioned variable resp. “outputting” its value.
We assume that no variable is live at the end of the code.

Listing 1: 3-address code example

1 a := input
2 b := input
3 d := a + b
4 c := a ∗ b // <− l o o k y h e r e
5 i f ( b < 5) {
6 while ( b < 0 ) {
7 a := b + 2
8 b := b + 1
9 }
10 d := 2 ∗ b
11 } else {
12 d := b ∗ 3
13 a := d − b
14 }
15 output a
16 output b

Which variables are live immediately at the end of line 4. Give a short explanation of your
answer.

4 Exam 2009
Exercise 8 (Code generation (%))

Consider the following program in 3-address intermediate code.

Listing 2: 3-address code example

1 a := input
2 b := input
3 t 1 := a + b // l i n e 3
4 t 2 := a ∗ 2
5 c := t 1 + t 2
6 i f a < c goto 8
7 t 2 := a + b
8 b := 25 // l i n e 8

9
Collection of exam questions 12. 05. 2016

9 c := b + c
10 d := a − b
11 i f t 2 = 0 goto 17
12 d := a + b
13 t 1 := b − c
14 c := d − t 1
15 i f c < d goto 3
16 c := a + b
17 output c // l i n e 17
18 output d

(a) Indicate where new basic blocks start. For each basic block, give the line number such that
the instruction in the line is the first one of that block.
(b) Give names B1 , B2 , . . . for the program’s basic blocks in the order the blocks appear in the
given listing. Draw the control flow graph making use of those names. Don’t put in the
code into the nodes of the flow graph, the labels Bi are good enough.
(c) The developer who is responsible for generating the intermediate TA-code assures that
temporary variables in the generated code are dead at the end of each basic block as well
as dead at the beginning of the program, even if the same temporary variable may well be
used in different basic blocks.
Formulate a general rule to check locally in a basic block whether or not the above claim
is honored or violated in a given program.
Assume that all variables are dead after the last instruction.
(d) Use the rule formulated in the previous sub-problem on the TA-code given, to check if the
condition is met or not. The remporary variables are called t1 , t2 etc. in the code.
(e) Draw the control flow graph of the probmel and find the values for inLive and outLive for
each basic block. Consider the temporaries as ordinary variables.
Point out how one can answer the previous question 4.d directly after having solved the
current sub-problem.
Are there instructions which can be omitted (thus optmizing the code)? Are there variables
which are potentially uninitialized the first time they are used.

5 Exam 2010
Exercise 9 (Code generation (–%))

(a) Arne has looked into the code generation algo at the end of the notat (from [Aho et al., 1986,
Chapter 9]). He surmises that for the following 3AIC
1 t 1 := a − b
2 t 2 := b − c

the code generation algorithm will produce the machine instructions below. He has assumed
two registers, both empty at the start.
Listing 3: 2AC
1 MOV a , R0
2 MOV b , R1
3 SUB R1 , R0
4 SUB c , R1

Ellen disagrees. Who is right? Explain your answer.

10
Collection of exam questions 12. 05. 2016

6 2011
Exercise 10 (CFGs and Parsing (25%%))

Given are the following 3 separate grammars:

A → bAc ∣  (1)
A → bAb ∣ b (2)
A → bAb ∣ c (3)

Symbol A is the start symbol and the (only) non-terminal, and b and c are terminals.

(a) For all three grammars:

(i) Calculate the First- and Follow -sets of A.

(ii) After extending the grammar with a new start symbol and production A′ → A, draw
the LR(0)-DFA.
(iii) Which of the 3 grammars is SLR, if any? Do the same for LR(0).

(b) For each of the 3 grammars: is the grammar LR(1)? It’s possible to determine and explain
that without referring to the LR(1)-DFA, but it’s ok to draw the LR(1) first and use it for
the answer.

(c) Which of the languages generated by the grammars is regular? In case of a “yes”, give a
regular expression capturing the language of the respective grammar. In case of a “no”
answer: give a short explanation.

(d) Draw a parsing table for grammar (1) and take care that it’s free from conflicts. Give a
step-by-step LR-analysis of the sentence “bbcc” in the same way as done in [Louden, 1997,
page 213, Table 5.8]

Exercise 11 (Classes and virtual tables (20%%))

Assume we are dealing with an OO language where a virtual methiod in a class can be
redefined (“overriding”) in subclasses of that class. A virtual method is declared via the
virtual modified, where a redefinition is declared with the modifier redef. Methods
without virtual modifier are “ordinary” methods and cannot be redefined. Note that it’s
not completely as in Java. In Java, all methods are virtual, whereas here, that’s only the
case for methods with virtual modifier.3 Consider the following classed, defined in that
assumed language
1 class A {
2 v i r t u a l void m ( i n t x , y ) { . . . }
3 void p ( ) { . . . }
4 v i r t u a l void q ( ) { . . . }
5 }
6
7 c l a s s B extends A {
8 redef void m ( i n t x , y ) { . . . }
9 void r ( ) { . . . }
10 }
11
12 c l a s s C extends A {
13 redef void q ( ) { . . . }
14 }

3
At that point it’s unclear if redef-methods may be redefined again.

11
Collection of exam questions 12. 05. 2016

15
16 c l a s s D extends B {
17 redef void m ( i n t x , y ) { . . . }
18 }
19
20 class E extend B {
21 redef void q ( ) { . . . }
22 }
23
24 c l a s s F extends C {
25 redef void m( i n t x , y ) { . . . }
26 }

(a) We assume first that the class for a given object determines, in the standard way, which
version of a virtual method is being called.
Do the virtual tables for the all the classes A, B, . . . , F. For each element in the table, use
the notation A::m to indicate which method actually is meant. The indices in this tables
are supposed to start with 0.

(b) For the rest of this problem, we assume the following semantics: A refined virtual methods,
say m, first executes the correspoidng virtual or redefined method (i.e., m) in the closest
superclass containing such a method, before executing its own body. This in turn may leads
to the situation that redefined or virtual methods m in further superclasses are executed.
One can implement that by setting in the right call as first statement in the body of
redefined methods. However: the semantics of parameter passing here is assumed to be a
little by specific in that the straightforward way won’t work. The parameters handed over
in the original call should go directly as parameters to the method which is being executed
first, i.e., the one which are marked virtual in the program. When that is finished
executing, the values which are contained in that versions parameters be transferred a
actual parameters for the next deeply nested redefined method, etc. As a consequence, the
stack of the call must be set-up first, and that the actual parameterrs must handed over
to the first virtual method which is supposed to be executed.
As example: asume m is called with m(1,2) on a D-object. In that case the stack is being
set up and the actual parameter go into the activation recode corresponding to A::m, and
the execution can start executing A::m. Upon exit of A::m: the values of x and y will be
handed over as actual parameters to the version of m which is supposed to be executed
next.
In order to implement this new semantics, we need to extend the virtual tables in such a
way that for each index, a list of methods is available. This list will, consequently, give the
sequence of methods which will be called.
Draw these new virtual tables for classes D and F. The tables for B and C are given in Table
1. To indicate methods, use the same notation as before.

Exercise 12 (Attribute grammars (30%%))

The following is a fragment of a grammar for a language with classes. A class cannot have
superclass; instead it must implement one or more interfaces.

12
Collection of exam questions 12. 05. 2016

Figure 1: Extended virtual tables for B and C

class → class name implements interfaces { decls }

decls → decls ; decl ∣ decl
decl → variable-decl ∣ method -decl
method -decl → typename ( params ) body
type → int ∣ bool ∣ void
interfaces → interfaces , interface ∣ interface
interface → name

The words in italics are non-terminals, those in bold-face are terminals, and name rep-
resent names handed over by the scanner. That terminal name has an attribute “name”
(a string).
A special feature of this language is that class methods with the same name as the interfaces
the class implements are constructors for the class. A class can thus contain more than
one method with the same name as one of the implemented interfaces, also with different
parameter. The latter, though, is not the topic of the problem here.
The generation of new objects is of the form

new ⟨classname⟩ .⟨interface − name⟩(⟨actual − parameters⟩)

since different classes can implement the same interface.

One requirement of this language is that constructor need to be specified with the type
void , and that’s the requirement which you are requested to check using semantical rules.
Thus: give semantical rules in the following fragment of an attribute grammar. In the
definition, you can use functions and set etc you need, but you need to define them properly.
Answer with question using the corresponding attachement.

13
Collection of exam questions 12. 05. 2016

Exercise 13 (Code generation & P-code (25%%))

(a) This sub-task is to design a “verifier” for programs in P-code, i.e., for sequences of P-code
instructions.

(i) List a many possible “properties” that the verifier can or should check or test in P-
code programs. Explain in which sense a P-code program is correct given the list of
properties being checked for.
(ii) Sketch which data structures

(b)

(c) We want to translate the P-code to machine code for a platform where all operations,
including comparisons, must be done between values which reside in registers and that

14
Collection of exam questions 12. 05. 2016

lda v “load address” Determine the address of variable v and push it on top
of the stack. An address is an integer number, as well.
ldv v “load value” Fetch the value of variable v and push it on top of the
stack
ldc k “load constant” Push the constant value k on top of the stack
add “addition” calculate the sum of the stack’s top two elements, re-
move (“pop”) both from the stack and push the result
onto the top of the stack.
sto “store”
jmp L “jump” goto the designated label
jge L “jump on greater-or-equal” similar conditional jumps (“greater-than”, “less-than”
. . . ) exist.
lab L “label” label to be used as targets for (conditional) jumps.

Table 1: P-code instructions

register-memory transfers must be done with dedicated LOAD and STORE operations. During
the translation, we have a stack of descriptors.
Consider the P-instruction
ldv b
where b is a variable whose value resides in the home position. This instruction therefore
pushes the value of b onto the top of the stack. When translating that to machine code, a
question there is what is better: 1) doing a LOAD instruction so that the value of b ends up
in register or alternatively 2) push a descriptor onto the stack marking that b resides in its
home position.
Discuss the two alternatives under different assumptions and side conditions. These may
include the whether the user-level source language assures an order of evaluation of com-
pound expressions. Other factors you think relevant can be discussed as well.

(d) Again we translate our P-code to machine code and, as in the previous sub-problem, we
assume we translate again one block at a time, in isolation, and that consequently all
registers have to be “emptied” at the end of a basic block in a controlled manner.
The question is to find out which data descriptors in the stack are needed and if other
kinds of descriptors are needed.
We assume that we can search through all the descriptors of the elements on the stack
each time this information is needed. In that way, we avoid having to add another layer of
descriptor(s).
With your descriptor design: describe how to find information needed during code gener-
ation and, if your design contains additional descriptor, how to make use of them.

7 2012
Exercise 14 (CFGs and Parsing (25%%))

Consider the following grammar G1 :

S → a ∣ S #S ∣ S @S

Here, S is the start symbol and the only non-terminal. The symbols a, #, and @ (and
the end-of-input symbol $) are terminals.

15
Collection of exam questions 12. 05. 2016

(a) Give a concrete argument why the grammar is ambiguous.

(b) Assume that

• the operator # has low precedence and is right-assosicative

• the operaotr @ has high precedence and is left-associative

Give a new grammar G2 which describes the same language as G1 and follows the rules
just given. You may introduce new non-terminals, and it’s not required to give arguments
that G2 is unambiguous beyond pointing out similarities of corresponding unambiguous
grammars from the pensum.

(c) We look at the grammars G1 and G2 , as well as tje following grammar G3 (where the latter
contains + as new terminal symbol)

S → a ∣ S #S ∣ S @S ∣ +S +

Which of the languages L(G1 ), L(G2 ), and L(G3 ), are regular and which not. Explain
and give a regular expression for those which languages which happen to be regular.

(d) Give the LR(0)-DFAs for the ambiguous grammar G1 (using a S ′ in the usual way).

(e) Give the First and Follow -sets of S in G1 (making the usual use of the symbol $). Indicate
which states from the DFA of the previous sub-problem have

(i) conflicts which cannot be resolved with LR(0)-criteria, but can be solved via SLR(1)-
criteria. Explain.
(ii) Conflicts which cannot be resolved by SLR(1)-criteria. Explain.

16
Collection of exam questions 12. 05. 2016

8 2013
Exercise 15 (CFG and parsing (35%))

Consider the following 2 grammars G1 and G2 :

S → (S ) ∣ 

S → (S ) ∣ a

S is the only non-terminal and thus also the start symbol. The symbols (, ), and a are
terminals (together with $, which has the usual meaning).

(a) Which of the languages L(G1 ) and L(G2 ) are regular? For those which are regular, give a
regular expression representing the language.

(b) Next we look at a slighty more complex grammar G3 :

A → (S ) ∣ (B ]
B → S ∣ (B
S → (S ) ∣ 

Now, A, B, and S are non-terminals with A as start symbol. The symbols (, ), and ], are
terminals (together with $, which has the usual meaning).
Give 4 sentences of the language L(G3 ) such that they, in the best possible manner, cover
the different “kinds” of sentences from the language L(G3 ). Describe additionally in words
the sentences from L(G3 )

(c) For G3 , determine the first and follow-sets for A, B, and S. Make use of  as in the book.
Just give the result, no need for explanation.

(d) Draw the LR(0)-DFA for grammar G3 , after having introduced a new start symbol A′ ,
as usual. Hint: there are approximately 10 states, and 2 of them contain 6 items. Be
precise not to forget any elements in the closures when building the state, and combine
equal states.

(e) Put numbers on the states, starting from 0. Consider all states and discuss shortly those
states which have (at least) one LR(0)-conflict. Which one of those have also and SLR(1)-
conflict. Is G3 an SLR(1)-grammar?

(f) Draw parts of the parsing table for G3 according to the SLR(1)-format, namely those 2
lines which correspond to the states of the automaton which contain 6 items. If G3 is not
SLR(1), give all alternatives in the slots where there is an SLR(1)-conflict. Take care not
to forget any of the “symbols” needed in the header-line of the table.

Exercise 16 (Code generation and analysis (25%))

(a) We partition a method in a program into basic blocks and draw the flow graph for the
method. At the end we figure out which variable is live at the beginning and at the end
of each basic block (for example useing the “iteration”-method). Answer the following
questions:

(i) How can one find TA-instructions (om noen) which are guaranteed not to have any
influence when executing the program?

17
Collection of exam questions 12. 05. 2016

(ii) How can one determine whether there is a variable (optionally which ones) that are
read (“used”) before that have been given a value in the program?

(b) Take a look at the following control-flow graph

B0

B1

B2 B3 B5

B4

Knut opines that the graph contains the following loops (where loop is understood as
defined in connection with code generation and control-flow graphs)

B1 , B2 , B4 , B5
B1 , B3 , B4 , B5
B1 , B2 , B3 , B4 , B5

Astrid disagrees. Who is right? Give an explanation. If Astrid got it right, give the correct
loops of the graph.

18
Index
associativity, 16
attribute grammar, 12
automaton
push-down, 9

basic block, 19

cfg
and regular expressions, 6
code generation, 1
conflict, 6
control-flow graph, 19

dead code, 19

First-set, 6
flow graph, 19
Follow -set, 6

grammar, 6, 16

live, 19
LR(0), 17
LR(0)-DFA, 6
LR(0)-grammar, 6
LR(1)-grammar, 6

parsing table, 6
conflict, 6
precedence, 16
push-down automaton, 9

regular languages, 16

scoping, 19
SLR(1), 17
symbol table, 19

TA-instruction, 19
TAIC, 19

virtual method, 10
virtual table, 10

19
Collection of exam questions 12. 05. 2016

References
[Aho et al., 1986] Aho, A. V., Sethi, R., and Ullman, J. D. (1986). Compilers: Principles, Techniques,
and Tools. Addison-Wesley.
[Louden, 1997] Louden, K. (1997). Compiler Construction, Principles and Practice. PWS Publishing.

20