Semantic Analysis Mooly Sagiv html://

Outline What is Semantic Analysis Why is it needed? Syntax directed translations/attribute grammar (Chapter 3)

Semantic Analysis The “meaning of the program” Requirements related to the “context” in which a construct occurs Context sensitive requirements - cannot be specified using a context free grammar Requires complicated and unnatural context free grammars Guides subsequent phases

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

Example Semantic Condition In C –break statements can only occur inside switch or loop statements

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

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  break; LStm  Exp; LStm  if (Exp) LStm LStm  if (Exp) LStm else LStm LStm  while (Exp) do LStm LStm  {LStList } LStList  LStList LStm LStList  

A Possible Abstract Syntax for C typedef struct A_St_ *A_St; struct A_St { enum {A_if, A_while, A_break, A_block,...} kind; A_pos pos; union { struct { A_Exp e; A_St st1; A_St st2; } if_st; struct { A_Exp e; A_St st; } while_st; struct { A_St st1; A_St st2; } block_st;... } u ; } A_St A_IfStm(A_Exp, A_St, A_St); A_St A_WhileStm(A_Exp A_St); A_St A_BreakStm(void); A_St A_BlockStm(A_St, A_St);

stm: IF ‘(‘ exp ‘)’ stm { $$ = A_IfStm($3, $5, NULL) ; } | IF ‘(‘ exp ‘)’ stm ELSE stm { $$ = A_IfStm($3, $5, $7) ; } | WHILE ‘(‘ exp ‘)’ stm { $$ = A_WhileStm($3, $5); } | ‘{‘ stmList ‘}’ { $$ = $2; } | BREAK `;' { $$ = A_BreakStm(); } ; stmList : stmList st { $$ = A_BlockStm($1, $2) ;} | /* empty */ {$$ = NULL ;} Partial Bison Specification

void check_break(A_St st) { switch (st->kind) { case A_if: check_break(st-> u.if_st.st1); check_break(st->u.if_st.st2); break; case A_while: break ; case A_break: error(“Break must be enclosed within a loop”, st->pos); break; case A_block: check_break(st->u.block_st.st1) check_break(st->u.block_st.st2); break; } A Semantic Check (on the abstract syntax tree)

%{static 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) error(“Break must be enclosed within a loop”, line_count); } ; stmList : stmList st | /* empty */ ; m : /* empty */ { loop_count++ ;} ; Syntax Directed Solution

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 semantics Modularity is impossible to achieve Some programming languages allow forward declarations (Algol, ML and Java)

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

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 }

Example Semantic Condition In Pascal Types in assignment must be “compatible”'

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

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

%... stm: id Assign exp {compat_ass(lookup($1), $4) ; } ; exp: exp PLUS exp { compat_op(PLUS, $1, $3); $$ = op_type(PLUS, $1, $3); } | exp MINUS exp { compat_op(MINUS, $1, $3); $$ = op_type(MINUS, $1, $3); } | ID { $$ = lookup($1); } | INCONST { $$= ty_int ; } | REALCONST { $$ = ty_real ;} | ‘(‘ exp ‘)’ { $$ = $2 ; } ; Syntax Directed Solution

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 –declarative Multiple visits of the abstract syntax tree

stm  id Assign exp {compat_ass(id.type, exp.type) } exp  exp PLUS exp { compat_op(PLUS, exp[1].type,exp[2].type) exp[0].type = op_type(PLUS, exp[1].type, exp[2].type) } exp  exp MINUS exp { compat_op(MINUS, exp[1].type, exp[2].type) exp[0].type = op_type(MINUS, exp[1].type, exp[2].type) } exp  ID { exp.type = lookup(id.repr) } exp  INCONST { exp.type= ty_int ; } exp  REALCONST { exp.type = ty_real ;} exp  ‘(‘ exp ‘)’ { exp[0].type = exp[1].type ; } Attribute Grammar for Types

Example Binary Numbers Z  L Z  L.L L  L B L  B B  0 B  1 Compute the numeric value of Z

Z  L { Z.v = L.v } Z  L.L { Z.v = L[1].v + L[2].v } L  L B { L[0].v = L[1].v + B.v } L  B { L.v = B.v } } B  0 {B.v = 0 } B  1 {B.v = ? }

Z  L { Z.v = L.v } Z  L.L { Z.v = L[1].v + L[2].v } L  L B { L[0].v = L[1].v + B.v } L  B { L.v = B.v } B  0 {B.v = 0 } B  1 {B.v = 2 B.s }

Z  L { Z.v = L.v } Z  L.L { Z.v = L[1].v + L[2].v } L  L B { L[0].v = L[1].v + B.v B.s = L[0].s L[1].s = L[0].s + 1} } L  B { L.v = B.v B.s = L.s } B  0 {B.v = 0 } B  1 {B.v = 2 B.s }

Z  L { Z.v = L.v L.s = 0 } Z  L.L { Z.v = L[1].v + L[2].v L[1].s = 0 L[2].s=? } L  L B { L[0].v = L[1].v + B.v B.s = L[0].s L[1].s = L[0].s + 1} } L  B { L.v = B.v B.s = L.s } B  0 {B.v = 0 } B  1 {B.v = 2 B.s }

Z  L { Z.v = L.v L.s = 0 } Z  L.L { Z.v = L[1].v + L[2].v L[1].s = 0 L[2].s=-L[2].l } L  L B { L[0].v = L[1].v + B.v B.s = L[0].s L[1].s = L[0].s + 1 L[0].l = L[1].l + 1} } L  B { L.v = B.v B.s = L.s L.l = 1 } B  0 {B.v = 0 } B  1 {B.v = 2 B.s }

Z L.L B 1 L B L B B L.l=1 L.l=2 L.l=3 L.s=0 L.s=-3 B.s=0 L.s=-1 B.s=-1 B.s=-2 B.s=-3 B.v=1 L.v=1 B.v=0.5 L.v=0.5 B.v=0 L.v=0.5 B.v=0.125 L.v=0.625 Z.v=1.625 L.s=-2

Summary Several ways to enforce semantic 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 semantic analyzer from specification (Based on attribute grammars)