In the lecture on "Three Address Code" by Mr. Sachin Jain, he emphasizes the simplicity and power of three address code in compiler design. Each instruction combines assignment and a binary operator, with at most three operands. The forms include assignments like X = Y operator Z, procedure calls, and array operations. Data structures like quadruples, triples, and indirect triples organize the code, each with its unique features. Quadruples include four fields: operator, argument1, argument2, and result. Triples lack a result field and use references to temporary values. Indirect triples further reference these temporary values. Understanding these structures is key to mastering compiler design.
This article provides an in-depth overview of "Three Address Code" in Compiler Design, as discussed in Lecture 03 by Mr. Sachin Jain at AKGEC. It delves into the concepts, various forms, and data structures associated with Three Address Code, elucidating with examples throughout.
π Three Address Code Overview
In Compiler Design, Three Address Code (3AC) serves as an intermediate representation of code, facilitating optimization and translation processes. It comprises instructions with a maximum of three operands, typically involving assignment and binary operators.
Three Address Code Structure
Each 3AC instruction features an assignment statement and a binary operator, with at most one operator on the right-hand side. Examples include assignments, conditional statements, procedure calls, and array and pointer operations.
| Instruction | Description |
|---|---|
| X = Y operator J | Assignment with binary operator |
| X = operator Y | Assignment with unary operator (optional second operand) |
| X = to Y | Simple assignment |
| Go to L | Unconditional jump |
| If X go to L, else go to M | Conditional jump |
| X reloop Y, go to L | Loop statement |
| Procedure calls using parameters | Function calls with parameters |
| Y = call procedure P and N | Calling a procedure with return value and parameters |
| X = to Y index I | Array assignment with index |
| Pointer and storage operations | Operations involving pointers and storage locations |
π οΈ Example Conversion
To illustrate the conversion process, consider the instruction a = -C * b + -C * D. Converting it to 3AC involves breaking it down into simpler operations using temporary variables.
Conversion Steps
- Assign
-Cto temporary variableT1. - Compute
B * T1and store inT2. - Assign
-Cto another temporary variableT3. - Compute
D * T3and store inT4. - Compute
T2 + T4and store inT5. - Assign
T5to variablea.
| Step | Three Address Code |
|---|---|
| 1 | T1 = -C |
| 2 | T2 = B * T1 |
| 3 | T3 = -C |
| 4 | T4 = D * T3 |
| 5 | T5 = T2 + T4 |
| 6 | a = T5 |
π Data Structures for Three Address Code
Three main data structures for organizing 3AC include Quadruple, Triple, and Indirect Triple. These structures vary in their representation of instructions and temporary variables.
Data Structure Comparison
| Structure | Description |
|---|---|
| Quadruple | Operator, argument 1, argument 2, result |
| Triple | Operator, argument 1, argument 2 |
| Indirect Triple | Triple with separate reference list |
π Conversion Examples
Converting the example instruction B * -C + B * -C into Quadruple, Triple, and Indirect Triple structures demonstrates their differences in representation.
Quadruple
-Cis assigned to temporaryT1.B * T1is computed and stored inT2.-Cis assigned to temporaryT3.D * T3is computed and stored inT4.T2 + T4is computed and stored inT5.ais assignedT5.
| Quadruple | |
|---|---|
| 1 | T1 = -C |
| 2 | T2 = B * T1 |
| 3 | T3 = -C |
| 4 | T4 = D * T3 |
| 5 | T5 = T2 + T4 |
| 6 | a = T5 |
Triple
-Cis assigned to temporaryT1.B * T1is computed and stored inT2.-Cis assigned to temporaryT3.D * T3is computed and stored inT4.T2 + T4is computed.
Reference Table:
0: T1, 1: T2, 2: T3, 3: T4
Indirect Triple
-Cis assigned to temporaryT1.B * T1is computed and stored inT2.-Cis assigned to temporaryT3.D * T3is computed and stored inT4.T2 + T4is computed.
Reference Table:
0: 1, 1: 2, 2: 3, 3: 4
Conclusion
Understanding Three Address Code and its associated data structures is fundamental in Compiler Design. Through proper conversion techniques, programmers can optimize code and enhance compiler efficiency.
π Key Takeaways
- Three Address Code serves as an intermediate representation in Compiler Design.
- Conversion involves breaking down complex instructions into simpler operations.
- Quadruple, Triple, and Indirect Triple are three main data structures for organizing Three Address Code.
- Each structure has its unique representation and usage in compiler optimization.
π€ FAQ
Q: How many operands can a Three Address Code instruction have?
A: A Three Address Code instruction can have at most three operands.
Q: What are the main data structures used for organizing Three Address Code?
A: The main data structures are Quadruple, Triple, and Indirect Triple.
Q: What is the purpose of using Three Address Code in Compiler Design?
A: Three Address Code serves as an intermediate representation for facilitating optimization and translation processes in compiler design.
Q: Can you explain the difference between Quadruple, Triple, and Indirect Triple?
A: Quadruple includes four fields: operator, argument 1, argument 2, and result. Triple lacks the result field and uses references to temporary variables. Indirect Triple further uses a separate reference list to access temporary variables indirectly.
This comprehensive guide elucidates the intricacies of Three Address Code, providing valuable insights into its structure, conversion techniques, and data structures. By mastering these concepts, developers can effectively optimize compilers and enhance code efficiency.
EN_GB