1. Course Overview Mooly Sagiv msagiv@post.tau.ac.il Schrierber 317 03-640-7606 Wed 10:00-12:00 html://www.math.tau.ac.il/~msagiv/courses/wcc01.html Textbook:Modern Compiler Implementation in C Andrew Appel ISBN 0-521-58390-X

2. Outline High level programming languages Interpreter vs. Compiler Abstract Machines Why study compilers? Main Compiler Phases

3. High Level Programming Languages Imperative –Algol, PL1, Fortran, Pascal, Ada, Modula, and C –Closely related to “von Neumann” Computers Object-oriented –Simula, Smalltalk, Modula3, C++, Java – Data abstraction and ‘evolutionary’ form of program development Class An implementation of an abstract data type (data+code) Objects Instances of a class Fields Data (structure fields) Methods Code (procedures/functions with overloading ) Inheritance Refining the functionality of a class with different fields and methods Functional Logic Programming

4. Other Languages Hardware description languages –VHDL – The program describes Hardware components – The compiler generates hardware layouts Shell-languages Shell, C-shell, REXX – Include primitives constructs from the current software environment Graphics and Text processing TeX, LaTeX, postscript –The compiler generates page layouts Web/Internet – HTML, MAWL, Telescript, JAVA Intermediate-languages –P-Code, Java bytecode, IDL

5. Interpreter Input – A program –An input for the program Output – The required output interpreter source-program program’s input

6. Example C interpreter int x; scanf(“%d”, &x); x = x + 1 ; printf(“%d”, x); 5 6

7. Compiler Input – A program Output – An object program that reads the input and writes the output compiler source-program program’s input object-program

8. Example Sparc-cc-compiler int x; scanf(“%d”, &x); x = x + 1 ; printf(“%d”, x); 56 add %fp,-8, %l1 mov %l1, %o1 call scanf ld [%fp-8],%l0 add %l0,1,%l0 st %l0,[%fp-8] ld [%fp-8], %l1 mov %l1, %o1 call printf assembler/linker object-program

9. Interpreter vs. Compiler Conceptually simpler (the definition of the programming language) Easier to port Can provide more specific error report Normally faster More efficient –Compilation is done once for all the inputs --- many computations can be performed at compile-time –Sometimes even compile-time + execution-time < interpretation-time Can report errors before input is given

10. Interpreters provide specific error report Input-program Input data y=0 scanf(“%d”, &y); if (y < 0) x = 5;... if (y <= 0) z = x + 1;

11. Compilers are usually more efficient Sparc-cc-compiler scanf(“%d”, &x); y = 5 ; z = 7 ; x = x +y*z; printf(“%d”, x); add %fp,-8, %l1 mov %l1, %o1 call scanf mov 5, %l0 st %l0,[%fp-12] mov 7,%l0 st %l0,[%fp-16] ld [%fp-8], %l0 add %l0, 35,%l0 st %l0,[%fp-8] ld [%fp-8], %l1 mov %l1, %o1 call printf

12. Compilers can provide errors before actual input is given Input-program Compiler-Output “line 4: improper pointer/integer combination: op ='' int a[100], x, y ; scanf(“%d”, y) ; if (y < 0) /* line 4*/y = a ;

13. Compilers can provide errors before actual input is given Input-program Compiler-Output “line 88: x may be used before set'' scanf(“%”, y); if (y < 0) x = 5;... if (y <= 0) /* line 88 */ z = x + 1;

14. Abstract Machines A compromise between compilers and interpreters An intermediate program representation The intermediate representation is interpreted Example: Zurich P4 Pascal Compiler(1981) Other examples: Java bytecode, MS.NET The intermediate code can be compiled Pascal compiler Pascal Program P-code interpreter program’s input

15. Why Study Compilers Become a compiler writer –New programming languages –New machines –New compilation modes: “just-in-time” Using some of the techniques in other contexts Design a very big software program using a reasonable effort Learn applications of many CS results (formal languages, decidability, graph algorithms, dynamic programming,... Better understating of programming languages and machine architectures Become a better programmer

16. Course Requirements Compiler Project 50% –Develop a Tiger Front-End in C –Tight schedule Bonus 15% Final exam 50%

17. Compiler Phases The compiler program is usually written as sequence of well defined phases The interfaces between the phases is well defined (another language) It is sometimes convenient to use auxiliary global information (e.g., symbol table) Advantages of the phase separation: –Modularity –Simplicity –Reusabilty

18. Basic Compiler Phases Source program (string) Fin. Assembly lexical analysis syntax analysis semantic analysis Translate Instruction selection Register Allocation Tokens Abstract syntax tree Intermediate representation Assembly Finite automata Pushdown automata Memory organization graph algorithms Dynamic programming

19. Example:straight-line programming Stm ::=Stm ; Stm //(CompoundStm) Stm ::=id := Exp // (AssignStm) Stm ::= print (ExpList)// (PrintStm) Exp ::= id// (IdExp) Exp ::= num// (NumExp) Exp ::= Exp Binop Exp // (OpExp) Exp ::= (Stm, Exp) // (EseqExp) ExpList ::= Exp, ExpList // (PairExpList) ExpList ::= Exp// (LastExpList) Binop ::= +// (Plus) Binop ::= - // (Minus) Binop ::= * // (Times) Binop ::= / // (Div)

20. Example Input a := 5 + 3; b := ( print(a, a-1), 10 * a); print(b)

21. Questions How to check that a program is correct? How to internally represent the compiled program?

22. Lexical Analysis a\b := 5 + 3 ;\nb := (print(a, a-1), 10 * a) ;\nprint(b) Input string Tokens id (“a”) assign num (5) + num(3) ; id(“b”) assign print(id(“a”), id(“a”) - num(1)), num(10) * id(“a”)) ; print(id(“b”))

23. Syntax Analysis Tokens Abstract Syntax tree id (“a”) assign num (5) + num(3) ; id(“b”) assign print(id(“a”), id(“a”) - num(1)), num(10) * id(“a”)) ; print(id(“b”)) CompoundStm AssignStm CompoundStm id opExp numExp Plus 53 a AssignStm id eseqExp PrintStm opExp b

24. Summary Phases drastically simplifies the problem of writing a good compiler The Textbook offers a reasonable partition into phases with interface definition (in C) Every week we will study a new compiler phase