structure of compilers l.
Skip this Video
Loading SlideShow in 5 Seconds..
Structure of Compilers PowerPoint Presentation
Download Presentation
Structure of Compilers

Loading in 2 Seconds...

play fullscreen
1 / 35

Structure of Compilers - PowerPoint PPT Presentation

Download Presentation
Structure of Compilers
An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Structure of Compilers Lexical Analyzer (scanner) Modified Source Program Tokens Syntactic Structure Semantic Analysis Parser Intermediate Representation Optimizer Symbol Table Code Generator Target machine code

  2. Binding • Binding - association of an operation and a symbol. • Binding time - when does the association take place? • Design time • Compile time • Link time • Runtime

  3. Binding time • Example: int count; count = count + 5; • Type of count is bound at compile time. • Value of count bound at execution time. • Meaning of + bound at compile time. • Possible types for count, internal representation of 5 and set of possible meanings for + bound at compiler design time.

  4. Binding • Static • It occurs before runtime and remains unchanged throughout program execution. • Dynamic • It occurs at runtime and can change in the course of program execution.

  5. Type Binding • Before a variable can be referenced in a program, it must be bound to a data type. • Two important questions to ask: 1. How is the type specified? • Explicit Declaration • Implicit Declaration • All variable names that start with the letters ‘i’ - ‘r’ are integer, real otherwise • @name is an array, %something is a hash structure • Determined by context and value

  6. Type Binding 2. When does the binding take place • Explicit declaration (static) • Implicit declaration (static) • Determined by context and value (dynamic) • Dynamic Type Binding • When a variable gets a value, the type of the variable is determined right there and then.

  7. Dynamic Type Binding • Specified through an assignment statement (set x ‘(1 2 3)) <== x becomes a list (set x ‘a) <== x becomes an atom • Advantage: • flexibility (generic program units) • Disadvantages: 1. High cost (dynamic type checking and interpretation) 2. Type error detection by the compiler is difficult

  8. Type Inference • Rather than by assignment statement, types are determined from the context of the reference. • Some languages don’t support assignment statements • Example: (define someFunction (m n) .... ) (someFunction ‘a ‘b) <== m becomes an atom (someFunction ‘(a b c) ‘(1 2 3)) <= m becomes a list

  9. Storage Bindings • Allocation • getting a cell from some pool of available cells • Deallocation • putting a cell back into the pool • The lifetime of a variable is the time during which it is bound to a particular memory cell.

  10. Variable lifetime • Static • bound to memory cells before execution begins and remains bound to the same memory cell throughout execution. • C’s static variables • Advantage: • efficiency (direct addressing), • history-sensitive subprogram support • Disadvantage: • lack of flexibility (no recursion)

  11. Variable lifetime • Stack-dynamic • Storage bindings are created for variables when their declaration statements are elaborated. • If scalar, all attributes except address are statically bound. • e.g. local variables in Pascal and C subprograms • Advantage: • allows recursion; conserves storage • Disadvantages: • Overhead of allocation and deallocation • Subprograms cannot be history sensitive

  12. Variable Lifetime • Explicit heap-dynamic • Allocated and deallocated by explicit directives, specified by the programmer, which take effect during execution. • Referenced only through pointers or references • e.g. dynamic objects in C++ (via new and delete) • all objects in Java • Advantage: • provides for dynamic storage management • Disadvantage: • inefficient and unreliable

  13. Variable lifetime • Implicit heap-dynamic • Allocation and deallocation caused by assignment statements • e.g. Lisp variables • Advantage: • flexibility • Disadvantages: • Inefficient, because all attributes are dynamic • Loss of error detection

  14. Type Checking - • Generalize the concept of operands and operators to include subprograms and assignments • Type checking is the activity of ensuring that the operands of an operator are of compatible types • A compatible type is one that is either legal for the operator, or is allowed under language rules to be implicitly converted, by compiler-generated code, to a legal type. This automatic conversion is called a coercion.

  15. Type Checking • A type error is the application of an operator to an operand of an inappropriate type. • If all type bindings are static, nearly all type checking can be static • If type bindings are dynamic, type checking must be dynamic • A programming language is strongly typed if type errors are always detected.

  16. Type Checking • Advantage of strong typing: • Allows the detection of the misuses of variables that result in type errors. • Languages: • 1. FORTRAN 77 is not: parameters, EQUIVALENCE • 2. Pascal is not: variant records • 3. Modula-2 is not: variant records, WORD type • 4. C and C++ are not: parameter type checking can be avoided; unions are not type checked. • 5. Ada is, almost (UNCHECKED CONVERSION is loophole) (Java is similar) • Coercion rules strongly affect strong typing • they can weaken it considerably (C++ versus Ada)

  17. Name Type Compatibility • Type compatibility by name means the two variables have compatible types if they are in either the same declaration or in declarations that use the same type name • Easy to implement but highly restrictive: • Subranges of integer types are not compatible with integer types • Formal parameters must be the same type as their corresponding actual parameters

  18. Name Type Compatibility type indextype = 1..100; //subrange var count : integer; index : indextype; Is count and index name type compatible?

  19. Structure Type Compatibility • Type compatibility by structure means that two variables have compatible types if their types have identical structures • More flexible, but harder to implement type myType1 = double; type myType2 = double; myType1 data1; myType2 data2; data1 = data2; //????

  20. Type Compatibility type type1 = arary [1..10] of integer; type2 = array [1..10] of integer; type3 = type2; type2 is compatible with type3 by name type1 is compatible with type2 by structure

  21. Type Compatibility • Anonymous types A: array [1..10] of INTEGER; B: array [1..10] of INTEGER; C, D: array [1..10] of INTEGER;

  22. Scope • The scope of a variable is the range of statements over which it is visible. • The nonlocal variables of a program unit are those that are visible but not declared there. • The scope rules of a language determine how references to names are associated with variables.

  23. Static scope • Based on program text • To connect a name reference to a variable, you (or the compiler) must find the declaration. • Search process: • search declarations, first locally, then in increasingly larger enclosing scopes, until one is found for the given name. • Enclosing static scopes (to a specific scope) are called its static ancestors; the nearest static ancestor is called a static parent.

  24. Static Scope • Blocks - a method of creating static scopes inside program units--from ALGOL 60 C and C++:for (...) { int index; ... } Ada: declare LCL : FLOAT; begin ... end

  25. Static Scope: Procedures Evaluation of Static Scoping (for nested procedures) Consider the example: MAIN Define Sub A Define Sub C Define Sub D Call Sub C Define Sub B Define Sub E Call Sub E Call Sub A MAIN A C D B E

  26. Static Scope: Variables program main; var x: integer; procedure sub1; begin print(x); end; {sub1} procedure sub2; var x: integer; begin x := 10; sub1; end; begin x := 5; sub2 end. Output 10 or 5?

  27. Static Scope • Suppose the spec is changed so that D must now access some data in B • Solutions: 1. Put D in B (but then C can no longer call it and D cannot access A's variables) 2. Move the data from B that D needs to MAIN (but then all procedures can access them) • Same problem for procedure access! • Overall: static scoping often encourages many globals

  28. Dynamic Scope • Based on calling sequences of program units, not their textual layout (temporal versus spatial) • References to variables are connected to declarations by searching back through the chain of subprogram calls that forced execution to this point. • Evaluation of Dynamic Scoping: • Advantage: convenience • Disadvantage:hard to debug, hard to understand the code

  29. Dynamic Scope: Variables program main; var x: integer; procedure sub1; begin print(x); end; {sub1} procedure sub2; var x: integer; begin x := 10; sub1; end; begin x := 5; sub2 end. Output 10 or 5?

  30. Scope vs. Lifetime • Scope and lifetime are sometimes closely related, but are different concepts!! • Consider a static variable in a C or C++ function void someFunction() { static int x; ... }

  31. Intermediate Representation • Almost no compiler produces code without first converting a program into some intermediate representation that is used just inside the compiler. • This intermediate representation is called by various names: • Internal Representation • Intermediate representation • Intermediate language

  32. Intermediate Representation • Intermediate Representations are also called by the form the intermediate language takes: • tuples • abstract syntax trees • Triples • Simplied language

  33. Intermediate Form • In general, an intermediate form is kept around only until the compiler generates code; then it cane be discarded. • Another difference in compilers is how much of the program is kept in intermediate form; this is related to the question of how much of the program the compiler looks at before it starts to generate code. • There is a wide spectrum of choices.

  34. Abstract Syntax Tree x = y + 3; = x + y 3

  35. Quadruples y a x b T1 T2 c T3 T4 y= a*(x+b)/(x-c); T1= x+b; (+, 3, 4, 5) T2=a*T1; (*, 2, 5, 6) T3=x-c; (-, 3, 7, 8) T4=T2/T3; (/, 6, 8, 9) y=T4; (=, 0, 9, 1)