1. Semantic Analysis Legality checks –Check that program obey all rules of the language that are not described by a context-free grammar Disambiguation –Name resolution, type resolution, overload resolution Expanded intermediate representation –Annotate tree to guide subsequent phases

2. A formal model : attributes Semantic information can be represented by computed values attached to an AST node For an identifier: the corresponding entity For a static expression: its computed value For a function: the return type For a record: the component names and types For a derived type: its parent type All of it is implicit in the original tree. Attributes provide compact, efficient representations

3. Attribute Computation The value of an attribute at a node can be computed from the values of attributes at immediate neighbor nodes The computation is keyed to the production in which the node appears Production Assignment => Var := Lit ; Equation: Type Lit = Type Var The type of the literal is inherited from the variable that is the lhs of the assignment

4. Inherited and synthesized attributes Production: N => ABC An attribute of non-terminal N that is computed from the attributes of A, B, C is synthesized An attribute of A that is computed from an attribute of N is inherited An attribute of A that is computed from attributes of B, C Is inherited (“has to go through N to reach A”)

5. Attributes grammars General formalism: define all context-dependent aspects as attributes. Provide equations for each attribute defined for each non-terminal. There are no restrictions on dependencies: an attribute can depend on any attribute of other symbols appearing in the production Semantic analysis is the computation of all attributes at each node of the AST Attribute grammars are universal (Turing-equivalent)

6. The dream of full automation Can define all aspects of the language with attribute grammars Given a language for attributes, we can build an attribute evaluator, like a parser generator. Attribute grammar + attribute evaluator = automatically generated compiler However: equations may be circular detecting circularity is exponential In practice, resulting compiler is too large / slow Attributes are a powerful concept, not a universal tool.

7. Synthesized attributes Most useful attributes are synthesized, I.e. computed bottom-up. Example: numeric value of a base-2 representation: Bit => ‘0’ Val Bit = 0 Bit => ‘1’ Val Bit = 1 Bit_String => Bit Val Str = Val Bit Bit_String => Bit_String Bit Val Str1 = 2*Val Str2 + Val Bit

8. Inherited attributes Inherited attributes describe context-dependent properties: visibility, typing. Inherited attributes are computed top-down. Usually done as a separate pass over AST The most important inherited attribute is the visibility environment, aka symbol table. Typically represented as a global data structure, not as an attribute that is propagated from node to node.

9. Definitions and uses A declaration introduces an entity: X : Integer; The node for X is its defining occurrence A subsequent occurrence of X in the current scope is a use of X X := 15; The use-occurrence must indicate that this is the X defined above The set of defining occurrences constitutes the symbol table.

10. Attributes of entities The defining occurrence is a symbol table entry. Holds all useful information about an entity –Type (another entity) –Size (numeric value: may be known statically) –Scope (another entity) –Name (pointer into names table) –Homonym (previous entity with same name) –Etc. (in GNAT, > 20 assorted fields. Described in Einfo)

11. Type entities and their attributes Numeric types: low_bound, high_bound –Static expressions of related numeric type Array types: list of index types, component type –Previously declared entities –Index bounds are expressions of the index type Record types: list of components, variants –Entities appearing in component declarations –Variants indexed by values of discriminants –Flags: type is limited, type has tasks, type is packed, etc. (in GNAT, > 160 misc. predicates)

12. Attributes of program unit entities All entities that contain local declarations have an attached list of local entities: –In GNAT, First_Entity, Last_Entity Procedures: names and types of formals Functions: names/types of formals, return type Packages: separate lists of visible entities and private entities Tasks: visible entries (operations), private data

13. Attributes of identifiers For a variable: Entity denoted by identifier –Value, if entity is static constant For a function: – set of possible interpretations (if overloaded) – single final interpretation (resolution) For all: Type (redundant but convenient)

14. Attributes of Expressions Possible types (if constituents are overloaded) Type (after resolution) Is_Static_Expression Expr_Value (if static) Raises_Constraint_Error (may be known) –In GNAT, described in Sinfo.

15. Bottom-up/Top Down processing With recursion, very similar: procedure Analyze (N : Node_Id) is begin -- bottom-up analyze each child of N Compute local attributes end; procedure Resolve (N : Node_Id, Typ : Entity_Id) is begin – top-down Compute local attributes Resolve each child of N with information from N end;

16. Name Resolution Compute the entity denoted by each identifier. Apply visibility rules of language: –For a block-structured language, examine local scope first. –If not found, look at enclosing scopes –If not found, look at scopes in context (with_clauses, use_clauses) –If not found, look at implicit rules for operators –Entities with same name linked in homonym chain

17. Type resolution Top-down pass: compute possible interpretations of each constituent, and their types X + Y – : if X and Y have same numeric type, node has type of X A (J) –if A is of an array type and J has the proper type for an index, node has component type of the type of A F (X, Y, Z) – if F is a function and X, Y, Z have proper types for its formals, node has return type of F.

18. Overload Resolution If a constituent is overloaded, context must impose a single type for resolution. function Convert (x : integer) return integer; function Convert (x : integer) return complex; function Convert (x : integer) return float; … Var := Convert (5); Compute possible interpretations of Convert, resolve with type of Var. Need to manipulate sets of names for types.

19. Finding a single interpretation For a procedure call proc (f (x), g(y), h (z)); proc, f, g, and h may be overloaded. There must be a single interpretation of proc whose formal parameters are compatible with one of the possible interpretations of f, g, h. Once proc is identified, resolve f with the type of its first formal, g with the type of the second, etc. If more than one interpretation: ambiguous call If none: illegal call

20. Analysis and expansion Expansion replaces portions of AST with semantically equivalent portions for which it is easier to generate code New tree fragments must be decorated with semantic information: – expansion and analysis are mutually recursive

21. Expansion: aggregates Length: integer := 5; type Arr is array (1..Length) of integer; X : integer := 22; Thing : Arr := (X, others => 42); -- complex construct Aggregate expands into: Thing : Arr; Thing (1) := X; Temp := 1; -- Created by compiler while Temp <= Length loop Thing (Temp) := 42; Temp := Integer’Succ (Temp); end loop;