Code Generation for Control Flow

1
Code Generation forControl Flow

• Mooly Sagiv
• html//www.math.tau.ac.il/msagiv/courses/wcc03.ht
  ml
• Chapter 6.4

2
Outline

• Local flow of control
• Conditionals
• Switch
• Loops
• Routine Invocation
• Non-local gotos
• Runtime errors
• Handling Exceptions
• Summary

3
Machine Code Assumptions
Instruction Meaning
GOTO Label Jump to Label
GOTO label register Indirect jump
IF condition register then GOTO Label Conditional Jump
IF not condition register then GOTO Label
4
Boolean Expressions

• In principle behave like arithmetic expressions
• But are treated specially
• Different machine instructions
• Shortcut computations

Code for a lt b yielding a condition value
Conversion condition value into
Boolean Conversion from Boolean in condition
value Jump to l on condition value
if (a lt b) goto l
5
Shortcut computations

• Languages such as C define shortcut computation
  rules for Boolean
• Incorrect translation of e1 e2 Code to
  compute e1 in loc1 Code to compute e2 in loc2
  Code for operator on loc1 and loc2

6
Code for Booleans(Location Computation)

• Top-Down tree traversal
• Generate code sequences instructions
• Jump to a designated true label when the
  Boolean expression evaluates to 1
• Jump to a designated false label when the
  Boolean expression evaluates to 0
• The true and the false labels are passed as
  parameters

7
Example
if ((a0) (b gt 5)) x ((7 a) b)
8
if
Lf


Lt
x


gt

b
Cmp_Constant R0, 0 IF NOT EQ THEN GOTO Lf
Cmp_Constant R0, 5 IF GT THEN GOTO Lt GOTO Lf
7
a
Code for
b
5
a
0
Load_Local -12(FP), R0
Load_Local -8(FP), R0
9
Location Computation for Booleans
10
Code generation for IF
Allocate two new labels Lf, Lend
Lend
if
Generate code for Boolean(left, 0, Lf)
GOTO Lend Lf
Boolean expression
true sequence
false sequence
Code for true sequence
Code for false sequence
Code for Boolean with jumps to Lf
11
Code generation for IF (no-else)
Allocate new label Lend
Lend
if
Generate code for Boolean(left, 0, Lend)
Boolean expression
true sequence
Code for true sequence
Code for Boolean with jumps to Lend
12
Coercions into value computations
Generate new label Lf

Load_Constant R0, 0
Generate code for Boolean(right, 0, Lf)
x
a gt b
Load_Local -8(FP), R1CMP R1, -12(FP) IF lt
GOTO Lf
Load_Constant R0, 1Lf Store_Local R0,
-20(FP)
13
Effects on performance

• Number of executed instructions
• Unconditional vs. conditional branches
• Instruction cache
• Branch prediction
• Target look-ahead

14
Code for case statements

• Three possibilities
• Sequence of IFs
• O(n) comparisons
• Jump table
• O(1) comparisons
• Balanced binary tree
• O(log n) comparisons
• Performance depends on n
• Need to handle runtime errors

15
Simple Translation
16
Jump Table

• Generate a table of Lhigh-Llow1 entries
• Filled at ?time
• Each entry contains the start location of the
  corresponding case or a special label
• Generated code tmp_case_value case
  expression if tmp_case_value ltLlow GOTO
  label_else if tmp_case_valuegtLhigh GOTO
  label_else GOTO tabletmp_case_value
  Llow

17
Balanced trees

• The jump table may be inefficient
• Space consumption
• Cache performance
• Organize the case labels in a balanced tree
• Left subtrees smaller labels
• Right subtrees larger labels
• Code generated for node_k label_k IF
  tmp_case_value lt lk THEN
  GOTO label of left branch
  IF tmp_case_value gtlk THEN
  GOTO label of right branch
  code for statement sequence
  GOTO label_next

18
Repetition Statements (loops)

• Similar to IFs
• Preserve language semantics
• Performance can be affected by different
  instruction orderings
• Some work can be shifted to compile-time
• Loop invariant
• Strength reduction
• Loop unrolling

19
while statements
Generate new labels test_label, Lend
while
test_label
Generate code for Boolean(left, 0, Lend)
GOTO test_label Lend
statement Sequence
Boolean expression
Code for statement sequence
Code for Boolean with jumps to Lend
20
while statements(2)
Generate labels test_label, Ls
while
GOTO test_labelLs
Generate code for Boolean(left, Ls, 0)
Code for statement sequence
test_label
statement Sequence
Boolean expression
Code for Boolean with jumps to LS
21
For-Statements

• Special case of while
• Tricky semantics
• Number of executions
• Effect on induction variables
• Overflow

22
Simple-minded translation
FOR i in lower bound .. upper bound DO
statement sequence END for
23
Correct Translation
FOR i in lower bound .. upper bound DO
statement sequence END for
24
Tricky question
25
Loop unrolling
FOR i 1 to n DO sum sum ai END FOR
26
Summary

• Handling control flow statements is usually
  simple
• Complicated aspects
• Routine invocation
• Non local gotos
• Runtime errors
• Runtime profiling can help

27
Routine Invocation

• Identify the called routine
• Generate calling sequence
• Some instructions are executed by the callee
• Filling the activation record
• Actual parameters (caller)
• Administrative part
• The local variable area
• The working stack

28
Parameter Passing Mechanisms

• By value
• By reference
• By result
• By value-result

• Pass the R-value of the parameter
• Pass the L-value of the parameter
• Pass the L-value of the parameter
• The callee creates a temporary
• Stores the temporary upon return
• Can use registers
• Pass the L-value of the parameter
• The callee creates a temporary
• Store the temporary upon return

29
Caller Sequence

• Save caller-save registers
• Pass actual parameters
• In stack
• In register
• Pass lexical pointer
• Generate code for the call
• Store return address
• Pass flow of control

30
Callee Sequence

• Allocate the frame
• Store callee-save registers
• Perform the procedure code
• Return function result
• Restore callee-save registers
• Deallocate the frame
• Transfer the control back to the caller

31
Two activation records on the stack
32
Non-Local goto in C syntax
33
Non-local gotos

• Close activation records
• Restore callee-save registers

Memory before
Main
p
r
q
34
Runtime errors

• The smartest compiler cannot catch all potential
  errors at compile-time
• Missing information
• Undecidability
• Compiler need to generate code to identify
  runtime errors
• Non-trivial

35
Common runtime errors

• Overflow
• Integers
• Stack frame
• Limited resources
• Division by zero
• Null pointer dereferences
• Dangling pointer dereferences
• Buffer overrun (array out of bound)

36
Runtime Errors

• C
• No support for runtime errors
• Situations with undefined ANSI C semantics
• Leads to security vulnerabilities
• Pascal
• Runtime errors abort execution
• Java
• Runtime errors result in raised exceptions
• Can be handled by the programmer code

37
Detecting a runtime error

• Array bound-checkfoo() int a100, i, j
  scanf(dd, i, j) while (i lt j)
  ai i i

38
Detecting a runtime error(2)

• Array bound-checkfoo() int a100, i, j
  scanf(dd, i, j) if ((i gt0) j lt100)
  while (i lt j) ai i
  i else

39
Handling Runtime Errors

• Abort
• Statically assigned error handlers (signal)
• Exceptions

40
Signal Handlers

• Binds errors to handler routines
• Invoke a specific routine when runtime error
  occurs
• Report an error
• Close open resources and exit
• Resume immediately after the error
• Resume in some synchronization point

41
Signal Example
42
Exceptions

• Flexible mechanism for handling runtime errors
• Available in modern programming languages
• Useful programming paradigm
• But are hard to compile

void f() g() catch(error1)

void g() h()
void h() throw error1
43
Why are exceptions hard to compile?

• Dynamic addresses
• Not always known when at compile time
• Non local goto
• Register state
• The handler may change in the execution of a
  routine
• The handler code assumes sequential execution

44
Handling Exceptions

• At compile time store mappings from exceptions to
  handlers
• Store a pointer to the table in the activation
  record
• When an exception is raised scan the stack frames
  to locate the most recent handler
• Perform a non-goto

45
Handler Code
Block/Routine

• Generate code for handler
• Terminate with a jump to the end of block/routine
• A unique label where the handler code begins

• Generate a table
• Store a pointer to the table at the activation
  record

exception handler
46
Code for raising exception

• Extract the pointer to the table from the
  activation record
• Search for a handler for the exception raised
• If not found pop the stack and repeat
• If found perform a non-local goto
• Usually combine the search and the goto

47
Summary

• Non local transfer of control can be expensive
• Hard to understand Hard to implement
• But are necessary
• Challenging optimization problems