[LLVMdev] Explicit register usage in LLVM assembly

Frits van Bommel fvbommel at gmail.com
Sat Apr 2 14:43:37 PDT 2011

On Sat, Apr 2, 2011 at 9:46 PM, Yiannis Tsiouris
<yiannis.tsiouris at gmail.com> wrote:
>  I am not sure i made myself clear about what i want. I was wondering
> if there
> is a way to communicate to LLVM's register allocator and define which
> registers are pre-coloured and should not be used for allocation.

Do you really need that, or would it be enough to be able to get the
value of the register at the start of a function and be able to set it
(or pass it along) when calling other functions? If so, the easiest
way really is to define a calling convention that uses it as e.g. the
first parameter register. Then you can just read the value from that
parameter, and have your compiler automatically pass it as that
parameter to other functions.

If it ever changes you'll also need to add it as e.g. the first return
register so functions can return the current value in it (note that
functions can return multiple values by returning structs). To keep
things simple, it's probably best to treat it as a local variable in
your frontend: alloca at the start of the function, store to it at the
start of the function and after every call that returns the current
value for it, then load it whenever you need it. Optimization passes
will easily clean this up.
This is probably a good idea even if it doesn't change, simply because
it tells the code generator that the parameter register isn't changed.
Or at least, that the value in the register after the call is still
the value it needs to use. Otherwise, it would likely store it to the
stack before the first call and load it before every subsequent call.

After optimization, the code generator would most likely prefer to
keep the value in the right register (since it starts there and later
needs to be there), but it might get moved elsewhere if there's a lot
of code between uses of the variable and the register is better used
for other things. This is usually a *good* thing, because it should be
better for performance.
As Sam said, the only place this might mess things up is when
interrupt functions (which aren't explicitly called, meaning LLVM
wouldn't know the register needs to contain the variable at that point
in the code) are involved. Well, and maybe debuggers I suppose, if the
register is hardcoded somewhere or you explicitly ask for the register
instead of the variable.

P.S. If it's important (or just convenient) for you to use a
unmodified LLVM, you might be able to get these changes into the
repository if you post a patch to the commits list. GHC had their own
special calling convention committed, for example.

More information about the llvm-dev mailing list