Syntax Directed Translation · Compiler Design · GATE CSE

Consider the following ANSI C program:

int main() {

Integer x;

return 0;

}

Which one of the following phases in a seven-phase C compiler will throw an error?  

Consider the following code segment.

x = u - t;
y = x * v;
x = y + w;
y = t - z;
y = x * y;

The minimum number of total variables required to convert the above code segment to static single assignment form is .

In the context of abstract-syntax-tree $$(AST)$$ and control-flow-graph $$(CFG),$$ which one of the following is TRUE?

One of the purposes of using intermediate code in compilers is to

Which of the following statements is FALSE?

In the following grammar:

$$\eqalign{ & X:: = X \oplus {Y \over Y} \cr & Y:: = Z*{Y \over Z} \cr & Z:: = id \cr} $$

Which of the following is true?

A linker is given object modules for a set of programs that were compiled separately. What information need to be included in an object module?

Generation of intermediate code based on an abstract machine model is useful in compilers because

Consider the following syntax-directed definition (SDD).

S → DHTU	{ S.val = D.val + H.val + T.val + U.val; }
D → “M” D1	{ D.val = 5 + D1.val; }
D → ε	{ D.val = –5; }
H → “L” H1	{ H.val = 5 * 10 + H1.val; }
H → ε	{ H.val = –10; }
T → “C” T1	{ T.val = 5 * 100 + T1.val; }
T → ε	{ T.val = –5; }
U → “K”	{ U.val = 5; }

Given “MMLK” as the input, which one of the following options is the CORRECT value computed by the SDD (in the attribute S.val)?

Consider the syntax directed translation given by the following grammar and semantic rules. Here N, I, F and B are non-terminals. N is the starting non-terminal, and #, 0 and 1 are lexical tokens corresponding to input letters "#", "0" and "1", respectively. X.val denotes the synthesized attribute (a numeric value) associated with a non-terminal X. I$$_1$$ and F$$_1$$ denote occurrences of I and F on the right hand side of a production, respectively. For the tokens 0 and 1, 0.val = 0 and 1.val = 1.

$\begin{array}{llll}N & \rightarrow & I \# F & \text { N.val }=I . v a l+F . v a l \\ I & \rightarrow & I_1 B & I . v a l=\left(2 I_1 \cdot v a l\right)+\text { B.val } \\ I & \rightarrow & B & I . v a l=B . v a l \\ F & \rightarrow & B F_1 & F . v a l=\frac{1}{2}\left(B . v a l+F_1 \cdot v a l\right) \\ F & \rightarrow & B & F . v a l=\frac{1}{2} B . v a l \\ B & \rightarrow & 0 & \text { B.val }=\mathbf{0} . \mathrm{val} \\ B & \rightarrow & 1 & \text { B.val }=\mathbf{1} . \mathrm{val}\end{array}$

The value computed by the translation scheme for the input string

$$10 \# 011$$

is ____________. (Rounded off to three decimal places)

Consider the following grammar along with translation rules.

S $$\to$$ S₁ # T {S.val = S₁.val * T.val}

S $$\to$$ T {S.val = T.val}

T $$\to$$ T₁ %R {T.val = T₁.val $$ \div $$ R.val}

T $$\to$$ R {T.val = R.val}

R $$\to$$ id {R.val = id.val}

Here # and % are operators and id is a token that represents an integer and id.val represents the corresponding integer value. The set of non-terminals is {S, T, R, P} and a subscripted non-terminal indicates an instance of the non-terminal. Using this translation scheme, the computed value of S.val for root of the parse tree for the expression 20#10%5#8%2%2 is ___________.

Consider the following grammar (that admits a series of declarations, followed by expressions) and the associated syntax directed translation (SDT) actions, given as pseudo-code:

P → D* E*

D → int ID {record that ID.lexeme is of type int}

D → bool ID { record that ID.lexeme is of type bool}

E → E₁ + E₂ {check that E₁.type = E₂.type = int; set E.type := int}

E → !E₁ {check that E₁.type = bool; set E.type := bool}

E → ID {set E.type := int}

With respect to the above grammar; which one of the following choices is correct?

Consider the following grammar and the semantic actions to support the inherited type declaration attributes. Let $X_1, X_2, X_3, X_4, X_5$, and $X_6$ be the placeholders for the nonterminals $\mathrm{D}, \mathrm{T}, \mathrm{L}$ or $\mathrm{L}_1$ in the following table :

Production rule	Semantic action
D → T L	X1.type = X2.type
T → int	T.type = int
T → float	T.type = float
L → L1, id	X3.type = X4.type addType(id.entry, X5.type)
L → id	addType(id.entry, X6.type)

Which one of the following are the appropriate choices for $X_1, X_2, X_3$ and $X_4$ ?

Consider the following Syntax Directed Translation Scheme $$(SDTS),$$ with non-terminals $$\left\{ {S,A} \right\}$$ and terminals $$\left\{ {A,B} \right\}.$$
$$S \to aA$$ $$\,\,\,\,\,$${ print $$1$$ }
$$S \to a$$ $$\,\,\,\,$$$$\,\,\,\,\,$${ print $$2$$ }
$$A \to Sb$$ $$\,\,\,\,\,$${ print $$3$$ }

Using the above $$SDTS,$$ the output printed by a bottom-up parser, for the input $$aab$$ is:

Consider the basic block given below.

a = b + c 
c = a + d 
d = b + c 
e = d - b 
a = e + b

The minimum number of nodes and edges present in the DAG representation of the above basic block respectively are

The program below uses six temporary variables a, b, c, d, e, f.

a = 1 
b = 10 
c = 20 
d = a + b 
e = c + d 
f = c + e 
b = c + e 
e = b + f 
d = 5 + e 
return d + f

Assuming that all operations take their operands from registers, what is the minimum number of registers needed to execute this program without spilling?