Unit 1 Answers:

Short Questions:
1. Define compiler. A compiler is a software program that
translates source code written in a high-level programming
language into machine code, bytecode, or another
programming language. The main function of a compiler is to
convert the entire program into a format that can be executed
by a computer.
2. What is Context Free Grammar? Context Free Grammar (CFG)
is a type of formal grammar that consists of a set of production
rules used to generate strings in a language. Each rule describes
how a symbol can be replaced with a combination of symbols.
CFGs are widely used in programming languages and compilers
to define the syntax of languages.
3. Define pre-processor. What are the functions of pre-
processor? A pre-processor is a tool that processes the source
code before it is compiled. It performs tasks such as macro
substitution, file inclusion, and conditional compilation.
Functions of a pre-processor include:
o Including header files.
o Defining macros.
o Conditional compilation based on defined constants.
4. What is input buffer? An input buffer is a temporary storage
area that holds the input data (source code) before it is
processed by the compiler. It allows the compiler to read the
input data efficiently, often in chunks, rather than one character
at a time.
5. Differentiate compiler and interpreter.
 o Compiler: Translates the entire source code into machine
code before execution, resulting in faster execution time
but longer initial compilation time.
o Interpreter: Translates source code into machine code line
by line during execution, which allows for immediate
execution but can be slower overall.
6. What is input buffering? Input buffering is a technique used to
read input data into a buffer (temporary storage) to improve
the efficiency of reading data. It allows the compiler to read
larger chunks of data at once rather than character by
character, reducing the number of I/O operations.
7. Define the following terms:
o a) Lexeme: A lexeme is a sequence of characters in the
source code that matches the pattern for a token. It is the
smallest unit of meaning in the source code.
o b) Token: A token is a categorized block of text,
representing a basic element of the programming
language, such as keywords, operators, identifiers, or
literals.
8. Define interpreter. An interpreter is a program that directly
executes instructions written in a programming or scripting
language without requiring them to be compiled into machine
code. It translates high-level code into machine code line by line
and executes it immediately.
9. What are the differences between the NFA and DFA?
o NFA (Nondeterministic Finite Automaton):
 Can have multiple transitions for the same input
symbol.
  Can have epsilon (ε) transitions (transitions without
consuming input).
 May not have a unique next state for a given input.
o DFA (Deterministic Finite Automaton):
 Has exactly one transition for each input symbol
from a given state.
 Does not allow epsilon transitions.
 Always has a unique next state for a given input.
Long Questions:
1. Explain the various phases of a compiler with an illustrative
example. The phases of a compiler include:
o Lexical Analysis: Converts the source code into tokens.
Example: Reading the code int a = 5; produces tokens
like int, a, =, 5, ;.
o Syntax Analysis: Checks the tokens against the grammar
of the language to form a parse tree. Example: Validating
the structure of the statement.
o Semantic Analysis: Ensures that the statements are
semantically correct (e.g., type checking).
o Intermediate Code Generation: Translates the parse tree
into an intermediate representation (IR).
o Code Optimization: Improves the IR to make it more
efficient.
o Code Generation: Converts the optimized IR into machine
code.
o Code Optimization: Further optimizes the machine code.
 o Code Linking and Loading: Combines various code
modules and prepares them for execution.
2. Define Regular expression. Explain the properties of Regular
expressions.
A regular expression is a sequence of characters that defines a
search pattern, primarily used for string matching within texts.
Properties of regular expressions include:
o Closure: Regular expressions are closed under operations
like union, concatenation, and Kleene star.
o Associativity: Concatenation and union operations are
associative.
o Distributive Law: Regular expressions can be distributed
over union.
o Identity: The empty string and the empty set serve as
identity elements for concatenation and union,
respectively.
3. Differentiate between top down and bottom up parsing
techniques.
o Top Down Parsing: Starts from the root of the parse tree
and works down to the leaves. It uses a predictive
approach and is often implemented using recursive
descent. Example: LL parsers.
o Bottom Up Parsing: Starts from the leaves and works up
to the root. It uses a shift-reduce approach and is
implemented using LR parsers. Example: SLR parsers.
4. Construct an FA equivalent to the regular expression (0+1)
(00+11)(0+1). The finite automaton (FA) for the regular
expression can be constructed by creating states for each part
of the expression and transitions based on the input symbols (0
 and 1). The FA will have states that accept strings matching the
pattern defined by the regular expression.

5. Explain the various phases of a compiler in detail. Also write

down the output for the following expression: position :=
initial + rate * 60.
The phases of a compiler include:
o Lexical Analysis: Tokenizes the input expression.
o Syntax Analysis: Validates the structure of the expression.
o Semantic Analysis: Checks for semantic correctness (e.g.,
type compatibility).
o Intermediate Code Generation: Generates an
intermediate representation.
o Code Generation: Produces machine code. The output for
the expression position := initial + rate * 60 would be a
series of machine code instructions that perform the
addition and multiplication operations.
6. Construct an FA equivalent to the regular expression
10(0+11)0*1.
Similar to the previous FA construction, this FA will have states
and transitions that correspond to the patterns defined in the
regular expression. The FA will accept strings that match the
pattern 10 followed by either 0 or 11, followed by zero or more 0s,
and ending with 1.
 Unit 2

Short Questions:
1. Define augmented grammar.
o Augmented grammar is a grammar that has been
extended with additional productions to facilitate parsing.
It typically includes a new start symbol and additional
rules that help in the parsing process, especially in LR
parsing techniques.
2. Compare the LR Parsers.
LR parsers are bottom-up parsers that read input from left to right
and produce a rightmost derivation. They can be classified into
different types such as SLR (Simple LR), LALR (Look-Ahead LR), and
Canonical LR. The main differences lie in their handling of lookahead
symbols and the complexity of their parsing tables.
3. Compare and contrast LR and LL Parsers.
o LR parsers are bottom-up and can handle a larger class of
grammars (LR(k) grammars) compared to LL parsers,
which are top-down and can only handle a subset of
context-free grammars (LL(k) grammars). LR parsers use a
stack to manage states and can handle left recursion,
while LL parsers cannot.
4. Differentiate between top down parsers.
o Top-down parsers construct the parse tree from the top
(the start symbol) down to the leaves (the input symbols).
They use a predictive approach based on the current input
 symbol and the production rules. In contrast, bottom-up
parsers start from the input symbols and work their way
up to the start symbol.
5. Define Dead code elimination?
o Dead code elimination is an optimization technique that
removes code that does not affect the program's output.
This includes code that is never executed or variables that
are never used after their assignment.
6. Eliminate immediate left recursion for the following grammar:
o For the grammar:
o E -> E + T | T
o T -> T * F | F
o F -> (E) | id
The immediate left recursion can be eliminated by rewriting it as:
Explain
E -> T E'
E' -> + T E' | ε
T -> F T'
T' -> * F T' | ε
F -> (E) | id
7. Mention the types of LR parser.
o The types of LR parsers include:
 SLR (Simple LR)
 LALR (Look-Ahead LR)
 Canonical LR
 8. Explain bottom up parsing method.
o Bottom-up parsing is a parsing technique that starts with
the input symbols and attempts to construct the parse
tree up to the start symbol. It uses a stack to keep track of
the states and applies reduction rules based on the
grammar to reduce the input to the start symbol. This
method is powerful and can handle a wider range of
grammars compared to top-down parsing.

UNIT 3

Short Questions:
1. Define Type Equivalence.
o Type equivalence refers to the concept of determining
whether two types are considered the same in a
programming language. This can be based on name
equivalence (types are equivalent if they have the same
name) or structural equivalence (types are equivalent if
they have the same structure, regardless of their names).
2. Explain the role of intermediate code generator in the
compilation process.
o The intermediate code generator translates the high-level
source code into an intermediate representation (IR) that
is easier to manipulate than the original source code but
not as low-level as machine code. This allows for
optimizations to be performed on the IR before
generating the final machine code.
3. Define leftmost derivation and rightmost derivation with
example.
o Leftmost derivation is a method of deriving a string from a
grammar by always replacing the leftmost non-terminal
first. Rightmost derivation replaces the rightmost non-
terminal first.
o Example:
 For the grammar:
 S -> AB
 A -> a
 B -> b
 Leftmost derivation of ab:
 S -> AB -> aB -> ab
 Rightmost derivation of ab:
 S -> AB -> A b -> a b
4. What are the various types of intermediate code
representation?
o The various types of intermediate code representation
include:
 Three-address code: Each instruction has at most
three operands.
 Quadruples: A representation where each
instruction is represented as a tuple of four fields
(operator, arg1, arg2, result).
 Triples: Similar to quadruples but without the result
field, using indices instead.
  Abstract Syntax Trees (AST): A tree representation
of the abstract syntactic structure of source code.
5. Write a note on the specification of a simple type checker.
o A simple type checker verifies that the types of variables
and expressions in a program are used consistently
according to the rules of the programming language. It
checks for type compatibility in operations, function calls,
and variable assignments, ensuring that operations are
performed on compatible types.
6. Explain intermediate code representations?
o Intermediate code representations are abstractions of the
source code that are used during the compilation process.
They serve as a bridge between the high-level source code
and the low-level machine code, allowing for
optimizations and transformations to be applied without
being tied to a specific machine architecture.
7. Define type expression with an example?
o A type expression is a formal representation of a type in a
programming language, which can include primitive types,
composite types, and type constructors. For example, in a
language with integers and arrays, a type expression could
be Array[Int], representing an array of integers.
8. State general activation record.
o An activation record (or stack frame) is a data structure
that contains information about a single execution of a
procedure or function. It typically includes:
 Return address
 Parameters
  Local variables
 Saved registers
 Control link (pointer to the previous activation
record)
Long Questions:
1. Explain in brief about equivalence of type expressions with
examples.
o Equivalence of type expressions determines whether two
type expressions represent the same type. For example, in
a language with user-defined
types, Point and Point (defined in the same scope) are
equivalent, while Point and Point (defined in different
scopes) may not be. Structural equivalence would
consider two types equivalent if they have the same
structure, such as struct { int x; int y; } being equivalent to
another struct with the same fields.
2. Explain about Type checking and Type Conversion with
examples.
o Type checking is the process of verifying that the types of
variables and expressions are used correctly according to
the language's rules. For example, in a statically typed
language, trying to assign a string to an integer variable
would result in a type error.
o Type conversion is the process of converting one type to
another, either implicitly (automatic conversion) or
explicitly (using a cast). For example, converting an integer
to a float can be done implicitly in many languages, while
converting a float to an integer may require an explicit
cast.
3. What is a three address code? Mention its types. How would
you implement the three address statements? Explain with
examples.
o Three-address code is an intermediate representation
where each instruction consists of at most three
operands. The types of three-address code include:
 Basic operations: Assignments, arithmetic
operations, and control flow.
 Example of three-address code:
 t1 = a + b
 t2 = t1 * c
 x = t2 - d
o Implementation involves generating these instructions
during the intermediate code generation phase of
compilation.
4. What is type checker? Explain the specification of a simple
type checker.
o A type checker is a component of a compiler that verifies
the type correctness of a program. It checks that
operations are performed on compatible types and that
variables are used consistently. A simple type checker
would maintain a symbol table to track variable types and
perform checks during the semantic analysis phase of
compilation.
5. Translate the following expression: (a + b) * (c + d) into a)
Quadruples b) Triples.
o a) Quadruples:
o (1) t1 = a + b
 o (2) t2 = c + d
o (3) t3 = t1 * t2
o b) Triples:

(1) ( + , a, b)
(2) ( + , c, d)
(3) ( * , 1, 2)
6. Construct a quadruple, triples for the following expression: a +
a * (b - c) + (b - c) * d?
o Quadruples:
Explain
(1) t1 = b - c
(2) t2 = a * t1
(3) t3 = t1 * d
(4) t4 = a + t2
(5) result = t4 + t3
o Triples:
Explain
(1) ( - , b, c)
(2) ( * , a, 1)
(3) ( * , 1, d)
(4) ( + , a, 2)
(5) ( + , 4, 3)
UNIT 4

Short Questions:
1. Write the quadruple for the following expression: (x + y) * (y +
z) + (x + y + z).
o Quadruples:
Explain
(1) t1 = x + y
(2) t2 = y + z
(3) t3 = t1 * t2
(4) t4 = x + y
(5) t5 = t4 + z
(6) result = t3 + t5
2. What is a DAG? Mention its applications.
o A Directed Acyclic Graph (DAG) is a graph that is directed
and contains no cycles. In compiler design, DAGs are used
to represent expressions and their dependencies.
Applications include:
 Representing computations in optimization phases.
 Eliminating common sub-expressions.
 Facilitating efficient code generation by reusing
previously computed values.
3. What are Abstract Syntax Trees?
 o An Abstract Syntax Tree (AST) is a tree representation of
the abstract syntactic structure of source code. Each node
in the tree represents a construct occurring in the source
code. ASTs are used in compilers to represent the
structure of the program in a way that is easier to analyze
and manipulate than the original source code.
4. Define address descriptor and register descriptor.
o An address descriptor is a data structure that provides
information about the location of a variable in memory,
including its address and type.
o A register descriptor is a data structure that keeps track of
the status of registers in the CPU, including which
variables are currently stored in which registers and their
types.
5. Discuss about common sub-expression elimination.
o Common sub-expression elimination is an optimization
technique that identifies and eliminates expressions that
are computed multiple times within a program. By storing
the result of the expression in a temporary variable and
reusing it, the compiler can reduce the number of
computations, leading to improved performance.
6. What is a Flow graph?
o A flow graph is a directed graph that represents the
control flow of a program. Nodes in the graph represent
basic blocks (straight-line code sequences), and edges
represent the flow of control between these blocks. Flow
graphs are used in various analyses and optimizations,
such as data flow analysis and loop optimization.
7. Define constant folding.
 o Constant folding is an optimization technique that
simplifies constant expressions at compile time rather
than at runtime. For example, an expression like 3 + 4 can
be evaluated to 7 during compilation, reducing the
amount of computation needed at runtime.
8. Define reduction in strength.
o Reduction in strength is an optimization technique that
replaces an expensive operation with a less expensive
one. For example, replacing a multiplication operation by
a power of two with a bit shift operation, which is
generally faster. This can lead to improved performance
without changing the program's output.
Long Questions:
1. Explain the issue and the difference between the heap
allocated activation records versus stack allocated activation
records.
o Heap allocated activation records are dynamically
allocated at runtime and can persist beyond the execution
of the function that created them. This allows for more
flexible memory usage but can lead to fragmentation and
requires manual management (allocation and
deallocation).
o Stack allocated activation records are allocated on the call
stack and are automatically managed. They are created
when a function is called and destroyed when the
function exits. This is generally faster and simpler but
limits the lifetime of the activation record to the duration
of the function call.
2. Write the principal sources of optimization.
o The principal sources of optimization in compilers include:
  Local optimizations: Optimizations that are applied
within a single basic block, such as dead code
elimination and constant folding.
 Global optimizations: Optimizations that consider
the entire program or multiple basic blocks, such as
common sub-expression elimination and loop
unrolling.
 Machine-dependent optimizations: Optimizations
that take advantage of specific features of the target
architecture, such as register allocation and
instruction scheduling.
 Machine-independent optimizations: Optimizations
that can be applied regardless of the target
architecture, such as inlining and constant
propagation.
3. Discuss about the following: a) Copy Propagation b) Dead code
Elimination c) Code motion.
o a) Copy Propagation: This optimization replaces
occurrences of a variable that is a copy of another variable
with the original variable. For example, if x = y and later z
= x, then z can be replaced with y.
o b) Dead Code Elimination: This optimization removes code
that does not affect the program's output, such as code
that is never executed or variables that are assigned but
never used.
o c) Code Motion: This optimization moves code outside of
loops or conditional statements when it is safe to do so,
reducing the number of times the code is executed. For
example, if a calculation does not depend on the loop
variable, it can be moved outside the loop.
4. Explain Lazy-code motion problem with an algorithm.
o Lazy-code motion is an optimization technique that
postpones the movement of code until it is certain that
the code can be moved without affecting the program's
semantics. The algorithm typically involves:
 Analyzing the control flow to identify code that can
be moved.
 Checking dependencies to ensure that moving the
code does not change the program's behavior.
 Moving the code to a more optimal location, such as
outside of loops.
5. Explain the following with an example: a) Redundant sub-
expression elimination b) Frequency reduction c) Copy
propagation.
o a) Redundant sub-expression elimination: This
optimization identifies expressions that are computed
multiple times and eliminates the redundancy. For
example, in the expression a + b + a + b, the sub-
expression a + b can be computed once and reused.
o b) Frequency reduction: This optimization reduces the
frequency of certain operations by replacing them with
simpler or less frequent operations. For example,
replacing a division operation with a multiplication by the
reciprocal when the divisor is a constant.
o c) Copy propagation: As mentioned earlier, this
optimization replaces copies of variables with their
original values. For example, if x = a and later y = x,
then y can be replaced with a.
6. Explain various methods to handle peephole optimization.
 o Peephole optimization involves looking at a small window
(or "peephole") of instructions and applying local
optimizations. Methods include:
 Elimination of Redundant Code: Removing
instructions that do not affect the program's output.
 Elimination of Unreachable Code: Removing code
that can never be executed.
 Combining Instructions: Merging multiple
instructions into a single instruction when possible,
such as combining adjacent arithmetic operations.
7. Explain the following peephole optimization techniques: a)
Elimination of Redundant Code b) Elimination of Unreachable
Code.
o a) Elimination of Redundant Code: This technique
identifies and removes instructions that compute the
same result multiple times without any changes in the
inputs. For example, if an instruction t = a + b appears
multiple times without any changes to a or b, subsequent
occurrences can be removed.
o b) Elimination of Unreachable Code: This technique
removes code that cannot be executed due to the control
flow of the program. For example, code after
a return statement in a function is unreachable and can be
eliminated.

UNIT 5
Short Questions
1. What are induction variables?
 o Induction variables are variables that are incremented or
decremented in a loop and are used to control the
number of iterations. They typically take on a sequence of
values that can be expressed as a function of the loop
index.
2. Explain about code motion.
o Code motion is an optimization technique that involves
moving computations that yield the same result outside of
a loop to reduce the number of times they are executed.
This can improve performance by minimizing redundant
calculations.
3. What is machine independent code optimization?
o Machine independent code optimization refers to
optimizations that can be applied to the intermediate
representation of code, regardless of the target machine
architecture. These optimizations aim to improve
performance and reduce resource usage without being
tied to specific hardware features.
4. Write a short note on copy propagation.
o Copy propagation is an optimization technique that
replaces occurrences of a variable with the value of
another variable that has been assigned to it. This can
simplify expressions and reduce the number of variables
in use, leading to more efficient code.
5. What are the induction variables?
o This question is a repeat of the first one. Induction
variables are typically used in loops to track the number
of iterations and can be optimized to improve
performance.
 6. Write a short note on Flow graph.
o A flow graph is a directed graph that represents the
control flow of a program. Nodes in the graph represent
basic blocks of code, while edges represent the flow of
control between these blocks. Flow graphs are useful for
various analyses, including data flow analysis and
optimization.
Long Questions
1. Explain data-flow schemas on basic blocks with flow graphs.
o Data-flow analysis involves examining the flow of data
within a program to optimize it. In the context of basic
blocks represented in flow graphs, data-flow schemas
help identify how data values are passed between blocks.
This analysis can be used to optimize variable usage,
eliminate dead code, and improve overall efficiency.
2. Explain Lazy-code motion problem with an algorithm.
o Lazy-code motion is an optimization strategy that
postpones the execution of certain computations until
their results are actually needed. This can help avoid
unnecessary calculations. An algorithm for lazy-code
motion typically involves analyzing the control flow to
determine when a computation can be safely moved or
delayed.
3. Explain in brief about different Principal sources of
optimization techniques with suitable examples.
o Principal sources of optimization techniques include:
 Loop Optimization: Techniques like loop unrolling or
invariant code motion that improve the performance
of loops.
  Dead Code Elimination: Removing code that does
not affect the program's output, thus reducing the
size and improving performance.
 Common Subexpression Elimination: Identifying
and reusing previously computed expressions to
avoid redundant calculations.
 Inline Expansion: Replacing a function call with the
function's body to eliminate the overhead of the
call.
1. Example of DAG for Register Allocation
A Directed Acyclic Graph (DAG) can be used to represent expressions
and their dependencies in a program. Each node in the DAG
represents an operation or a variable, and edges represent
dependencies between them.
Example: Consider the expression:
a=b+c
d=a*e
f=a+g
The corresponding DAG would look like this:
Explain
+
/\
b c
\
a
/\
 * +
/\/\
a ea g
In this DAG:
o The nodes b, c, e, and g are operands.
o The nodes + and * represent operations.
o The node a is computed from b + c and is reused in
both d and f.
Register Allocation: When allocating registers, the compiler can use
the DAG to identify which values can be stored in registers and which
can be computed on-the-fly. For instance, since a is used multiple
times, it can be allocated to a register, while b, c, e, and g can be
loaded into registers as needed.
2. Machine Dependent Code Optimization Techniques and Their
Drawbacks
Machine Dependent Optimization Techniques:
o Instruction Scheduling: Rearranging the order of
instructions to minimize stalls and improve pipeline
utilization.
 Drawback: This can lead to increased complexity in
the compiler and may not always yield significant
performance improvements due to varying
execution times of different instructions.
o Register Allocation: Assigning variables to a limited
number of registers to minimize memory access.
 Drawback: The complexity of register allocation
algorithms can lead to suboptimal usage of registers,
especially in large functions with many variables.
 o Loop Unrolling: Expanding loops to decrease the
overhead of loop control.
 Drawback: This can increase the size of the code,
leading to potential cache misses and increased
instruction fetch times.
o Branch Prediction: Using hardware or software
techniques to predict the direction of branches to improve
flow control.
 Drawback: Incorrect predictions can lead to pipeline
flushes, negating the performance benefits.

3. Issues in the Design of Code Generator

o Target Architecture: The code generator must be tailored
to the specific architecture of the target machine, which
can vary widely in terms of instruction set, register
availability, and memory architecture.
o Optimization Trade-offs: Balancing between generating
efficient code and maintaining simplicity in the code
generation process can be challenging. More complex
optimizations may lead to longer compilation times.
o Error Handling: The code generator must handle errors
gracefully, providing meaningful feedback while ensuring
that the generated code is still valid.
o Resource Management: Efficiently managing resources
such as registers and memory during code generation is
crucial to avoid performance bottlenecks.
4. Peep Hole Optimization
Peep hole optimization is a local optimization technique that
examines a small window (or "peep hole") of instructions to identify
and replace inefficient sequences with more efficient ones.
Examples of Peep Hole Optimizations:
o Redundant Instruction Elimination: Removing
instructions that do not affect the program's outcome.
o Constant Folding: Evaluating constant expressions at
compile time rather than at runtime.
o Instruction Combining: Merging multiple instructions into
a single instruction when possible.
Procedure:
15. Identify a small set of instructions (the peep hole).
16. Analyze the instructions for potential optimizations.
17. Replace the inefficient sequence with a more efficient
one.
18. Repeat the process until no further optimizations can be
made.
5. Machine Dependent vs. Machine Independent Optimization
o Machine Dependent Optimization:
 Optimizations that are tailored to a specific
architecture or machine. Examples include
instruction scheduling, register allocation, and
specific instruction usage.
  Pros: Can yield significant performance
improvements on the target machine.
 Cons: Less portable; optimizations may not apply to
other architectures.
o Machine Independent Optimization:
 Optimizations that can be applied to the
intermediate representation of code, regardless of
the target machine. Examples include constant
propagation, dead code elimination, and loop
transformations.
 Pros: More portable and can be applied across
different architectures.
 Cons: May not exploit specific features of the target
machine, potentially leading to less optimal
performance.
6. Data-Flow Analysis of Structural Programs
Data-flow analysis is a technique used to gather information about
the possible set of values calculated at various points in a computer
program. It is particularly useful in optimizing compilers.
Key Concepts:
o Control Flow Graph (CFG): Represents the flow of control
in a program, where nodes represent basic blocks and
edges represent control flow.
o Data-Flow Equations: Used to compute information such
as reaching definitions, live variables, and available
expressions.
o Transfer Functions: Define how data values are
transformed as control flows from one block to another.
Applications:
o Optimization: Helps in identifying opportunities for
optimizations like constant folding and dead code
elimination.
o Type Checking: Assists in ensuring that variables are used
consistently throughout the program.
7. Procedure to Eliminate Global Common Subexpression
Global common subexpression elimination (CSE) is an optimization
technique that identifies and eliminates expressions that are
computed multiple times across different parts of a program.
Procedure:
26. Identify Expressions: Traverse the intermediate
representation of the program to identify expressions that
are computed more than once.
27. Build a Use-Def Chain: Create a use-def chain to track
where each expression is used and defined.
28. Replace Redundant Expressions: For each identified
common subexpression, replace subsequent occurrences
with a reference to the previously computed value.
29. Update the Intermediate Representation: Modify the
intermediate representation to reflect these changes,
ensuring that the program's semantics remain unchanged.
Example: For the expression:
x=a+b
y=a+b*c
The common subexpression a + b can be computed once and reused:
temp = a + b
x = temp
y = temp * c
This optimization reduces redundant calculations and improves
performance.
If you need further details or examples on any specific topic, feel free
to ask!