Skip to content

Data flow analysis in Compiler

Three address code in Compiler

Last Updated : 27 Dec, 2024

TAC is an intermediate representation of three-address code utilized by compilers to ease the process of code generation. Complex expressions are, therefore, decomposed into simple steps comprising, at most, three addresses: two operands and one result using this code. The results from TAC are always stored in the temporary variables that a compiler generates. This design ensures explicit ordering of the operations that come into play. Since it is simple, TAC lends itself nicely to optimization and translation to machine code. TAC represents control flow and data dependencies. It falls somewhere between high-level source code and machine-level instructions. Therefore, it is a very essential phase in compiler designing.

Three Address Codes are Used in Compiler Applications

Optimization: Three-address code is often used as an intermediate representation of code during the optimization phases of the compilation process. The three-address code allows the compiler to analyze the code and perform optimizations that can improve the performance of the generated code.
Code generation: Three address codes can also be used as an intermediate representation of code during the code generation phase of the compilation process. The three-address code allows the compiler to generate code that is specific to the target platform, while also ensuring that the generated code is correct and efficient.
Debugging: Three address codes can be helpful in debugging the code generated by the compiler. Since the address code is a low-level language, it is often easier to read and understand than the final generated code. Developers can use the three address codes to trace the execution of the program and identify errors or issues that may be present.
Language translation: Three address codes can also be used to translate code from one programming language to another. By translating code to a common intermediate representation, it becomes easier to translate the code to multiple target languages.

General Representation

a = b
a = op b 
a = b op c

Where a, b, or c represents operands like names, constants or compiler-generated temporaries and op represents the operator

Example-1: Convert the expression a * - (b + c) into three address codes.

Three Address Code

Example 2,: Write three address codes for the following code

for(i = 1; i<=10; i++)
 {
  a[i] = x * 5;                                       
 }

Three address code — 3 address code for the for loop

Implementation of Three Address Code

There are 3 representations of three address code namely

Quadruple
Triples
Indirect Triples

1. Quadruple: It is a structure which consists of 4 fields namely op, arg1, arg2 and result. op denotes the operator and arg1 and arg2 denotes the two operands and result is used to store the result of the expression.

Advantage

Easy to rearrange code for global optimization.
One can quickly access value of temporary variables using symbol table.

Disadvantage

Contain lot of temporaries.
Temporary variable creation increases time and space complexity.

Example - Consider expression a = b * - c + b * - c. The three address code is:

t1 = uminus c   (Unary minus operation on c)
t2 = b * t1 
t3 = uminus c (Another unary minus operation on c)
t4 = b * t3 
t5 = t2 + t4 
a = t5  (Assignment of t5 to a)

Quadruple Representation

2. Triples: This representation doesn't make use of extra temporary variable to represent a single operation instead when a reference to another triple's value is needed, a pointer to that triple is used. So, it consist of only three fields namely op, arg1 and arg2.

Disadvantage

Temporaries are implicit and difficult to rearrange code.
It is difficult to optimize because optimization involves moving intermediate code. When a triple is moved, any other triple referring to it must be updated also. With help of pointer one can directly access symbol table entry.

Example - Consider expression a = b * - c + b * - c

Triples Representation

3. Indirect Triples This representation makes use of pointer to the listing of all references to computations which is made separately and stored. Its similar in utility as compared to quadruple representation but requires less space than it. Temporaries are implicit and easier to rearrange code.

Example - Consider expression a = b * - c + b * - c

Question - Write quadruple, triples and indirect triples for following expression : (x + y) * (y + z) + (x + y + z)

Explanation - The three address code is:

(1) t1 = x + y
(2) t2 = y + z
(3) t3 = t1 * t2
(4) t4 = t1 + z
(5) t5 = t3 + t4

Quadruple Representation

Triples Representation

Indirect Triples

Implementation of Three Address Code

1. Source Code Parsing and Abstract Syntax Tree Generation.

Lexical Analysis: source code is converted into tokens, keywords, identifiers, operators, literals, etc.
Syntax Analysis: An Abstract Syntax Tree that would be the representation of the grammatical structure of the code.
Semantic Analysis: Derivation of semantic errors type mismatches, undeclared variables, etc. and builds a symbol table.

2. TAC Instructions Generation

Traversal of the Abstract Syntax Tree: visiting each of the nodes in the abstract syntax tree generates the proper TAC instructions.
Use temporaries for intermediate computation.
Three address form: Each instruction should have at most three operands, two source and one target.

3. Evaluation of Expressions

Arithmetic Expressions: Divide complex expression into simpler expressions by using the temporaries. Example a + b * c which should be encoded as follows:
t1 = b * c
t2 := a + t1

3. Logical Expressions:

Translate the logical AND, OR and NOT operators into conditional jumps. Uses temporary registers.

4. Control Flow Constructs

If Statements :Use conditional jumps.
While Loops : Involve in unconditional jumps to the loop header and conditional jumps to exit.
For Loops: Converted to equivalent while loops.
Goto Statements: Unconditionally jump to the specified labels.

5. Procedure Calls

Argument Passing : Arguments are pushed onto the stack
Function Call: A jump is made to the function's entry point.
Return Value: Stored in a temporary variable while popping the arguments off the stack..

Conclusion

TAC is the important intermediate representation major compiler designers use because of its simplicity and efficiency. Complex expressions are broken down into simple, manageable instructions that have a maximum usage of three addresses, therefore making the generation and optimization processes easy. One of the strong points of TAC is flexibility: it handles a large variety of programming constructs while remaining independent of machine architecture. This form also allows optimizations such as constant folding and removal of dead code that make the final executable code considerably leaner. TAC is a useful independent language, situated between high-level source and machine code.

What kind of instructions does TAC comprise?

Other TACs involve arithmetic, AND and OR logical operations, assignment statements, and the control flow instructions of the form of conditional jump or function call. This usually contains two operands with its result usually stored in a temporary or destination variable.

How many operators are usually specified in three-address codes?

The operator set usually includes arithmetic operations-add, subtract; logical operations-AND, OR; comparisons; and control flow-conditional jumps, function calls, load/store for memory access.

In what ways is three-address code different from the other already used formats of intermediate representation?

Three-address code makes both the operation and operands explicit whereas none of the other intermediate representations (ASTs do) are making TAC easier to generate, manipulate, and optimize.

Data flow analysis in Compiler

A

Ankit87

Improve

Article Tags :

Practice Tags :

Misc

Similar Reads

Introduction of Compiler Design

A compiler is software that translates or converts a program written in a high-level language (Source Language) into a low-level language (Machine Language or Assembly Language). Compiler design is the process of developing a compiler.The development of compilers is closely tied to the evolution of