alloca and labels as values

alloca and labels as values

[Marc Nieper-Wißkirchen]

Hi,

let me first say that libgccjit is a great project and that I like the 
API very much!

Is `alloca' currently possible with libgccjit? I haven't found anything 
about it in the documentation. If it isn't possible at the moment, I'd 
love to see it added to libgccjit very soon. (One use case would be a 
compiler like the Chicken Scheme compiler that employs Cheney-on-the-MTA 
where the youngest heap generation is allocated on the stack.)

Another thing that may be missing is label values as implemented by the 
GCC C/C++ frontends.

Thanks!

Marc

Re: alloca and labels as values

[David Malcolm]

On Mon, 2018-12-17 at 08:07 +0100, Marc Nieper-Wißkirchen wrote:
> Hi,
> 
> let me first say that libgccjit is a great project and that I like
> the 
> API very much!

Thanks.

> Is `alloca' currently possible with libgccjit? I haven't found
> anything 
> about it in the documentation. If it isn't possible at the moment,
> I'd 
> love to see it added to libgccjit very soon. (One use case would be
> a 
> compiler like the Chicken Scheme compiler that employs Cheney-on-the-
> MTA 
> where the youngest heap generation is allocated on the stack.)

I haven't tested this, but I believe you ought to be able to access it
via the "__builtin_alloca" builtin, via something like:


gcc_jit_function *fn_alloca
  = gcc_jit_context_get_builtin_function (ctxt, "__builtin_alloca");


gcc_jit_rvalue *call =
	gcc_jit_context_new_call (ctxt,
				  loc,
				  fn_alloc_a,
				  1, &size_t_arg);

 gcc_jit_block_add_assignment (block, loc,
                               dst_lvalue,
                               call);

...or something like that.


> Another thing that may be missing is label values as implemented by
> the 
> GCC C/C++ frontends.

Probably.  IIRC that isn't implemented.

> Thanks!
> 
> Marc

Dave

Re: alloca and labels as values

[Marc Nieper-Wißkirchen]

Am Di., 18. Dez. 2018 um 15:02 Uhr schrieb David Malcolm <dmalcolm@redhat.com>:

[...]

> On Tue, 2018-12-18 at 08:12 +0100, Marc Nieper-Wißkirchen wrote:
> > > > Is `alloca' currently  possible with libgccjit? I haven't found

[...]

> >  > I haven't tested this, but I believe you ought to be able to
> > access it
> >  > via the "__builtin_alloca" builtin, via something like:

[...]

> > That was helpful; thank you very much. I overlooked the procedure
> > `gcc_jit_context_get_builtin_function' in the documentation. Is there
> > a
> > way to determine which builtins are supported by a specific version
> > of
> > the library or would I have to add a few scripts to my project's
> > `configure.ac' myself?
>
> I think you'd need a configure check.

[...]

Having thought about it once more I think the configure check I asked
about makes no sense. Configure can tell me the available builtins of
the host compiler but nothing about the available builtins of the
target system that eventually runs libgccjit (if we don't want to give
up the option of cross-compiling).

What we need, I think, is that <libgccjit.h> exports a number of
macros that define the

Thus we need that libgccjit's header defines a number of macros that
define the capabilities of the GCC embedded in libgccjit.so.

Concretely, source code that uses libgccjit can test the feature macro
__GNUC__. This, however, returns the GCC version of the build system.
What is missing is another macro like GCC_JIT_GNUC that is defined in
<libgccjit.h> and returns the GCC version of the libgccjit library.

It may also be worth to reflect some macros from
https://gcc.gnu.org/onlinedocs/gccint/Target-Macros.html as
GCC_JIT_XXX macros in <libgccjit.h>.

-- Marc

Re: alloca and labels as values

[Marc Nieper-Wißkirchen]

> > Is `alloca' currently  possible with libgccjit? I haven't found
 > > anything
 > > about it in the documentation. If it isn't possible at the moment,
 > > I'd
 > > love to see it added to libgccjit very soon. (One use case would be
 > > a
 > > compiler like the Chicken Scheme compiler that employs Cheney-on-the-
 > > MTA
 > > where the youngest heap generation is allocated on the stack.)
 >
 > I haven't tested this, but I believe you ought to be able to access it
 > via the "__builtin_alloca" builtin, via something like:
 >
 >
 > gcc_jit_function *fn_alloca
 >   = gcc_jit_context_get_builtin_function (ctxt, "__builtin_alloca");
 >
 >
 > gcc_jit_rvalue *call =
 >         gcc_jit_context_new_call (ctxt,
 >                                   loc,
 >                                   fn_alloc_a,
 >                                   1, &size_t_arg);
 >
 >  gcc_jit_block_add_assignment (block, loc,
 >                                dst_lvalue,
 >                                call);
 >
 > ...or something like that.


That was helpful; thank you very much. I overlooked the procedure 
`gcc_jit_context_get_builtin_function' in the documentation. Is there a 
way to determine which builtins are supported by a specific version of 
the library or would I have to add a few scripts to my project's 
`configure.ac <http://configure.ac>' myself?

-- Marc

P.S.: Another thing I wasn't able to find so far was how to declare 
variables as thread local (i.e. GCC's __thread or C11's thread_local).

Re: alloca and labels as values

[David Malcolm]

On Tue, 2018-12-18 at 08:12 +0100, Marc Nieper-Wißkirchen wrote:
> > > Is `alloca' currently  possible with libgccjit? I haven't found
> 
>  > > anything
>  > > about it in the documentation. If it isn't possible at the
> moment,
>  > > I'd
>  > > love to see it added to libgccjit very soon. (One use case would
> be
>  > > a
>  > > compiler like the Chicken Scheme compiler that employs Cheney-
> on-the-
>  > > MTA
>  > > where the youngest heap generation is allocated on the stack.)
>  >
>  > I haven't tested this, but I believe you ought to be able to
> access it
>  > via the "__builtin_alloca" builtin, via something like:
>  >
>  >
>  > gcc_jit_function *fn_alloca
>  >   = gcc_jit_context_get_builtin_function (ctxt,
> "__builtin_alloca");
>  >
>  >
>  > gcc_jit_rvalue *call =
>  >         gcc_jit_context_new_call (ctxt,
>  >                                   loc,
>  >                                   fn_alloc_a,
>  >                                   1, &size_t_arg);
>  >
>  >  gcc_jit_block_add_assignment (block, loc,
>  >                                dst_lvalue,
>  >                                call);
>  >
>  > ...or something like that.
> 
> 
> That was helpful; thank you very much. I overlooked the procedure 
> `gcc_jit_context_get_builtin_function' in the documentation. Is there
> a 
> way to determine which builtins are supported by a specific version
> of 
> the library or would I have to add a few scripts to my project's 
> `configure.ac <http://configure.ac>' myself?

I think you'd need a configure check.

> -- Marc
> 
> P.S.: Another thing I wasn't able to find so far was how to declare 
> variables as thread local (i.e. GCC's __thread or C11's
> thread_local).

There isn't currently a way to do thread local variables.  I suspect
that something like a variant of gcc_jit_context_new_global could do
it, e.g. "gcc_jit_context_new_thread_local" or somesuch.  Or maybe a
way to mark the result of gcc_jit_context_new_global as being thread-
local.

Dave