Compilers Project

Topic: Compiler for Flat Tiny C (FLTC)

Compilers
A Compiler translates a program in a source language to an equivalent program in a target language
Source Program

Compiler

Target Program

Typically
Source Languages - C, C++, ADA, FORTRAN etc.

Target languages - Instruction set of a microprocessor

An assembler translates assemble language programs in to object

code.

GCC

Structure of a Three Phase Compiler

Front End Optimize r Back End
Compile r

Source Progra m

IR

IR

Target ALP

An Optimizer
Analyzes IR and rewrites (or transforms) IR Primary goal is to reduce running time of the compiled code

May also improve space, power consumption,

Must preserve meaning of the code Measured by values of named variables

progra m Lexical Analyzer token stream Syntax Analyzer syntax tree Symbol Table Semantic Analyzer syntax tree Intermediate Code Generator intermediate representation Machine-Independent Code Optimizer intermediate representation Code Generator

Structure of a Typical Compiler

Front End

Instruction Selection Register Allocation Instruction Scheduling MachineDependent Code Optimizer

Back End

target-machine code

target-machine code

The Front End

program Lexical Analyzer/Scanner token stream Syntax Analyzer/Parser syntax tree Symbol Table Semantic Analyzer syntax tree Intermediate Code Generator intermediate representation

The Front End: Scanner and Parser

Source Code

Scanner

Tokens

Parser

IR Error s

Parser
Takes as input a stream of tokens

Checks if the stream of tokens constitutes a syntactically valid program of

the language
If the input program is syntactically correct

Output an intermediate representation of the code (like AST)

If the input program has syntactic errors Outputs relevant diagnostic information

Context Free Grammars and Programming Languages Expr Binop Expr Binop Expr | Expr | ! Expr | ( Expr ) Arithop | Relop | Eqop | Condop

Arithop + | | * | / | % | << | >>

Relop < | > | <= | >=

Eqop

== | !=

Condop && | ||

CFGs and Programming Languages

Statement Location = Expr ; | MethodCall ;

|
|

if ( Expr ) Block
if ( Expr ) Block else Block

while ( Expr ) Block

| continue ; | Block

Block { VarDeclList StatementList } StatementList Statement | Statement StatementList

Context Free Grammars and Programming Languages

Key Idea: All modern programming languages can be expressed using context free grammars (by design!)
Programs have recursive structures
A program is a collection of functions A function is a sequence of statements A statement can be any of if, while, for, assignment statements etc. The body of a while loop is a sequence of statements An arithmetic expression is a sum/product of two AEs.

CFGs are a nice way of expressing programs with recursive structure

CFGs and Programming Languages

Advantages of using CFGs to specify syntactic structure of languages
Clear and concise syntactic specification for languages Language can be developed or evolved iteratively
New constructs in the language can be added with relative ease.

Programming languages can be specified using a special sub-class of CFGs for which efficient parsing techniques and automatic parser generators exists.
These special class of CFGs also allow for automatically capturing ambiguities in

the language
CFGs impose a structure on the program which facilitates easy translation to

intermediate or target object code.

Grammar for FTC

Program class main { Field_Decl* Statement* } Field_Decl Type { id | id [ int_literal ] }+, ;

Type int | boolean | char

Statement Labelled_Statement | Location = Expr ; | if Expr then goto label ; | goto label ; | Method_Call; Labelled_Statement label Statement //Think of label as id: // label is a token like id

Grammar for FTC

Location id | id [ Expr ] Expr Literal | Location | Expr Binop Expr

| - Exp | ! Expr | ( Expr )

Binop Arithop | Relop | Condop Arithop + | - | * | / Relop < | > | <= | >= | == | != Condop && | || Method_Call print( Expr +,); | read(Location); Literal int_literal | string_literal | char_literal | bool_literal

Parsing Approaches
Cocke-Younger-Kasami (CYK) algorithm can construct a parse tree

for a given string and CFG in (n3) worst-case time.

Earleys algorithm
O(n3) for general CFGs

O(n2) for unambiguous grammars

We would like to have linear-time algorithms for parsing programs.

Yacc (Bison)

Structure of a Yacc Specification file

Yacc

flex can generate the yylex() function using the lexical specification.

Yacc

Abstract Syntax Trees (ASTs)

Compilers often use an abstract syntax tree instead of a parse tree The AST summarizes grammatical structure, without including detail

about the derivation

x+2-y

This is much more concise ASTs are one kind of intermediate representation (IR)

Abstract Syntax Trees

While if

expr subtree

statement subtree

expr subtree

statement subtree

if-else

expr subtree

ifstatement subtree

elsestatement subtree

AST Construction for Expression Grammar

%{ struct { enum Op op; struct astnode *left; struct astnode *right } astnode; #define YYSTYPE struct astnode *; %} %token NUMBER %left - + %left * / %%

Note: This yacc specification is not complete. I highlighted only the important parts.

expr: expr + expr { $$ = getNewAstnode(); $$->op = plus; $$->left = $1; $$->right = $3; }
| expr - expr { $$ = getNewAstnode(); $$->op = minus; $$->left = $1; $$->right = $3; } | expr * expr { $$ = getNewAstnode(); $$->op = mult; $$->left = $1; $$->right = $3; } | expr / expr { $$ = getNewAstnode(); $$->op = div; $$->left = $1; $$->right = $3; }

Abstract Syntax Trees

While if

expr subtree

statement subtree

expr subtree

statement subtree

if-else

expr subtree

ifstatement subtree

elsestatement subtree

AST Construction
Note: The way statement lists are handled here is different from the code I have shown in the class.

Symbol Tables