1 / 47

Code Generation for Control Flow

Learn about code generation techniques for control flow statements such as conditionals, loops, and routine invocation.

dida
Download Presentation

Code Generation for Control Flow

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Code Generation forControl Flow Mooly Sagiv html://www.math.tau.ac.il/~msagiv/courses/wcc03.html 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

  4. Boolean Expressions • In principle behave like arithmetic expressions • But are treated specially • Different machine instructions • Shortcut computations Code for a < b yielding a condition value Conversion condition value into Boolean Conversion from Boolean in condition value Jump to l on condition value if (a < 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. if && := x + == > a 0 b 5 * b 7 a Example if ((a==0) && (b > 5)) x = ((7 * a) + b)

  8. Lt Lf Lt No label Lf Lf if Lf: && := Lt: x + == > * 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 GOTO Lend Lf: Generate code for Boolean(left, 0, 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 > b Load_Local -8(FP), R1;CMP R1, -12(FP) ; IF <= 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-Llow+1 entries • Filled at ?time • Each entry contains the start location of the corresponding case or a special label • Generated codetmp_case_value:= case expression; if tmp_case_value <Llow GOTO label_else; if tmp_case_value>Lhigh GOTO label_else; GOTO table[tmp_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 < lk THEN GOTO label of left branch ; IF tmp_case_value >lk 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 labelstest_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_label:Ls: 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. i := lower_bound; tmp_ub := upper_bound; WHILE I <= tmp_ub DO code for statement sequence i := i + 1;END WHILE Simple-minded translation FOR i in lower bound .. upper bound DO statement sequence END for

  23. i := lower_bound; tmp_ub := upper_bound; IF i >tmp_ub THEN GOTO end_label; loop_label: code for statement sequence if (i==tmp_ub) GOTO end_label; i := i + 1; GOTO loop_label; end_label: 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 + a[i]; 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. Memory After code Main p: l: p q: goto l; 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. if (“i” < 0 || “i” >=100) THROW range_error; Detecting a runtime error • Array bound-checkfoo() { int a[100], i, j; scanf(“%d%d”, &i, &j); while (i < j) { a[i] = i ; i++;}

  38. Detecting a runtime error(2) • Array bound-checkfoo() { int a[100], i, j; scanf(“%d%d”, &i, &j); if ((i >=0) && j <=100) { while (i < j) { a[i] = 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. 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 Handler Code Block/Routine

  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

More Related