[LLVMdev] Explicit register usage in LLVM assembly

[Yiannis Tsiouris]

On 04/03/2011 12:43 AM, Frits van Bommel wrote:
> 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.
>   
First of all, i would like to thank you both for your quick answers!

I am working on creating a backend for a language that already has a
compiler. This compiler already maps some virtual registers of the VM,
such as stack and heap pointers, to physical ones for performance and
interoperability. If I understood well, there is no simple, predefined
way to retain these conventions (custom pre-coloured registers) with
LLVM compiler infrastructure. I would be surprised if I was the first
one to have ever stumbled upon this problem!

~y.