Symbol Table Attributes: Why the Correct Answer Is “All of These”

A symbol table is a compiler data structure that records information about identifiers such as variables, functions, constants, parameters, and user-defined types. Its entries commonly associate an identifier with attributes including its type, scope, and storage location or address.

Therefore, for the question:

Which attribute is commonly stored in a symbol table?

• (i) Variable type — Yes
• (ii) Address — Yes
• (iii) Scope — Yes
• (iv) All of these — Correct

The correct answer is (iv) All of these.

A compiler may store additional attributes such as the identifier name, category, size, value, parameter list, return type, declaration line, storage class, and array dimensions. The exact set depends on the programming language and compiler implementation.

Footnotes

1. Symbol Table in Compiler - Describes symbol tables as storing identifier names, types, scopes, and memory locations. ↩

2. Building Your Compiler: The Symbol Table - University lecture material discussing symbol categories, types, scope, and additional attributes. ↩

1. What Is a Symbol?

A symbol is a name that represents a program entity. Examples include:

• A variable such as total
• A function such as calculateSum
• A constant such as PI
• A parameter such as length
• A user-defined type such as Student

When the compiler encounters a declaration, it creates or updates a symbol-table entry for that symbol.

For example:

1int count;

A simplified entry might contain:

The symbol table is used throughout compilation for declaration checking, scope resolution, type checking, storage allocation, and code generation.

Footnotes

1. Compiler Design — Symbol Table - Explains symbol attributes, insertion, lookup, and scope management. ↩

2. Variable Type

The type attribute records the data type associated with a symbol.

Examples include:

• int
• float
• char
• boolean
• Array types
• Structure or class types
• Function types

For the declaration:

1float price;

the symbol-table entry for price records float as its type.

Why the Type Attribute Matters

The compiler uses type information to:

1. Check whether an assignment is valid.
2. Determine the size of an object.
3. Select appropriate machine instructions.
4. Validate function arguments and return values.
5. Detect incompatible operations.

For example:

1int count;
2count = 3.14;

Depending on the language rules, the compiler may permit a conversion, issue a warning, or report a type error. It can make this decision because the symbol table records that count has type int.

Type checking is a major function of semantic analysis.

Footnotes

1. Symbol Table in Compiler - Describes the use of symbol-table information for semantic analysis and type checking. ↩

3. Address or Storage Location

The address attribute identifies where a symbol will be stored or accessed at run time.

The stored value may be:

• An absolute memory address
• A relative address
• A stack-frame offset
• A register assignment
• A global-data label
• A relocation entry
• An intermediate representation location

For example, a compiler might represent local variables using offsets from a frame pointer:

The exact address may not be known during the earliest compilation phase. The compiler can initially record a symbolic location or offset and resolve the final address during code generation or linking.

Why the Address Attribute Matters

The compiler needs location information to generate instructions such as:

1LOAD register, [frame_pointer - 4]
2STORE [frame_pointer - 4], register

In this example, the symbol table helps connect the source-level name x to its machine-level storage location.

For object files and machine-code formats, a symbol table commonly contains at least a symbol’s name and location or address. Relocatable formats may also store relocation-related information.

Footnotes

1. Symbol Table in Compiler Design - Discusses storage locations bound to names at run time and common symbol-table entry information. ↩

2. Symbol table - Describes names, locations or addresses, relocatability information, and high-level language types in symbol tables. ↩

4. Scope

The scope attribute identifies where a symbol can be referenced.

Common scope categories include:

• Global scope
• Function scope
• Block scope
• Class scope
• Module or namespace scope
• Parameter scope

Consider:

1int value = 10;
2
3void example(void) {
4    int value = 20;
5}

There are two declarations named value, but they belong to different scopes. A scoped symbol table distinguishes them and ensures that a reference resolves to the correct declaration.

Scope Resolution

Name resolution typically searches the current scope first, then enclosing scopes.

A compiler may implement scope using:

• One table per scope
• A hierarchy of nested tables
• A single table with scope levels
• A stack of active environments

The scope may be stored explicitly as an attribute, or it may be represented implicitly by the organization of the symbol tables.

Footnotes

1. 7.0 Semantic Analysis: Symbol Tables - Explains scope as an attribute and describes additional symbol attributes and scope organization. ↩

5. How the Attributes Work Together

The three attributes in the question are not independent. The compiler combines them to translate source code into executable instructions.

Suppose the source contains:

1int total;
2total = total + 1;

A simplified symbol-table entry might be:

The compiler uses:

• Name to identify the symbol.
• Type to verify that arithmetic is valid.
• Scope to determine which declaration of total is intended.
• Address to generate load and store instructions.

This demonstrates why the answer is not merely one of the first three options. Each is a commonly stored or represented attribute, so all of these is the best answer.

Footnotes

1. Lecture 7: Semantic Analysis — Types and Symbol Tables - Discusses symbol-table entries, type information, and hierarchical symbol tables for scopes. ↩

6. Example Symbol Table

Consider:

1int globalCount;
2
3void process(int limit) {
4    float ratio;
5    globalCount = limit;
6}

A simplified symbol-table organization could be:

Global Scope

Function Scope: process

The function name belongs to the outer scope, while its parameter and local variable belong to the function’s scope. This organization allows the compiler to resolve names correctly and detect invalid references.

7. Exam-Oriented Reasoning

The question lists three attributes:

1. Variable type
2. Address
3. Scope

Each is associated with symbol-table information:

Thus:

$$\boxed{\text{Correct answer: (iv) All of these}}$$

A useful memory aid is:

TAS — Type, Address, Scope.

These attributes connect a source-level identifier to its meaning, visibility, and runtime representation.