Dead code elimination in Compiler Design - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to identify dead code by checking if a statement's result is {{BLANK_1}}.

Compiler Design

if statement.result == [1]:
    print("Dead code detected")

Drag options to blanks, or click blank then click option'

Anull

Bused

Cactive

Dunused

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing 'used' with 'unused' when checking code usage.

Dead code is code whose result is never used, so checking for unused results helps identify it.

2fill in blank

medium

Complete the code to remove dead code by deleting statements that have no side effect.

Compiler Design

for stmt in program.statements:
    if not stmt.has_side_effect and stmt.result == None:
        program.statements.remove([1])

Drag options to blanks, or click blank then click option'

Aprogram

Bresult

Cstmt

Dside_effect

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to remove the whole program or unrelated attributes.

To remove dead code, we delete the statement itself, so stmt is the correct choice.

3fill in blank

hard

Fix the error in the code that checks if a variable is dead by comparing its use count.

Compiler Design

if variable.[1] == 0:
    mark_as_dead(variable)

Drag options to blanks, or click blank then click option'

Ause_count

Bdefinition

Cvalue

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Checking variable name or value instead of usage count.

A variable is dead if it is never used, so checking use_count equals zero is correct.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps variables to their usage count only if the count is zero.

Compiler Design

dead_vars = {var: var.[1] for var in variables if var.[2] == 0}

Drag options to blanks, or click blank then click option'

Ause_count

Bvalue

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names or values instead of usage count.

The dictionary maps variables to their use_count if the use_count is zero, indicating dead variables.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps variable names in uppercase to their usage count, but only if the usage count is zero.

Compiler Design

dead_vars = { [1]: [2] for var in variables if var.[3] == 0}

Drag options to blanks, or click blank then click option'

Avar.name.upper()

Bvar.use_count

Cuse_count

Dvar.name

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names without uppercase or wrong property names.

The comprehension uses var.name.upper() as keys, var.use_count as values, and filters where use_count is zero.

Practice

1. What is the main purpose of dead code elimination in compiler design?

easy

A. To remove code that never affects the program's output

B. To add extra debugging information

C. To increase the size of the compiled program

D. To change the program's logic for optimization

Solution

1. Step 1: Understand dead code

   Dead code is code that does not affect the program's output or behavior.

2. Step 2: Purpose of elimination

   Removing such code makes the program faster and smaller without changing its meaning.

3. Final Answer:

   To remove code that never affects the program's output -> Option A

4. Quick Check:

   Dead code elimination = Remove unused code [OK]

Hint: Dead code does not run or affect results, so remove it [OK]

Common Mistakes:

• Thinking dead code changes program logic
• Confusing dead code elimination with debugging
• Believing it increases program size

2. Which of the following code snippets is an example of dead code that can be eliminated?

easy

A. int z = 2; z = z + 1; return z;

B. int x = 5; x = 10; return x;

C. int y = 3; if (false) { y = 7; } return y;

D. int a = 4; a = a * 2; return a;

Solution

1. Step 1: Identify dead code

   The code inside if (false) never runs, so y = 7; is dead code.

2. Step 2: Check other options

   Other assignments affect the returned value, so they are not dead code.

3. Final Answer:

   int y = 3; if (false) { y = 7; } return y; -> Option C

4. Quick Check:

   Code inside false condition = Dead code [OK]

Hint: Code inside 'if(false)' or unreachable blocks is dead code [OK]

Common Mistakes:

• Thinking all variable reassignments are dead code
• Ignoring conditions that never execute
• Confusing dead code with useful code

3. Consider the following code snippet:

int a = 10;
int b = 20;
if (a > b) {
  b = a + 5;
}
return b;

After dead code elimination, what will be the returned value?

medium

A. 10

B. 20

C. 25

D. Compiler error

Solution

1. Step 1: Analyze the condition

   The condition a > b is 10 > 20, which is false, so the if block never runs.

2. Step 2: Identify dead code and final value

   The assignment inside the if block is dead code and removed. The value of b remains 20 and is returned.

3. Final Answer:

   20 -> Option B

4. Quick Check:

   False condition skips code, return original b = 20 [OK]

Hint: If condition is false, code inside is dead and removed [OK]

Common Mistakes:

• Assuming if block runs and changes b
• Returning a instead of b
• Confusing dead code with runtime error

4. Identify the dead code in the following snippet and suggest the correct fix:

int x = 5;
return x;
x = 10;

medium

A. No dead code; code is correct as is

B. The return statement is dead code and should be removed

C. The variable declaration int x = 5; is dead code

D. The assignment x = 10; is dead code and should be removed

Solution

1. Step 1: Understand code flow

   After return x;, the function exits, so x = 10; never runs.

2. Step 2: Identify dead code and fix

   The assignment x = 10; is dead code and should be removed to clean the code.

3. Final Answer:

   The assignment x = 10; is dead code and should be removed -> Option D

4. Quick Check:

   Code after return is dead and removable [OK]

Hint: Code after return is dead and can be removed [OK]

Common Mistakes:

• Thinking code after return runs
• Removing return statement mistakenly
• Confusing variable declaration as dead code

5. You have this code:

int sum = 0;
for (int i = 0; i < 5; i++) {
  if (false) {
    sum += i;
  }
}
return sum;

How does dead code elimination optimize this loop?

hard

A. Removes the entire loop since it does nothing

B. Removes only the if block but keeps the loop

C. Keeps all code as is because loop runs 5 times

D. Changes the loop to run 0 times

Solution

1. Step 1: Analyze the loop body

   The if condition is always false, so sum += i; never runs, making the loop body dead code.

2. Step 2: Optimize the loop

   Since the loop does not change sum, the entire loop can be removed, returning 0 directly.

3. Final Answer:

   Removes the entire loop since it does nothing -> Option A

4. Quick Check:

   Loop with dead body = Remove whole loop [OK]

Hint: If loop body never runs, remove whole loop [OK]

Common Mistakes:

• Removing only if block but keeping loop
• Assuming loop changes sum despite false condition
• Changing loop count incorrectly