The document discusses code generation which involves mapping intermediate code to machine code. It describes three key issues in code generator design: instruction selection which determines the best machine instructions to use, register allocation which assigns variables to registers, and evaluation order which determines the order of instructions. The document outlines three algorithms for code generation that involve partitioning code into basic blocks, performing intra-block optimizations, and code selection and assignment.

1. CODE GENERATION
LECTURE 16

2. CODE GENERATION
The code generation problem is the task of
mapping intermediate code to machine code.
Requirements:
 Correctness
 Must preserve semantic meaning of source program
 Efficiency
 Make effective use of available resources
 Code Generator itself must run efficiently
2

3. COMPILER ARCHITECTURE
Scanner
(lexical
analysis)
Parser
(syntax
analysis)
Code
Optimizer
Semantic
Analysis
(IC generator)
Code
Generator
Symbol
Table
Source
language
tokens
Syntactic
structure
Intermediate
Language
Target
language
Intermediate
Language
3

4. INPUT TO THE CODE GENERATOR
 We assume, front end has
Scanned, parsed and translate the source program into
a reasonably detailed intermediate representations
Type checking, type conversion and obvious semantic
errors have already been detected
Symbol table is able to provide run-time address of the
data objects
Intermediate representations may be
 Postfix notations
 Three address representations
 Syntax tree
 DAG
4

5. TARGET PROGRAMS
 The output of the code generator is the target program.
 Target architecture: must be well understood
Significantly influences the difficulty of code
generation
RISC, CISC
 Target program may be
Absolute machine language
 It can be placed in a fixed location of memory and immediately
executed
Re-locatable machine language
 Subprograms to be compiled separately
 A set of re-locatable object modules can be linked together and
loaded for execution by a linker 5

6. ISSUES IN THE DESIGN OF A CODE
GENERATOR
 Instruction Selection
 Register Allocation
 Evaluation Order
6

7. INSTRUCTION SELECTION
 There may be a large number of ‘candidate’
machine instructions for a given IR instruction
Level of IR
 High: Each IR translates into many machine
instructions
 Low: Reflects many low-level details of machine
Nature of the instruction set
 Uniformity and completeness
Each has own cost and constraints
 Accurate cost information is difficult to obtain
 Cost may be influenced by surrounding context
7

8. INSTRUCTION SELECTION
 For each type of three-address statement, a code
skeleton can be designed that outlines the target code to
be generated for that construct.
 Say, x := y + z
Mov y, R0
Add z, R0
Mov R0, x
Statement by statement code generation often
produces poor code
8

9. INSTRUCTION SELECTION
a := b + c
d := a + e
MOV b, R0
ADD c, R0
MOV R0, a
MOV a, R0
ADD e, R0
MOV R0, d
MOV a, R0
MOV R0, a If a is subsequently
used
9

10. INSTRUCTION SELECTION:
MACHINE IDIOMS
10

11. REGISTER ALLOCATION
 How to best use the bounded number of registers.
 Use or registers
 Register allocation
 We select a set of variables that will reside in registers at each point
in the program
 Register assignment
 We pick the specific register that a variable will reside in.
 Complications:
 special purpose registers
 operators requiring multiple registers.
 Optimal assignment is NP-complete
11

12. REGISTER ALLOCATION
r4
12

13. REGISTER ALLOCATION
13

14. EVALUATION ORDER
 Choosing the order of instructions to best utilize
resources
 Picking the optimal order is NP-complete problem
 Simplest Approach
 Don’t mess with re-ordering.
 Target code will perform all operations in the same order
as the IR code
 Trickier Approach
 Consider re-ordering operations
 May produce better code
... Get operands into registers just before they are
needed
... May use registers more efficiently
14

15. MOVING RESULTS BACK TO
MEMORY
 When to move results from registers back into
memory?
 After an operation, the result will be in a register.
 Immediately
 Move data back to memory just after it is computed.
 May make more registers available for use elsewhere.
 Wait as long as possible before moving it
back
 Only move data back to memory “at the end”
 or “when absolutely necessary”
 May be able to avoid re-loading it later!
15

16. CODE GENERATION ALGORITHM #1
Simple code generation algorithm:
Define a target code sequence to each intermediate code
statement type.
16

17. CODE GENERATION ALGORITHM #1
17

18. EXAMPLE TARGET MACHINE
18

19. EVALUATING A POTENTIAL
CODE SEQUENCE
 Each instruction has a “cost”
Cost = Execution Time
 Execution Time is difficult to predict.
Pipelining, Branches, Delay Slots, etc.
 Goal: Approximate the real cost
A “Cost Model”

20. A BETTER COST MODEL

21. COST GENERATION EXAMPLE
21

22. BASIC BLOCKS
22

23. BASIC BLOCKS
23

24. BASIC BLOCKS
24

25. CONTROL FLOW GRAPH
25

26. ALGORITHM TO PARTITION
INSTRUCTIONS INTO BASIC
BLOCKS
26

27. ALGORITHM TO PARTITION
INSTRUCTIONS INTO BASIC
BLOCKS
 INPUT: A sequence of three-address instructions.
 OUTPUT: A list of the basic blocks for that sequence in
which each instruction is assigned to exactly one basic
block.
 METHOD: First, we determine those instructions in the
intermediate code that are leaders, that is, the first
instructions in some basic block. The instruction just past
the end of the intermediate program is not included as a
leader. The rules for finding leaders are:
 The first three-address instruction in the intermediate code is
a leader.
 Any instruction that is the target of a conditional or
unconditional jump is a leader.
 Any instruction that immediately follows a conditional or
unconditional jump is a leader
27

28. IDENTIFY LEADERS – EXAMPLE 1:
28

29. IDENTIFY LEADERS – EXAMPLE 1:
29

30. IDENTIFY LEADERS – EXAMPLE 1:
30

31. IDENTIFY LEADERS
31

32. IDENTIFY LEADERS – EXAMPLE 2:
32

33. IDENTIFY LEADERS – EXAMPLE
2:
 According to rule 1 : 1
 According to rule 2 : 3, 2, 13
 According to rule 3 : 10, 12
33

34. LOOK AT EACH BASIC BLOCK IN
ISOLATION
34

35. COMMON SUB-EXPRESSION
ELIMINATION
35

36. COMMON SUB-EXPRESSION
ELIMINATION
36

37. REORDERING INSTRUCTIONS IN A
BASIC BLOCK
37

38. LIVE VARIABLES
38

39. DEAD VARIABLES
39

40. LIVENESS EXAMPLE
40

41. LIVENESS EXAMPLE
41

42. LIVE VARIABLE ANALYSIS
42

43. TEMPORARIES
43

44. DEAD CODE
44

45. TEMPORARIES
45

46. ALGEBRAIC TRANSFORMATION
46

47. CONTROL FLOW GRAPHS
47

48. REPRESENTING FLOW GRAPHS:
IDEA 1
48

49. REPRESENTING FLOW GRAPHS:
IDEA 2
49

50. WHAT IS LOOP?
50

51. NATURAL LOOP
51

52. LOOPS WITH MULTIPLE ENTRIES
52

53. CODE GENERATION ALGORITHM #2
AND #3
53

54. CODE GENERATION ALGORITHM #2
54

55. CODE GENERATION ALGORITHM #2
55

56. DEFINITION AND USE OF VARIABLES
56

57. THE “NEXT-USE” INFORMATION
57

58. THE “NEXT-USE” ALGORITHM
58

59. “NEXT-USE” EXAMPLE
59

60. “NEXT-USE” ALGORITHM
60

61. “NEXT-USE” ALGORITHM
61

62. “NEXT-USE” ALGORITHM - EXAMPLE
62

63. “NEXT-USE” ALGORITHM - EXAMPLE
63

64. “NEXT-USE” ALGORITHM - EXAMPLE
64

65. “NEXT-USE” ALGORITHM - EXAMPLE
65

66. “NEXT-USE” ALGORITHM - EXAMPLE
66

67. “NEXT-USE” ALGORITHM - EXAMPLE
67

68. “NEXT-USE” ALGORITHM - EXAMPLE
68

69. “NEXT-USE” ALGORITHM - EXAMPLE
69

70. “NEXT-USE” ALGORITHM - EXAMPLE
70

71. “NEXT-USE” ALGORITHM - EXAMPLE
71

72. “NEXT-USE” ALGORITHM - EXAMPLE
D
L ( 1 )
72

73. WHY LIVE VARIABLE ANALYSIS?
73

74. CODE GENERATION ALGORITHM #2
74

75. CODE GENERATION ALGORITHM #2
75

76. DATA NEEDED DURING CODE
GENERATION
76

77. CODE GENERATION ALGORITHM #3
(OVERVIEW)
77

78. CODE GENERATION ALGORITHM #3
78

79. CODE GENERATION ALGORITHM #3
79

80. CODE GENERATION ALGORITHM #3
80

81. CODE GENERATION ALGORITHM #3
81

82. CODE GENERATION ALGORITHM #3
82

83. SPECIAL CASE
83

84. CODE GENERATION ALGORITHM #2
84

85. EXAMPLE
85

86. EXAMPLE
86

87. EXAMPLE
87

88. EXAMPLE
88

89. EXAMPLE
89

90. EXAMPLE
90

91. EXAMPLE
91

92. EXAMPLE
92

93. EXAMPLE
93

94. EXAMPLE
94

95. EXAMPLE
95

96. EXAMPLE
96

97. EXAMPLE
97

98. EXAMPLE
98

99. ANY QUESTION ?
99