Context Analysis. Mooly Sagiv. html://

Size: px

Start display at page:

Download "Context Analysis. Mooly Sagiv. html://www.cs.tau.ac.il/~msagiv/courses/wcc11-12.html"

Jennifer Banks
6 years ago
Views:

1 Context Analysis Mooly Sagiv html:// 1

2 Short Decaf Program Interface not declared class MyClass implements MyInterface { string myinteger; void dosomething() { int[] x = new string; Type mismatch x[5] = myinteger * y ; y is undefined } Can t multiple integers void dosomething() { Can t redefine functions } int fibonacci(int n) { return dosomething() + fibonacci(n 1); } Can t add void } 2

3 Outline What is Context (Context) Analysis Why is it needed? Scopes and type checking for imperative languages (Chapter 6) Attribute grammars (Chapter 3) 3

4 Context Analysis Requirements related to the context in which a construct occurs Context sensitive requirements - cannot be specified using a context free grammar (Context handling) Requires complicated and unnatural context free grammars Guides subsequent phases 4

5 Basic Compiler Phases Source program (string) Symbol Table Front-End lexical analysis Tokens syntax analysis Abstract syntax tree context analysis Back-End Fin. Assembly 5

6 Example Context Condition In C break statements can only occur inside switch or loop statements 6

7 Stm Exp; Partial Grammar for C Stm if (Exp) Stm Stm if (Exp) Stm else Stm Stm while (Exp) do Stm StList StList Stm StList Stm break; Stm {StList } 7

8 Refined Grammar for C Stm Exp; Stm if (Exp) Stm Stm if (Exp) Stm else Stm Stm while (Exp) do LStm Stm {StList } StList StList Stm StList LStm Exp; LStm if (Exp) LStm LStm if (Exp) LStm else LStm LStm while (Exp) do LStm LStList LStList LStm LStm {LStList } LStm break; LStList 8

9 A Possible Abstract Syntax for C Stmt Exp (Exp) Stmt Stmt (SeqStmt) Exp Stmt Stmt (IfStmt) Exp Stmt (WhileStmt) (BreakSt) 9

10 A Possible Abstract Syntax for C package Absyn; abstract public class Absyn { public int pos ;} class Exp extends Absyn { }; class Stmt extends Absyn {} ; class SeqStmt extends Stmt { public Stmt fstst; public Stmt secondst; SeqStmt(Stmt s1, Stmt s2) { fstst = s1; secondst s2 ; } } class IfStmt extends Stmt { public Exp exp; public Stmt thenst; public Stmt elsest; IfStmt(Exp e, Stmt s1, Stmt s2) { exp = e; thenst = s1; elsest s2 ; } } class WhileStmt extends Stmt {public Exp exp; public Stmt body; WhileSt(Exp e; Stmt s) { exp =e ; body = s; } class BreakSt extends Stmt {}; 10

11 Partial CUP Specification... %% stm::= IF ( exp: e ) stm:s {: RESULT = new IfStm(e, s, null) ; :} IF ( exp: e ) stm:s1 ELSE stm: s2 {: RESULT = new IfStm(e, s1, s2) ; :} WHILE ( exp: e ) stm: s {: RESULT= new WhileStm(e, s); :} { s: stmlist } {: RESULT = s; :} BREAK `;' {: RESULT = new BreakStm(); :} ; stmlist ::= stmlist:s1 stmt:s2 {: RESULT = new SeqStm(s1, s2) ; :} /* empty */ {: RESULT = null ; :} 11

12 A Context Check (on the abstract syntax tree) static void checkbreak(stmt st) { if (st instanceof SeqSt) { SeqSt seqst = (SeqSt) st; checkbreak(seqst.fstst); checkbreak(seqst.secondst); } else if (st instanceof IfSt) { IfSt ifst = (IfSt) st; checkbreak(ifst.thenst); checkbreak(ifst elsest); } else if (st instanceof WhileSt) ; // skip else if (st instanceof BreakeSt) { System.error.println( Break must be enclosed within a loop. st.pos); } } 12

13 Syntax Directed Solution parser code {: public int loop_count = 0 ; :} stm : := exp ; IF ( exp ) stm IF ( exp ) stm ELSE stm WHILE ( exp ) m stm {: loop_count--; :} { stmlist } BREAK ; {: if (loop_count == 0) system.error.println( Break must be enclosed within a loop ); :} ; stmlist ::= stmlist st /* empty */ ; m ::= /* empty */ {: loop_count++ ; :} ; 13

14 Problems with Syntax Directed Translations Grammar specification may be tedious (e.g., to achieve LALR(1)) May need to rewrite the grammar to incorporate different Contexts Modularity is impossible to achieve Some programming languages allow forward declarations (Algol, ML and Java) 14

15 Example Context Condition: Scope Rules Variables must be defined within scope Dynamic vs. Static Scope rules Cannot be coded using a context free grammar 15

16 Dynamic vs. Static Scope Rules procedure p; var x: integer procedure q ; begin { q } x end { q }; procedure r ; var x: integer begin { r } q ; end; { r } begin { p } q ; r ; end { p } 16

17 Example Context Condition In Pascal Types in assignment must be compatible ' 17

18 Stm id Assign Exp Exp IntConst Exp RealConst Exp Exp + Exp Exp Exp -Exp Exp ( Exp ) Partial Grammar for Pascal 18

19 Refined Grammar for Pascal Stm RealId Assign RealExp Stm IntExpAssign IntExp Stm RealId Assign IntExp RealExp RealConst RealIntExp RealId RealExp RealExp + RealExp RealExp RealExp + IntExp RealExp IntExp + RealExp RealExp RealExp -RealExp RealExp RealExp -RealExp RealExp RealExp -IntExp RealExp IntExp -RealExp RealExp ( RealExp ) IntExp IntConst IntExp IntId IntExp IntExp + IntExp IntExp IntExp -IntExp IntExp ( IntExp ) 19

20 Syntax Directed Solution %%... stm : := id:i Assign exp:e {: compatass(lookup(i), e) ; :} ; exp ::= exp:e1 PLUS exp:e2 { : compatop(op.plus, e1, e2); RESULT = optype(op.plus, e1, e2); :} exp:e1 MINUS exp:e2 {: compatop(op.minus, e1, e2); RESULT = optype(op.minus, e1, e2); :} ID: i {: RESULT = lookup(i); :} INCONST {: RESULT = new TyInt() ; :} REALCONST {: RESULT = new TyReal(); :} ( exp: e ) {: RESULT = e ; :} ; 20

21 Type Checking (Imperative languages) Identify the type of every expression Usually one or two passes over the syntax tree Handle scope rules 21

22 Types What is a type Varies from language to language Consensus A set of values A set of operations Classes One instantiation of the modern notion of types 22

23 Why do we need type systems? Consider assembly code add $r1, $r2, $r3 What are the types of $r1, $r2, $r3? 23

24 Types and Operations Certain operations are legal for values of each type It does not make sense to add a function pointer and an integer in C It does make sense to add two integers But both have the same assembly language implementation! 24

25 Type Systems A language s type system specifies which operations are valid for which types The goal of type checking is to ensure that operations are used with the correct types Enforces intended interpretation of values because nothing else will! The goal of type inference is to infer a unique type for every valid expression 25

26 Type Checking Overview Three kinds of languages Statically typed: (Almost) all checking of types is done as part of compilation Context Analysis C, Java, ML Dynamically typed: Almost all checking of types is done as part of program execution Code generation Scheme, Python Untyped No type checking (Machine Code) 26

27 Type Wars Competing views on static vs. dynamic typing Static typing proponents say: Static checking catches many programming errors Prove properties of your code Avoids the overhead of runtime type checks Dynamic typing proponents say Static type systems are restrictive Rapid prototyping difficult with type systems Complicates the programming language and the compiler Compiler optimizations can hide costs 27

28 Type Wars (cont.) In practice, most code is written in statically typed languages with escape mechanisms Unsafe casts in C Java union in C It is debatable whether this compromise represents the best or worst of both worlds 28

29 Soundness of type systems For every expression e, for every value v of e at runtime v val(type(e)) The type may actually describe more values The rules can reject logically correct programs Becomes more complicated with subtyping (inheritance) 29

30 Issues in Context Analysis Implementation Name Resolution Type Checking Type Equivalence Type Coercions Casts Polymorphism Type Constructors 30

31 Name Resolution (Identification) Connect applied occurrences of an identifier/operator to its defining occurrence month: Integer RANGE [1..12]; month := 1 while month <> 12 do print_string(month_name[month]); month:= month +1; done; 31

32 Name Resolution (Identification) Connect applied occurrences of an identifier/operator to its defining occurrence Forward declarations Separate name spaces struct one_int { int i ; } i; i.i = 3; Scope rules 32

33 A Simple Implementation A separate table per scope/name space Record properties of identifiers Create entries for defining occurrences Search for entries for applied occurrences Create table per scope enter Remove table per scope enter Expensive search 33

34 Example void roate(double angle) { } void paint(int left, int right) { Shade matt, signal; { Counter right; wrong ; } level wrong signal right paint printf properties P P P P right P matt P left P rotate P signal null null } 0 scope stack P P 34

35 A Hash-Table Based Implementation A unified hashing table for all occurrences Separate entries for every identifier Ordered lists for different scopes Separate table maps scopes to the entries in the hash Used for ending scopes 35

36 Example void roate(double angle) { } void paint(int left, int right) { Shade matt, signal; { Counter right; wrong ; } hash table id.info name paint macro decl 1 P name signal macro null decl 3 P 0 P name right macro decl 4 P 2 P null null } 36

37 Example(cont.) void roate(double angle) { } void paint(int left, int right) { Shade matt, signal; { Counter right; wrong ; } } level scope stack id.info( wrong ) id.info( right ) id.info( signal ) id.info( mattt ) right 37 null

38 Overloading Some programming languages allow to resolve identifiers based on the context is different than Overloading user defined functions PUT(s: STRING) PUT(i: INTEGER) Type checking and name resolution interact May need several passes 38

39 Type Checking Non-trivial Construct a type table (separate name space) May require several passes 39

40 Type Equivalence Name equivalence TYPE t1 = ARRAY[Integer] of Integer; TYPE t2 = ARRAY[Integer] of Integer; TYPE t3 = ARRAY[Integer] of Integer; TYPE t4 = t3; Structural equivalence TYPE t5= RECORD {c: Integer ; p: Pointer to t5;} TYPE t6= RECORD {c: Integer ; p: Pointer to t6 ;} TYPE t7 = RECORD {c: Integer ; p : Pointer to RECORD {c: Integer ; p: Pointer to t5;}} 40

41 Simple Inference The type of an expression depends on the type of the arguments and the required result If e1 has type Integer and e2 has type Integer then the result has type Integer 41

42 Corner Cases What about power operator 42

43 Casts and Coercions The compiler may need to insert implicit conversions between types float x = 5; The programmer may need to insert explicit conversions between types 43

44 L-values vs. R-values Assignment x := exp is compiled into: Compute the address of x Compute the value of exp Store the value of exp into the address of x Generalization R-value Maps program expressions into Context values L-value Maps program expressions into locations Not always defined Java has no small L-values 44

45 A Simple Example int x = 5; Runtime memory x = x + 1;

46 A Simple Example int x = 5; lvalue(x)=17, rvalue(x) =5 lvalue(5)=, rvalue(5)=5 x = x + 1; Runtime memory 17 6 lvalue(x)=17, rvalue(x) =5 lvalue(5)=, rvalue(5)=5 46

47 Partial rules for Lvalue in C Type of e is pointer to T Type of e1 is integer lvalue(e2) exp lvalue rvalue id location(id) content(location(id)) const value(const) *e rvalue(e) content(rvalue(e)) &e2 lvalue(e2) e + e1 rvalue(e)+sizeof(t)*rvalue(e1) 47

48 Kind Checking Defined L-values in assignments expected found lvalue rvalue lvalue - deref rvalue error - 48

49 Type Constructors Record types Union Types Arrays 49

50 Routine Types Usually not considered as data The data can be a pointer to the generated code 50

51 Dynamic Checks Certain consistencies need to be checked at runtime in general But can be statically checked in many cases Examples Overflow Bad pointers 51

52 Summary Context analysis requires multiple traversals of the AST Is there a generalization? 52

53 Attribute Grammars [Knuth 68] Generalize syntax directed translations Every grammar symbol can have several attributes Every production is associated with evaluation rules Context rules The order of evaluation is automatically determined Dependency order Acyclicity Multiple visits of the abstract syntax tree 53

54 Summary Several ways to enforce Context correctness conditions syntax Regular expressions Context free grammars syntax directed traversals on the abstract syntax tree later compiler phases? Runtime? There are tools that automatically generate Context analyzer from specification (Based on attribute grammars) 62

Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler so far

Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler so far Outline Semantic Analysis The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Statically vs. Dynamically typed languages