Chapter 6: Code Optimization

Code optimization in compiler design is a critical phase in the process of compiler design
that aims to improve the efficiency and performance of compiled programs. By applying
various techniques, compilers can generate optimized code that consumes fewer resources,
executes faster, and delivers better overall performance.
Code optimization in compiler design refers to the process of improving the efficiency and
performance of a program by making modifications to its code. It involves analyzing the
code and applying various techniques to eliminate redundancies, reduce computational
overhead, minimize memory usage, and optimize the generated machine code. The goal is
to produce optimized code that performs the same functionality as the original code but
with improved execution speed and resource utilization. Code optimization plays a crucial
role in enhancing the overall quality and performance of compiled programs.

Code optimization occurs during the compilation phase, where the compiler analyzes the
code and applies various transformations to optimize it.

Advantages of Code Optimization

Optimizing code offers several advantages, including:

Faster Execution Speed: Optimized code executes more quickly, leading to improved
program responsiveness and user experience.
Efficient Memory Utilization: Code optimization ensures efficient utilization of
memory, reducing resource consumption and enabling programs to run smoothly on
various hardware platforms.
Enhanced Performance: Optimized code performs better in terms of speed and
efficiency, resulting in overall improved program performance.

Code Optimization Techniques:

Code optimization techniques in compiler design are used to improve the efficiency,
performance, and quality of the generated machine code.
Here are some commonly used code optimization techniques:

1. Constant Folding
2. Dead Code Elimination
3. Common Subexpression Elimination
4. Loop Optimization
5. Register Allocation
6. Inline Expansion
7. Strength Reduction
8. Control Flow Optimization

1. Constant Folding

Constant folding is a powerful optimization technique that involves evaluating constant

expressions at compile time and replacing them with their computed results. By performing
computations during compilation rather than runtime, constant folding eliminates the need
for repetitive calculations, resulting in faster and more efficient code execution.

The technique focuses on simplifying and optimizing code by replacing the original
expressions with their resolved values.

Example:

int result = 2 + 3 * 4;

During constant folding, the expression “2 + 3 * 4” is evaluated at compile time, resulting in

the value 14. The optimized code would then replace the original expression with the
computed result:

int result = 14;

By eliminating the need for runtime computations, constant folding improves code
efficiency and enhances the overall performance of the program.

2. Dead Code Elimination

Dead code elimination is a crucial optimization technique that involves identifying and
removing code segments that are unreachable or have no impact on the program’s output.
By eliminating dead code, the compiler reduces the size of the executable and enhances
code clarity and maintainability.

Example:

int x = 5; if (x > 10) { int y = x * 2;

}

In this case, the code inside the if statement is dead code since the condition is never true.
During the dead code elimination process, the compiler detects that the code block inside
the if statement will never be executed and removes it from the optimized code:

int x = 5;

By eliminating dead code, the compiler streamlines the program, reducing unnecessary
computations and improving execution efficiency.

3. Common Subexpression Elimination

Common subexpression elimination is an optimization technique that aims to identify and

eliminate redundant computations in a program. By recognizing expressions that have
already been computed and storing their results for reuse, common subexpression
elimination reduces redundant calculations and enhances code efficiency.

Example:

int a = b + c; int d = b + c * 2;

In this case, the expression “b + c” is a common subexpression occurring twice. During

common subexpression elimination, the compiler detects this redundancy and assigns the
result of “b + c” to a temporary variable, which can then be reused in subsequent
computations:

int temp = b + c; int a = temp; int d = temp * 2;

By eliminating redundant computations, common subexpression elimination reduces

computational overhead, leading to improved code efficiency and faster execution.
4. Loop Optimization

Loop optimization techniques focus on enhancing the efficiency of loops. Loop

optimization aims to optimize the execution of loops by minimizing the number of
iterations, reducing unnecessary computations, and improving memory access patterns.
This optimization technique plays a crucial role in improving the overall performance of
programs that heavily rely on loop constructs.

Example:
int sum = 0; for (int i = 0; i < n; i++) {
sum += i;
}

Loop optimization techniques, such as loop unrolling, can be applied to optimize this loop.
Loop unrolling involves duplicating the loop body to reduce loop control overhead and
improve instruction-level parallelism. After loop unrolling, the code would look like:

int sum = 0; for (int i = 0; i < n; i += 2) {

sum += i;
sum += i + 1;
}

By reducing the number of iterations and improving instruction-level parallelism, loop

optimization techniques enhance the efficiency of loop execution and contribute to overall
code optimization.

5. Register Allocation

Register allocation is the process of efficiently assigning variables to the limited number of
CPU registers available. By minimizing memory accesses and maximizing register usage,
execution speed and resource utilization can be improved.

Example:

int a = 5;
int b = 10;
int c = a + b;
During register allocation, the values of variables ‘a’ and ‘b’ can be stored in registers, and
the computation can be performed directly on the registers instead of accessing memory
repeatedly.

6. Inline Expansion

Inline expansion involves replacing function calls with their actual code to eliminate the
overhead of function call and return. This technique is beneficial for small, frequently called
functions.

Example: Consider a function that calculates the square of a number

int square(int x) { return x * x;

}

By applying inline expansion, the function call square(5) can be replaced with the actual
code 5 * 5, eliminating the need for a function call.

7. Strength Reduction

Strength reduction is an optimization technique that aims to replace expensive or complex

operations with simpler and more efficient alternatives. By identifying opportunities to
replace computationally expensive operations with less costly ones, strength reduction
improves code efficiency and execution speed.

Example:

int result = a * 8;

In this case, the multiplication operation with the constant 8 is computationally expensive.
However, through strength reduction, the compiler can replace the multiplication with a
more efficient operation:

int result = a << 3;

In this optimized version, the shift-left operation by 3 bits achieves the same result as
multiplying by 8 but with fewer computational steps.
By replacing expensive operations with simpler alternatives, strength reduction reduces
computational overhead and improves code execution efficiency.

8. Control Flow Optimization

Control flow optimization is a technique in compiler design that improves the efficiency of
control flow structures in a program. It includes optimizations such as branch prediction,
loop optimization, dead code elimination, simplification of control flow graphs, and tail
recursion elimination.

The main objective is to minimize the impact of conditional branches and loops on program
performance. By predicting branch outcomes, optimizing loops, removing dead code,
simplifying control flow graphs, and transforming tail recursion, the compiler enhances
execution speed and resource utilization.

Example:

int x = 10;
int y = 20;
int z;
if (x > y) {
z = x + y;
} else {
z = x - y;
}

In this code, there is a conditional statement that checks if x is greater than y. Based on the
condition, either the addition or subtraction operation is performed, and the result is stored
in variable z.

Through control flow optimization, the compiler can perform branch prediction and
determine that the condition x > y is always false. In this case, it knows that the code inside
the if block will never be executed.

As a result, the compiler can optimize the code by eliminating the unused code block,
resulting in the following optimized code:

int x = 10; int y = 20; int z = x - y;

By removing the unnecessary conditional branch, the optimized code becomes simpler and
more efficient. This improves the program’s execution speed and reduces any overhead
associated with evaluating the condition.