Register Allocation. 2. register contents, namely which variables, constants, or intermediate results are currently in a register, and

Size: px

Start display at page:

Download "Register Allocation. 2. register contents, namely which variables, constants, or intermediate results are currently in a register, and"

Luke Baldwin
6 years ago
Views:

1 Register Allocation Introduction The main idea behind good register allocation is to keep variables and constants in registers as long as possible and to never spill intermediate results into memory. Thus, the number of times that values have to be stored and/or retrieved from memory is minimized. The sentinel work in this area was done by Chaitin in Preston Briggs completed a full investigation of this area in the early 1990s. The main idea behind Chaitin's work was to determine register allocation by coloring nodes in a graph. We will not be implementing this approach. However, we will be using many of the ideas of Chaitin and Briggs in our approach. The approach that we will be taking is to create a simulation of the registers in our target machine. We will use this register simulation to determine 1. free registers, namely those registers that do not have any meaningful variables, constants, or intermediate result names stored in them 2. register contents, namely which variables, constants, or intermediate results are currently in a register, and 3. register spillage, namely which intermediate results need to be swapped to temporary storage (memory) because a register is needed for a computation. We also saw in the code template section that we have two tasks to perform, namely putting an operand into a register if it is not already in a register and putting the results of an operation into a register. We will handle each of these two tasks with a separate algorithm. Our simulation will be composed of physical registers and virtual registers. The physical registers will simulate which variables, constants, and intermediate result names are in which registers at any given time. The virtual registers are used to store intermediate result names that have to be spilled from physical registers to memory. We will assume that only items in physical registers can have operations performed on them. Consider the example below that represents an 8 register machine with 4 virtual registers. Contents Registers I$00046 Reg 0 Index Reg 1 I$00047 Reg 2 Reg 3 Reg 4 Reg 5 Reg 6 Reg 7 VR 0 VR 1 VR 2 VR 3

2 where Reg i is physical register i and VR k is virtual register k. In the above example we have intermediate result I$00046 in register 0, the variable index in register 1 and intermediate result I$00047 in register 2. In reality the virtual registers will be implemented as memory locations in your project. Register Load Algorithm In the register load algorithm we are trying to find either the operand already in a register, or we will load the operand into a register. The parameters to the load procedure are the operand to be loaded and the other operand. The procedure returns the register that the operand will be in. 1. Search the registers for the operand. Note that if the operand is a variable or constant, then you only need to search the physical registers. If the operand is an intermediate result, then both the physical and virtual registers will need to be searched. If the operand is found in a register, then return the register, and no assembly code will need to be generated. Note that if the operand is found in a virtual register, then it will have to be loaded into a physical register before any operation can be performed on it, and you will generate appropriate assembly code to load that intermediate result from a virtual register (a memory location) into a physical register. 2. Search the registers for an available (free) register. Available registers are those registers that do not have any variables, constants, or intermediate results in them. If an available register is found, then 3. Search for a constant in a register that is not the other operand. If a constant is found in a register, then 4. Search for a variable in a register that is not the other operand. If a variable is found in a register, then 5. Arbitrarily pick a register that does not contain the other operand {register spillage} move the intermediate result to a virtual register (write assembly code to store the intermediate result into a virtual register, memory) occupy that virtual register in the simulation with the moved operand occupy the picked register in the simulation with the operand write assembly code to load the operand into the picked physical register return the picked register.

3 Register Store Algorithm In the register store algorithm we are trying to find a register for the results to go in. The parameters to the register store algorithm are the results and the two operands. 1. If either or both of the operands are intermediate results, then free the registers that contain those operand(s). We free a register by setting its contents to blank. 2. Search for an available register for the results. If a register is found, then occupy that register and return the register. 3. Search for a constant in a register. If found, then occupy that register and 4. Search for a variable in a register. If found, then occupy that register and 5. Error if you get here! Assembly Pseudo Code: Suppose that we have the following code a <- b - c + d ; b <- c + a - c; The 4-tuples that we might get from this are 1. I$001 - b c 2. I$002 + I$001 d 3. a = I$ I$003 - a c 5. I$004 + c I$ b = I$004 The register simulation would be R1: R2: R3: Click here for the answer.

4 Register Spillage Register spillage occurs when all of the registers are occupied with intermediate results, and you need a free register in which to store an item. In our method of doing register allocation, the only time that registers need to be spilled, i.e. the contents of a register needs to be store in a temporary or virtual register, is when all of the registers have intermediate results in them, and a register is needed. Suppose that we have a three register machine and the following expression: The intermediate code would be 1. I$001 - a c 2. I$002 - b d 3. I$003 - e f 4. I$004 - I$002 I$ I$005 - I$001 I$ a = I$005 The register simulation would be R1: a <- ( a c ) ( ( b d ) ( e f ) ) R2: R3: VR1: Click here for the answer. Notes Some items to remember 1. Whenever you encounter a label or a procedure call, you will flush all contents from your registers in your simulation. 2. Intelligent register usage means that you remember that a variable, constant, or intermediate result is in a register and that you do not unnecessarily reload that variable or constant since it is already in a register.

5 ANSWERS The register simulation is R1: b d d I$003 I$004 b R2: c c c c c c R3: I$001 I$001 a a a a Return The register simulation is R1: a b I$002 e I$003 I$004 I$005 a R2: c d f I$ R3: I$001 I$001 I$001 I$ VR1: - - I$ Return

Principles of Compiler Design

Principles of Compiler Design Code Generation Compiler Lexical Analysis Syntax Analysis Semantic Analysis Source Program Token stream Abstract Syntax tree Intermediate Code Code Generation Target Program