Compiler Design for GATE CSE: Important Topics

The most important Compiler Design topics for GATE CSE 2027 are syntax-directed translation, LR parsing conflicts, LL(1) parsing with FIRST and FOLLOW, and data-flow analysis. It is the smallest core subject by marks, at about 5 a paper recently. It is also one of the most predictable, because nearly every question follows a handful of mechanical procedures.

Key takeaways

• The syllabus is unchanged for 2027. Data-flow analysis (constant propagation, liveness, common subexpression elimination) has been named since 2021.
• Analyst compilations put Compiler Design at about 4.6 marks on average from 2009 to 2026, and about 5.4 from 2018 onward.
• Evaluating a syntax-directed definition on an input is the most reliable question, appearing in roughly 20 of 27 years.
• LL(1) has moved from an occasional topic to a near-annual one, and analysts reported it again in 2026 Shift 2.
• Most questions are computations with one numeric answer. Practise about eight procedures and you have covered most of the subject's history.

What the GATE 2027 Compiler Design syllabus says

The official 2027 syllabus reads: "Lexical analysis, parsing, syntax-directed translation. Runtime environments. Intermediate code generation. Local optimisation, Data flow analyses: constant propagation, liveness analysis, common sub expression elimination."

This is unchanged from 2026. The last real change came in 2021, when local optimisation and data-flow analyses were added. Before that, optimisation questions were rare and mostly definitional. Now they are computational. Bootstrapping and T-diagrams are no longer named. They, along with operator-precedence parsing tables, have effectively disappeared from the paper. Confirm the wording at gate2027.iitm.ac.in.

How many marks Compiler Design carries

These are third-party analyst compilations (gateexam.info, GeeksforGeeks, careers360, goclasses.in, PW), not official figures. Grammar and ambiguity questions are sometimes counted under Theory of Computation, so figures vary by 1–2 marks.

The trend is mildly upward. The subject has not dropped below 4 marks since 2018. Post-exam analyses rarely call Compiler Design questions difficult, which is why they are some of the safest marks in the paper. Compare subjects in GATE CSE subject-wise weightage.

The most-tested Compiler Design topics and how they are asked

The years are reconstructed from PYQ repositories and are approximate.

1. Syntax-directed translation

This is the single most reliable question in the subject, seen in roughly 20 of 27 years. You get a grammar with semantic rules, often using unfamiliar operator symbols, and must compute an attribute value for a given input. This is usually a 2-mark NAT. Variants: the order in which embedded print actions fire, a string-valued attribute, or which SDD is L-attributed. The trap is associativity. E → E # T makes # left-associative, E → T # E makes it right-associative, and the two give different answers.

2. LR parsing: conflicts, classes and state counts

This appears in roughly 16–18 of 27 years, counting conflict and class questions together. Question forms: identify which parser class a grammar falls into (LR(0), SLR(1) but not LR(0), and so on up to CLR(1)), find the state with a shift–reduce or reduce–reduce conflict, or count states in the canonical LR(0) collection as a 2-mark NAT. MSQs test hierarchy statements such as "merging LR(1) states with the same core can introduce reduce–reduce conflicts but never shift–reduce conflicts".

3. LL(1) parsing, FIRST and FOLLOW

This appears in roughly 15–17 of 27 years. You compute FIRST or FOLLOW for a grammar with nullable nonterminals, fill LL(1) table entries, count entries, or decide whether a grammar is LL(1). A related 1-mark item asks for the correct grammar after removing left recursion or left factoring.

4. Runtime environments

Program output under static vs dynamic scoping, and output under call by reference, value-result or name (often with an array-index side effect). Activation record fields and access vs control links come up as shorter conceptual items.

5. Intermediate code

The minimum number of three-address instructions or temporaries for an expression, and node or edge counts in a DAG with repeated subexpressions.

6. Data-flow analysis and local optimisation

Seen in 2021, and approx. every year from 2022 to 2026. You find live variables at a point in a basic block, constants at a join in a small control-flow graph, or whether an expression is available. Classifying an optimisation (constant folding, copy propagation, strength reduction, dead code elimination) is a common 1-mark item. Counting basic blocks is growing as a short NAT.

A quick liveness example: take the block p = q * r, s = p + t, q = s - 1, with only q live at the exit. Working backwards: before the third line, s is live. Before the second, p and t are live. Before the first, q, r and t are live, so three variables are live at entry.

7. Lexical analysis

Count tokens in a C fragment, or say which tasks belong to the lexer. It is short, usually 1 mark, and easy if you know the traps.

Compiler Design priority table for GATE 2027

Tiers come from an eight-factor weighted score: historical and recent frequency, variety of question forms, syllabus centrality, time since last asked, format fit, IIT Madras history and other evidence. They guide study time. They do not promise any question.

The book's Compiler Design chapter scores all 19 subtopics individually, describes the likely question shape for each top topic, and includes 28 original practice questions with fully worked solutions. See what the book includes.

Common Compiler Design traps

• FOLLOW sets never contain ε, and $ always belongs to FOLLOW of the start symbol.
• Nullable chains. In A → B C D with B and C nullable, FIRST(D) goes into FIRST(A).
• LL(1) ε-entries. A → ε goes under every terminal in FOLLOW(A). A FIRST/FOLLOW overlap is a conflict even when the FIRST sets are disjoint.
• LALR state count. LALR(1) has the same number of states as LR(0)/SLR(1), and fewer than CLR(1).
• Merging lookaheads. Merging same-core states can create reduce–reduce conflicts, never shift–reduce.
• Ambiguous grammars are never LR(k), and left-recursive grammars are never LL(1).
• Precedence from grammar. An operator lower in the grammar (closer to the leaves) binds tighter. Left recursion means left associativity.
• Token counting. A string literal is one token, a comment is zero, and >= is one token. Maximal munch splits a+++b as a ++ + b.
• Dynamic scoping follows the call chain, not the program text.
• Call by name re-evaluates the argument each time it is used. That is why A[i] can refer to a different element after i changes.
• DAG counts. Identical subexpressions and repeated variable leaves share one node.
• Available expressions. An expression is available only if it is computed on every path with no later change to its operands. A variable holding different constants on two paths is not constant at the join.
• Phases. An undeclared variable is a semantic error, not a lexical one. An unterminated string is lexical.

Keep counting rules on your own formula sheet. One example: the number of LR(0) items is the sum of (RHS length + 1) over all productions, plus 2 for the augmented production. The GATE CSE formula sheet is a good place to start.

What past IIT Madras papers suggest

IIT Madras set the CS paper in 2003, 2011 and 2019. Compiler Design carried about 3 marks in 2011 and 5–6 in 2019. All three years used the standard computational patterns: LR conflicts, SDT and token counts. That shows no bias particular to Madras. The 2019 paper had 24 NAT questions, and Compiler Design lends itself to NAT, so plan to answer state counts, attribute values and live-variable counts without options to check against.

How to prepare Compiler Design for GATE 2027

1. Start with SDT. Build the parse tree using the grammar's own associativity, then evaluate bottom-up. Do print-order schemes and S/L-attributed classification in the same sitting.
2. FIRST, FOLLOW and LL(1). Practise on grammars with ε-productions and nullable chains until your sets come out right every time.
3. LR parsing as one procedure. Build LR(0) item sets, check LR(0) conflicts, resolve with FOLLOW for SLR, then check lookaheads for LALR and CLR. Count states carefully and watch for gotos that return to an existing state.
4. Data-flow analysis. Liveness backwards, constant propagation forwards, available expressions forwards on every path. Write the in and out sets for each block.
5. Runtime and intermediate code. Scoping and parameter-passing programs, three-address instruction counts, DAG node counts.
6. Lexical analysis and phases last. They are quick, so a short revision is enough.

Compiler Design shares grammars, ambiguity and parse-tree counting with Theory of Computation, so revising them back to back saves time. Because the subject is small and stable, it slots well into the late stages of a GATE CSE 2027 preparation strategy. The book's last-minute revision sheet puts the Compiler Design formulas and traps on a few pages for final revision (details).