mod1fig5.gif (9955 bytes)

6.0 Introduction

Computer programs, like English sentences, have both a syntactic structure, illustrated by a parse tree, and a semantic structure which describes the meaning. Although there are many formal definitions of program semantics, we will take the operational semantics point of view. This approach defines the meaning of a program to be the executable code it generates. For us, this is the assembly language code. Thus, the actions performed by the semantic analysis phase are a begining of the process which will generate code.

Specifically, semantic analysis performs two major actions: (1) it finishes the syntax analysis and also performs actions such as symbol table creation and (2) it translates the parse tree to an intermediate representation more appropriate for the later phases of optimization and code generation.

6.1 Static Checking

The term static checking refers to error checks made at compile time. The opposite of static is dynamic, which refers to the time a program is executing. The error handing described in Module 5 finds static errors which do not correspond to the BNF description of that language. BNF is a metalanguage. A metalanguage is a way of describing another language. Thus, BNF describes a class of languages called context-free. Context-free languages can describe programming language syntactic structures such as statements and loop structures. Thus, if an END is left out, the error routines described in Module 5 will discover this.

However, context-free languages cannot describe the fact that a variable has been used but not defined or that a referenced label is not there. This requires contextual constraints which context-free grammars cannot specify.

There is a widely-accepted formalism, attribute grammars, for describing the range of semantic actions needed to do static checking of programming languages.

6.2 Attribute Grammars

An attribute grammar is a context-free grammar with the addition of attributes and attribute evaluation rules called semantic functions. Thus, an attribute grammar can specify both semantics and syntax while BNF specifies only the syntax.

6.2.1 Attributes

Attributes are variables to which values are assigned. Each attribute variable is associated with one or more nonterminals or terminals of the grammar.

In the grammar of Section 6.2.2, the attribute Value is associated with the nonterminals E, T, and F as well as with the terminal Constant. For nonterminal E, this is written:

This notation indicates that nonterminal "E" has an attribute called Value attribute names will be italicized.

6.2.2 Semantic Functions

Although it is possible to evaluate some attributes at parse time, we will asume that all attributes are evaluated after the program has been parsed. Values are assigned to local attributes by equations called semantic functions. Local attributes are those which fall within the scope of a production as it appears in the parse tree. For example:

Syntax                 Semantics
       E0  E1 + T         E0.Value := E1.Value + T.Value

Here, the production is EE+T. The subscripts are used only to distinguish the two E's. The attribute Value is associated with both E's and with T. If this production were in a parse tree, it would be denoted:

The value of the attribute Value is passed up the parse tree because E1.Value and T.Value are used to compute E0.Value. Such attributes are termed synthesized attributes. Attributes whose values are apssed down the tree are called inherited attributes.

Terminals may have only synthesized attributes, and their values are assigned by the lexical analyzer. Inherited values of the Start symbol. If any, are given values by way of parameters when attribute evaluation begins.

6.2.3 A Word about Example 1

It is common in computer science to use examples which explain the idea clearly, but which are not necessarily the best application of the idea. Thus, recursion is often introduced using factorial, a nice clear example, but not necessarily the best way to compute a factorial ( iteratively is faster and takes up less space). So it is with our first example of an attribute grammar. This example computes the value of the expression represented in a parse tree. Most compilers would not do this since their ultimate gola is to put out code (which then gets executed).

EXAMPLE 1 Using attributes to evaluate expressions

Consider the string 4+2*3 and its parse tree:

Using the semantic functions, and starting at the bottom of the tree, the various values of Value are computed. The lexical analyzer finds the value of Constant.Value. This is the value shown in the above parse tree.

6.2.4 A More Practical Example

Example 2 is a more practical one; it might be used by a symbol table routine to attach type information to the variables in a declaration.

EXAMPLE 2 Assigning declaration types to variables

6.2.5 Other Static Checks

Other static checks include type checking expressions to make sure operators are compatible with
their operands, checking that a variable used has been declared, checking that an array declared
to be of a certain dimension is used with the correct number of subscripts, and a myriad of other
tasks. Some static checks are language dependent since not all languages have the same
constraints. FORTRAN, for instance, does not require variables to be declared before being used.

6.3 Translation to an Intermediate

In order to perform optimizations on a program and to generate code, it is convenient to produce an intermediate representation better suited to these tasks than the parse tree representation. Abstract syntax trees (AST's), are used in many modern compilers. Diana, the intermediate language for Ada, is an attributed AST.

We will show the following intermediate representations:

6.3.1 Polish Postfix

Polish postfix is a linear line of code which is more useful for code generation that for the optimization phases since it is difficult to do the sorts of ransformations on it which are performed during the optimization phase.

Anyone who has ever used a Hewlett Packard calculator is familiar with Polish postfix (for expressions). Essentially, Polish postfix puts the operands first followed by their operator.







The assignment statement:

is denoted

It is more difficult to devise a reasonable postfix notation for other programming language constructs such as IF statements.

6.3.2 Abstract Syntax Tree (AST)

An abstract syntax tree is a parse tree stripped of unnecessary information such as singleton productions (e.g., ETF). Each nonleaf represents an operator and each leaf represents an operand.

Thus A + B might have the following parse tree and abstract syntax tree:

S := A + B * C has abstract syntax tree:

which can be represented in parenthesized form as

The parenthesized form is often used by the compiler designer for debugging output. It is essentially a preorder transversal of the tree.

IF A<B THEN Max := B is represented

and A[i]:=B is

Even though ASt's are more convenient for optimization, there is a one-one correspondence between AST's and Polish postfix:

Thus, AST's can be easily converted to Polish prefix if desired. The "tree" can be seen by starting at the right-hand end and taking the upper of the two arrows as the left child and the lower as the right child.

6.3.3 Three-Address Code

This intermediate form is called three-address because each "line" of code contains one operator and up to three operands, represented as addresses. Since most assembly languages represent a single operation in an instruction, three-address code is closer to the target code than the parse tree representation. There are a number of variants of three-address code, some more appropriate than others for optimization.

Quadruples (A Three-Address Code)

Quadruples ("quads" for short) consist of an operation, (up to) two operands, and a result.

A + B would be translated into quads as:

A + B * C would be translated into two quads:

         *    B    C    T1         
+    A    T1   T2

and S := A + B * C would be:

*   B    C     T1         
+   A    T1    T2         
=   T2   _     S

Notice that the last quad here had only one operand rather than two.

An alternative notation for quads, one we will use in the chapters on optimization, is to write them as a sequence of assignment statements. Thus S = A + B + C would be written:

T1 = B * C        
T2 = A + T1         
S = T2

If we think of GOTO L as an operator and a result, the quad would be:

A[i] := B would be:


[ ] A I T1 = T1 _ B

The reasoning for the intermediate code for IF statements is similar to the reasoning used to implement such constructs into assembly language. For example, IF A<B THEN Max := B would be:

<        A   B   Label 1     
GOTO             Label 2                      
Label 1     =        B       Max                      
Label 2

Here, the first line can be thought of as "if A<B then execute the code at Label 1". The second line can be thought of as "Otherwise execute the code at Label 2". The third line has only a result field--Label 1. These lines can be translated easily into assembly language code.

Triples(A Three-Address Code)

Quadruples use a name, sometimes called a temporary name or "temp", to represent the single operation. Triples are a form of three-address code which do not use an extra temporary variable; when a reference to another triple's value is needed, a pointer to that triple is used. We show the same examples as above for triples:

A + B would be translated into triples as:

A + B * C would be translated into two triples:

(1)   *   B   C   
(2)   +   A  (1)

Here, the triples have been numbered and a reference to the first triple is used as an operand of the second. S := A + B * C would be

(1)   *   B    C   
(2)   +   A   (1)   
(3)   =   S   (2)

Triples are really an abstract syntax tree in disguise:

Triples are difficult to optimize because optimization involves moving intermediate code. When a triple is moved, any other triple referring to it must be updated also. A variant of triples called indirect triples is easier to optimize.

Indirect Triples(A Three-Address Code)

Here, the triples are separated from their execution order:

Since the execution order here is the same as the order of the triples themselves, it is difficult to see the use of indirect triples. Example 3 shows a case where the execution order is not the same as the order of the indirectriple list.

With indirect triples, optimization can change the execution order, rather than the triples themselves, so few references need be changed.

EXAMPLE 3 Optimizing indirect triples

As an indication of how intermediate form might be generated during parsing, Section 6.3.6 describes how to generate abstract syntax trees during recursive descent parsing. Similar (semantic) routines would be written for generating AST's if the parser were generated using a tool. Most tools allow such routines to be written.

6.3.4 Other Intermediate Representations

Strictly speaking, any form between the source program and the object program might be
called an intermediate representation. The optimization process often creates a graphical
representation called a control flow graph. A parse tree or an abstract syntax tree with attached
attributes is often called an attribute tree or a semantic tree - yet another possible intermediate

6.3.5 Arrays

Array references are often translated to intermediate code with an array operator and two children. The left child is the name of the array, and the right child is the subscript expression.


as an abstract syntax tree would be

and as quadruples would be

Using the notation, the code generator would have to compute the array offset for machines which do not have an indexing addressing mode. The alternative is to expand the intermediate representation.

Using "( )" to mean "contents of" and "addr" to mean "address of," the quadruples for "Temp = List[i]" would be:

        T1 = addr(List)         T2 = T1 + i        Temp = (T2)

Similarly, if the array reference is on the left-hand side of an assignment statement as in "List[i] = Temp", low-level quadruples would be:

        T1 = addr(List)         T2 = T1 + i        (T2) = Temp 

Even if a machine has an indexing addressing mode, translating array references into their low-level format may allow optimizations (for example, if the array subscript were a common subexpression).

6.3.6 Adding AST Routines to Recursive
Descent Parsing

An abstract syntax tree node consists of an information field and a number of pointer fields. We will show an example for the expression grammar with assignment statements added and presume a binary tree so that there are two pointer fields to a left and right child in addition to the information field.

Thus if an AST node is called Node, these three field will be denoted as Node.Info, Node.Left and Node.Right. Get(Node) will create a new emplty AST node.

The method consists of adding a parameter to each of the procedures which will carry the (partial) AST from procedure to procedure, adding on to it as appropriate.

Consider the recursive descent procedure for an assignment statement:

    {Assignment  Variable = Expression}

PROCEDURE Assignment (Tree:AST)


IF Next Token = Variable THEN


Node.Info = Variable

Node.Left = Nil

Node.Right = Nil

Tree = Node

IF NextToken is "=" THEN


Node.Info = "="

Node.Left = Tree

Node.Right = Nil

Tree = Node

Expression (Tree.Right)



Following this pseudo-code for the assignment statement:

we obtain the following abstract syntax tree, presuming the call to Expression(Tree.Right) returns a node whose information field contains B and Tree.Right is a pointer to it:

To show this, we will continue this process for Expression, Term and Factor (in outline form):

    {Expression  Term {+Term} }

PROCEDURE Expression (Tree:AST)



WHILE Next Token = "+" DO


Node.Info = "+"

Node.Left = Tree

Term (Tree.Right)

Tree = Node



    {Term  Factor {* Factor} }




WHILE Next Token = "*" DO


Node.Info = "*"

Node.Left = Tree

Factor (Tree.Right)

Tree = Node



    {Factor  Const | ( Expression ) }



IF Next Token <> "(" THEN


Node.Info = Token

Node.Left = Nil

Node.Right = Nil

Tree = Node



Try tracing this for A = B and A = B + C * D

6.4 Semantic Analyzer Generators

      A semantic analyzer generator does not follow the table/ driver model developed in the previous chapters. The input, an attribute grammar, is more of a specification language than a true metalanguage.

      Most parser generators allow semantic actions to be attached to the productions in the BNF. A few allow these semantic actions to be described using attribute grammars.

The amount of processing done at generation time depends on the attribute grammar itself. Consider the picture shown in Figure 1:

      In some cases, the evaluator generator will be null, that is, an evaluator will not be generated. If the generator is null, it may be that the attributes were in a form that could be evaluated during parsing. Another possibility is that the attributes are evaluated one. We will discuss all of these possibilities.

6.5 More on Attribute Grammars

Attribute grammars are a formalism for expressing semantics much as a context-free grammar is a formalism for expressing syntax. We will look at some further definitions relating to attribute grammars.

6.5.1 Fundamental Definitions

As we know, an attribute grammar is a context-free grammar to which attribute and semantic functions have been added:

      Consider a production p in the set of production P :

              p : X0 X1 X2 X3. . . Xn                    n > = 1

      For any Xi in the production p, there may be finite disjoint sets I(Xi) and S(Xi.) The are the inherited attributes and synthesized attributes, respectively.

      In general, the values of inherited attributes are passed down the parse tree. The value of synthesized attributes are passed up the parse tree.

      The set of all attributes for X i is denoted A(Xi):

              A(Xi) = I(Xi) U S(Xi)

      An attribute a of Xi is denoted Xi.a whether it is a reference to attribute a in the parse tree or the grammar.

      Predefined attribute values are called intrinsic. Synthesized, intrinsic attributes of terminals are computed by the lexical analysis phase. Inherited intrinsic attributes of the start symbol are passed as parameters before evaluation begins from the parser.

      A production p : X0 X1 X2 X3. . . Xn possesses an attribute occurrence, (a, k), if Xk is at node #m ( in some tree-numbering scheme), then we say Xk possesses an attribute realization, (a, m), if Xk has an attribute a. A semantic function, sometimes called an attribute rule, gives a value to an attribute occurence(a, k), in production p. Such a function is denoted fp(a,k)

      The set of values upon which fp(a,k)depends is called the dependency set for (a, k) and is denoted Dp(a,k). Thus,

                Dp(a,k) = { (b, j) | fp(a,k) = g (. . .Xj.b, . . . ) }

      This is read "the value of attribute occurrence (a, k), or Xk. a depends on the set of attributes { (b, j) } or { Xj.b } where each Xj.b is used in the calculation of Xk. a".

      Example 1 illustrates these definitions. This example is an adaptation from Knuth (1968) where he first defined attribute grammars.

      The attributes in Example 1 are:

       I (Number)                 =
       I (Sign)                    =
       I (List)                    = {Scale}
              I (BinaryDigit)      = {Scale}
       S (Number)                = { Value }
       S (Sign)                    = { Neg }
       S (List)                    = {Value }
       S (BinaryDigit)      = {Value }

Thus, Scale is an inherited attribute, and Value and Neg are synthesized attributes. The intrinsic attributes are Sign.Neg in productions one and two, BinaryDigit.Value in production five, and List.Scale in production zero.

      The function to compute List0.Value in production four is denoted f4(Value, 0).

      Since depends List0.Value depends on List1.Value and BinaryDigit.Value,

                D4(Value, 0) = { (Value, 1 ) , (Value, 2) }

      Example 1 generates strings of binary digits. Example 2 shows an unevaluated parse tree for the string - 1 0:

      Section 6.6 discusses efficient methods for attribute evaluation, but we can "guess" at a method here: since we know      value is a synthesized attribute, and Scale is an inherited attribute, we can try to evaluate values by moving up the tree, then down, or by moving down the tree, then up. The latter suffices, and Example 3 shows the evaluated tree.

      Example 3 shows that the "semantics" of this example computes the decimal value of the string and leaves this value at the root of the tree.

     Example 1 through 3 are a short and simple illustration of attribute grammars. It is possible to evaluate all the attributes in one pass down and then up the parse tree.

When a grammar is large and contains many attributes, it is not always easy to see how to evaluate the attributes. One method is to restrict the form of the attributes and attribute functions so that the method of evaluation is known. A second way is to create a graph of dependencies and check to see that it has no cycles. If it has no cycles, the dependency graph itself can be used to give an order in which to evaluate the attributes. We discuss all of these in the next sections.

      Example 5 shows calculation of array offsets. This calculation might be performed in order to allocate the relative position of each array element.

      Exercise 5 asks the reader to create attributes that will pass information about the array A (the dimensions d1, d2, d3) down the tree and then to calculate this offset while reascending the tree. Exercise 6 asks the reader to consider a different grammar for this same example.

6.5.2 L-Attributed Attribute Grammars

A top-down parser can evaluate attributes as it parses if the attribute values can be computed in a top-down fashion. Such attribute grammars are termed L-Attributed.       First, we introduce a new type of symbol called an action symbol. Action symbols appear in the grammar in any place a terminal or nonterminal may appear. They may also have their own attributes. They may, however, be pushed onto their own stack, called a semantic stack or attribute stack.

      We illustrate action symbols using the notation "<>" which indicates that the symbol within the brackets is to be pushed onto the semantic stack when it appears at the top of the parse stack. By inserting this action in appropriate places, we will create a translator which converts from infix expressions to postfix expressions.

We parse and translate a + b * c. The top is on the left for both stacks.

When the semantic stack is popped, the translated string is:

           a b c * +

the input string translated to postfix. In Example 6, the action symbol did not have any attached attributes.

     The BNF in Example 6 is in LL(1) form. This is necessary for the top-down parse.

      The formal definition of an L-attributed grammars is as follows. An attribute grammar is L-attributed if and only if for each production X0 X1 X2. . . Xi. . . Xn,

 (1) {Xi.inh} = f ({Xj.inh} , {Xk.att})            i, j >= 1, 0<=k<i

 (2) {X0.syn} = f ({X0.inh} , {Xj.att})            1<=j<=n

 (3) {ActionSymbol.Syn} = f ({ActionSymbol.Inh})

     (1) says that each inherited attribute of a symbol on the right-hand side depends only on inherited attributes of the right-hand side and arbitrary attributes of the symbols to the left of the given right-hand side symbol.

     (2) says that each synthesized attributes of the left-hand-side symbol depends only on inherited attributes of that symbol and arbitrary attributes of right-hand-side symbols.

     (2) says that the synthesized attributes of any action symbol depend only on the inherited attributes of the action symbol.

      Conditions (1), (2), and (3) allow attributes to be evaluated in one left-to-right pass (see Exercise 2).

      If the underlying grammar is LL(1), then an L-attributed grammar allows attributes to be evaluated while parsing. The reader may wish to review the LL(1) parsing driver in Chapter 4. The evaluation algorithm is:

      Exercise 3 asks the reader to combine this algorithm with the LL(1) driver algorithm given in Chapter 4.

      For the next few sections, we focus on restrictions to attributes that allow for efficient attribute evaluation.

6.5.3 S-Attributed Attribute Grammars

Attribute in an S-attributed grammar can be evaluated at parse time by a bottom-up parser. Interestingly, these grammars form a subset of the L-attributed grammars.

      An attribute grammar is S-attributed if and only if:

           This allows attributes to be evaluated during LR-parsing.

      L-attributed and S-attributed grammars allow efficient evaluation---either during parsing or as a single pass after parsing.

      In Section 6.6, we see another method and a different attribute restriction that allows attribute evaluation during top-down parsing.

     For the next few sections, we focus on restrictions to attributes that allow for efficient attribute evaluation.

6.5.4 Noncircular Attribute Grammars

If the calculation of an attribute comes around to using its own value in the calculation, then we have a circularity. We will, however, need a more formal definition of circularity in terms of dependency graphs.

Dependency Graph of a Production

The dependency graph of a production, p, is a set of vertices and edges. The vertices are the attribute occurrences (see Section 6.1.1) and the edges are dependencies.

Formally, for each production

            p: Xo X1 X2. . . Xn,

           DVp = { (a, k) | a is in A(Xk), 0<=k<=n }


           DEp = {<(b, i) ,(a, k)> | < (b,i) is in Dp(a, k)}

Thus, if O1 is in the dependency set for O2, then there is an arc between attribute occurrence O1 and attribute occurrence O2.

In Example 7,

         DV4 = { (Value, 0), (Scale, 0), (Value, 1), (Scale, 1), (Value, 2), (Scale, 2) }

         DE4 = { <(Value, 1), (Value, 0)>, <(Scale, 0), (Scale, 1)>, <(Value, 2), (Value, 0)>, <(Scale, 0), (Scale, 2)> }

     The dependency graph for an input program is produced by merging the dependency graphs for each production used to parse the program. It is defined in terms of the parse tree, T.

     Since the dependency graph for an input is defined by augmenting the nodes of the parse tree with attributes, the definition of noncircularity is in terms of this parse tree:

     An attribute grammar G is noncircular if there does not exist even one tree, T, such that DGT contains a cycle.

     Attribute grammars which are circular are undesirable. Knuth (1968, 1971) presents an algorithm which tests a grammar for noncircularity. It is exponential in the worst case. Jazayeri et al. (1975) show that there is no algorithm that tests a grammar for circularity which is not exponential in the worse case. Fortunately, most grammars do not exhibit this worst case behavior.

6.5.5 Absolutely Noncircular Attribute

In Section 6.6 we present some efficient attribute evaluation methods. One of them requires that the attribute grammar be noncircular in an even stronger way than the noncircular definition above.

      We start with the dependency graphs for the productions of a grammar. Figure 2 shows the nodes of the dependency graph for the binary digit grammar.

      Example 8 shows these graphs merged to create the dependency graph for a parse tree, T. List's Scale attribute is handed down the tree to the BinaryDigit node where it is used to calculate the value of Scale. This value is handed back up the tree, changing as it goes, but ultimately it is used to calculate List's Value attribute. In functional notation, we would write:

               List.Value = f (List.Scale)

where function, f (the accumulation of the changes to Scale as it descends the tree), is used to compute Value and then is handed back up to the node. We indicate these closure steps by drawing an arc in the list node labeled with an asterisk, and we label the nodes themselves with asterisks, calling the new graph augmented dependency graphs.

      With augmented dependency graphs defined, we can define absolute noncircularity. An attribute grammar is absolutely noncircular if none of the augmented dependency graphs, DG*p, contains a cycle.

     Absolute noncircularity is a stronger restriction than noncircularity.

6.7 Summary

This module decsribes semantic analysis, the bridge between the front-end and the back-end of compiling. The specification of semantics is often done using attribute grammars, and much of this module is devoted to attribute grammars. Attributes are evaluated at compile-time; however, some processing toward generation of the evaluator may be moved back to compiler generation time.

Grammatical restrictions and efficient evaluation are interconnected in many cases. Thus, the attributes described by L-attributed grammars can be evaluated at parse-time by a top-down parser or after the parse in a single pass down the tree.

The attributes described by S-attributed grammars can be evaluated at parse-time by a bottom-up parser or after the parse by a single pass up the tree.

For unrestricted attribute grammars, tree-walk evaluators may require multiple passes over the parse tree. More efficient evaluators may be obtained by creating a dependency graph from the parse tree and the semantic functions. A dependency graph ensures that the attributes upon which a semantic function depends are evaluated first.

Another task of semantic analysis is creation of an intermediate representation of the program.

Yet another task of semantic analysis is Symbol Table creation.