Thanks for your reviews. I attached the new patch to this email.
See answers below: Le jeudi 13 mai 2021 à 17:30 -0400, David Malcolm a écrit : > On Tue, 2020-11-03 at 17:13 -0500, Antoni Boucher wrote: > > I was missing a check in gcc_jit_struct_get_field, I added it in > > this > > new patch. > > > > Sorry about the long delay in reviewing this patch. > > The main high-level points are: > - currently the get_*_count functions return "ssize_t" - why? Only > unsigned values are meaningful; shouldn't they return "size_t" > instead? For those, I had this question in a previous email: That seemed off to return NULL for the functions returning a size_t to indicate an error. So I changed it to return -1 (and return type to ssize_t). Is that the proper way to indicate an error? Once I know the answer for this error handling question, I'll fix the types. > - the various "lookup by index" functions take "int" i.e. signed, but > only >= 0 is meaningful. I think it makes sense to make them take > size_t instead. That's fixed in the new patch. > Sorry if we covered that before in the review, it's been a while. > > Various nitpicks inline below... > > [...snip...] > > > diff --git a/gcc/jit/docs/topics/compatibility.rst > > b/gcc/jit/docs/topics/compatibility.rst > > index 6bfa101ed71..236e5c72d81 100644 > > --- a/gcc/jit/docs/topics/compatibility.rst > > +++ b/gcc/jit/docs/topics/compatibility.rst > > @@ -226,3 +226,44 @@ entrypoints: > > -------------------- > > ``LIBGCCJIT_ABI_14`` covers the addition of > > :func:`gcc_jit_global_set_initializer` > > + > > +.. _LIBGCCJIT_ABI_15: > > + > > +``LIBGCCJIT_ABI_15`` > > +-------------------- > > +``LIBGCCJIT_ABI_15`` covers the addition of reflection functions via > > API > > +entrypoints: > > This needs updating, as I used LIBGCCJIT_ABI_15 for inline asm. This was updated for the new patch. > [...snip...] > > > diff --git a/gcc/jit/docs/topics/functions.rst > > b/gcc/jit/docs/topics/functions.rst > > index eb40d64010e..aa6de87282d 100644 > > --- a/gcc/jit/docs/topics/functions.rst > > +++ b/gcc/jit/docs/topics/functions.rst > > @@ -171,6 +171,16 @@ Functions > > underlying string, so it is valid to pass in a pointer to an on- > > stack > > buffer. > > > > +.. function:: ssize_t \ > > + gcc_jit_function_get_param_count (gcc_jit_function > > *func) > > + > > + Get the number of parameters of the function. > > + > > +.. function:: gcc_jit_type \* > > + gcc_jit_function_get_return_type (gcc_jit_function > > *func) > > + > > + Get the return type of the function. > > As noted before, this doesn't yet document all the new entrypoints; I > think you wanted to hold off until all the details were thrashed out, > but hopefully we're close. > > The documentation for an entrypoint should specify which ABI it was > added in. The documentation was added in the new patch. > [...snip...] > > > +/* Public entrypoint. See description in libgccjit.h. > > + > > + After error-checking, the real work is done by the > > + gcc::jit::recording::type::is_struct method, in > > + jit-recording.c. */ > > + > > +gcc_jit_struct * > > +gcc_jit_type_is_struct (gcc_jit_type *type) > > +{ > > + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); > > + gcc::jit::recording::struct_ *struct_type = type->is_struct (); > > + return (gcc_jit_struct *)struct_type; > > +} > > + > > +/* Public entrypoint. See description in libgccjit.h. > > + > > + After error-checking, the real work is done by the > > + gcc::jit::recording::vector_type::get_num_units method, in > > + jit-recording.c. */ > > + > > +ssize_t > > +gcc_jit_vector_type_get_num_units (gcc_jit_vector_type > > *vector_type) > > +{ > > + RETURN_VAL_IF_FAIL (vector_type, -1, NULL, NULL, "NULL > > vector_type"); > > + return vector_type->get_num_units (); > > +} > > + > > +/* Public entrypoint. See description in libgccjit.h. > > + > > + After error-checking, the real work is done by the > > + gcc::jit::recording::vector_type::get_element_type method, in > > + jit-recording.c. */ > > + > > +gcc_jit_type * > > +gcc_jit_vector_type_get_element_type (gcc_jit_vector_type > > *vector_type) > > +{ > > + RETURN_NULL_IF_FAIL (vector_type, NULL, NULL, "NULL > > vector_type"); > > + return (gcc_jit_type *)vector_type->get_element_type (); > > +} > > + > > +/* Public entrypoint. See description in libgccjit.h. > > + > > + After error-checking, the real work is done by the > > + gcc::jit::recording::type::unqualified method, in > > + jit-recording.c. */ > > + > > +gcc_jit_type * > > +gcc_jit_type_unqualified (gcc_jit_type *type) > > +{ > > + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); > > + > > + return (gcc_jit_type *)type->unqualified (); > > +} > > + > > +/* Public entrypoint. See description in libgccjit.h. > > + > > + After error-checking, the real work is done by the > > + gcc::jit::recording::type::dyn_cast_function_type method, in > > + jit-recording.c. */ > > + > > +gcc_jit_function_type * > > +gcc_jit_type_is_function_ptr_type (gcc_jit_type *type) > > +{ > > + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); > > + gcc::jit::recording::type *func_ptr_type = type->dereference (); > > + RETURN_NULL_IF_FAIL (func_ptr_type, NULL, NULL, "NULL type"); > > + gcc::jit::recording::function_type *func_type = > > + func_ptr_type->dyn_cast_function_type (); > > + RETURN_NULL_IF_FAIL (func_type, NULL, NULL, "NULL type"); > > I notice that the other new "*_is_*" functions don't fail if the > dyncast returns NULL, whereas this one does. > > RETURN_NULL_IF_FAIL calls jit_error; do we really want that? It > seems > more consistent to have it return NULL without an error for the case > where "type" isn't a function ptr type. This is fixed in the patch. > > > + > > + return (gcc_jit_function_type *)func_type; > > +} > > + > > +/* Public entrypoint. See description in libgccjit.h. > > + > > + After error-checking, the real work is done by the > > + gcc::jit::recording::function_type::get_return_type method, in > > + jit-recording.c. */ > > + > > +gcc_jit_type * > > +gcc_jit_function_type_get_return_type (gcc_jit_function_type > > *function_type) > > +{ > > + RETURN_NULL_IF_FAIL (function_type, NULL, NULL, "NULL > > struct_type"); > > Wrong error message; should be "NULL function_type". Fixed in the patch. > > > > + return (gcc_jit_type *)function_type->get_return_type (); > > +} > > + > > +/* Public entrypoint. See description in libgccjit.h. > > + > > + After error-checking, the real work is done by the > > + gcc::jit::recording::function_type::get_param_types method, in > > + jit-recording.c. */ > > + > > +ssize_t > > +gcc_jit_function_type_get_param_count (gcc_jit_function_type > > *function_type) > > +{ > > + RETURN_VAL_IF_FAIL (function_type, -1, NULL, NULL, "NULL > > struct_type"); > > Wrong error message; should be "NULL function_type". Fixed in the patch > > > + return function_type->get_param_types ().length (); > > +} > > + > > +/* Public entrypoint. See description in libgccjit.h. > > + > > + After error-checking, the real work is done by the > > + gcc::jit::recording::function_type::get_param_types method, in > > + jit-recording.c. */ > > + > > +gcc_jit_type * > > +gcc_jit_function_type_get_param_type (gcc_jit_function_type > > *function_type, > > + int index) > > +{ > > + RETURN_NULL_IF_FAIL (function_type, NULL, NULL, "NULL > > struct_type"); > > Wrong error message; should be "NULL function_type". Fixed in the patch. > > > > + int num_params = function_type->get_param_types ().length (); > > + gcc::jit::recording::context *ctxt = function_type->m_ctxt; > > "index" should either be unsigned, or we need to check here for >= 0. > > > + RETURN_NULL_IF_FAIL_PRINTF3 (index < num_params, > > + ctxt, NULL, > > + "index of %d is too large (%s has %d > > params)", > > + index, > > + function_type->get_debug_string (), > > + num_params); > > + return (gcc_jit_type *)function_type->get_param_types ()[index]; > > +} > > + > > /* Public entrypoint. See description in libgccjit.h. > > > > After error-checking, the real work is done by the > > @@ -731,6 +930,36 @@ gcc_jit_struct_set_fields (gcc_jit_struct > > *struct_type, > > (gcc::jit::recording::field **)fields); > > } > > > > + > > +/* Public entrypoint. See description in libgccjit.h. > > + > > + After error-checking, the real work is done by the > > + gcc::jit::recording::fields::get_field method in > > + jit-recording.c. */ > > +extern gcc_jit_field * > > +gcc_jit_struct_get_field (gcc_jit_struct *struct_type, > > + int index) > > +{ > > + RETURN_NULL_IF_FAIL (struct_type, NULL, NULL, "NULL struct > > type"); > > + RETURN_NULL_IF_FAIL (struct_type->get_fields (), NULL, NULL, > > "NULL struct fields"); > > "index" should either be unsigned, or we need to check here for >= 0. Fixed in the patch. > > > + RETURN_NULL_IF_FAIL (index < struct_type->get_fields ()->length > > (), NULL, > > + NULL, "NULL struct type"); > > + return (gcc_jit_field *)struct_type->get_fields ()->get_field > > (index); > > +} > > [...snip...] > > > diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h > > index 7134841bb07..db4ccffb41c 100644 > > --- a/gcc/jit/libgccjit.h > > +++ b/gcc/jit/libgccjit.h > > @@ -96,6 +96,12 @@ typedef struct gcc_jit_field gcc_jit_field; > > the layout for, or an opaque type. */ > > typedef struct gcc_jit_struct gcc_jit_struct; > > > > +/* A gcc_jit_function_type encapsulates a function type. */ > > +typedef struct gcc_jit_function_type gcc_jit_function_type; > > + > > +/* A gcc_jit_vector_type encapsulates a vector type. */ > > +typedef struct gcc_jit_vector_type gcc_jit_vector_type; > > + > > Please add these to the ASCII art inheritance diagram immediately > above: > typedef struct gcc_jit_object gcc_jit_object; Done. > > [...snip...] > > > /* Unions work similarly to structs. */ > > extern gcc_jit_type * > > gcc_jit_context_new_union_type (gcc_jit_context *ctxt, > > @@ -1518,6 +1533,78 @@ gcc_jit_version_minor (void); > > extern int > > gcc_jit_version_patchlevel (void); > > > > +#define LIBGCCJIT_HAVE_REFLECTION > > + > > +/* Reflection functions to get the number of parameters, return > > type of > > + a function and whether a type is a bool from the C API. > > + > > + This API entrypoint was added in LIBGCCJIT_ABI_15; you can test > > for its > > + presence using > > + #ifdef LIBGCCJIT_HAVE_REFLECTION > > +*/ > > +/* Get the return type of a function. */ > > +extern gcc_jit_type * > > +gcc_jit_function_get_return_type (gcc_jit_function *func); > > + > > +/* Get the number of params of a function. */ > > +extern ssize_t > > +gcc_jit_function_get_param_count (gcc_jit_function *func); > > You're using ssize_t here, why? Wouldn't size_t be better? > The count can't be negative. As explained aboved, it is to indicate an error. > > Should we use size_t for indexes, rather than "int"? > > (this happens in various places e.g. > gcc_jit_function_type_get_param_count and > gcc_jit_vector_type_get_num_units) > > [...snip...] > > > diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map > > index a6e67e781a4..720b6ca286f 100644 > > --- a/gcc/jit/libgccjit.map > > +++ b/gcc/jit/libgccjit.map > > @@ -192,3 +192,24 @@ LIBGCCJIT_ABI_14 { > > global: > > gcc_jit_global_set_initializer; > > } LIBGCCJIT_ABI_13; > > + > > +LIBGCCJIT_ABI_15 { > > + global: > > + gcc_jit_function_get_return_type; > > + gcc_jit_function_get_param_count; > > + gcc_jit_function_type_get_return_type; > > + gcc_jit_function_type_get_param_count; > > + gcc_jit_function_type_get_param_type; > > + gcc_jit_type_unqualified; > > + gcc_jit_type_is_array; > > + gcc_jit_type_is_bool; > > + gcc_jit_type_is_function_ptr_type; > > + gcc_jit_type_is_integral; > > + gcc_jit_type_is_pointer; > > + gcc_jit_type_is_vector; > > + gcc_jit_vector_type_get_element_type; > > + gcc_jit_vector_type_get_num_units; > > + gcc_jit_struct_get_field; > > + gcc_jit_type_is_struct; > > + gcc_jit_struct_get_field_count; > > +} LIBGCCJIT_ABI_14; > > As noted above, this will need to be LIBGCCJIT_ABI_16 as I used > LIBGCCJIT_ABI_15 for inline asm. Fixed. > > [...snip...] > > > diff --git a/gcc/testsuite/jit.dg/test-reflection.c > > b/gcc/testsuite/jit.dg/test-reflection.c > > new file mode 100644 > > index 00000000000..b3cf2942f3a > > --- /dev/null > > +++ b/gcc/testsuite/jit.dg/test-reflection.c > > @@ -0,0 +1,89 @@ > > +#include <stdlib.h> > > +#include <stdio.h> > > + > > +#include "libgccjit.h" > > + > > +#include "harness.h" > > + > > +void > > +create_code (gcc_jit_context *ctxt, void *user_data) > > +{ > > + /* Do nothing. */ > > +} > > + > > +void > > +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) > > +{ > > + /* Get the built-in functions. */ > > + gcc_jit_function *builtin_sin = > > + gcc_jit_context_get_builtin_function (ctxt, "sin"); > > + > > + CHECK_VALUE (gcc_jit_function_get_param_count(builtin_sin), 1); > > + > > + gcc_jit_type *double_type = > > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_DOUBLE); > > + CHECK_VALUE (gcc_jit_function_get_return_type(builtin_sin), > > double_type); > > + CHECK (!gcc_jit_type_is_integral(double_type)); > > + > > + gcc_jit_type *bool_type = > > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_BOOL); > > + CHECK (gcc_jit_type_is_bool(bool_type)); > > + CHECK (!gcc_jit_type_is_integral(bool_type)); > > + > > + gcc_jit_type *aligned_bool_type = > > + gcc_jit_type_get_aligned(gcc_jit_context_get_type (ctxt, > > GCC_JIT_TYPE_BOOL), 8); > > + CHECK (gcc_jit_type_is_bool(aligned_bool_type)); > > + CHECK (bool_type != aligned_bool_type); > > + CHECK_VALUE (gcc_jit_type_unqualified(aligned_bool_type), > > bool_type); > > + > > + CHECK_VALUE > > (gcc_jit_type_unqualified(gcc_jit_type_get_const(bool_type)), > > bool_type); > > + CHECK_VALUE > > (gcc_jit_type_unqualified(gcc_jit_type_get_volatile(bool_type)), > > bool_type); > > + > > + gcc_jit_type *int64 = > > + gcc_jit_context_get_int_type(ctxt, 8, 1); > > + CHECK (gcc_jit_type_is_integral(int64)); > > + gcc_jit_type *uint64 = > > + gcc_jit_context_get_int_type(ctxt, 8, 0); > > + CHECK (gcc_jit_type_is_integral(uint64)); > > + gcc_jit_type *int8 = > > + gcc_jit_context_get_int_type(ctxt, 1, 1); > > + CHECK (gcc_jit_type_is_integral(int8)); > > + gcc_jit_type *uint8 = > > + gcc_jit_context_get_int_type(ctxt, 1, 0); > > + CHECK (gcc_jit_type_is_integral(uint8)); > > + > > + CHECK (!gcc_jit_type_is_vector(double_type)); > > + gcc_jit_type *vec_type = gcc_jit_type_get_vector (double_type, > > 4); > > + gcc_jit_vector_type *vector_type = > > gcc_jit_type_is_vector(vec_type); > > + CHECK (vector_type); > > + CHECK (vec_type != double_type); > > + CHECK_VALUE (gcc_jit_vector_type_get_element_type(vector_type), > > double_type); > > + CHECK_VALUE (gcc_jit_vector_type_get_num_units(vector_type), 4); > > + > > + CHECK (!gcc_jit_type_is_pointer(double_type)); > > + CHECK_VALUE > > (gcc_jit_type_is_pointer(gcc_jit_type_get_pointer(double_type)), > > double_type); > > + > > + gcc_jit_type* params[2] = {int8, uint64}; > > + gcc_jit_type *function_ptr_type = > > gcc_jit_context_new_function_ptr_type(ctxt, NULL, int64, 2, params, > > 0); > > + gcc_jit_function_type *function_type = > > gcc_jit_type_is_function_ptr_type (function_ptr_type); > > + CHECK (function_type); > > + int param_count = > > gcc_jit_function_type_get_param_count(function_type); > > + CHECK_VALUE (param_count, 2); > > + gcc_jit_type *return_type = > > gcc_jit_function_type_get_return_type(function_type); > > + CHECK_VALUE (return_type, int64); > > + gcc_jit_type *param1 = > > gcc_jit_function_type_get_param_type(function_type, 0); > > + CHECK_VALUE (param1, int8); > > + gcc_jit_type *param2 = > > gcc_jit_function_type_get_param_type(function_type, 1); > > + CHECK_VALUE (param2, uint64); > > + > > + gcc_jit_field *field1 = gcc_jit_context_new_field (ctxt, NULL, > > uint64, "field1"); > > + gcc_jit_field *field2 = gcc_jit_context_new_field (ctxt, NULL, > > double_type, "field2"); > > + gcc_jit_field *fields[2] = { field1, field2 }; > > + gcc_jit_struct *struct_type = gcc_jit_context_new_struct_type > > (ctxt, NULL, "testStruct", 2, fields); > > + CHECK_VALUE (gcc_jit_struct_get_field_count(struct_type), 2); > > + CHECK_VALUE (gcc_jit_struct_get_field(struct_type, 0), field1); > > + CHECK_VALUE (gcc_jit_struct_get_field(struct_type, 1), field2); > > + gcc_jit_struct *struct_ty = > > gcc_jit_type_is_struct(gcc_jit_struct_as_type(struct_type)); > > + CHECK_VALUE (struct_ty, struct_type); > > > I think this is missing test coverage for the various > gcc_jit_type_is_* > entrypoints gracefully returning NULL when the type passed to them is > wrong (e.g. a non-struct type passed to gcc_jit_type_is_struct, etc) I added tests for those. > > Hope this is constructive; sorry again about the delay in reviewing > it. > Dave > >
From 6f2d37a67ad9ad72eaf3f17f4d20a5be5a093ac4 Mon Sep 17 00:00:00 2001 From: Antoni Boucher <boua...@zoho.com> Date: Sat, 1 Aug 2020 17:52:17 -0400 Subject: [PATCH] This patch add some reflection functions in the jit C api [PR96889] 2020-09-1 Antoni Boucher <boua...@zoho.com> gcc/jit/ PR target/96889 * docs/topics/compatibility.rst (LIBGCCJIT_ABI_16): New ABI tag. * docs/topics/functions.rst: Add documentation for the functions gcc_jit_function_get_return_type and gcc_jit_function_get_param_count * docs/topics/types.rst: Add documentation for the functions gcc_jit_function_type_get_return_type, gcc_jit_function_type_get_param_count, gcc_jit_function_type_get_param_type, gcc_jit_type_unqualified, gcc_jit_type_is_array, gcc_jit_type_is_bool, gcc_jit_type_is_function_ptr_type, gcc_jit_type_is_integral, gcc_jit_type_is_pointer, gcc_jit_type_is_vector, gcc_jit_vector_type_get_element_type, gcc_jit_vector_type_get_num_units, gcc_jit_struct_get_field, gcc_jit_type_is_struct, and gcc_jit_struct_get_field_count * libgccjit.c: (gcc_jit_function_get_return_type, gcc_jit_function_get_param_count, gcc_jit_function_type_get_return_type, gcc_jit_function_type_get_param_count, gcc_jit_function_type_get_param_type, gcc_jit_type_unqualified, gcc_jit_type_is_array, gcc_jit_type_is_bool, gcc_jit_type_is_function_ptr_type, gcc_jit_type_is_integral, gcc_jit_type_is_pointer, gcc_jit_type_is_vector, gcc_jit_vector_type_get_element_type, gcc_jit_vector_type_get_num_units, gcc_jit_struct_get_field, gcc_jit_type_is_struct, gcc_jit_struct_get_field_count): New functions. (struct gcc_jit_function_type, struct gcc_jit_vector_type): New types. * libgccjit.h: (gcc_jit_function_get_return_type, gcc_jit_function_get_param_count, gcc_jit_function_type_get_return_type, gcc_jit_function_type_get_param_count, gcc_jit_function_type_get_param_type, gcc_jit_type_unqualified, gcc_jit_type_is_array, gcc_jit_type_is_bool, gcc_jit_type_is_function_ptr_type, gcc_jit_type_is_integral, gcc_jit_type_is_pointer, gcc_jit_type_is_vector, gcc_jit_vector_type_get_element_type, gcc_jit_vector_type_get_num_units, gcc_jit_struct_get_field, gcc_jit_type_is_struct, gcc_jit_struct_get_field_count): New function declarations. (struct gcc_jit_function_type, struct gcc_jit_vector_type): New types. * jit-recording.h: New functions (is_struct and is_vector) * libgccjit.map (LIBGCCJIT_ABI_16): New ABI tag. gcc/testsuite/ PR target/96889 * jit.dg/all-non-failing-tests.h: Add test-reflection.c. * jit.dg/test-reflection.c: New test. --- gcc/jit/docs/topics/compatibility.rst | 43 +++- gcc/jit/docs/topics/functions.rst | 26 ++ gcc/jit/docs/topics/types.rst | 122 +++++++++ gcc/jit/jit-recording.h | 7 + gcc/jit/libgccjit.c | 256 +++++++++++++++++++ gcc/jit/libgccjit.h | 89 +++++++ gcc/jit/libgccjit.map | 21 ++ gcc/testsuite/jit.dg/all-non-failing-tests.h | 10 + gcc/testsuite/jit.dg/test-reflection.c | 95 +++++++ 9 files changed, 668 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/jit.dg/test-reflection.c diff --git a/gcc/jit/docs/topics/compatibility.rst b/gcc/jit/docs/topics/compatibility.rst index 239b6aa1a92..cec40ca508c 100644 --- a/gcc/jit/docs/topics/compatibility.rst +++ b/gcc/jit/docs/topics/compatibility.rst @@ -230,7 +230,7 @@ entrypoints: .. _LIBGCCJIT_ABI_15: ``LIBGCCJIT_ABI_15`` ------------------------ +-------------------- ``LIBGCCJIT_ABI_15`` covers the addition of API entrypoints for directly embedding assembler instructions: @@ -243,3 +243,44 @@ embedding assembler instructions: * :func:`gcc_jit_extended_asm_add_input_operand` * :func:`gcc_jit_extended_asm_add_clobber` * :func:`gcc_jit_context_add_top_level_asm` + +.. _LIBGCCJIT_ABI_16: + +``LIBGCCJIT_ABI_16`` +-------------------- +``LIBGCCJIT_ABI_16`` covers the addition of reflection functions via API +entrypoints: + + * :func:`gcc_jit_function_get_return_type` + + * :func:`gcc_jit_function_get_param_count` + + * :func:`gcc_jit_type_is_array` + + * :func:`gcc_jit_type_is_bool` + + * :func:`gcc_jit_type_is_integral` + + * :func:`gcc_jit_type_is_pointer` + + * :func:`gcc_jit_type_is_struct` + + * :func:`gcc_jit_type_is_vector` + + * :func:`gcc_jit_type_unqualified` + + * :func:`gcc_jit_type_is_function_ptr_type` + + * :func:`gcc_jit_function_type_get_return_type` + + * :func:`gcc_jit_function_type_get_param_count` + + * :func:`gcc_jit_function_type_get_param_type` + + * :func:`gcc_jit_vector_type_get_num_units` + + * :func:`gcc_jit_vector_type_get_element_type` + + * :func:`gcc_jit_struct_get_field` + + * :func:`gcc_jit_struct_get_field_count` diff --git a/gcc/jit/docs/topics/functions.rst b/gcc/jit/docs/topics/functions.rst index b2d9239aa0a..950da4e5a76 100644 --- a/gcc/jit/docs/topics/functions.rst +++ b/gcc/jit/docs/topics/functions.rst @@ -171,6 +171,32 @@ Functions underlying string, so it is valid to pass in a pointer to an on-stack buffer. +.. function:: ssize_t \ + gcc_jit_function_get_param_count (gcc_jit_function *func) + + Get the number of parameters of the function. + +.. function:: gcc_jit_type *\ + gcc_jit_function_get_return_type (gcc_jit_function *func) + + Get the return type of the function. + + The API entrypoints relating to getting info about parameters and return + types: + + * :c:func:`gcc_jit_function_get_return_type` + + * :c:func:`gcc_jit_function_get_param_count` + + were added in :ref:`LIBGCCJIT_ABI_15`; you can test for their presence + using + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_REFLECTION + + .. type:: gcc_jit_case + Blocks ------ .. type:: gcc_jit_block diff --git a/gcc/jit/docs/topics/types.rst b/gcc/jit/docs/topics/types.rst index 831f11b679a..73cdca11c3b 100644 --- a/gcc/jit/docs/topics/types.rst +++ b/gcc/jit/docs/topics/types.rst @@ -345,3 +345,125 @@ Function pointer types Function pointer types can be created using :c:func:`gcc_jit_context_new_function_ptr_type`. + +Reflection API +-------------- + +.. function:: gcc_jit_type *\ + gcc_jit_type_is_array (gcc_jit_type *type) + + Get the element type of an array type or NULL if it's not an array. + +.. function:: int\ + gcc_jit_type_is_bool (gcc_jit_type *type) + + Return non-zero if the type is a bool. + +.. function:: gcc_jit_function_type *\ + gcc_jit_type_is_function_ptr_type (gcc_jit_type *type) + + Return the function type if it is one or NULL. + +.. function:: gcc_jit_type *\ + gcc_jit_function_type_get_return_type (gcc_jit_function_type *function_type) + + Given a function type, return its return type. + +.. function:: ssize_t\ + gcc_jit_function_type_get_param_count (gcc_jit_function_type *function_type) + + Given a function type, return its number of parameters. + +.. function:: gcc_jit_type *\ + gcc_jit_function_type_get_param_type (gcc_jit_function_type *function_type, + size_t index) + + Given a function type, return the type of the specified parameter. + +.. function:: int\ + gcc_jit_type_is_integral (gcc_jit_type *type) + + Return non-zero if the type is an integral. + +.. function:: gcc_jit_type *\ + gcc_jit_type_is_pointer (gcc_jit_type *type) + + Return the type pointed by the pointer type or NULL if it's not a pointer. + +.. function:: gcc_jit_vector_type *\ + gcc_jit_type_is_vector (gcc_jit_type *type) + + Given a type, return a dynamic cast to a vector type or NULL. + +.. function:: gcc_jit_struct *\ + gcc_jit_type_is_struct (gcc_jit_type *type) + + Given a type, return a dynamic cast to a struct type or NULL. + +.. function:: ssize_t\ + gcc_jit_vector_type_get_num_units (gcc_jit_vector_type *vector_type) + + Given a vector type, return the number of units it contains. + +.. function:: gcc_jit_type *\ + gcc_jit_vector_type_get_element_type (gcc_jit_vector_type * vector_type) + + Given a vector type, return the type of its elements. + +.. function:: gcc_jit_type *\ + gcc_jit_type_unqualified (gcc_jit_type *type) + + Given a type, return the unqualified type, removing "const", "volatile" and + alignment qualifiers. + +.. function:: gcc_jit_field *\ + gcc_jit_struct_get_field (gcc_jit_struct *struct_type, + size_t index) + + Get a struct field by index. + +.. function:: ssize_t\ + gcc_jit_struct_get_field_count (gcc_jit_struct *struct_type) + + Get the number of fields in the struct. + + The API entrypoints related to the reflection API: + + * :c:func:`gcc_jit_function_type_get_return_type` + + * :c:func:`gcc_jit_function_type_get_param_count` + + * :c:func:`gcc_jit_function_type_get_param_type` + + * :c:func:`gcc_jit_type_unqualified` + + * :c:func:`gcc_jit_type_is_array` + + * :c:func:`gcc_jit_type_is_bool` + + * :c:func:`gcc_jit_type_is_function_ptr_type` + + * :c:func:`gcc_jit_type_is_integral` + + * :c:func:`gcc_jit_type_is_pointer` + + * :c:func:`gcc_jit_type_is_vector` + + * :c:func:`gcc_jit_vector_type_get_element_type` + + * :c:func:`gcc_jit_vector_type_get_num_units` + + * :c:func:`gcc_jit_struct_get_field` + + * :c:func:`gcc_jit_type_is_struct` + + * :c:func:`gcc_jit_struct_get_field_count` + + were added in :ref:`LIBGCCJIT_ABI_15`; you can test for their presence + using + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_REFLECTION + + .. type:: gcc_jit_case diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h index 03fa1160cf0..4a994fe7094 100644 --- a/gcc/jit/jit-recording.h +++ b/gcc/jit/jit-recording.h @@ -546,7 +546,9 @@ public: virtual bool is_bool () const = 0; virtual type *is_pointer () = 0; virtual type *is_array () = 0; + virtual struct_ *is_struct () { return NULL; } virtual bool is_void () const { return false; } + virtual vector_type *is_vector () { return NULL; } virtual bool has_known_size () const { return true; } bool is_numeric () const @@ -663,6 +665,7 @@ public: bool is_bool () const FINAL OVERRIDE { return m_other_type->is_bool (); } type *is_pointer () FINAL OVERRIDE { return m_other_type->is_pointer (); } type *is_array () FINAL OVERRIDE { return m_other_type->is_array (); } + struct_ *is_struct () FINAL OVERRIDE { return m_other_type->is_struct (); } protected: type *m_other_type; @@ -745,6 +748,8 @@ public: void replay_into (replayer *) FINAL OVERRIDE; + vector_type *is_vector () FINAL OVERRIDE { return this; } + private: string * make_debug_string () FINAL OVERRIDE; void write_reproducer (reproducer &r) FINAL OVERRIDE; @@ -951,6 +956,8 @@ public: const char *access_as_type (reproducer &r) FINAL OVERRIDE; + struct_ *is_struct () FINAL OVERRIDE { return this; } + private: string * make_debug_string () FINAL OVERRIDE; void write_reproducer (reproducer &r) FINAL OVERRIDE; diff --git a/gcc/jit/libgccjit.c b/gcc/jit/libgccjit.c index 0cc650f9810..b0cbd3a2b6a 100644 --- a/gcc/jit/libgccjit.c +++ b/gcc/jit/libgccjit.c @@ -60,6 +60,14 @@ struct gcc_jit_struct : public gcc::jit::recording::struct_ { }; +struct gcc_jit_function_type : public gcc::jit::recording::function_type +{ +}; + +struct gcc_jit_vector_type : public gcc::jit::recording::vector_type +{ +}; + struct gcc_jit_field : public gcc::jit::recording::field { }; @@ -515,6 +523,194 @@ gcc_jit_type_get_volatile (gcc_jit_type *type) return (gcc_jit_type *)type->get_volatile (); } +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::type::is_array method, in + jit-recording.c. */ + +gcc_jit_type * +gcc_jit_type_is_array (gcc_jit_type *type) +{ + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); + + return (gcc_jit_type *)type->is_array (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::type::is_bool method, in + jit-recording.c. */ + +int +gcc_jit_type_is_bool (gcc_jit_type *type) +{ + RETURN_VAL_IF_FAIL (type, FALSE, NULL, NULL, "NULL type"); + + return type->is_bool (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::type::is_pointer method, in + jit-recording.c. */ + +gcc_jit_type * +gcc_jit_type_is_pointer (gcc_jit_type *type) +{ + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); + + return (gcc_jit_type *)type->is_pointer (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::type::is_int method, in + jit-recording.c. */ + +int +gcc_jit_type_is_integral (gcc_jit_type *type) +{ + RETURN_VAL_IF_FAIL (type, FALSE, NULL, NULL, "NULL type"); + + return type->is_int (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::type::is_vector method, in + jit-recording.c. */ + +gcc_jit_vector_type * +gcc_jit_type_is_vector (gcc_jit_type *type) +{ + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); + gcc::jit::recording::vector_type *vector_type = type->is_vector (); + return (gcc_jit_vector_type *)vector_type; +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::type::is_struct method, in + jit-recording.c. */ + +gcc_jit_struct * +gcc_jit_type_is_struct (gcc_jit_type *type) +{ + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); + gcc::jit::recording::struct_ *struct_type = type->is_struct (); + return (gcc_jit_struct *)struct_type; +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::vector_type::get_num_units method, in + jit-recording.c. */ + +ssize_t +gcc_jit_vector_type_get_num_units (gcc_jit_vector_type *vector_type) +{ + RETURN_VAL_IF_FAIL (vector_type, -1, NULL, NULL, "NULL vector_type"); + return vector_type->get_num_units (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::vector_type::get_element_type method, in + jit-recording.c. */ + +gcc_jit_type * +gcc_jit_vector_type_get_element_type (gcc_jit_vector_type *vector_type) +{ + RETURN_NULL_IF_FAIL (vector_type, NULL, NULL, "NULL vector_type"); + return (gcc_jit_type *)vector_type->get_element_type (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::type::unqualified method, in + jit-recording.c. */ + +gcc_jit_type * +gcc_jit_type_unqualified (gcc_jit_type *type) +{ + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); + + return (gcc_jit_type *)type->unqualified (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::type::dyn_cast_function_type method, in + jit-recording.c. */ + +gcc_jit_function_type * +gcc_jit_type_is_function_ptr_type (gcc_jit_type *type) +{ + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); + gcc::jit::recording::type *func_ptr_type = type->dereference (); + RETURN_NULL_IF_FAIL (func_ptr_type, NULL, NULL, "NULL type"); + + return (gcc_jit_function_type *)func_ptr_type->dyn_cast_function_type (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::function_type::get_return_type method, in + jit-recording.c. */ + +gcc_jit_type * +gcc_jit_function_type_get_return_type (gcc_jit_function_type *function_type) +{ + RETURN_NULL_IF_FAIL (function_type, NULL, NULL, "NULL function_type"); + return (gcc_jit_type *)function_type->get_return_type (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::function_type::get_param_types method, in + jit-recording.c. */ + +ssize_t +gcc_jit_function_type_get_param_count (gcc_jit_function_type *function_type) +{ + RETURN_VAL_IF_FAIL (function_type, -1, NULL, NULL, "NULL function_type"); + return function_type->get_param_types ().length (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::function_type::get_param_types method, in + jit-recording.c. */ + +gcc_jit_type * +gcc_jit_function_type_get_param_type (gcc_jit_function_type *function_type, + size_t index) +{ + RETURN_NULL_IF_FAIL (function_type, NULL, NULL, "NULL function_type"); + size_t num_params = function_type->get_param_types ().length (); + gcc::jit::recording::context *ctxt = function_type->m_ctxt; + RETURN_NULL_IF_FAIL_PRINTF3 (index < num_params, + ctxt, NULL, + "index of %ld is too large (%s has %ld params)", + index, + function_type->get_debug_string (), + num_params); + return (gcc_jit_type *)function_type->get_param_types ()[index]; +} + /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the @@ -736,6 +932,37 @@ gcc_jit_struct_set_fields (gcc_jit_struct *struct_type, (gcc::jit::recording::field **)fields); } + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::fields::get_field method in + jit-recording.c. */ +extern gcc_jit_field * +gcc_jit_struct_get_field (gcc_jit_struct *struct_type, + size_t index) +{ + RETURN_NULL_IF_FAIL (struct_type, NULL, NULL, "NULL struct type"); + RETURN_NULL_IF_FAIL (struct_type->get_fields (), NULL, NULL, + "NULL struct fields"); + RETURN_NULL_IF_FAIL ((int) index < struct_type->get_fields ()->length (), + NULL, NULL, "NULL struct type"); + return (gcc_jit_field *)struct_type->get_fields ()->get_field (index); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, this calls the trivial + gcc::jit::recording::struct_::get_fields method in + jit-recording.h. */ + +ssize_t +gcc_jit_struct_get_field_count (gcc_jit_struct *struct_type) +{ + RETURN_VAL_IF_FAIL (struct_type, -1, NULL, NULL, "NULL struct type"); + return struct_type->get_fields ()->length (); +} + /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the @@ -1017,6 +1244,35 @@ gcc_jit_function_get_param (gcc_jit_function *func, int index) return static_cast <gcc_jit_param *> (func->get_param (index)); } +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::function::get_params method, in + jit-recording.h. + */ + +ssize_t +gcc_jit_function_get_param_count (gcc_jit_function *func) +{ + RETURN_VAL_IF_FAIL (func, -1, NULL, NULL, "NULL function"); + gcc::jit::recording::context *ctxt = func->m_ctxt; + JIT_LOG_FUNC (ctxt->get_logger ()); + return func->get_params ().length (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::function::get_return_type method, in + jit-recording.h. */ + +gcc_jit_type * +gcc_jit_function_get_return_type (gcc_jit_function *func) +{ + RETURN_NULL_IF_FAIL (func, NULL, NULL, "NULL function_type"); + return (gcc_jit_type *)func->get_return_type (); +} + /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h index 5c722c2c57f..1e5c5c169cb 100644 --- a/gcc/jit/libgccjit.h +++ b/gcc/jit/libgccjit.h @@ -61,6 +61,8 @@ typedef struct gcc_jit_result gcc_jit_result; +- gcc_jit_location +- gcc_jit_type +- gcc_jit_struct + +- gcc_jit_function_type + +- gcc_jit_vector_type +- gcc_jit_field +- gcc_jit_function +- gcc_jit_block @@ -97,6 +99,12 @@ typedef struct gcc_jit_field gcc_jit_field; the layout for, or an opaque type. */ typedef struct gcc_jit_struct gcc_jit_struct; +/* A gcc_jit_function_type encapsulates a function type. */ +typedef struct gcc_jit_function_type gcc_jit_function_type; + +/* A gcc_jit_vector_type encapsulates a vector type. */ +typedef struct gcc_jit_vector_type gcc_jit_vector_type; + /* A gcc_jit_function encapsulates a function: either one that you're creating yourself, or a reference to one that you're dynamically linking to within the rest of the process. */ @@ -654,6 +662,15 @@ gcc_jit_struct_set_fields (gcc_jit_struct *struct_type, int num_fields, gcc_jit_field **fields); +/* Get a field by index. */ +extern gcc_jit_field * +gcc_jit_struct_get_field (gcc_jit_struct *struct_type, + size_t index); + +/* Get the number of fields. */ +extern ssize_t +gcc_jit_struct_get_field_count (gcc_jit_struct *struct_type); + /* Unions work similarly to structs. */ extern gcc_jit_type * gcc_jit_context_new_union_type (gcc_jit_context *ctxt, @@ -1621,6 +1638,78 @@ gcc_jit_context_add_top_level_asm (gcc_jit_context *ctxt, gcc_jit_location *loc, const char *asm_stmts); +#define LIBGCCJIT_HAVE_REFLECTION + +/* Reflection functions to get the number of parameters, return type of + a function and whether a type is a bool from the C API. + + This API entrypoint was added in LIBGCCJIT_ABI_15; you can test for its + presence using + #ifdef LIBGCCJIT_HAVE_REFLECTION +*/ +/* Get the return type of a function. */ +extern gcc_jit_type * +gcc_jit_function_get_return_type (gcc_jit_function *func); + +/* Get the number of params of a function. */ +extern ssize_t +gcc_jit_function_get_param_count (gcc_jit_function *func); + +/* Get the element type of an array type or NULL if it's not an array. */ +extern gcc_jit_type * +gcc_jit_type_is_array (gcc_jit_type *type); + +/* Return non-zero if the type is a bool. */ +extern int +gcc_jit_type_is_bool (gcc_jit_type *type); + +/* Return the function type if it is one or NULL. */ +extern gcc_jit_function_type * +gcc_jit_type_is_function_ptr_type (gcc_jit_type *type); + +/* Given a function type, return its return type. */ +extern gcc_jit_type * +gcc_jit_function_type_get_return_type (gcc_jit_function_type *function_type); + +/* Given a function type, return its number of parameters. */ +extern ssize_t +gcc_jit_function_type_get_param_count (gcc_jit_function_type *function_type); + +/* Given a function type, return the type of the specified parameter. */ +extern gcc_jit_type * +gcc_jit_function_type_get_param_type (gcc_jit_function_type *function_type, + size_t index); + +/* Return non-zero if the type is an integral. */ +extern int +gcc_jit_type_is_integral (gcc_jit_type *type); + +/* Return the type pointed by the pointer type or NULL if it's not a + * pointer. */ +extern gcc_jit_type * +gcc_jit_type_is_pointer (gcc_jit_type *type); + +/* Given a type, return a dynamic cast to a vector type or NULL. */ +extern gcc_jit_vector_type * +gcc_jit_type_is_vector (gcc_jit_type *type); + +/* Given a type, return a dynamic cast to a struct type or NULL. */ +extern gcc_jit_struct * +gcc_jit_type_is_struct (gcc_jit_type *type); + +/* Given a vector type, return the number of units it contains. */ +extern ssize_t +gcc_jit_vector_type_get_num_units (gcc_jit_vector_type *vector_type); + +/* Given a vector type, return the type of its elements. */ +extern gcc_jit_type * +gcc_jit_vector_type_get_element_type (gcc_jit_vector_type *vector_type); + +/* Given a type, return the unqualified type, removing "const", "volatile" + * and alignment qualifiers. */ +extern gcc_jit_type * +gcc_jit_type_unqualified (gcc_jit_type *type); + #ifdef __cplusplus } #endif /* __cplusplus */ diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map index 337ea6c7fe4..84358763cd6 100644 --- a/gcc/jit/libgccjit.map +++ b/gcc/jit/libgccjit.map @@ -205,3 +205,24 @@ LIBGCCJIT_ABI_15 { gcc_jit_extended_asm_add_clobber; gcc_jit_context_add_top_level_asm; } LIBGCCJIT_ABI_14; + +LIBGCCJIT_ABI_16 { + global: + gcc_jit_function_get_return_type; + gcc_jit_function_get_param_count; + gcc_jit_function_type_get_return_type; + gcc_jit_function_type_get_param_count; + gcc_jit_function_type_get_param_type; + gcc_jit_type_unqualified; + gcc_jit_type_is_array; + gcc_jit_type_is_bool; + gcc_jit_type_is_function_ptr_type; + gcc_jit_type_is_integral; + gcc_jit_type_is_pointer; + gcc_jit_type_is_vector; + gcc_jit_vector_type_get_element_type; + gcc_jit_vector_type_get_num_units; + gcc_jit_struct_get_field; + gcc_jit_type_is_struct; + gcc_jit_struct_get_field_count; +} LIBGCCJIT_ABI_15; diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h index 4202eb7798b..a269144d2df 100644 --- a/gcc/testsuite/jit.dg/all-non-failing-tests.h +++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h @@ -258,6 +258,13 @@ #undef create_code #undef verify_code +/* test-reflection.c */ +#define create_code create_code_reflection +#define verify_code verify_code_reflection +#include "test-reflection.c" +#undef create_code +#undef verify_code + /* test-string-literal.c */ #define create_code create_code_string_literal #define verify_code verify_code_string_literal @@ -424,6 +431,9 @@ const struct testcase testcases[] = { {"reading_struct ", create_code_reading_struct , verify_code_reading_struct }, + {"reflection", + create_code_reflection , + verify_code_reflection }, {"string_literal", create_code_string_literal, verify_code_string_literal}, diff --git a/gcc/testsuite/jit.dg/test-reflection.c b/gcc/testsuite/jit.dg/test-reflection.c new file mode 100644 index 00000000000..46ab2c3e887 --- /dev/null +++ b/gcc/testsuite/jit.dg/test-reflection.c @@ -0,0 +1,95 @@ +#include <stdlib.h> +#include <stdio.h> + +#include "libgccjit.h" + +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + /* Do nothing. */ +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) +{ + /* Get the built-in functions. */ + gcc_jit_function *builtin_sin = + gcc_jit_context_get_builtin_function (ctxt, "sin"); + + CHECK_VALUE (gcc_jit_function_get_param_count(builtin_sin), 1); + + gcc_jit_type *double_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_DOUBLE); + CHECK_VALUE (gcc_jit_function_get_return_type(builtin_sin), double_type); + CHECK (!gcc_jit_type_is_integral(double_type)); + + gcc_jit_type *bool_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_BOOL); + CHECK (gcc_jit_type_is_bool(bool_type)); + CHECK (!gcc_jit_type_is_integral(bool_type)); + + gcc_jit_type *aligned_bool_type = + gcc_jit_type_get_aligned(gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_BOOL), 8); + CHECK (gcc_jit_type_is_bool(aligned_bool_type)); + CHECK (bool_type != aligned_bool_type); + CHECK_VALUE (gcc_jit_type_unqualified(aligned_bool_type), bool_type); + + CHECK_VALUE (gcc_jit_type_unqualified(gcc_jit_type_get_const(bool_type)), bool_type); + CHECK_VALUE (gcc_jit_type_unqualified(gcc_jit_type_get_volatile(bool_type)), bool_type); + + gcc_jit_type *int64 = + gcc_jit_context_get_int_type(ctxt, 8, 1); + CHECK (gcc_jit_type_is_integral(int64)); + gcc_jit_type *uint64 = + gcc_jit_context_get_int_type(ctxt, 8, 0); + CHECK (gcc_jit_type_is_integral(uint64)); + gcc_jit_type *int8 = + gcc_jit_context_get_int_type(ctxt, 1, 1); + CHECK (gcc_jit_type_is_integral(int8)); + gcc_jit_type *uint8 = + gcc_jit_context_get_int_type(ctxt, 1, 0); + CHECK (gcc_jit_type_is_integral(uint8)); + + CHECK (!gcc_jit_type_is_vector(double_type)); + gcc_jit_type *vec_type = gcc_jit_type_get_vector (double_type, 4); + gcc_jit_vector_type *vector_type = gcc_jit_type_is_vector(vec_type); + CHECK (vector_type); + CHECK (vec_type != double_type); + CHECK_VALUE (gcc_jit_vector_type_get_element_type(vector_type), double_type); + CHECK_VALUE (gcc_jit_vector_type_get_num_units(vector_type), 4); + + CHECK (!gcc_jit_type_is_pointer(double_type)); + CHECK_VALUE (gcc_jit_type_is_pointer(gcc_jit_type_get_pointer(double_type)), double_type); + + gcc_jit_type* params[2] = {int8, uint64}; + gcc_jit_type *function_ptr_type = gcc_jit_context_new_function_ptr_type(ctxt, NULL, int64, 2, params, 0); + CHECK (!gcc_jit_type_is_function_ptr_type (int64)); + gcc_jit_function_type *function_type = gcc_jit_type_is_function_ptr_type (function_ptr_type); + CHECK (function_type); + int param_count = gcc_jit_function_type_get_param_count(function_type); + CHECK_VALUE (param_count, 2); + gcc_jit_type *return_type = gcc_jit_function_type_get_return_type(function_type); + CHECK_VALUE (return_type, int64); + gcc_jit_type *param1 = gcc_jit_function_type_get_param_type(function_type, 0); + CHECK_VALUE (param1, int8); + gcc_jit_type *param2 = gcc_jit_function_type_get_param_type(function_type, 1); + CHECK_VALUE (param2, uint64); + + gcc_jit_field *field1 = gcc_jit_context_new_field (ctxt, NULL, uint64, "field1"); + gcc_jit_field *field2 = gcc_jit_context_new_field (ctxt, NULL, double_type, "field2"); + gcc_jit_field *fields[2] = { field1, field2 }; + gcc_jit_struct *struct_type = gcc_jit_context_new_struct_type (ctxt, NULL, "testStruct", 2, fields); + CHECK_VALUE (gcc_jit_struct_get_field_count(struct_type), 2); + CHECK_VALUE (gcc_jit_struct_get_field(struct_type, 0), field1); + CHECK_VALUE (gcc_jit_struct_get_field(struct_type, 1), field2); + CHECK (!gcc_jit_type_is_struct(double_type)); + gcc_jit_struct *struct_ty = gcc_jit_type_is_struct(gcc_jit_struct_as_type(struct_type)); + CHECK_VALUE (struct_ty, struct_type); + + CHECK (!gcc_jit_type_is_array(double_type)); + gcc_jit_type* array_type = gcc_jit_context_new_array_type(ctxt, NULL, double_type, 1); + CHECK_VALUE (gcc_jit_type_is_array(array_type), double_type); +} + -- 2.31.1