From b1b06887e519ae100cb31888f451f7aa0bc55dbe Mon Sep 17 00:00:00 2001 From: Antoni Boucher Date: Sun, 9 May 2021 20:14:37 -0400 Subject: [PATCH] Add support for types used by atomic builtins [PR96066] [PR96067] 2021-05-17 Antoni Boucher gcc/jit/ PR target/PR96066 PR target/PR96067 * jit-builtins.c: Implement missing types for builtins. * jit-recording.c: Allow sending a volatile const void * as argument. * jit-recording.h: New enum decorated_type_variant, new function type::get_variant, and new field type::m_variant. gcc/testsuite/ PR target/PR96066 PR target/PR96067 * jit.dg/all-non-failing-tests.h: Add test-builtin-types.c. * jit.dg/test-builtin-types.c: New test. --- gcc/jit/jit-builtins.c | 10 ++--- gcc/jit/jit-recording.c | 14 ++++++- gcc/jit/jit-recording.h | 31 ++++++++++++--- gcc/testsuite/jit.dg/all-non-failing-tests.h | 12 +++++- gcc/testsuite/jit.dg/test-builtin-types.c | 41 ++++++++++++++++++++ 5 files changed, 94 insertions(+), 14 deletions(-) create mode 100644 gcc/testsuite/jit.dg/test-builtin-types.c diff --git a/gcc/jit/jit-builtins.c b/gcc/jit/jit-builtins.c index 1ea96f4e025..c279dd858f9 100644 --- a/gcc/jit/jit-builtins.c +++ b/gcc/jit/jit-builtins.c @@ -541,11 +541,11 @@ builtins_manager::make_primitive_type (enum jit_builtin_type type_id) // case BT_DFLOAT128: // case BT_VALIST_REF: // case BT_VALIST_ARG: - // case BT_I1: - // case BT_I2: - // case BT_I4: - // case BT_I8: - // case BT_I16: + case BT_I1: return m_ctxt->get_int_type (1, true); + case BT_I2: return m_ctxt->get_int_type (2, true); + case BT_I4: return m_ctxt->get_int_type (4, true); + case BT_I8: return m_ctxt->get_int_type (8, true); + case BT_I16: return m_ctxt->get_int_type (16, true); // case BT_PTR_CONST_STRING: } } diff --git a/gcc/jit/jit-recording.c b/gcc/jit/jit-recording.c index 117ff70114c..798be57a611 100644 --- a/gcc/jit/jit-recording.c +++ b/gcc/jit/jit-recording.c @@ -2598,8 +2598,18 @@ recording::memento_of_get_pointer::accepts_writes_from (type *rtype) return false; /* It's OK to assign to a (const T *) from a (T *). */ - return m_other_type->unqualified () - ->accepts_writes_from (rtype_points_to); + if (m_other_type->unqualified () + ->accepts_writes_from (rtype_points_to)) + return true; + + /* It's OK to assign to a (volatile const T *) from a (volatile const T *). */ + if (m_other_type->get_variant () == DECORATED_TYPE_VOLATILE + && rtype->get_variant () == DECORATED_TYPE_VOLATILE + && m_other_type->unqualified ()->unqualified () + ->accepts_writes_from (rtype_points_to->unqualified ())) + return true; + + return false; } /* Implementation of pure virtual hook recording::memento::replay_into diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h index 03fa1160cf0..86e183c1201 100644 --- a/gcc/jit/jit-recording.h +++ b/gcc/jit/jit-recording.h @@ -496,6 +496,14 @@ private: bool m_created_by_user; }; +enum decorated_type_variant { + NORMAL_TYPE, + DECORATED_TYPE_CONST, + DECORATED_TYPE_VOLATILE, + DECORATED_TYPE_ALIGNED, + DECORATED_TYPE_VECTOR, +}; + class type : public memento { public: @@ -554,6 +562,11 @@ public: return is_int () || is_float () || is_bool (); } + enum decorated_type_variant get_variant () const + { + return m_variant; + } + playback::type * playback_type () { @@ -565,9 +578,12 @@ public: protected: type (context *ctxt) : memento (ctxt), + m_variant (NORMAL_TYPE), m_pointer_to_this_type (NULL) {} + enum decorated_type_variant m_variant; + private: type *m_pointer_to_this_type; }; @@ -652,9 +668,12 @@ private: class decorated_type : public type { public: - decorated_type (type *other_type) + decorated_type (type *other_type, enum decorated_type_variant variant) : type (other_type->m_ctxt), - m_other_type (other_type) {} + m_other_type (other_type) + { + m_variant = variant; + } type *dereference () FINAL OVERRIDE { return m_other_type->dereference (); } @@ -673,7 +692,7 @@ class memento_of_get_const : public decorated_type { public: memento_of_get_const (type *other_type) - : decorated_type (other_type) {} + : decorated_type (other_type, DECORATED_TYPE_CONST) {} bool accepts_writes_from (type */*rtype*/) FINAL OVERRIDE { @@ -696,7 +715,7 @@ class memento_of_get_volatile : public decorated_type { public: memento_of_get_volatile (type *other_type) - : decorated_type (other_type) {} + : decorated_type (other_type, DECORATED_TYPE_VOLATILE) {} /* Strip off the "volatile", giving the underlying type. */ type *unqualified () FINAL OVERRIDE { return m_other_type; } @@ -713,7 +732,7 @@ class memento_of_get_aligned : public decorated_type { public: memento_of_get_aligned (type *other_type, size_t alignment_in_bytes) - : decorated_type (other_type), + : decorated_type (other_type, DECORATED_TYPE_ALIGNED), m_alignment_in_bytes (alignment_in_bytes) {} /* Strip off the alignment, giving the underlying type. */ @@ -734,7 +753,7 @@ class vector_type : public decorated_type { public: vector_type (type *other_type, size_t num_units) - : decorated_type (other_type), + : decorated_type (other_type, DECORATED_TYPE_VECTOR), m_num_units (num_units) {} size_t get_num_units () const { return m_num_units; } diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h index 4202eb7798b..45a0a8c2abc 100644 --- a/gcc/testsuite/jit.dg/all-non-failing-tests.h +++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h @@ -181,6 +181,13 @@ #undef create_code #undef verify_code +/* test-builtin-types.c */ +#define create_code create_code_builtin_types +#define verify_code verify_code_builtin_types +#include "test-builtin-types.c" +#undef create_code +#undef verify_code + /* test-hello-world.c */ #define create_code create_code_hello_world #define verify_code verify_code_hello_world @@ -444,7 +451,10 @@ const struct testcase testcases[] = { verify_code_version}, {"volatile", create_code_volatile, - verify_code_volatile} + verify_code_volatile}, + {"builtin-types", + create_code_builtin_types, + verify_code_builtin_types} }; const int num_testcases = (sizeof (testcases) / sizeof (testcases[0])); diff --git a/gcc/testsuite/jit.dg/test-builtin-types.c b/gcc/testsuite/jit.dg/test-builtin-types.c new file mode 100644 index 00000000000..e20d71571b5 --- /dev/null +++ b/gcc/testsuite/jit.dg/test-builtin-types.c @@ -0,0 +1,41 @@ +#include +#include +#include +#include + +#include "libgccjit.h" + +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + CHECK_NON_NULL (gcc_jit_context_get_builtin_function (ctxt, "__atomic_fetch_add_4")); + + gcc_jit_function *atomic_load = gcc_jit_context_get_builtin_function (ctxt, "__atomic_load_8"); + + gcc_jit_type *volatile_void_ptr = + gcc_jit_type_get_volatile(gcc_jit_type_get_const(gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR))); + gcc_jit_type *void_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID); + gcc_jit_type *long_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_LONG); + gcc_jit_type *int_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + gcc_jit_function *func = + gcc_jit_context_new_function (ctxt, NULL, GCC_JIT_FUNCTION_EXPORTED, void_type, "atomics", 0, NULL, 0); + + gcc_jit_lvalue *variable = gcc_jit_function_new_local (func, NULL, long_type, "variable"); + gcc_jit_rvalue *builtin_args[2]; + gcc_jit_rvalue *param1 = gcc_jit_lvalue_get_address(variable, NULL); + builtin_args[0] = gcc_jit_context_new_cast(ctxt, NULL, param1, volatile_void_ptr); + builtin_args[1] = gcc_jit_context_new_rvalue_from_long(ctxt, int_type, 0); + gcc_jit_context_new_call (ctxt, NULL, atomic_load, 2, builtin_args); +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) +{ + /* Verify that no errors were emitted. */ + CHECK_NON_NULL (result); +} -- 2.31.1