11/8/2012 The Structure of a Compiler (2) The Structure of a Compiler (1) Any compiler must perform two major tasks Sourc rce Progra ram Tokens Syntactic Semantic Scanner Parser Structure re Routines (Chara racter r St Stre ream) Compiler Interm rmediate Representation Compiler Design and Construction Symbol and Analysis Synthesis Optimizer Attri ribute Semantic Analysis Tables Analysi ysis of the source program Slides modified from Louden Book, Dr. Scherger, & Y Chung (Used by all Phases of The Compiler) r) (NTHU), and Fischer, Leblanc Synthesis sis of a machine-language program Code Genera rator 3 2 Target machine code Source Code Semantic Processing Abstract Syntax Tree Compiler Stages Scanner Tokens Semantic routines interpret meaning based on syntactic 1 st step in semantic processing is to build a syntax tree structure of input (modern compilers do this) representing input program Parser Syntax Tree This makes the compilation syntax-directed Don't need literal parse tree Literal Semantic Intermediate nodes for precedence and associativity Table Semantic routines finish the analysis Analyzer Symbol e -rules Annotated Verify static semantics are followed Table Tree Source Code Just enough info to drive semantic processing Variables declared, compatible operands (type and #), etc. Optimizer Error Or even recreate input Handler Semantic routines also start the synthesis Intermediate Code Code Generate either IR or target machine code Generator Semantic processing performed by traversing the tree 1 The semantic action is attached to the productions (or Target or more times Code sub trees of a syntax tree). Target Code Optimizer Attributes attached to nodes aid semantic processing Target Chapter 1: Introduction January, 2010 5 Chapter 6:Semantic Analysis April, 2011 4 1
11/8/2012 7.1.1 Using a Syntax Tree Representation of a Parse (1) Abstract Syntax Tree Abstract Syntax Tree parse tree Parsing: <assign> build the parse tree := := <target> := <exp> Non-terminals for operator precedence and associatively are included. id <exp> + <term> Id + Id(Y) + <factor> <term> id <term> * <factoor> <factor> id * Id * Id(I) Semantic processing : Const build and decorate the A bstract S yntax T ree ( AST ) Const Id Const(3) Id(X) Non-terminals used for ease of parsing may be omitted in the abstract syntax tree. abstract syntax tree Abstract syntax tree for Y:=3*X+I Abstract syntax tree for Y:=3*X+I with initial := values id + id * 7 2012/11/8 const id 7.1.1 Using a Syntax Tree Representation of a Parse (2) Abstract Syntax Tree Abstract Syntax Tree Semantic routines traverse (post-order) the AST, computing attributes of the nodes of AST. Initially, attributes only at leaves :=(itof) Attributes propagate during the static semantic Initially, only leaves (i.e. terminals, e.g. const, id) have checking Id(Y)(f) +(i) attributes Processing declarations to build symbol table Find symbols in ST to get attributes to attach Ex. Y := 3*X + I * (i) Id(I,i) Determining expression/operand types := Declarations propagate top-down Const(3,i) Id(X,i) + Expressions propagate bottom-up id(Y) A tree is decorated after sufficient info for code * id(I) Abstract syntax tree for Y:=3*X+I with generation has propagated. propagated values const(3) id(X) 12 2012/11/8 2
11/8/2012 7.1.1 7.1.1 Static Semantic Checks Using a Syntax Tree Representation of a Parse (3) Using a Syntax Tree Representation of a Parse (4) The attributes are then propagated to other nodes using Static semantics can be checked at compile time After attribute propagation is done, some functions, e.g. the tree is decorated and ready for code generation, Check only propagated attributes build symbol table use another pass over the decorated AST to generate code. Type compatibility across assignment Int B; attach attributes of nodes B := 5.2; illegal check types, etc. B := 3; legal Actually, these can be combined in a single pass Build the AST Use attributes and structure bottom-up / top-down propagation Correct number and types of parameters Decorate the AST procedure foo(int a, float b, int c, float b); int C; Generate the target code <program> float D; ‘‘‘ ‘‘ ‘‘ <stmt> declaration call foo(C,D,3,2.9) legal ‘‘ := What we have described is essentially ‘‘‘‘‘ call foo(C,D,3.3, 2.9) illegal id + exp. the Attribute Grammars(AG) (Details in chap.14) call foo(1,2,3,4,5) illegal type symbol * id ‘ ‘‘‘check types: integer * or floating * table ” Need to consult symbol table for types of id’s. const id ‘‘‘ 15 Chapter 6:Semantic Analysis April, 2011 13 2012/11/8 14 2012/11/8 Dynamic Semantic Checks Translation Compiler Organization Some checks can’t be done at compile time Translation task uses attributes as data, but it is driven by one-pass compiler the structure Array bounds, arithmetic errors, valid addresses of pointers, Single pass used for both analysis and synthesis variables initialized before use. Translation output can be several forms Scanning, parsing, checking, & translation all interleaved, Some languages allow explicit dynamic semantic checks No explicit IR generated Machine code Semantic routines must generate machine code i.e. assert denominator not = 0 Intermediate representation Only simple optimizations can be performed Decorated tree itself T ends to be less portable These are handled by the semantic routines inserting Sent to optimizer or code generator code to check for these semantics Violating dynamic semantics result in exceptions 3
11/8/2012 7.1.2 Compiler Organization Compiler Organization Compiler Organization Alternatives (2) We prefer the code generator completely hides machine one-pass with peephole optimization one-pass analysis and IR synthesis plus a code generation details and semantic routines are independent of machines. pass Optimizer makes a pass over generated machine code, looking at a small number of instructions at a time Adds flexibility Allows for simple code generation Explicit IR created & sent to code generator Can be violated to produce better code. IR typically simple Suppose there are several classes of registers, each for a different purpose. Peephole: looking at only a few instructions at a time Optimization can examine as much of IR as wanted Better for register allocation to be performed by semantic Effectively a separate pass Less machine-dependent analysis routines than code generator since semantic routines have a So easier to retarget Simple but effective broader view of the AST. Simplifies code generator since there is a pass of post- processing. 19 2012/11/8 7.1.2 7.1.3 Compiler Organization Compiler Organization Alternatives (7) Single Pass (1) Multi-pass analysis Multi-language and multi-target compilers In Micro of chap 2, scanning, parsing and semantic processing Scan, then parse, then check declarations, then static semantics are interleaved in a single pass. Usually used to save space (memory usage or compiler) Components may be shared and parameterized. Ex : Ada uses Diana (language-dependent IR) (+) simple front-end Multi-pass synthesis (+) less storage if no explicit trees Separate out machine dependence Ex : GCC uses two IRs. Better optimization one is high-level tree-oriented (-) immediately available information is limited since no complete tree is built. Generate IR the other(RTL) is more machine-oriented Do machine independent optimization Generate machine code ..... FORTRAN PASCAL ADA C Machine dependent optimization Relationships Many complicated optimization and code generation algorithms require multiple passes semantic ..... rtn 1 i.e. optimizations that need a more global view call call machine-independent optimization semantic semantic scanner parser for I = 1 to N rtn 2 records tokens foo = 35*bar(i)+16; bar(i) { return 3;}; semantic rtn k SUN PC main-frame 23 2012/11/8 24 2012/11/8 language - and machine-independent IRs 4
Recommend
More recommend
