.. _LIBGCCJIT_ABI_15:
``LIBGCCJIT_ABI_15``
------------------------
+--------------------
``LIBGCCJIT_ABI_15`` covers the addition of API entrypoints for directly
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_dyncast_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_dyncast_vector`
+
+ * :func:`gcc_jit_type_unqualified`
+
+ * :func:`gcc_jit_type_dyncast_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`
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 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_16`; you can test for their presence
+ using
+
+ .. code-block:: c
+
+ #ifdef LIBGCCJIT_HAVE_REFLECTION
+
+ .. type:: gcc_jit_case
+
Blocks
------
.. type:: gcc_jit_block
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_dyncast_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_dyncast_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:: size_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_dyncast_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:: size_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:: size_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_dyncast_array`
+
+ * :c:func:`gcc_jit_type_is_bool`
+
+ * :c:func:`gcc_jit_type_dyncast_function_ptr_type`
+
+ * :c:func:`gcc_jit_type_is_integral`
+
+ * :c:func:`gcc_jit_type_is_pointer`
+
+ * :c:func:`gcc_jit_type_dyncast_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_16`; you can test for their presence
+ using
+
+ .. code-block:: c
+
+ #ifdef LIBGCCJIT_HAVE_REFLECTION
+
+ .. type:: gcc_jit_case
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
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;
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;
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;
{
};
+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
{
};
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_dyncast_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_dyncast_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. */
+
+size_t
+gcc_jit_vector_type_get_num_units (gcc_jit_vector_type *vector_type)
+{
+ RETURN_VAL_IF_FAIL (vector_type, 0, 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_dyncast_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 ();
+ if (!func_ptr_type)
+ {
+ return NULL;
+ }
+
+ 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. */
+
+size_t
+gcc_jit_function_type_get_param_count (gcc_jit_function_type *function_type)
+{
+ RETURN_VAL_IF_FAIL (function_type, 0, 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
(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");
+ size_t num_fields = struct_type->get_fields ()->length ();
+ RETURN_NULL_IF_FAIL_PRINTF3 (index < num_fields,
+ NULL, NULL,
+ "index of %ld is too large (%s has %ld fields)",
+ index,
+ struct_type->get_debug_string (),
+ 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. */
+
+size_t
+gcc_jit_struct_get_field_count (gcc_jit_struct *struct_type)
+{
+ RETURN_VAL_IF_FAIL (struct_type, 0, 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
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.
+ */
+
+size_t
+gcc_jit_function_get_param_count (gcc_jit_function *func)
+{
+ RETURN_VAL_IF_FAIL (func, 0, 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
+- 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
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. */
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 size_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,
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_16; 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 size_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_dyncast_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_dyncast_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 size_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_dyncast_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 size_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 */
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_dyncast_array;
+ gcc_jit_type_is_bool;
+ gcc_jit_type_dyncast_function_ptr_type;
+ gcc_jit_type_is_integral;
+ gcc_jit_type_is_pointer;
+ gcc_jit_type_dyncast_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;
#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
{"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},
--- /dev/null
+#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_dyncast_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_dyncast_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_dyncast_function_ptr_type (int64));
+ gcc_jit_function_type *function_type = gcc_jit_type_dyncast_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_dyncast_array(double_type));
+ gcc_jit_type* array_type = gcc_jit_context_new_array_type(ctxt, NULL, double_type, 1);
+ CHECK_VALUE (gcc_jit_type_dyncast_array(array_type), double_type);
+}
+
projects / thirdparty / gcc.git / commitdiff
