[committed] Fix crash accessing builtins in sanitizer.def and after (PR jit/82174)

[Michael Cree]

On Wed, Oct 04, 2017 at 09:56:15AM -0400, David Malcolm wrote:
> On Sun, 2017-09-17 at 22:05 +1200, Michael Cree wrote:
> > On Thu, Sep 14, 2017 at 04:09:34PM -0400, David Malcolm wrote:
> > > Calls to gcc_jit_context_get_builtin_function that accessed
> > > builtins
> > > in sanitizer.def and after (or failed to match any builtin) led to
> > > a crash accessing a NULL builtin name.
> > 
> >   [snip]
> > > This patch updates jit-builtins.c to cope with such entries, fixing
> > > the
> > > crash.
> > 
> > Thanks for fixing that.
> > 
> > I would now like to get access to the architecture specific builtins.
> > Any possibility of that being implemented into libgccjit?  My project
> > is basically dead in the water without them.
> 
> I looked at doing that, but it's a little tricky:

That's a bummer.  The gcc vector optimiser will vectorise standard
operators but unfortunately is rather limited.  It did not, for
example, understand my attempt to implement saturating arithmetic
and proceeded to vectorise every individual operation rather than
replace the sequence with one saturating arithmetic instruction.

If the compiler knew more operators than the standard arithmetic and
logical operations, i.e., if it had a means of specifying min/max
operations and saturating arithmetic operations, and the vector
optimiser then did the conversion to machine specific SIMD
instructions, that would go quite a long way to assisting me.

Doing complex, real/complex and imaginary/complex multiplication
could be really useful to implement generating specific FFTs on the
fly.  I see gcc jit does support the C99 _Complex float/double type
so I must check whether the vector optimiser can produce good SIMD
code for complex arithmetic.  If it doesn't I would probably be back
to wanting machine specific builtins again as some architectures
implement CPU instructions to assist complex multiplication.

> > Secondly, I am trying to work out how to initialise a vector rvalue
> > with specified values.  Something in the vein of
> > gcc_jit_new_rvalue_from_int() but creating a type with vector
> > attribute and where each individual element is set to some specified
> > value and it may not be the same value for each element.
> 
> I've implemented:
> 
> extern gcc_jit_rvalue *
> gcc_jit_context_new_rvalue_from_vector (gcc_jit_context *ctxt,
>                                         gcc_jit_location *loc,
>                                         gcc_jit_type *vec_type,
>                                         size_t num_elements,
>                                         gcc_jit_rvalue **elements);
> 
> which is analogous to:
> 
>   { element0, element1, ... elementN-1}
> 
> in the C frontend.

Brilliant, that should enable one to make good use of the gcc
__builtin_shuffle() builtin which provides a very important SIMD
operation. (Here I am assuming the gcc jit already has access to
that particular builtin; I haven't tested it yet as it was no use
trying without being able to arbitrarily initialise a vector.)

> > The gcc C manual says "vectors can be subscripted as if the vector
> > were an array [...]" so I tried initialising a vector with
> > gcc_jit_context_new_array_access() but that fails with errors that
> > the vector is not a pointer or array at the time of JIT compilation.
> 
> I haven't implemented that yet; do you need it?

No, the above new implemented function provides what is needed.

Thanks,
Michael.