From e025f95f4790ae861e709caf23cbc0723c1a3804 Mon Sep 17 00:00:00 2001 From: Antoni Boucher Date: Mon, 23 Jan 2023 17:21:15 -0500 Subject: [PATCH] libgccjit: Add support for machine-dependent builtins gcc/ChangeLog: PR jit/108762 * config/i386/i386-builtins.cc: New function (clear_builtin_types). gcc/jit/ChangeLog: PR jit/108762 * docs/topics/compatibility.rst (LIBGCCJIT_ABI_26): New ABI tag. * docs/topics/functions.rst: Add documentation for the function gcc_jit_context_get_target_builtin_function. * dummy-frontend.cc: Include headers target.h, jit-recording.h, print-tree.h, unordered_map and string, new variables (target_builtins, target_function_types, and target_builtins_ctxt), new function (tree_type_to_jit_type). * jit-builtins.cc: Specify that the function types are not from target builtins. * jit-playback.cc: New argument is_target_builtin to new_function. * jit-playback.h: New argument is_target_builtin to new_function. * jit-recording.cc: New argument is_target_builtin to new_function_type, function_type constructor and function constructor, new function (get_target_builtin_function). * jit-recording.h: Include headers string and unordered_map, new variable target_function_types, new argument is_target_builtin to new_function_type, function_type and function, new functions (get_target_builtin_function, copy). * libgccjit.cc: New function (gcc_jit_context_get_target_builtin_function). * libgccjit.h: New function (gcc_jit_context_get_target_builtin_function). * libgccjit.map: New functions (gcc_jit_context_get_target_builtin_function). gcc/testsuite: PR jit/108762 * jit.dg/all-non-failing-tests.h: New test test-target-builtins.c. * jit.dg/test-target-builtins.c: New test. --- gcc/config/i386/i386-builtins.cc | 18 ++ gcc/jit/docs/topics/compatibility.rst | 9 + gcc/jit/docs/topics/functions.rst | 19 ++ gcc/jit/dummy-frontend.cc | 204 ++++++++++++++++++- gcc/jit/jit-builtins.cc | 6 +- gcc/jit/jit-playback.cc | 11 +- gcc/jit/jit-playback.h | 5 +- gcc/jit/jit-recording.cc | 76 ++++++- gcc/jit/jit-recording.h | 111 +++++++++- gcc/jit/libgccjit.cc | 18 ++ gcc/jit/libgccjit.h | 13 ++ gcc/jit/libgccjit.map | 4 + gcc/testsuite/jit.dg/all-non-failing-tests.h | 3 + gcc/testsuite/jit.dg/test-target-builtins.c | 77 +++++++ 14 files changed, 554 insertions(+), 20 deletions(-) create mode 100644 gcc/testsuite/jit.dg/test-target-builtins.c diff --git a/gcc/config/i386/i386-builtins.cc b/gcc/config/i386/i386-builtins.cc index 42fc3751676..5cc1d6f4d2e 100644 --- a/gcc/config/i386/i386-builtins.cc +++ b/gcc/config/i386/i386-builtins.cc @@ -225,6 +225,22 @@ static GTY(()) tree ix86_builtins[(int) IX86_BUILTIN_MAX]; struct builtin_isa ix86_builtins_isa[(int) IX86_BUILTIN_MAX]; +static void +clear_builtin_types (void) +{ + for (int i = 0 ; i < IX86_BT_LAST_CPTR + 1 ; i++) + ix86_builtin_type_tab[i] = NULL; + + for (int i = 0 ; i < IX86_BUILTIN_MAX ; i++) + { + ix86_builtins[i] = NULL; + ix86_builtins_isa[i].set_and_not_built_p = true; + } + + for (int i = 0 ; i < IX86_BT_LAST_ALIAS + 1 ; i++) + ix86_builtin_func_type_tab[i] = NULL; +} + tree get_ix86_builtin (enum ix86_builtins c) { return ix86_builtins[c]; @@ -1483,6 +1499,8 @@ ix86_init_builtins (void) { tree ftype, decl; + clear_builtin_types (); + ix86_init_builtin_types (); /* Builtins to get CPU type and features. */ diff --git a/gcc/jit/docs/topics/compatibility.rst b/gcc/jit/docs/topics/compatibility.rst index ebede440ee4..764de23341e 100644 --- a/gcc/jit/docs/topics/compatibility.rst +++ b/gcc/jit/docs/topics/compatibility.rst @@ -378,3 +378,12 @@ alignment of a variable: -------------------- ``LIBGCCJIT_ABI_25`` covers the addition of :func:`gcc_jit_type_get_restrict` + +.. _LIBGCCJIT_ABI_26: + +``LIBGCCJIT_ABI_26`` +-------------------- + +``LIBGCCJIT_ABI_26`` covers the addition of a function to get target builtins: + + * :func:`gcc_jit_context_get_target_builtin_function` diff --git a/gcc/jit/docs/topics/functions.rst b/gcc/jit/docs/topics/functions.rst index cf5cb716daf..e9b77fdb892 100644 --- a/gcc/jit/docs/topics/functions.rst +++ b/gcc/jit/docs/topics/functions.rst @@ -140,6 +140,25 @@ Functions uses such a parameter will lead to an error being emitted within the context. +.. function:: gcc_jit_function *\ + gcc_jit_context_get_target_builtin_function (gcc_jit_context *ctxt,\ + const char *name) + + Get the :type:`gcc_jit_function` for the built-in function with the + given name. For example: + + .. code-block:: c + + gcc_jit_function *fn + = gcc_jit_context_get_target_builtin_function (ctxt, "__builtin_ia32_pmuldq512_mask"); + + .. note:: Due to technical limitations with how libgccjit interacts with + the insides of GCC, not all built-in functions are supported. More + precisely, not all types are supported for parameters of built-in + functions from libgccjit. Attempts to get a built-in function that + uses such a parameter will lead to an error being emitted within + the context. + .. function:: gcc_jit_object *\ gcc_jit_function_as_object (gcc_jit_function *func) diff --git a/gcc/jit/dummy-frontend.cc b/gcc/jit/dummy-frontend.cc index a729086bafb..3ca9702d429 100644 --- a/gcc/jit/dummy-frontend.cc +++ b/gcc/jit/dummy-frontend.cc @@ -20,6 +20,7 @@ along with GCC; see the file COPYING3. If not see #include "config.h" #include "system.h" #include "coretypes.h" +#include "target.h" #include "jit-playback.h" #include "stor-layout.h" #include "debug.h" @@ -29,8 +30,14 @@ along with GCC; see the file COPYING3. If not see #include "options.h" #include "stringpool.h" #include "attribs.h" +#include "jit-recording.h" +#include "print-tree.h" #include +#include +#include + +using namespace gcc::jit; /* Attribute handling. */ @@ -86,6 +93,11 @@ static const struct attribute_spec::exclusions attr_const_pure_exclusions[] = ATTR_EXCL (NULL, false, false, false) }; +hash_map target_builtins{}; +std::unordered_map target_function_types +{}; +recording::context target_builtins_ctxt{NULL}; + /* Table of machine-independent attributes supported in libgccjit. */ const struct attribute_spec jit_attribute_table[] = { @@ -594,6 +606,7 @@ jit_langhook_init (void) build_common_tree_nodes (false); + target_builtins.empty (); build_common_builtin_nodes (); /* The default precision for floating point numbers. This is used @@ -601,6 +614,8 @@ jit_langhook_init (void) eventually be controllable by a command line option. */ mpfr_set_default_prec (256); + targetm.init_builtins (); + return true; } @@ -668,11 +683,198 @@ jit_langhook_type_for_mode (machine_mode mode, int unsignedp) return NULL; } -/* Record a builtin function. We just ignore builtin functions. */ +recording::type* tree_type_to_jit_type (tree type) +{ + if (TREE_CODE (type) == VECTOR_TYPE) + { + tree inner_type = TREE_TYPE (type); + recording::type* element_type = tree_type_to_jit_type (inner_type); + poly_uint64 size = TYPE_VECTOR_SUBPARTS (type); + long constant_size = size.to_constant (); + if (element_type != NULL) + return element_type->get_vector (constant_size); + return NULL; + } + if (TREE_CODE (type) == REFERENCE_TYPE) + // For __builtin_ms_va_start. + // FIXME: wrong type. + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_VOID); + if (TREE_CODE (type) == RECORD_TYPE) + // For __builtin_sysv_va_copy. + // FIXME: wrong type. + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_VOID); + for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++) + if (type == FLOATN_NX_TYPE_NODE (i)) + // FIXME: wrong type. + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_VOID); + if (type == void_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_VOID); + else if (type == ptr_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_VOID_PTR); + else if (type == const_ptr_type_node) + { + // Void const ptr. + recording::type* result = + new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_VOID_PTR); + return new recording::memento_of_get_const (result); + } + else if (type == unsigned_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_UNSIGNED_INT); + else if (type == long_unsigned_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_UNSIGNED_LONG); + else if (type == integer_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_INT); + else if (type == long_integer_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_LONG); + else if (type == long_long_integer_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_LONG_LONG); + else if (type == signed_char_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_SIGNED_CHAR); + else if (type == char_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_CHAR); + else if (type == unsigned_intQI_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_UINT8_T); + else if (type == short_integer_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_SHORT); + else if (type == short_unsigned_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_UNSIGNED_SHORT); + else if (type == complex_float_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_COMPLEX_FLOAT); + else if (type == complex_double_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_COMPLEX_DOUBLE); + else if (type == complex_long_double_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE); + else if (type == float_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_FLOAT); + else if (type == double_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_DOUBLE); + else if (type == long_double_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_LONG_DOUBLE); + else if (type == bfloat16_type_node) + // FIXME: wrong type. + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_VOID); + else if (type == dfloat128_type_node) + // FIXME: wrong type. + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_VOID); + else if (type == long_long_unsigned_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_UNSIGNED_LONG_LONG); + else if (type == boolean_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_BOOL); + else if (type == size_type_node) + return new recording::memento_of_get_type (&target_builtins_ctxt, + GCC_JIT_TYPE_SIZE_T); + else if (TREE_CODE (type) == POINTER_TYPE) + { + tree inner_type = TREE_TYPE (type); + recording::type* element_type = tree_type_to_jit_type (inner_type); + return element_type->get_pointer (); + } + else + { + // Attempt to find an unqualified type when the current type has qualifiers. + tree tp = TYPE_MAIN_VARIANT (type); + for ( ; tp != NULL ; tp = TYPE_NEXT_VARIANT (tp)) + { + if (TYPE_QUALS (tp) == 0 && type != tp) + { + recording::type* result = tree_type_to_jit_type (tp); + if (result != NULL) + { + if (TYPE_READONLY (tp)) + result = new recording::memento_of_get_const (result); + if (TYPE_VOLATILE (tp)) + result = new recording::memento_of_get_volatile (result); + return result; + } + } + } + + fprintf (stderr, "Unknown type:\n"); + debug_tree (type); + abort (); + } + + return NULL; +} + +/* Record a builtin function. We save their types to be able to check types + in recording and for reflection. */ static tree jit_langhook_builtin_function (tree decl) { + if (TREE_CODE (decl) == FUNCTION_DECL) + { + const char* name = IDENTIFIER_POINTER (DECL_NAME (decl)); + target_builtins.put (name, decl); + + std::string string_name (name); + if (target_function_types.count (string_name) == 0) + { + tree function_type = TREE_TYPE (decl); + tree arg = TYPE_ARG_TYPES (function_type); + bool is_variadic = false; + + auto_vec param_types; + + while (arg != void_list_node) + { + if (arg == NULL) + { + is_variadic = true; + break; + } + if (arg != void_list_node) + { + recording::type* arg_type = tree_type_to_jit_type (TREE_VALUE (arg)); + if (arg_type == NULL) + return decl; + param_types.safe_push (arg_type); + } + arg = TREE_CHAIN (arg); + } + + tree result_type = TREE_TYPE (function_type); + recording::type* return_type = tree_type_to_jit_type (result_type); + + if (return_type == NULL) + return decl; + + recording::function_type* func_type = + new recording::function_type (&target_builtins_ctxt, return_type, + param_types.length (), + param_types.address (), is_variadic, + false); + + target_function_types[string_name] = func_type; + } + } return decl; } diff --git a/gcc/jit/jit-builtins.cc b/gcc/jit/jit-builtins.cc index fdd0739789d..63628beac81 100644 --- a/gcc/jit/jit-builtins.cc +++ b/gcc/jit/jit-builtins.cc @@ -215,7 +215,8 @@ builtins_manager::make_builtin_function (enum built_in_function builtin_id) param_types.length (), params, func_type->is_variadic (), - builtin_id); + builtin_id, + false); delete[] params; /* PR/64020 - If the client code is using builtin cos or sin, @@ -582,7 +583,8 @@ builtins_manager::make_fn_type (enum jit_builtin_type, result = m_ctxt->new_function_type (return_type, num_args, param_types, - is_variadic); + is_variadic, + false); error: delete[] param_types; diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc index 18cc4da25b8..d71ee2b61a7 100644 --- a/gcc/jit/jit-playback.cc +++ b/gcc/jit/jit-playback.cc @@ -509,7 +509,8 @@ new_function (location *loc, const char *name, const auto_vec *params, int is_variadic, - enum built_in_function builtin_id) + enum built_in_function builtin_id, + int is_target_builtin) { int i; param *param; @@ -543,6 +544,14 @@ new_function (location *loc, DECL_RESULT (fndecl) = resdecl; DECL_CONTEXT (resdecl) = fndecl; + if (is_target_builtin) + { + tree *decl = target_builtins.get (name); + if (decl != NULL) + fndecl = *decl; + else + add_error (loc, "cannot find target builtin %s", name); + } if (builtin_id) { gcc_assert (loc == NULL); diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h index f9e29d0baec..06128b4d640 100644 --- a/gcc/jit/jit-playback.h +++ b/gcc/jit/jit-playback.h @@ -104,7 +104,8 @@ public: const char *name, const auto_vec *params, int is_variadic, - enum built_in_function builtin_id); + enum built_in_function builtin_id, + int is_target_builtin); lvalue * new_global (location *loc, @@ -818,4 +819,6 @@ extern playback::context *active_playback_ctxt; } // namespace gcc +extern hash_map target_builtins; + #endif /* JIT_PLAYBACK_H */ diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc index 9b5b8005ebe..d63293bd642 100644 --- a/gcc/jit/jit-recording.cc +++ b/gcc/jit/jit-recording.cc @@ -933,14 +933,16 @@ recording::function_type * recording::context::new_function_type (recording::type *return_type, int num_params, recording::type **param_types, - int is_variadic) + int is_variadic, + int is_target_builtin) { recording::function_type *fn_type = new function_type (this, return_type, num_params, param_types, - is_variadic); + is_variadic, + is_target_builtin); record (fn_type); return fn_type; } @@ -962,7 +964,8 @@ recording::context::new_function_ptr_type (recording::location *, /* unused loc = new_function_type (return_type, num_params, param_types, - is_variadic); + is_variadic, + false); /* Return a pointer-type to the function type. */ return fn_type->get_pointer (); @@ -1005,7 +1008,7 @@ recording::context::new_function (recording::location *loc, loc, kind, return_type, new_string (name), num_params, params, is_variadic, - builtin_id); + builtin_id, false); record (result); m_functions.safe_push (result); @@ -1044,6 +1047,53 @@ recording::context::get_builtin_function (const char *name) return bm->get_builtin_function (name); } +/* Create a recording::function instance for a target-specific builtin. + + Implements the post-error-checking part of + gcc_jit_context_get_target_builtin_function. */ + +recording::function * +recording::context::get_target_builtin_function (const char *name) +{ + const char *asm_name = name; + if (target_function_types.count (name) == 0) + { + fprintf (stderr, "Cannot find target builtin %s\n", name); + return NULL; + } + + recording::function_type* func_type = target_function_types[name] + ->copy (this)->dyn_cast_function_type (); + const vec& param_types = func_type->get_param_types (); + recording::param **params = new recording::param *[param_types.length ()]; + + int i; + recording::type *param_type; + FOR_EACH_VEC_ELT (param_types, i, param_type) + { + char buf[16]; + snprintf (buf, 16, "arg%d", i); + params[i] = new_param (NULL, + param_type, + buf); + } + + recording::function *result = + new recording::function (this, + NULL, + GCC_JIT_FUNCTION_IMPORTED, + func_type->get_return_type (), + new_string (asm_name), + param_types.length (), + params, + func_type->is_variadic (), + BUILT_IN_NONE, + true); + record (result); + + return result; +} + /* Create a recording::global instance and add it to this context's list of mementos. @@ -3145,11 +3195,13 @@ recording::function_type::function_type (context *ctxt, type *return_type, int num_params, type **param_types, - int is_variadic) + int is_variadic, + int is_target_builtin) : type (ctxt), m_return_type (return_type), m_param_types (), - m_is_variadic (is_variadic) + m_is_variadic (is_variadic), + m_is_target_builtin (is_target_builtin) { for (int i = 0; i< num_params; i++) m_param_types.safe_push (param_types[i]); @@ -4091,7 +4143,8 @@ recording::function::function (context *ctxt, int num_params, recording::param **params, int is_variadic, - enum built_in_function builtin_id) + enum built_in_function builtin_id, + int is_target_builtin) : memento (ctxt), m_loc (loc), m_kind (kind), @@ -4102,7 +4155,8 @@ recording::function::function (context *ctxt, m_builtin_id (builtin_id), m_locals (), m_blocks (), - m_fn_ptr_type (NULL) + m_fn_ptr_type (NULL), + m_is_target_builtin (is_target_builtin) { for (int i = 0; i< num_params; i++) { @@ -4161,7 +4215,8 @@ recording::function::replay_into (replayer *r) m_name->c_str (), ¶ms, m_is_variadic, - m_builtin_id)); + m_builtin_id, + m_is_target_builtin)); } /* Create a recording::local instance and add it to @@ -4394,7 +4449,8 @@ recording::function::get_address (recording::location *loc) = m_ctxt->new_function_type (m_return_type, m_params.length (), param_types.address (), - m_is_variadic); + m_is_variadic, + m_is_target_builtin); m_fn_ptr_type = fn_type->get_pointer (); } gcc_assert (m_fn_ptr_type); diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h index 4a8082991fb..81544d6f005 100644 --- a/gcc/jit/jit-recording.h +++ b/gcc/jit/jit-recording.h @@ -24,12 +24,17 @@ along with GCC; see the file COPYING3. If not see #include "jit-common.h" #include "jit-logging.h" +#include +#include + class timer; +extern std::unordered_map + target_function_types; + namespace gcc { namespace jit { - extern const char * const unary_op_reproducer_strings[]; extern const char * const binary_op_reproducer_strings[]; @@ -116,7 +121,8 @@ public: new_function_type (type *return_type, int num_params, type **param_types, - int is_variadic); + int is_variadic, + int is_target_builtin); type * new_function_ptr_type (location *loc, @@ -143,6 +149,9 @@ public: function * get_builtin_function (const char *name); + function * + get_target_builtin_function (const char *name); + lvalue * new_global (location *loc, enum gcc_jit_global_kind kind, @@ -540,6 +549,8 @@ public: these types. */ virtual size_t get_size () { gcc_unreachable (); } + virtual type* copy (context* ctxt) = 0; + /* Dynamic casts. */ virtual function_type *dyn_cast_function_type () { return NULL; } virtual function_type *as_a_function_type() { gcc_unreachable (); return NULL; } @@ -615,6 +626,11 @@ public: size_t get_size () final override; + type* copy (context* ctxt) final override + { + return ctxt->get_type (m_kind); + } + bool accepts_writes_from (type *rtype) final override { if (m_kind == GCC_JIT_TYPE_VOID_PTR) @@ -666,6 +682,13 @@ public: type *dereference () final override { return m_other_type; } + type* copy (context* ctxt) final override + { + type* result = new memento_of_get_pointer (m_other_type->copy (ctxt)); + ctxt->record (result); + return result; + } + size_t get_size () final override; bool accepts_writes_from (type *rtype) final override; @@ -726,6 +749,13 @@ public: return false; } + type* copy (context* ctxt) final override + { + type* result = new memento_of_get_const (m_other_type->copy (ctxt)); + ctxt->record (result); + return result; + } + /* Strip off the "const", giving the underlying type. */ type *unqualified () final override { return m_other_type; } @@ -759,6 +789,13 @@ public: return m_other_type->is_same_type_as (other->is_volatile ()); } + type* copy (context* ctxt) final override + { + type* result = new memento_of_get_volatile (m_other_type->copy (ctxt)); + ctxt->record (result); + return result; + } + /* Strip off the "volatile", giving the underlying type. */ type *unqualified () final override { return m_other_type; } @@ -785,6 +822,13 @@ public: return m_other_type->is_same_type_as (other->is_restrict ()); } + type* copy (context* ctxt) final override + { + type* result = new memento_of_get_restrict (m_other_type->copy (ctxt)); + ctxt->record (result); + return result; + } + /* Strip off the "restrict", giving the underlying type. */ type *unqualified () final override { return m_other_type; } @@ -805,6 +849,14 @@ public: : decorated_type (other_type), m_alignment_in_bytes (alignment_in_bytes) {} + type* copy (context* ctxt) final override + { + type* result = new memento_of_get_aligned (m_other_type->copy (ctxt), + m_alignment_in_bytes); + ctxt->record (result); + return result; + } + /* Strip off the alignment, giving the underlying type. */ type *unqualified () final override { return m_other_type; } @@ -826,6 +878,13 @@ public: : decorated_type (other_type), m_num_units (num_units) {} + type* copy (context* ctxt) final override + { + type* result = new vector_type (m_other_type->copy (ctxt), m_num_units); + ctxt->record (result); + return result; + } + size_t get_num_units () const { return m_num_units; } vector_type *dyn_cast_vector_type () final override { return this; } @@ -868,6 +927,14 @@ class array_type : public type type *dereference () final override; + type* copy (context* ctxt) final override + { + type* result = new array_type (ctxt, m_loc, m_element_type->copy (ctxt), + m_num_elements); + ctxt->record (result); + return result; + } + bool is_int () const final override { return false; } bool is_float () const final override { return false; } bool is_bool () const final override { return false; } @@ -895,7 +962,8 @@ public: type *return_type, int num_params, type **param_types, - int is_variadic); + int is_variadic, + int is_target_builtin); type *dereference () final override; function_type *dyn_cast_function_type () final override { return this; } @@ -903,6 +971,20 @@ public: bool is_same_type_as (type *other) final override; + type* copy (context* ctxt) final override + { + auto_vec new_params{}; + for (size_t i = 0; i < m_param_types.length (); i++) + new_params.safe_push (m_param_types[i]->copy (ctxt)); + + type* result = new function_type (ctxt, m_return_type->copy (ctxt), + m_param_types.length (), + new_params.address (), + m_is_variadic, m_is_target_builtin); + ctxt->record (result); + return result; + } + bool is_int () const final override { return false; } bool is_float () const final override { return false; } bool is_bool () const final override { return false; } @@ -931,6 +1013,7 @@ private: type *m_return_type; auto_vec m_param_types; int m_is_variadic; + int m_is_target_builtin; }; class field : public memento @@ -1032,9 +1115,11 @@ public: return static_cast (m_playback_obj); } -private: +protected: location *m_loc; string *m_name; + +private: fields *m_fields; }; @@ -1047,6 +1132,13 @@ public: struct_ *dyn_cast_struct () final override { return this; } + type* copy (context* ctxt) final override + { + type* result = new struct_ (ctxt, m_loc, m_name); + ctxt->record (result); + return result; + } + type * as_type () { return this; } @@ -1094,6 +1186,13 @@ public: void replay_into (replayer *r) final override; + type* copy (context* ctxt) final override + { + type* result = new union_ (ctxt, m_loc, m_name); + ctxt->record (result); + return result; + } + bool is_union () const final override { return true; } private: @@ -1302,7 +1401,8 @@ public: int num_params, param **params, int is_variadic, - enum built_in_function builtin_id); + enum built_in_function builtin_id, + int is_target_builtin); void replay_into (replayer *r) final override; @@ -1357,6 +1457,7 @@ private: auto_vec m_locals; auto_vec m_blocks; type *m_fn_ptr_type; + int m_is_target_builtin; }; class block : public memento diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc index 0451b4df7f9..9ce4941e6b9 100644 --- a/gcc/jit/libgccjit.cc +++ b/gcc/jit/libgccjit.cc @@ -1760,6 +1760,24 @@ gcc_jit_context_new_array_constructor (gcc_jit_context *ctxt, reinterpret_cast(values)); } +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::context::get_target_builtin_function method, in + jit-recording.c. */ + +gcc_jit_function * +gcc_jit_context_get_target_builtin_function (gcc_jit_context *ctxt, + const char *name) +{ + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + JIT_LOG_FUNC (ctxt->get_logger ()); + RETURN_NULL_IF_FAIL (name, ctxt, NULL, "NULL name"); + + return static_cast ( + ctxt->get_target_builtin_function (name)); +} + /* Public entrypoint. See description in libgccjit.h. */ extern gcc_jit_lvalue * diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h index 749f6c24177..b70723fd1f6 100644 --- a/gcc/jit/libgccjit.h +++ b/gcc/jit/libgccjit.h @@ -1030,6 +1030,19 @@ extern gcc_jit_lvalue * gcc_jit_global_set_initializer_rvalue (gcc_jit_lvalue *global, gcc_jit_rvalue *init_value); +#define LIBGCCJIT_HAVE_gcc_jit_context_get_target_builtin_function + +/* Create a reference to a machine-specific builtin function (sometimes called + intrinsic functions). + + This API entrypoint was added in LIBGCCJIT_ABI_25; you can test for its + presence using + #ifdef LIBGCCJIT_HAVE_gcc_jit_context_get_target_builtin_function +*/ +extern gcc_jit_function * +gcc_jit_context_get_target_builtin_function (gcc_jit_context *ctxt, + const char *name); + #define LIBGCCJIT_HAVE_gcc_jit_global_set_initializer /* Set an initial value for a global, which must be an array of diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map index 8b90a0e2ff3..5be7a63557b 100644 --- a/gcc/jit/libgccjit.map +++ b/gcc/jit/libgccjit.map @@ -276,3 +276,7 @@ LIBGCCJIT_ABI_25 { global: gcc_jit_type_get_restrict; } LIBGCCJIT_ABI_24; + +LIBGCCJIT_ABI_26 { + gcc_jit_context_get_target_builtin_function; +} LIBGCCJIT_ABI_25; diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h index e762563f9bd..9875cbe623c 100644 --- a/gcc/testsuite/jit.dg/all-non-failing-tests.h +++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h @@ -322,6 +322,9 @@ /* test-setting-alignment.c: This can't be in the testcases array as it is target-specific. */ +/* test-target-builtins.c: This can't be in the testcases array as it + is target-specific. */ + /* test-string-literal.c */ #define create_code create_code_string_literal #define verify_code verify_code_string_literal diff --git a/gcc/testsuite/jit.dg/test-target-builtins.c b/gcc/testsuite/jit.dg/test-target-builtins.c new file mode 100644 index 00000000000..0ffb48e97f6 --- /dev/null +++ b/gcc/testsuite/jit.dg/test-target-builtins.c @@ -0,0 +1,77 @@ +/* { dg-do compile { target x86_64-*-* } } */ + +#include +#include + +#include "libgccjit.h" + +#define TEST_PROVIDES_MAIN +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + CHECK_NON_NULL (gcc_jit_context_get_target_builtin_function (ctxt, "__builtin_ia32_xgetbv")); + gcc_jit_function *builtin_eh_pointer = gcc_jit_context_get_target_builtin_function (ctxt, "__builtin_eh_pointer"); + CHECK_NON_NULL (builtin_eh_pointer); + + gcc_jit_type *int_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + gcc_jit_type *void_ptr = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR); + gcc_jit_function *func_main = + gcc_jit_context_new_function (ctxt, NULL, + GCC_JIT_FUNCTION_EXPORTED, + int_type, + "main", + 0, NULL, + 0); + gcc_jit_rvalue *zero = gcc_jit_context_zero (ctxt, int_type); + gcc_jit_block *block = gcc_jit_function_new_block (func_main, NULL); + gcc_jit_lvalue *variable = gcc_jit_function_new_local(func_main, NULL, void_ptr, "variable"); + gcc_jit_block_add_assignment (block, NULL, variable, + gcc_jit_context_new_call (ctxt, NULL, builtin_eh_pointer, 1, &zero)); + gcc_jit_block_end_with_return (block, NULL, zero); +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) +{ + CHECK_NON_NULL (result); +} + +int +main (int argc, char **argv) +{ + /* This is the same as the main provided by harness.h, but it first create a dummy context and compile + in order to add the target builtins to libgccjit's internal state. */ + gcc_jit_context *ctxt; + ctxt = gcc_jit_context_acquire (); + if (!ctxt) + { + fail ("gcc_jit_context_acquire failed"); + return -1; + } + gcc_jit_result *result; + result = gcc_jit_context_compile (ctxt); + gcc_jit_result_release (result); + gcc_jit_context_release (ctxt); + + int i; + + for (i = 1; i <= 5; i++) + { + snprintf (test, sizeof (test), + "%s iteration %d of %d", + extract_progname (argv[0]), + i, 5); + + //printf ("ITERATION %d\n", i); + test_jit (argv[0], NULL); + //printf ("\n"); + } + + totals (); + + return 0; +} -- 2.42.1