GCCJIT and tail-recursive calls

[Basile Starynkevitch]

On 07/10/2015 04:41 PM, David Malcolm wrote:

> This is done by: gcc/tree-tailcall.c controlled by: 
> -foptimize-sibling-calls which is on by default at -02 and above. 
> Normally you'd do something like: gcc_jit_block_end_with_return (... 
> gcc_jit_context_new_call (...)); or gcc_jit_block_add_eval (... 
> gcc_jit_context_new_call (...)); gcc_jit_block_end_with_void return 
> (...); The tailcall is obvious in both of these cases.
>>>> I was thinking of adding a construct where the GCCJIT client knows
>>>> for sure that the call should be tail-rec (and if GCCJIT was not able to
>>>> make a tailcall, that would be an error).
>>> It's not clear to me why that would be useful.  Am I missing something?
>>
>> You are coding a JIT for your implementation of Scheme.
>> Scheme requires that tailcails are effectively ilmplemented as such.
> What do you mean by the word "requires" here?
>
>    performance? that if enough tailcalls aren't optimized, then things
> will be painfully slow?
>
>    legal? that if every tailcall isn't optimized, then some trademark
> owner will send a Cease-and-Desist letter?


No, technically only.

IIRC, Scheme specification has words that don't allow a stack overflow
for a very deep tail-recursive function call.
>> So your Scheme implementation has to detect tailcalls and want to be
>> sure that GCCJIT
>> is implementing them as needed.
> Can't you just trust the optimizer?
>
>> How would you ensure that?
> >From a testing perspective, I suppose you could pass in:
>   -fdump-tree-tailr1-details -fdump-tree-tailr2-details
> and then use:
> https://gcc.gnu.org/onlinedocs/jit/topics/contexts.html#gcc_jit_context_enable_dump
>
> to capture these dumpfiles in memory and somehow analyze them.  I use
> this approach in one of the jit testcase to verify that an optimization
> does take place (similar to how many of gcc's DejaGnu testcases work).

Ok.


> Another approach might be to add an attribute to the call, saying "must
> be handled as a tail call", and have that pass issue an error if it
> can't do it.  Maybe via a builtin that can wrap calls and tags them as
> such?  That would require some work from the gcc side.



Yes, I was thinking of something similar...


Thanks!

-- 
Basile STARYNKEVITCH         http://starynkevitch.net/Basile/
email: basile<at>starynkevitch<dot>net mobile: +33 6 8501 2359
8, rue de la Faiencerie, 92340 Bourg La Reine, France
*** opinions {are only mine, sont seulement les miennes} ***