Re: Register allocation

"thibault.langlois@di.fc.ul.pt" <thibault.langlois@di.fc.ul.pt> writes:




> I have a question about register allocation using a graph coloring
> algorithm.
> The front-end of my compiler produces a three address code
> representation.
> The register allocation should be performed on the intermediate
> representation (to assign temporaries to registers) or should I choose
> the instructions of the target processor first, assuming an infinite
> number of registers and then use the register allocation to match the
> actual set of registers ?


There are advantages and disadvantages to both approaches:


If you do register allocation on intermediate code:


  - You can share the register allocator among all target
      architectures, just parameterising with number of registers etc.


  - You can generate spill code as intermediate code, which the
      instruction selector may optimise.


  - The register allocator wil be simpler, as intermediate code is more
      regular than machine code.


  - But you will have to leve a few register unallocated, as the code
      generator may have to use extra registers as temporaries etc.


With allocation on machine code:


  - You can more easily handle instructions that require
      operands/results in specific registers.


  - You can tune the allocator better to the calling convention, i.e.,
      regarding caller-saves/callee-saves registers, parameter registers
      and spill.


  - But spill code may break the optimality of instruction selection
      and scheduling.


  - And it is more work to port the register allocator to a different
      target architecture.


Overall, I would say you get the best result by postponing register
allocation to machine code, but it will also be more work to do so.


                Torben

Return to the comp.compilers page.
Search the comp.compilers archives again.