Class 03: Compilation Steps

Held Friday, January 26, 2001

Summary

Today we consider revisit the basics of compilation by looking at the precise steps that may be involved in translating some sample programs.

Assignments

• Read chapter 2 of Aho, Sethi, Ullman.
• Start chapter 3 of Aho, Sethi, Ullman.

Due

• Sample Pascal programs

Notes

• I'll ask for some interesting short sample programs to ground today's discussion.
  • Did anyone write code that had some errors? (Syntactic or logical?)

Overview

• Sample programs
• Lexical analysis
• Syntactic analysis
• Generating intermediate representation trees
• Semantic analysis
• Generating assembly code
• Optimization

A Sample Program

• Our goal for today is to follow the steps of compilation for some sample programs (or portions of programs).
• I'll rely on your sample programs for most of the work, but we'll start with one of mine.

  { Program: count.
    Purpose: Count from 1 to max
    Author:  Samuel A. Rebelsky
    Version: 1.0 of 26 January 2001
  }
  program count(output);
  
  const max = 20;
  
  procedure countto(top: integer);
    var i: integer; { counter variable }
  begin
    for i := 1 to top do
      writeln(i + 0.0)
  end;
  
  begin
    countto(max)
  end.
  

Lexical Analysis

• The goal of lexical analysis is to group characters together (or pull them apart) to build a sequence of simple tokens

  PROGRAM ID(count) OPEN_PAREN ID(output) CLOSE_PAREN SEMICOLON CONST
  ID(max) EQUALS NUMBER(20) SEMICOLON PROCEDURE ID(countto) OPEN_PAREN
  ID(top) COLON TYPE(integer) CLOSE_PAREN VAR ID(i) COLON TYPE(integer)
  SEMICOLON BEGIN FOR ID(i) ASSIGN NUMBER(1) TO ID(max) DO ID(writeln)
  OPEN_PAREN ID(i) OPERATOR(+) NUMBER(0.0) CLOSE_PAREN END SEMICOLON BEGIN
  ID(countto) OPEN_PAREN ID(max) CLOSE_PAREN END PERIOD
  

Syntactic Analysis

• The goal of syntactic analysis is to group the tokens together to make structures (which turn out to be tree-like).

  program
    program-head
      PROGRAM 
      ID(count) 
      OPEN_PAREN 
      file-identifier
        ID(output) 
      CLOSE_PAREN 
      SEMICOLON 
    block
      label-declaration
        empty
      constant-definition-part
        CONST
        constant-definition
          ID(max) 
          EQUALS 
          constant
            NUMBER(20) 
        more-constant-defintions
          empty
      type-definition-part
        empty
      variable-definition-part
        empty
      procedure-definition-part
  ...
  

Intermediate Representation Trees

• We often throw away the useless tokens (and perhaps add some extra information) once we've built the first tree. Some people refer to these variant trees as intermediate representation trees.
• It may also help to think of these as objects with particular attributes

  program
    name: ID(count)
    procedures: ...
    body: ...
  

Semantic Analysis

• Once the tree is built, we can do a form of tree walk to verify certain aspects of the program that are difficult to describe or represent syntactically:
  • Variable lifetimes
  • Types
  • Etc.
• You can also build symbol tables and such.
• You may also look at register usage at this point.

Translation

• At this point, you may translate to something approximating the assembly code. (We'll have some fun here.)

Some Potential Bugs

• What happens if i is a real number?
• What happens if we try to change max?
• What happens if we try to print i after the loop?