run-time organization and general principles of code...
TRANSCRIPT
![Page 1: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/1.jpg)
Prof. Bodik CS 164 Fall 2003 1
Run-time organization and
General Principles of Code Generation
Lecture 12
![Page 2: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/2.jpg)
Prof. Bodik CS 164 Fall 2003 2
Status
• We have covered the front-end phases – Lexical analysis – Parsing – Semantic analysis
• Next are the back-end phases – Intermediate Code Generation – Optimization – Code generation
• We’ll do code generation first . . .
![Page 3: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/3.jpg)
Prof. Bodik CS 164 Fall 2003 3
Run-time environments
• Before discussing code generation, we need to understand what we are trying to generate
• There are a number of standard techniques for structuring executable code that are widely used
![Page 4: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/4.jpg)
Prof. Bodik CS 164 Fall 2003 4
Outline
• Management of run-time resources
• Correspondence between static (compile-time) and dynamic (run-time) structures
• Storage organization
![Page 5: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/5.jpg)
Prof. Bodik CS 164 Fall 2003 5
Run-time Resources
• Execution of a program is initially under the control of the operating system
• Run-Time Enviroment: Where the program is being executed
• When a program is invoked: – The OS allocates space for the program – The code is loaded into part of the space – The OS jumps to the entry point (i.e., “main”)
![Page 6: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/6.jpg)
Prof. Bodik CS 164 Fall 2003 6
Memory Layout
Low Address
High Address
Memory
Code
Other Space
![Page 7: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/7.jpg)
Prof. Bodik CS 164 Fall 2003 7
Notes
• By tradition, pictures of machine organization have: – Low address at the top – High address at the bottom – Lines delimiting areas for different kinds of data
• These pictures are simplifications – E.g., not all memory need be contiguous
![Page 8: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/8.jpg)
Prof. Bodik CS 164 Fall 2003 8
What is Other Space?
• Holds all data for the program • Other Space = Data Space
• Compiler is responsible for: – Generating code – Orchestrating use of the data area
![Page 9: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/9.jpg)
Prof. Bodik CS 164 Fall 2003 9
Code Generation Goals
• Two goals: – Correctness – Speed
• Most complications in code generation come from trying to be fast as well as correct
![Page 10: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/10.jpg)
Prof. Bodik CS 164 Fall 2003 10
Assumptions about Execution
1. Execution is sequential; control moves from one point in a program to another in a well-defined order.
2. When a procedure is called, control eventually returns to the point immediately after the call.
Do these assumptions always hold?
![Page 11: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/11.jpg)
Prof. Bodik CS 164 Fall 2003 11
Activations
• An invocation of procedure P is an activation of P
• The lifetime of an activation of P is – All the steps (instructions sequence) to execute P – Including all the steps in procedures that P calls
![Page 12: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/12.jpg)
Prof. Bodik CS 164 Fall 2003 12
Lifetimes of Variables
• The lifetime of a variable x is the portion of execution in which x is defined
• Note that – Lifetime is a dynamic (run-time) concept – Scope is a static concept
![Page 13: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/13.jpg)
Prof. Bodik CS 164 Fall 2003 13
Activation Trees
• Assumption (2) requires that when P calls Q, then Q returns before P does
• Lifetimes of procedure activations are properly nested
• Activation lifetimes can be depicted as a tree
![Page 14: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/14.jpg)
Prof. Bodik CS 164 Fall 2003 14
Example
class Main { int g() { return 1; } int f() {return g(); } void main() { g(); f(); }
} Main
f g
g
![Page 15: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/15.jpg)
Prof. Bodik CS 164 Fall 2003 15
Example 2
class Main { int g() { return 1; } int f(int x) { if (x == 0) { return g(); } else { return f(x - 1); } } void main() { f(3); }
} What is the activation tree for this example?
![Page 16: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/16.jpg)
Prof. Bodik CS 164 Fall 2003 16
Notes
• The activation tree depends on run-time behavior, in particular:
• The activation tree may be different for a different input
• Since activations are properly nested, a stack can track currently active procedures
![Page 17: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/17.jpg)
Prof. Bodik CS 164 Fall 2003 17
Example
class Main { int g() { return 1; } int f() { return g(); } void main() { g(); f(); }
} Main Stack
Main
![Page 18: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/18.jpg)
Prof. Bodik CS 164 Fall 2003 18
Example
Main
g
Stack
Main
g
class Main { int g() { return 1; } int f() { return g(); } void main() { g(); f(); }
}
![Page 19: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/19.jpg)
Prof. Bodik CS 164 Fall 2003 19
Example
Main
g f
Stack
Main
f
class Main { int g() { return 1; } int f() { return g(); } void main() { g(); f(); }
}
![Page 20: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/20.jpg)
Prof. Bodik CS 164 Fall 2003 20
Example
Main
f g
g
Stack
Main
f g
class Main { int g() { return 1; } int f() { return g(); } void main() { g(); f(); }
}
![Page 21: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/21.jpg)
Prof. Bodik CS 164 Fall 2003 21
Revised Memory Layout
Low Address
High Address
Memory
Code
Stack
![Page 22: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/22.jpg)
Prof. Bodik CS 164 Fall 2003 22
Activation Records (Stack Allocation)
• The information needed to manage one procedure activation is called an activation record (AR) or frame
• Each live activation has its own AR pushed in
the stack which is popped when it terminates • If procedure F calls G, then G’s activation
record contains a mix of info about F and G.
![Page 23: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/23.jpg)
Prof. Bodik CS 164 Fall 2003 23
What is in G’s AR when F calls G?
• F is “suspended” until G completes, at which point F resumes. G’s AR contains information needed to resume execution of F.
• G’s AR may also contain: – G’s return value (to resume F) – Actual parameters to G (supplied by F) – Space for G’s local variables
![Page 24: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/24.jpg)
Prof. Bodik CS 164 Fall 2003 24
The Contents of a Typical AR for G
1. Space for G’s return value 2. Actual parameters 3. Pointer to the previous activation record:
The optional Control Link 4. Pointer to previous activation records
– The (optional) control link points to AR of the immediate super-nested procedure, needed to access non-local data stored in other ARs due to scope nexting of variables
5. Machine status prior to calling G – Contents of registers & program counter
6. Local and Temporary variables
![Page 25: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/25.jpg)
Prof. Bodik CS 164 Fall 2003 25
Discussion
• The advantage of placing the return value 1st in a AR is that the caller can find it at a fixed offset from the end of its own AR without knowing the layout of the AR for the callee.
• Similar considerations apply for the local
parameters.
![Page 26: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/26.jpg)
Prof. Bodik CS 164 Fall 2003 26
Example 2, Revisited
class Main { int g() { return 1; } int f(int x) { if (x == 0) { return g(); } else { return f(x - 1); (**) } } void main() { f(3); (*) }
}
AR for f:
return result parameters control link return address and Registers Local+Temporary
![Page 27: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/27.jpg)
Prof. Bodik CS 164 Fall 2003 27
Stack After Two Calls to f
Main
(**)
2 (result) f (*)
3 (result) f
![Page 28: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/28.jpg)
Prof. Bodik CS 164 Fall 2003 28
Notes
• Main has no argument or local variables and its result is never used; its AR is uninteresting
• (*) and (**) are return addresses of the invocations of f – The return address is where execution resumes
after a procedure call finishes
• This is only one of many possible AR designs – Would also work for C, Pascal, FORTRAN, etc.
![Page 29: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/29.jpg)
Prof. Bodik CS 164 Fall 2003 29
Local Variables
• Locals are stored in different AR for each different procedure execution: – Locals are bound to different storage in each
activation (think of recursive calls) • Storage is lost (free) when the activation ends • The position of an AR is decided at run-time
and stored in the SP (Stack Pointer) Register: a pointer to the beginning of the AR .
• Addresses for locals are determined at run-time as an offset from the SP Register and computed starting from the offset stored in the Symbol Table
![Page 30: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/30.jpg)
Prof. Bodik CS 164 Fall 2003 30
The Main Point
The compiler must determine, at compile-time,
the layout of activation records and generate code that correctly accesses locations in the
activation record
Thus, the AR layout and the code generator must be designed together!
![Page 31: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/31.jpg)
Prof. Bodik CS 164 Fall 2003 31
Example
The picture shows the state after the call to 2nd invocation of f returns
Main
(**)
2 1 f (*)
3 (result) f
![Page 32: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/32.jpg)
Prof. Bodik CS 164 Fall 2003 32
Discussion
• There is nothing magic about this organization
– Can rearrange order of AR elements – Can divide caller/callee responsibilities differently – An organization is better if it improves execution
speed or simplifies code generation
![Page 33: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/33.jpg)
Prof. Bodik CS 164 Fall 2003 33
Globals
• All references to a global variable point to the same object – Can’t store a global in an activation record
• Globals are assigned a fixed address once – Variables with fixed address are “statically
allocated” • Depending on the language, there may be
other statically allocated values
![Page 34: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/34.jpg)
Prof. Bodik CS 164 Fall 2003 34
Memory Layout with Static Data
Low Address
High Address
Memory
Code
Stack
Static Data
![Page 35: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/35.jpg)
Prof. Bodik CS 164 Fall 2003 35
The Heap Storage
• A value that outlives the procedure that creates it cannot be kept in the AR
Bar foo() { return new Bar }
The Bar value must survive deallocation of foo’s AR • Languages with dynamically allocated data use
the heap to store dynamic data • Memory requests are satisfied by allocating
portions from a large pool of memory called the heap or free store.
![Page 36: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/36.jpg)
Prof. Bodik CS 164 Fall 2003 36
Memory Layout
• The code area contains object code – For most languages, fixed size and read only
• The static area contains data (not code) with fixed addresses (e.g., global data) – Fixed size, may be readable or writable
• The stack contains an AR for each currently active procedure – Each AR usually fixed size, contains locals
• The Heap contains all other data – Dynamic Data Structures – In C, the heap is managed by malloc and free
![Page 37: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/37.jpg)
Prof. Bodik CS 164 Fall 2003 37
Memory Layout (Cont.)
• Both the heap and the stack grow
• Must take care that they don’t grow into each other
• Solution: start heap and stack at opposite ends of memory and let the grow towards each other
![Page 38: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/38.jpg)
Prof. Bodik CS 164 Fall 2003 38
Code for AR Allocation/Deallocation
return address Local+Temporary
• In the following we introduce a simplified Stack-Allocation code for AR
• We assume a simplified AR containing just
the return address and Local+Temporary variables.
![Page 39: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/39.jpg)
Procedure Call
Prof. Bodik CS 164 Fall 2003 39
• The code for the first procedure initializes the stack by setting SP to the start of the of the Stack Area in Memory:
MOV #stackstart, SP /* #stackstart given by OS */ • A Procedure Call Sequence must:
• Increment the SP to point to the next AR • Transfer control to the called procedure
ADD #caller.recordsize, SP MOV *PC+16, *SP /* save return address */ GOTO calle.code_area
Note: The constant caller.recordsize is determined at complile time for each procedure using info in the Symbol Table.
![Page 40: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/40.jpg)
Return Sequence
Prof. Bodik CS 164 Fall 2003 40
• The called procedure transfers control to the caller procedure using the return address stored at the beginning of its AR:
GOTO *0(SP) /* return to caller */ • While 0(SP) denotes the address of first word in AR, *0(SP) is
the return address saved there. • In the caller procedure we need to decrement SP by restoring
SP to point to the beginning of the caller AR:
SUB #caller.recordsize, SP
![Page 41: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/41.jpg)
General Principles of Code Generation
Prof. Bodik CS 164 Fall 2003 41
• The target language depends on the particular architecture, e.g., RISC, CISC, Stack Machine,…
• 3 MAIN TASKS:
1. Instruction Selection 2. Register Allocation 3. Instruction Ordering
![Page 42: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/42.jpg)
General Principles of Code Generation
Prof. Bodik CS 164 Fall 2003 42
Instruction Selection • Select the most appropriate instruction-set based on
the set of instructions available in the target language (e.g., INC x must be preferred to x := x+1)
![Page 43: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/43.jpg)
General Principles of Code Generation
Prof. Bodik CS 164 Fall 2003 43
Register Allocation • Register are fast but limited in space: decide what
variables to hold in Registers and what to hold in main memory;
• Good performing algorithms for Registers allocation makes a huge difference in performance;
• Avoid redundant LOAD and STORE operations; • Minimize register usage for intermediate results.
![Page 44: Run-time organization and General Principles of Code ...artale/Compiler/Lectures/slide12-runtime.pdf · Run-time organization and General Principles of Code Generation Lecture 12](https://reader034.vdocuments.mx/reader034/viewer/2022042122/5e9c5b969c0d1725fc3aee74/html5/thumbnails/44.jpg)
General Principles of Code Generation
Prof. Bodik CS 164 Fall 2003 44
Instruction Ordering • Involves deciding in what order to schedule the
execution of instructions; • Important in modern multi-processors machine that
can execute several operations in a single clock cycle; • The compiler is responsible for deciding what part of
the generated code can be executed in parallel.