deep

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Register Allocation ======
Starting with the SSA form for each result of an SSA instruction a register has to be assigned. However, it must be decided how the registers of a processor will be used generally.

===== Register Usage =====
Registers can be classified as //dedicated//, //volatile// or //nonvolatile//. //Dedicated// are register with a special purpose, such as the stackpointer. //Volatile// means, that this register might be used any time. It does not have to be stored when another method is called. //Nonvolatile// registers must be saved in the prologue of a method before they can be used and after use they must be restored. The number of volatile and nonvolatile registers must be equal for all methods. 

  * [[dev:crosscompiler:backend_ppc:register_allocation|Register Allocation for PPC]] 
  * [[dev:crosscompiler:backend_arm:register_allocation|Register Allocation for ARM]]
===== Resolving of Phi-Functions =====
The operands of a phi-function must all get the same register as the result of the phi-function. For this purpose all these operands have a field //join//. \\
Before the phi-functions can be resolved, loops need special treatment. Let's consider the folowing case:
[{{ .:phifunctionloop1.png?110 |//Phi-Function in a loop//}}]

The SSAValue of //a// is used in the loop. The live range of //a// extends to the instruction for //b = 2 * a//. However, this would be wrong, because the register for //a// would be released at this point and might be used otherwise. It must stay reserved until the end of the loop. At the beginning of node 2 a phi-function is created for //a//. This function will be deleted because //a// is set in node 1 and only read in node 2. For all phi-functions in loops (whether deleted or not) the field //last// is set to the last instruction of this loop.\\
Subsequently, all instructions of all SSA nodes are copied into an array, since the control flow is no longer important for the further processing and the access is faster.\\
All used phi-functions are marked (field //used//). //used// indicates if a deleted phi-Funktion is used further downstream. If not, the register can be released immediately. The reason for doing this is the fact, that phi-functions were inserted for every local variable if loops are present. Most of this phi-functions are deleted and should not occupy a register unnecessarily. \\
Phi-functions will be resolved as follows: A new state array //join// is created. The field //join// of the result of the phi-function and of its operands refer to the value in this state array with the same index as the phi-function. Several phi-functions might refer to the same //join// value. \\
There are cases where two different phi-functions with the same index refer to two different variables, as in: 
<code java>
  if() {
    int a = ...;
    while() a = ...;
  } else {
    float f = ...;
    while() f = ...;
  }
</code>
//a// and //f// occupy the same slot (or index). Nevertheless, the two ranges must not be integrated into one. If the two variables have the same type it wouldn't really matter, though it wouldn't be efficient. However, in this case the type is different and later, we have to assign different registers. Therefore, we check if the range of a new phi-function overlaps with the range of a phi-function further upstream at the same index. If this is not the case, we create another //join// value in the state array and link it to the previous one.
[{{ .:phifunctionjoin1.png?200 |//Phi-functions for same slots but different types//}}]


===== Determination of Live Range =====
We determine for the results of all SSA instructions up to which instruction they are used (field //end//).
Results of phi-functions must be handled separately. Such results might be used as operands of instructions which are placed further upstream. For this reason the live range of a phi-function does not start with its instruction but with its first use of an operand or the phi-function itself. Hence, phi-function need a field //start//.

===== Determine the Register Type =====
Before beeing able to assign registers we have to decide whether to use a volatile or nonvolatile register. As soon there is a call to a method within the live range of a value (holds also for phi-functions) then this value must be assigned a nonvolatile Register. Other values are assigned a volatile register. The same is true for exceptions. If the live range of a variable extends into (or over) a catch block we must assign a nonvolatile register, as the handling of the exception destroys volatiles.\\
A special case is the SSA instruction //sCloadLocal//. With this we must ckeck if a method call occurs between the start of the method to the end of the live range. If this is not the case we can leave the parameter in the the register where it was passed, which is a volatile register already.

===== Determine Used Parameters =====
Parameters are passed in volatile registers. Some of them have to be copied to nonvolatile registers. Some parameters might not be used at all in a method. This can be determined in the exit set of the last node. If a value is null in that set the parameter with this index was never loaded and hence no register must be reserved. The following example demonstrates parameter usage on a PPC platform.
<code java>
  float m2(long a, float b, double c, byte[] d, short e, int f, int g) {
    a = 0x7545 & a;
    e += 100;
    T08Calls.classMethod(d[2]);
    e = (short)(20 + e);
    g |= 0x223344;
    c = 3.2;
    int h = g - e;
    T08Calls.classMethod(h);
    short i = (short)h;		
    return b;
  }
</code>
|**Variable**|this|a|b|c|d|e|f|g|
|**Typ**|ref|Long|Float|Double|ByteArray|Short|Integer|Integer|
|**Register Typ**| |vol|nonVol|vol|vol|vol| |nonVol|
|**not used**|x| | | | | |x| |
|**Register**| |R3,R4|FR31|FR2|R5|R6| |R31|

===== Register Assignment =====
Finally the results of all SSA instructions will be assigned a register.

===== Releasing of Registers of phi-Functions =====
As described above, phi-functions have a field //last// which is used to make sure that a registers of a phi-function lives to the very end of its loop. At the this end the register of the phi-function (which is actually given in its join value) could be released. However, at this stage we already passed the phi-function. For this purpose all phi-functions are referenced in a linked list (with the field //next//) in the first SSA instruction of the node following the node with the phi-function.

==== Loading of Parameters ==== 
All //sCloadLocal// instructions use the same register as their parameter. In case of //join != null//, the referenced phi function gets the same register.
==== Reservation of Auxiliary Registers ==== 
Some instruction need 1 or 2 additional (auxiliary) registers. These will be reserved and stored in //regAux1// and //regAux2//. At the end of the instruction they can be released again. It's possible that the result of the SSA instruction occupies the same register as one of the auxiliary registers.
==== Releasing of Operand Registers ==== 
Registers of operands, whose live range expires, must be released. If they are of type //long//, this step must happen at the very end.
==== Reservation of a Result Register ==== 
The register pool will be searched for a free register for the result. The result type determines if 1 or 2 GPR's or a FPR must be reserved. The following two cases must be considered.
=== 1. join != null ===
The same register must be assigned as the result of the phi function. If not handled yet the phi function has to be dealt with first. It can happen that several phi funtions occupy the same index in the state array:
<code java>
  switch(i) {
  case 0: return 0;
  case 1: i++; break;
  case 2: return 2;
  case 3: i += 3;
  case 4: i += 4; break;
  default: return -1;
  ..
  return i + 3;
</code>
In those cases all phi functions with the same index get the same register assigned. 
=== 2. Loading of a Constant ===
If a constant can be used as immediate operand by the machine instruction no register has to be reserved. However, if the value shows up in the state array (index >= 0), it must be loaded into a register anyway. This is the case with the conditional operator. A register must be assigned also in case of //join != null//.
==== Releasing of Result Registers ====
The result register can be released immediately if the live range already expires. 

===== Locals on the Stack =====
Local variables which cannot be assigned a register get assigned a stack slot. Stack slots are numbered from 0x100. The code generator will handle the transfer to and from these stack slots. Whenever the code generator tries to translate an SSA instruction and one of the operands is on the stack, the following has to be dones:

  * load stack slot into free register
  * execute instruction

If the result of the SSA instruction is assigned a stack slot, the code generator will have to save to the stack:

  * execute instruction, destination register is free register
  * store destination register onto stack

During register allocation of a method a variable //fullRegSet// signals, if at least one stack slot was used. If that was the case the register allocation is done again, but this time with a reduced register set, because some of the registers must be free in order to be used for fetching stack slots and using them in the following instructions.
deep

User Tools

Site Tools

Page Tools
