Forward Transfer of Control in Compilers

---

---

In any program, instructions generally follow a sequential order. However, there are cases where execution deviates from this sequence, requiring a jump to another section of the program before completing the current one. This mechanism is known as forward transfer of control.

Forward transfer of control is a crucial concept in compiler design, enabling the handling of conditional statements, loops, function calls, and exception handling. The compiler must accurately translate these high-level constructs into branch and jump instructions at the machine code level.

In this chapter, we will explore the concept of forward transfer of control, discuss its different types, and look at a couple of examples for a better understanding of the concept.

What is Forward Transfer of Control?

Forward transfer of control takes place when the execution jumps ahead in the program. This jump is doing by skipping over some instructions before returning or continuing. This is different from backward transfer of control. Where it is typically used in loops where execution jumps back to a previous statement.

Forward control transfer is used in the following fields:

• Conditional Jumps − Skipping a section of code when a condition is met.
• Function Calls − Jumping to a subroutine and returning afterward.
• Exception Handling − Skipping sections of code in response to an error.

The compiler's task is to convert these high-level constructs into branching instructions. And it also makes it proper to execute them correctly.

Types of Forward Transfer of Control

Let us see some of the types of loops used in forward control −

Conditional Jumps

Conditional Jumps transfer the control forward if a certain condition becomes True. These are used in if-else statements and loop exits.

Example: If-Else Statement in C

Take a look at the following example −

if (x > y)  
   max = x;  
else  
   max = y;  

Intermediate Representation (IR) using Atoms −

(TST, x, y, >, L1)   # If x > y, jump to L1  
(MOV, y, , max)      # Else block: max = y  
(JMP, L2)            # Skip then-block  
(LBL, L1)  
(MOV, x, , max)      # Then block: max = x  
(LBL, L2)  

Translation to Machine Code (MIPS Example) −

lw $t1, x  
lw $t2, y  
ble $t1, $t2, ELSE   # If x  y, jump to ELSE  

# THEN block  
move $t3, $t1        # max = x  
j END  

ELSE:  
move $t3, $t2        # max = y  

END:  

Here we can see the instruction "ble $t1, $t2, ELSE" checks if x <= y. If true. This execution jumps forward to ELSE. This skipping the max = x statement.

Function Calls and Returns

A function call is another form of forward transfer where execution moves to a function definition and returns after completing the function.

Example: Function Call in C

Take a look at the following example −

int add(int a, int b) {  
   return a + b;  
}  

int main() {  
   int sum = add(5, 10);  
}  

Intermediate Representation (IR) using Atoms −

(CALL, add, 5, 10, T1)   # Call function add(a, b)  
(MOV, T1, , sum)         # Store result in sum  

Translation to Machine Code (MIPS Example) −

main:  
    li $a0, 5  
    li $a1, 10  
    jal add       # Jump to function and store return address  

    move $t0, $v0 # Store return value  
    j exit  

add:  
    add $v0, $a0, $a1  # Perform addition  
    jr $ra             # Return to caller

Here, instruction "jal add" (jump and link) transfers control forward to add. And the "jr $ra" (jump register) returns execution to main.

Switch-Case and Jump Tables

The switch-case statement is used for sequence of condition checking. This is often used in forward transfer to jump directly to the correct case. Instead of multiple if-else conditions, the compilers use jump tables. Here it stores the memory locations for each case.

Example: Switch Statement in C

Take a look at the following example −

switch (n) {  
   case 1: x = 10; break;  
   case 2: x = 20; break;  
   case 3: x = 30; break;  
}  

Intermediate Representation (IR) using Atoms −

(JT, n, Table)      # Jump to case using jump table  
(LBL, Case1)  
(MOV, 10, , x)  
(JMP, End)  
(LBL, Case2)  
(MOV, 20, , x)  
(JMP, End)  
(LBL, Case3)  
(MOV, 30, , x)  
(LBL, End)  

Translation to Machine Code (MIPS Example) −

la $t0, table  
sll $t1, $t2, 2     # Multiply index by 4  
lw $t3, 0($t0)      # Load address from jump table  
jr $t3              # Jump to corresponding case  

table:  
.word Case1, Case2, Case3  

Case1:  
    li $t4, 10  
    j END  

Case2:  
    li $t4, 20  
    j END  

Case3:  
    li $t4, 30  

END:  

As we can see, the jump table allows direct jumps to the required case. This is making execution faster than multiple if-else statements.

Exception Handling

Exceptions in the code transfer the control forward to an error handler when something goes wrong. The compiler generate code to detect errors and jump to the correct handling routine.

Example: Try-Catch in Java

Take a look at the following example −

try {  
   x = 10 / y;  
} catch (Exception e) {  
   System.out.println("Error!");  
}  

Intermediate Representation (IR) using Atoms −

(DIV, 10, y, T1)  
(IFERR, L1)         # If error occurs, jump to L1  
(MOV, T1, , x)  
(JMP, End)  
(LBL, L1)  
(PRINT, "Error!")  
(LBL, End)  

Translation to Machine Code (MIPS Example) −

li $t1, 10  
div $t1, $t2  
mfhi $t3  
bne $t3, $zero, HANDLE_ERROR  # If remainder nonzero, jump to error  

sw $t1, x  
j END  

HANDLE_ERROR:  
    li $v0, 4  
    la $a0, error_msg  
    syscall  

END:  

Here, we can say, if y = 0, division by zero triggers a jump to HANDLE_ERROR.

The following table highlights the important points of Forward Transfer of Control −

Conclusion

In this chapter, we explored the concept of forward transfer of control in compiler design and examined how compilers translate high-level control structures into jump and branch instructions. We also discussed its role in conditional statements, function calls, switch-case jumps, and exception handling.

Efficient handling of forward jumps allows compilers to optimize execution and reduce runtime overhead. Whether skipping instructions in an if-else statement or jumping to a function, these control transfers are fundamental to efficient program execution.