Extracting information from GCC register allocation

Extracting information from GCC register allocation

[Nikolaos Kavvadias]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
 
Hi there

i have a few questions about register allocation in GCC (mainly for
RISC targets).

First of all, it is true that GCC takes a rather complex way around
things. It seems to me that there are at least four passes for
register allocation:
lreg, greg, and a couple of reload passes (postreload?, rnreg? i'm not
sure). This is understandable due to the incremental way that things have
progressed. Now, to be more specific:

1. Is it possible to emit something close to assembly with
pseudo-registers instead of registers? I mean, is it possible to do this
just before each one of these passes? Or would it be possible to
devise such pass (e.g. an emitter just prior greg). I can see some RTL
stuff with pseudos (e.g. *.lreg) but is it semantically complete in
order to be possible to translate it to assembly (even though with
infinite registers)?

2. Is it possible to explicitly mark the fill/spill instructions (or
RTL statements) in such RTL dumps?

3. Supposedly a <machine.h> description is devised that has a
ridiculously large of registers (so that spills *almost* never will
occur).
Will this approach the effect of register allocation for infinite
registers or there exist other GCC-specific constraints. What are the
limits in the number of registers, registers in classes, allocable
registers etc (i've seen some very bad restrictions in LCC due to the
use of masks with host-dependent size).

And a last one:

4. There is some discussion around gmp/mpfr support in GCC lately. Are
we close to using arbitrary-size integers throught the GCC
infrastructure?

Kind regards
Nikolaos Kavvadias

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.0 (MingW32)
Comment: Using GnuPG with Thunderbird - http://enigmail.mozdev.org
 
iD8DBQFFWd08MPiy0tCWlz4RAjgcAKDGY7NojujIPXv0zaNDetHXiyUEWgCgsN1Y
U4wrq1DfbmmOi93KyrGnVeg=
=/zSX
-----END PGP SIGNATURE-----

Re: Extracting information from GCC register allocation

[Ian Lance Taylor]

Nikolaos Kavvadias <nkavv@physics.auth.gr> writes:

> 1. Is it possible to emit something close to assembly with
> pseudo-registers instead of registers? I mean, is it possible to do this
> just before each one of these passes? Or would it be possible to
> devise such pass (e.g. an emitter just prior greg). I can see some RTL
> stuff with pseudos (e.g. *.lreg) but is it semantically complete in
> order to be possible to translate it to assembly (even though with
> infinite registers)?

Yes.

> 2. Is it possible to explicitly mark the fill/spill instructions (or
> RTL statements) in such RTL dumps?

It would take a bit of work in reload, but, yes, it is possible.

> 3. Supposedly a <machine.h> description is devised that has a
> ridiculously large of registers (so that spills *almost* never will
> occur).
> Will this approach the effect of register allocation for infinite
> registers or there exist other GCC-specific constraints. What are the
> limits in the number of registers, registers in classes, allocable
> registers etc (i've seen some very bad restrictions in LCC due to the
> use of masks with host-dependent size).

There are no gcc constraints of this form, up to having a few million
hard registers.  Implementing a very large number of hard registers
will tend to slow the compiler down, as there are a number of arrays
and bitmaps which are sized to the number of registers.

> 4. There is some discussion around gmp/mpfr support in GCC lately. Are
> we close to using arbitrary-size integers throught the GCC
> infrastructure?

No, not at all.  That would be very slow and would bring little
benefit.

Ian