[llvm-dev] Altering the return address , for a function with multiple return paths

[Philip Reames via llvm-dev]

On 7/24/19 7:42 AM, John McCall wrote:
>
> On 24 Jul 2019, at 1:46, Philip Reames wrote:
>
>     We've also got some cases where returning a value in a flag might
>     be useful.  Our typical use case is we have a "rare, but not
>     *that* rare* slowpath which sometimes needs to run after a call
>     from a runtime function.  Our other compiler(s) - which use hand
>     rolled assembly for all of these bits - return the "take-rare" bit
>     in ZF, and branch on that after the call.  For our LLVM based
>     system, we just materialize the value into $rax and branch on
>     that.  That naive scheme has been surprisingly not bad performance
>     wise.
>
>     * The "not *that* rare" part is needed to avoid having exceptional
>     unwinding be the right answer.
>
>     If we were to support something like this, you'd really want to be
>     able to define individual flags in the callee's calling convention
>     clobber/preserve lists.  It's really common to have a helper
>     routine which sets say ZF, but leaves others unchanged.  Or to
>     have a function which sets ZF, clobbers OF, and preserves all
>     others.  But if we were going to do that, we'd quickly realize
>     that the x86 backend doesn't track individual flags at all, and
>     thus conclude it probably wasn't worth it begin with.  :)
>
> I'm intrigued what functions would usefully /preserve/ flags. That's 
> quite difficult on x86, since it means you have to spill flags if you 
> do any basic arithmetic at all (unless you do it all with |lea|). 
> Maybe on a target like PPC with really fleshed-out support for flags 
> and conditionality?
>
My use case would be hand written assembly stubs for particular fastpath 
operations.  These aren't compiler generated, and the hour of human time 
to line of code ratio is quite high.  Having said that, while I have 
practical examples where returning flags have been used, I don't, off 
the top of my head, have a concrete example of needing to preserve flags 
(except DF).  So, take that part more as a "if we're there anyways, the 
ideal would be...". On a practical level, return via flags with full 
clobber (except DF) would probably be more than sufficient.

* On every x86 abi I know of, the direction flag (DF) is assumed to be 
preserved through a call.  Messing with it and forgetting to reset it 
results in "interesting and unpleasant" bugs.

Philip

p.s. Has anyone played with lowering a switch via sahf and a series of 
jccs to dispatch?  It occurs to me that given all the combo variants of 
jccs, you could probably lower many switches on 4 bit values this way.  
Purely asking as a fun thought experiment, nothing more.

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20190724/974bcbf0/attachment.html>