compilers, register allocation, ...

Concerning PL.8 compiler targets, the '82 overview paper mentions 5 targets
(the 801, the 370, the 68000, and 2 other experimental machines) and 2
source languages (PL.8 and Pascal). I expect one of the expermental
machines was the ROMP. They've also added C to the list of languages I
believe.


Robert Henry notes that the ports made very limited use of the CISC targets'
addressing modes. For the 370 at least, this was a concious decision made
in an attempt to achieve better pipelining. It might have been a mistake
for the 68000.


David Keppel (pardo@june.cs.washington.edu) invokes Wirth in support of
register windows vs. compiler managed register allocation. That is, he
supports the idea of a simple hardware scheme vs. complex software.


But coloring register allocators aren't that big. Mine's about 1500 lines
of C (though "tersely" commented) and about 15K bytes of object. With
development effort, I expect that both compactness and speed could be
improved considerably. This may seem large compared to other allocation
schemes (I dunno), but it's certainly not a large program.


Are they complex? It's in the eyes of the beholder I suppose. Most of the
complexity in mine is due to the machine details I have to account for.
Overall, the coloring approach is a wonderful way to abstract away from all
the grubbiness.


How easy is it to allocate the registers using register windows? Aren't the
register allocation tasks identical for machines with fixed-size windows
"normal" machines? Variable-sized windows might be slightly easier (no
spill code), but you still want to minimize total register usage, so I still
see the same inteference analysis required.


I suppose that we could guide allocation using "register" declarations (!)
(if we happen to be compiling C). Without optimization, we'd be unlikely
to need spill code. But windows won't make up for all the loss in
performance incured by turning off the optimizer (except perhaps in
agressively hand-tuned C).


So, I speculate that register windows are not a way to avoid the complexity
of register allocation. They do seem to be a way to avoid some of the
penalty of procedure calls. However, see Wall's '88 paper.


Preston Briggs
preston@titan.rice.edu

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