Symbol

Symbols are used as handles for variables, procedures, and potential targets of branches and jumps.

    abstract Symbol : SymbolTableObject
      {
         virtual Type * reference symbol_type;
         bool is_address_taken;
      };

symbol_type	type of the symbol.
is_address_taken	whether or not the address of the symbol is taken. Most of the time most symbols are never addressed, which facilitates optimizations and analysis of code referring to those symbols.

• VariableSymbol. A VariableSymbol represents a unit of storage, just as variables in Fortran, C++, or C do.

      concrete VariableSymbol : Symbol
        {
          QualifiedType* reference type in symbol_type;
          VariableDefinition * reference definition omitted;
        };
  

  type

  Type of the variable

  definition

  Initialization for variable. The initalization may be static or not as defined by the is_static field on the definition. A statically allocated variable does not have a definition if it is in the external scope and it refers to a variable defined outside the current file set that will be linked in later. A VariableSymbol at file or global scope in Standard SUIF is assumed to be statically allocated. A VariableSymbol at procedure scope or block scope within a procedure is assumed to be an auto variable unless it has a VariableDefinition and that definition has the is_static field set, in which case it is statically allocated.

• FieldSymbol. Fields within a GroupType are represented by FieldSymbol objects. The field name and type are the name and type inherited from the Symbol and VariableSymbol levels. FieldSymbols can occur only within GroupSymbolTables.

      concrete FieldSymbol : VariableSymbol
        {
          Expression * owner bit_offset;
        };
  

  bit_offset

  Specifies how far into the GroupType the field begins.

• NestingVariableSymbol. Same as a regular variable symbol except that optionally it can be made a sub-variable of another variable. A sub-variable is one whose storage is part of another variable. This is used to represent fields within common blocks in Fortran and it could also be used to represent fields within particular instances of structures. There can be multiple sub-variables for a given parent and the different sub-variables are allowed to overlap arbitrarily, but they are not allowed to extend outside the parent variable. No sub-variable is allowed to have a variable definition, though the parent may have one. Following the chain of parents from one variable to another is not allowed to result in a cyle that comes back to the original variable.

      concrete NestingVariableSymbol : VariableSymbol
        {
          NestingVariableSymbol * reference super_variable;
          Expression * owner bit_offset;
          list<NestingVariableSymbol *reference> child_variables;
        };
  

  super_variable	shows which variable is the parent, if any
  bit_offset	shows how far past the start of the parent the sub-variable starts.
  child_variables	list of its children variables

• ParameterSymbol. A special VariableSymbol used to represent a formal parameter to a procedure. They are allowed only in procedure scopes, and each is required to show up in the list of formal parameters kept by the appropriate procedure definition. It is this list of formals in the procedure_definition that specifies the order of formals - i.e. how they map to the actual parameters.

       concrete ParameterSymbol : VariableSymbol {};
  

• ProcedureSymbol. Represents a procedure, whether or not a definition is available. Procedure symbols are allowed only in symbol tables for file or global scope, not within a procedure definition.

       concrete ProcedureSymbol : Symbol
         {
           ProcedureType* reference type in symbol_type;
           ProcedureDefinition * reference definition optional;
         };
  

  type	Type of the procedure
  definition	Definition of procedure. This is optional.

• CodeLabelSymbol. Represents a location within a body of code.

       concrete CodeLabelSymbol : Symbol
         {
           LabelType* reference type in symbol_type;
         };
  

  type	Type of the label