add notes

I start to believe that it is possible to simply
reuse the regalloc I wrote.  All the data structures
seem fine.

Here is a list modifications to make for sure:
 - Keep track of the mapping for live in variables
   for each block.
 - Make sure 'loc' (or a new function) returns
   registers for the arguments of base instructions.

Spilling
--------

When we need a register and none are left.  If we
are at the end of a block, simply spill anybody (the
resolving will take care of adding the moves).  If we
are in a block, find somebody to spill and its next
use, if the next use is in the same block, emit reload
code, otherwise, decide to emit the reload at the
end of the cheapest block (this means that we have to
patch some mappings that were already stored).  We let
the resolve handle the insertion of the reload code.

Example:

  +----------------------+
  |                      |
  |                      |
  |   +----+     +----+  |   +----+
 -+-> | b1 | --> | b2 | -+-> | b3 | -->
      +----+     +----+      +----+
        ^                       ^
        Spill x                 First use of x
        (Was in r1)

The cheapest position for reload code is at the
beginning of b3, so we have to modify the mapping
at the end of b1, beginning of b2, and end of b2 to
change it from (x -> r1) to (x -> spill).

Reloading
---------

When a spilled variable is needed in register.  In this
case, we are necessarily inside a block (or at a branch)
because that is the only place we require a variable to
be in register.  Here again we are constrained to insert
the spill code before the next use of the variable, but
more importantly, we must do it before the register
chosen is *in use next*.

0 files changed, 0 insertions, 0 deletions