Dead code elimination in Compiler Design - Mini Project: Build & Apply

Dead Code Elimination

📖 Scenario: You are working on a simple compiler optimization step called Dead Code Elimination. This process removes parts of the code that never affect the program's output, making the program smaller and faster.Imagine you have a list of instructions in a program, and some instructions assign values to variables that are never used later. Your task is to identify and remove these unnecessary instructions.

🎯 Goal: Build a step-by-step process to identify and remove dead code from a list of instructions. You will create a data structure to hold instructions, mark which variables are used, and then filter out instructions that assign to unused variables.

📋 What You'll Learn

Create a list of instructions with exact variable assignments and usage

Create a set to track variables that are used later

Implement logic to identify and remove instructions assigning to unused variables

Complete the final filtered list representing the optimized code

💡 Why This Matters

🌍 Real World

Dead code elimination is a common optimization in compilers that helps reduce program size and improve performance by removing unnecessary instructions.

💼 Career

Understanding dead code elimination is important for compiler developers, software engineers working on performance optimization, and anyone interested in how programming languages and tools improve code efficiency.

1

Create the list of instructions

Create a list called instructions with these exact strings representing code lines: 'a = 5', 'b = 10', 'c = a + b', 'd = 20', 'print(c)'.

Compiler Design

# Create the list of instructions
# Your code here

Need a hint?

Use a Python list with the exact strings in the given order.

2

Create a set of used variables

Create a set called used_vars containing the exact variable names 'a', 'b', and 'c' which are used in the program.

Compiler Design

instructions = ['a = 5', 'b = 10', 'c = a + b', 'd = 20', 'print(c)']
# Create the set of used variables
# Your code here

Need a hint?

Use curly braces to create a set with the exact variable names.

3

Filter out dead code instructions

Create a new list called optimized_instructions that includes only instructions from instructions where the assigned variable is in used_vars. Use a for loop with variable instr to check each instruction's assigned variable before adding it to optimized_instructions.

Compiler Design

instructions = ['a = 5', 'b = 10', 'c = a + b', 'd = 20', 'print(c)']
used_vars = {'a', 'b', 'c'}
# Create optimized_instructions by filtering dead code
# Your code here

Need a hint?

Check if the instruction contains '=' to find assigned variables, then keep only those in used_vars. Also keep instructions without assignments like print(c).

4

Complete the optimized code list

Add the final line to the code that assigns optimized_instructions as the filtered list representing the program after dead code elimination.

Compiler Design

instructions = ['a = 5', 'b = 10', 'c = a + b', 'd = 20', 'print(c)']
used_vars = {'a', 'b', 'c'}
optimized_instructions = []
for instr in instructions:
    if '=' in instr:
        var = instr.split('=')[0].strip()
        if var in used_vars:
            optimized_instructions.append(instr)
    else:
        optimized_instructions.append(instr)
# Finalize the optimized instructions list
# Your code here

Need a hint?

The final step confirms the filtered list is ready to use as the optimized program.