Abstract Syntax Trees in Compiler Design | GATE CS Concepts

Semantic analysis ensures programs satisfy rules about variables, objects, expressions, and treatments. Key tasks include finding declarations, determining static types, reorganizing the abstract syntax tree, and detecting errors. Static properties can be determined without execution, while dynamic properties require considering all possible executions. Symbol tables provide additional information to the AST for determining variable scope and types, implementing narrow scope declarations that override wider scope declarations. They can be implemented using stack-based approaches (push declarations, pop when scope ends) or tree-based hierarchies.

The semantic analyzer walks the AST to verify code correctness beyond syntax. It performs two main tasks: scope resolution (building a symbol table mapping variables to their declarations and visibility) and type checking (verifying operations are valid for given types). For example, adding a string to an integer would trigger a type error. Some languages also perform type inference, automatically determining types where not explicitly specified. By the end, every node in the tree is annotated with its type and linked to its declaration.

Semantic analysis creates a decorated AST by attaching and evaluating attributes to every node through tree traversal. Attributes are classified as synthesized (from children) or inherited (from parent/sibling). Key semantic rules include: variables must be defined before use, no redeclaration in same scope, assignment LHS/RHS must match types, and if conditions must be boolean. These rules are categorized into scope-based rules and type checking. Syntax errors are caught during AST creation, while semantic errors require semantic analysis. Scope resolution uses symbol tables storing symbol names, types, scopes, and function signatures, maintaining a hierarchy of scopes to track variable declarations and visibility.

An abstract syntax tree (AST) is a simplified hierarchical representation of the program's structure, omitting unnecessary syntactic details. The AST is used for semantic analysis, which verifies that the program's meaning is correct. This includes type checking (ensuring variables are used with compatible types), checking that variables are declared before use, and verifying that function calls match their declarations. Symbol tables track information about program entities during semantic analysis.

Semantic analysis checks code meaning, including type checking and scope verification. Scope is managed using a linked list where each scope has a parent scope. The symbol table stores identifier information (like types) and searches through nested scopes to find variables. If a variable isn't found in the current scope or any parent scope, it's considered unreachable. This helps catch errors like using undeclared variables or accessing variables outside their scope.

Three-address code is a generic intermediate representation that can be implemented as quadruples (with operator, arg1, arg2, and result fields), triples (using indexed entries without explicit result fields), or directed acyclic graphs (DAGs) to efficiently represent expressions by eliminating redundant computations.

Intermediate Code Generation involves DAG construction and three-address code formats. For DAG: assign IDs to unique terminals, process from innermost brackets, create nodes for operations, reuse nodes for shared subexpressions. Three-address code formats include quadruples (operator, arg1, arg2, result), triples (operator, arg1, arg2), indirect triples (using addresses), and static single assignment (each variable assigned once). The DAG optimizes expressions by eliminating redundant computations.

Intermediate Representation (IR) serves as a bridge between the Abstract Syntax Tree (AST) generated by the parser and the code generation phase. Three-Address Code (TAC) is a specific IR format that closely mirrors assembly language structure. A 'quad' is the fundamental unit of TAC, consisting of four components: a destination register where the result is stored, two source registers containing operands, and an operator specifying the operation. This format simplifies the mapping to actual machine instructions by abstracting away format-specific details.

Intermediate code generation is a crucial phase in compiler design that translates source code into an intermediate representation (IR) between the source program and target machine code, enabling easier analysis, optimization, and target code generation; this IR can be represented through various forms including graphical representations like syntax trees and DAV (Directed Acyclic Graph), postfix notation, and three-address code (which uses at most three addresses per instruction with operands and results), with three common implementations being quadruples, triples, and indirect triples, each offering different trade-offs in terms of storage efficiency and ease of modification during code optimization.

Four primary intermediate code representations exist: postfix notation, three address code, syntax tree, and DAG. Three Address Code (TAC) is the most popular format, where each instruction contains at most three operands. For example, 'A + B + C' becomes T1 = A + B, T2 = A + B, T3 = T2 + C. Syntax trees are condensed parse trees using only terminals. DAGs eliminate redundant computations by sharing common subexpressions. TAC uses seven instruction types: binary operations (x = y op z), unary operations (x = op y), assignment (x = y), conditional jumps (if x op y goto L), unconditional jumps (goto L), array indexing (x = a[i]), and pointer dereferencing (x = *p).

This section covers the first major phase of compiler optimization operating on the Abstract Syntax Tree. The compiler performs cosmetic cleanup by removing redundant parentheses, casts, and unary operators. It normalizes different syntactic forms of the same expression. Most languages have syntactic sugar layered on top of a smaller core, which the compiler rewrites before further processing (for loops to while loops, async/await to state machines). The as-if rule is the fundamental principle: the compiler can perform any transformation as long as observable behavior remains unchanged. Constant folding replaces expressions with known results, while constant propagation substitutes variables with their known values. Dead code elimination removes unreachable branches, unused variables, and never-called functions. Control flow cleanup includes flattening nested ifs and applying boolean shortcircuiting.

This video explains code optimization strategies for Python, covering automatic compiler optimizations (constant folding, dead code elimination, JIT compilation) and manual optimization techniques (constant propagation, attribute access optimization, function inlining). The presenter demonstrates how to implement a custom AST-based optimizer using Python's ast and inspect modules to perform constant propagation, showing both the potential benefits (10-20% performance gains on synthetic examples) and practical limitations (complexity, maintenance challenges, and minimal real-world impact of 5-10%). The video also discusses alternative approaches like PyPy and Cython for achieving better performance improvements.

Constant folding is an optimization technique that simplifies ASTs by evaluating constant expressions at compile time. The process recursively traverses the tree, checking if both children of an operation node are constants. If so, the operation is performed immediately and the result replaces the entire subtree. This optimization reduces runtime computation by eliminating unnecessary operations on constant values.

Dead code elimination removes assignments to variables that are never used and basic blocks that are never reached. In constant propagation, variables with constant values are identified and substituted with those constants in place of references. Constant folding computes the value of expressions with constant operands. These optimizations work together: dead code elimination removes unnecessary assignments, constant propagation replaces variables with their known constant values, and constant folding evaluates constant expressions directly. For example, if X is assigned the value 3 and never reassigned, all references to X can be replaced with 3, enabling further constant folding optimizations.

Constant folding is the process of recognizing constant expressions and computing them at compile time rather than runtime. For example, a equals 2 times 3 can be simplified to a equals 6. This optimization applies to expressions with known values at compile time, including literals and variables whose values are known. Constant folding reduces runtime computation and can change the resulting bytecode.