[PATCH] libgccjit: add some reflection functions in the jit C api

Antoni Boucher bouanto@zoho.com
Tue Nov 3 22:13:24 GMT 2020


I was missing a check in gcc_jit_struct_get_field, I added it in this 
new patch.

On Thu, Oct 15, 2020 at 05:52:33PM -0400, David Malcolm wrote:
>On Thu, 2020-10-15 at 13:39 -0400, Antoni Boucher wrote:
>> Thanks. I updated the patch with these changes.
>
>Thanks for patch; review below.  Sorry if it seems excessively nitpicky
>in places.
>
>> 2020-09-1  Antoni Boucher  <bouanto@zoho.com>
>>
>>     gcc/jit/
>>             PR target/96889
>>             * docs/topics/compatibility.rst (LIBGCCJIT_ABI_14): New ABI tag.
>
>15 now.
>
>>             * docs/topics/functions.rst: Add documentation for the
>>             functions gcc_jit_function_get_return_type and
>>             gcc_jit_function_get_param_count
>>             * libgccjit.c: New functions:
>>               * 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_int;
>>               * 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;
>
>This isn't valid ChangeLog format; it will fail the git hooks.
>
>>             * libgccjit.h
>
>Likewise.
>
>>             * jit-recording.h: New functions (is_struct and is_vector)
>>             * libgccjit.map (LIBGCCJIT_ABI_14): New ABI tag.
>
>15 now.
>
>>
>>     gcc/testsuite/
>>             PR target/96889
>>             * jit.dg/all-non-failing-tests.h: Add test-reflection.c.
>>             * jit.dg/test-reflection.c: New test.
>
>[...]
>
>
>> diff --git a/gcc/jit/docs/topics/functions.rst b/gcc/jit/docs/topics/functions.rst
>> index eb40d64010e..9819c28cda2 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::  size_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 documentation part of the patch is incomplete: it hasn't been
>updated to add all the new entrypoints.
>Also, the return type of gcc_jit_function_get_param_count is
>inconsistent (size_t above, but ssize_t below).
>
>
>> diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h
>> index 30e37aff387..525b8bc921d 100644
>> --- a/gcc/jit/jit-recording.h
>> +++ b/gcc/jit/jit-recording.h
>> @@ -538,7 +538,9 @@ public:
>>    virtual bool is_bool () const = 0;
>>    virtual type *is_pointer () = 0;
>>    virtual type *is_array () = 0;
>> +  virtual struct_ *is_struct () { return NULL; }
>
>Can't you use dyn_cast_struct for this?
>Or is this about looking through decorated_type? e.g. for const and
>volatile variants?
>
>I guess my question is, what is the purpose of gcc_jit_type_is_struct?
>
>>    virtual bool is_void () const { return false; }
>> +  virtual vector_type *is_vector () { return NULL; }
>
>Likewise, can't you use dyn_cast_vector_type for this?
>
>>    virtual bool has_known_size () const { return true; }
>>
>>    bool is_numeric () const
>> @@ -595,6 +597,8 @@ public:
>>    bool is_bool () const FINAL OVERRIDE;
>>    type *is_pointer () FINAL OVERRIDE { return dereference (); }
>>    type *is_array () FINAL OVERRIDE { return NULL; }
>> +  vector_type *is_vector () FINAL OVERRIDE { return NULL; }
>> +  struct_ *is_struct () FINAL OVERRIDE { return NULL; }
>
>Likewise, and this is redundant, as it's merely copying the base class
>implementation.
>
>>    bool is_void () const FINAL OVERRIDE { return m_kind == GCC_JIT_TYPE_VOID; }
>>
>>  public:
>> @@ -629,6 +633,8 @@ public:
>>    bool is_bool () const FINAL OVERRIDE { return false; }
>>    type *is_pointer () FINAL OVERRIDE { return m_other_type; }
>>    type *is_array () FINAL OVERRIDE { return NULL; }
>> +  vector_type *is_vector () FINAL OVERRIDE { return NULL; }
>> +  struct_ *is_struct () FINAL OVERRIDE { return NULL; }
>
>Likewise.
>
>
>> @@ -655,6 +661,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 (); }
>
>Aha: with a decorated type you look through the decoration.
>
>>  protected:
>>    type *m_other_type;
>> @@ -737,6 +744,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;
>> @@ -765,6 +774,8 @@ class array_type : public type
>>    bool is_bool () const FINAL OVERRIDE { return false; }
>>    type *is_pointer () FINAL OVERRIDE { return NULL; }
>>    type *is_array () FINAL OVERRIDE { return m_element_type; }
>> +  vector_type *is_vector () FINAL OVERRIDE { return NULL; }
>> +  struct_ *is_struct () FINAL OVERRIDE { return NULL; }
>
>Are these redundant?
>
>>    int num_elements () { return m_num_elements; }
>>
>>    void replay_into (replayer *) FINAL OVERRIDE;
>> @@ -799,6 +810,8 @@ public:
>>    bool is_bool () const FINAL OVERRIDE { return false; }
>>    type *is_pointer () FINAL OVERRIDE { return NULL; }
>>    type *is_array () FINAL OVERRIDE { return NULL; }
>> +  vector_type *is_vector () FINAL OVERRIDE { return NULL; }
>> +  struct_ *is_struct () FINAL OVERRIDE { return NULL; }
>
>Likewise.
>
>>    void replay_into (replayer *) FINAL OVERRIDE;
>>
>> @@ -912,6 +925,7 @@ public:
>>    bool is_bool () const FINAL OVERRIDE { return false; }
>>    type *is_pointer () FINAL OVERRIDE { return NULL; }
>>    type *is_array () FINAL OVERRIDE { return NULL; }
>> +  vector_type *is_vector () FINAL OVERRIDE { return NULL; }
>
>Likewise.
>
>>    bool has_known_size () const FINAL OVERRIDE { return m_fields != NULL; }
>>
>> @@ -943,6 +957,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 a00aefc7108..8e6a9e85ff0 100644
>> --- a/gcc/jit/libgccjit.c
>> +++ b/gcc/jit/libgccjit.c
>> @@ -21,6 +21,7 @@ along with GCC; see the file COPYING3.  If not see
>>  #include "config.h"
>>  #include "system.h"
>>  #include "coretypes.h"
>> +#include "tm.h"
>
>Why is this included?  It's not mentioned in the ChangeLog.
>
>>  #include "timevar.h"
>>  #include "typed-splay-tree.h"
>>  #include "cppbuiltin.h"
>> @@ -60,6 +61,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
>> +{
>> +};
>> +
>
>FWIW these aren't mentioned in the ChangeLog either.
>
>>  struct gcc_jit_field : public gcc::jit::recording::field
>>  {
>>  };
>> @@ -510,6 +519,197 @@ gcc_jit_type_get_volatile (gcc_jit_type *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.  */
>> +
>> +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");
>> +  int num_params = function_type->get_param_types ().length ();
>> +  gcc::jit::recording::context *ctxt = function_type->m_ctxt;
>
>Should check that index >= 0 as well (or make it unsigned).
>
>Given that gcc_jit_function_get_param_count returns ssize_t, should
>that be the type of "index"?
>
>> +  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];
>> +}
>
>[...]
>
>> +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");
>
>Similar comments as per gcc_jit_function_type_get_param_type above.
>Should check here that index is in range (>=0 and < num fields).
>
>> +  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 ();
>> +}
>> +
>
>[...]
>
>> diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h
>> index 7134841bb07..6056d00a3ea 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;
>> +
>>  /* 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.  */
>> @@ -586,6 +592,61 @@ gcc_jit_type_get_const (gcc_jit_type *type);
>>  extern gcc_jit_type *
>>  gcc_jit_type_get_volatile (gcc_jit_type *type);
>>
>> +/* Given type "T", return TRUE if the type is an array.  */
>> +extern gcc_jit_type *
>> +gcc_jit_type_is_array (gcc_jit_type *type);
>
>The comment is unclear; does this actually return the type vs NULL?
>
>As noted above, I think we need to think about what happens on
>qualified types; is stripping them the responsibility of the caller?
>Should it be?  (I'm thinking "yes", but presumably all this is
>motivated by your rust hacking).
>
>Also, there isn't a type "T" here; the param name is "type", and there
>isn't a supporting example using "T" as a placeholder.
>Maybe just lose the 'Given type "T", ' prefix here and below (unless
>giving a example).
>
>> +/* Given type "T", return TRUE if the type is a bool.  */
>> +extern int
>> +gcc_jit_type_is_bool (gcc_jit_type *type);
>
>I'd prefer "return non-zero" over "return TRUE" (here, and in various
>places below).
>
>Does this check for the "bool" type i.e.:
>  /* C++'s bool type; also C99's "_Bool" type, aka "bool" if using
>     stdbool.h.  */
>  GCC_JIT_TYPE_BOOL,
>?
>
>> +/* Given type "T", 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,
>> +				int index);
>> +
>> +/* Given type "T", 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 type "T", return TRUE if the type is an int.  */
>> +extern int
>> +gcc_jit_type_is_int (gcc_jit_type *type);
>
>I'm not sure I understand what this function does, which suggests it's
>misnamed.  The current name suggests that it checks for the C "int"
>type, whereas I believe it actually checks for an integral
>type.  Should it be:
>
>extern int
>gcc_jit_type_is_integral (gcc_jit_type *type);
>
>?
>
>What's the output?  Do you merely need nonzero/zero for boolean, or
>information on the width of the type/signedness, or whatnot?  (perhaps
>have some out params for extracting width/signedness for when it
>returns nonzero?)
>
>Looking at the testcase, it looks like it currently returns false on
>the _Bool type.  Is that correct?
>
>
>> +/* Given type "T", return the unqualified type, i.e. for a
>> + * decorated type, return the type it wraps.  */
>> +extern gcc_jit_type *
>> +gcc_jit_type_unqualified (gcc_jit_type *type);
>
>"decorated" is a term used inside the implementation, but not in the
>user-facing docs.
>
>How about:
>
>  /* Given a type, return the unqualified type, removing "const",
>"volatile"
>     and alignment qualifiers.  */
>
>or somesuch.
>
>> +/* Given type "T", return TRUE if the type is a vector type.  */
>> +extern gcc_jit_vector_type *
>> +gcc_jit_type_is_vector (gcc_jit_type *type);
>
>As above, this doesn't return TRUE, it's more of a dynamic cast.
>Likewise about responsibility for qualifiers.
>
>> +/* Given type "T", return the struct type or NULL.  */
>> +extern gcc_jit_struct *
>> +gcc_jit_type_is_struct (gcc_jit_type *type);
>
>Wording could be improved as noted above.
>
>> +/* 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);
>> +
>
>[...]
>
>> @@ -647,6 +708,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,
>> +			   int index);
>> +
>> +/* Get the number of fields.  */
>> +extern ssize_t
>> +gcc_jit_struct_get_field_count (gcc_jit_struct *struct_type);
>
>Do we need these for unions?  Or skip them for now?
>
>> @@ -740,6 +810,14 @@ gcc_jit_function_as_object (gcc_jit_function *func);
>>  extern gcc_jit_param *
>>  gcc_jit_function_get_param (gcc_jit_function *func, int index);
>>
>> +/* Get the number of params of a function.  */
>> +extern ssize_t
>> +gcc_jit_function_get_param_count (gcc_jit_function *func);
>> +
>> +/* Get the return type of a function.  */
>> +extern gcc_jit_type *
>> +gcc_jit_function_get_return_type (gcc_jit_function *func);
>
>Are these redundant if there's a way to ask a gcc_jit_function for its
>type, and then to use the gcc_jit_function_type_ functions?
>(I don't mind if they are)
>
>> @@ -1518,6 +1596,47 @@ gcc_jit_version_minor (void);
>>  extern int
>>  gcc_jit_version_patchlevel (void);
>>
>> +#define LIBGCCJIT_HAVE_gcc_jit_function_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_gcc_jit_function_reflection
>> +*/
>
>This has become a big mixture of things beyond just function
>reflection, so I think I'd prefer it if each entrypoint "funcname" had
>its own "LIBGCCJIT_HAVE_funcname" define.  Or just "REFLECTION" rather
>than "function_reflection", that's probably simpler.
>Note that the existing "HAVE_foo" defines are lowercase "foo" when it's
>an actual entrypoint named "foo", and are uppercase otherwise e.g.
>LIBGCCJIT_HAVE_SWITCH_STATEMENTS and LIBGCCJIT_HAVE_TIMING_API.
>
>> +extern gcc_jit_type *
>> +gcc_jit_function_get_return_type (gcc_jit_function *func);
>> +extern ssize_t
>> +gcc_jit_function_get_param_count (gcc_jit_function *func);
>> +extern gcc_jit_type *
>> +gcc_jit_type_is_array (gcc_jit_type *type);
>> +extern int
>> +gcc_jit_type_is_bool (gcc_jit_type *type);
>> +extern gcc_jit_function_type *
>> +gcc_jit_type_is_function_ptr_type (gcc_jit_type *type);
>> +extern gcc_jit_type *
>> +gcc_jit_function_type_get_return_type (gcc_jit_function_type *function_type);
>> +extern ssize_t
>> +gcc_jit_function_type_get_param_count (gcc_jit_function_type *function_type);
>> +extern gcc_jit_type *
>> +gcc_jit_function_type_get_param_type (gcc_jit_function_type *function_type,
>> +				int index);
>> +extern int
>> +gcc_jit_type_is_int (gcc_jit_type *type);
>> +extern gcc_jit_type *
>> +gcc_jit_type_is_pointer (gcc_jit_type *type);
>> +extern gcc_jit_vector_type *
>> +gcc_jit_type_is_vector (gcc_jit_type *type);
>> +extern gcc_jit_struct *
>> +gcc_jit_type_is_struct (gcc_jit_type *type);
>> +extern ssize_t
>> +gcc_jit_vector_type_get_num_units (gcc_jit_vector_type *vector_type);
>> +extern gcc_jit_type *
>> +gcc_jit_vector_type_get_element_type (gcc_jit_vector_type *vector_type);
>> +extern gcc_jit_type *
>> +gcc_jit_type_unqualified (gcc_jit_type *type);
>
>Is this part of the patch a duplicate copy of the various things added
>above?  Perhaps copy-and-paste error, or am I misreading this?
>
>[...]
>
>Hope this is constructive
>Dave
>
-------------- next part --------------
>From a9409a119adf55ab9989de700266702ca78e8da5 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@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  <bouanto@zoho.com>

    gcc/jit/
            PR target/96889
            * docs/topics/compatibility.rst (LIBGCCJIT_ABI_15): 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
            * 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_int,
            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_int,
            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_15): 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        |  41 +++
 gcc/jit/docs/topics/functions.rst            |  10 +
 gcc/jit/jit-recording.h                      |   7 +
 gcc/jit/libgccjit.c                          | 258 +++++++++++++++++++
 gcc/jit/libgccjit.h                          |  87 +++++++
 gcc/jit/libgccjit.map                        |  21 ++
 gcc/testsuite/jit.dg/all-non-failing-tests.h |  10 +
 gcc/testsuite/jit.dg/test-reflection.c       |  89 +++++++
 8 files changed, 523 insertions(+)
 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 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:
+
+  * :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 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.
+
 Blocks
 ------
 .. type:: gcc_jit_block
diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h
index 30e37aff387..8f494a060ef 100644
--- a/gcc/jit/jit-recording.h
+++ b/gcc/jit/jit-recording.h
@@ -538,7 +538,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
@@ -655,6 +657,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;
@@ -737,6 +740,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;
@@ -943,6 +948,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 a00aefc7108..406c62beb55 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
 {
 };
@@ -510,6 +518,197 @@ 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");
+  gcc::jit::recording::function_type *func_type =
+    func_ptr_type->dyn_cast_function_type ();
+  RETURN_NULL_IF_FAIL (func_type, NULL, NULL, "NULL type");
+
+  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");
+  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");
+  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");
+  int 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 %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");
+  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);
+}
+
+/* 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
@@ -1012,6 +1241,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");
+    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 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;
+
 /* 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.  */
@@ -647,6 +653,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,
+			   int 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,
@@ -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);
+
+/* 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,
+				int 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 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;
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..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);
+}
+
-- 
2.29.2



More information about the Gcc-patches mailing list