From 74230be2c324876b255fc1cc96fae4eece8ff2a2 Mon Sep 17 00:00:00 2001 From: Antoni Boucher Date: Sun, 9 May 2021 20:14:37 -0400 Subject: [PATCH] libgccjit: Add support for types used by atomic builtins [PR96066] [PR96067] 2021-11-20 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 functions (is_volatile, is_const) and allow comparing qualified types. 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 Signed-off-by: Antoni Boucher --- gcc/jit/jit-builtins.c | 10 ++--- gcc/jit/jit-recording.c | 9 +++- gcc/jit/jit-recording.h | 16 ++++++++ gcc/testsuite/jit.dg/all-non-failing-tests.h | 10 +++++ gcc/testsuite/jit.dg/test-builtin-types.c | 43 ++++++++++++++++++++ 5 files changed, 81 insertions(+), 7 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..2eecf44c8db 100644 --- a/gcc/jit/jit-recording.c +++ b/gcc/jit/jit-recording.c @@ -2598,8 +2598,13 @@ 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 *). */ + return m_other_type->is_same_type_as (rtype_points_to); } /* Implementation of pure virtual hook recording::memento::replay_into diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h index 4a994fe7094..60aaba2a246 100644 --- a/gcc/jit/jit-recording.h +++ b/gcc/jit/jit-recording.h @@ -545,6 +545,8 @@ public: virtual bool is_float () const = 0; virtual bool is_bool () const = 0; virtual type *is_pointer () = 0; + virtual type *is_volatile () { return NULL; } + virtual type *is_const () { return NULL; } virtual type *is_array () = 0; virtual struct_ *is_struct () { return NULL; } virtual bool is_void () const { return false; } @@ -687,6 +689,13 @@ public: /* Strip off the "const", giving the underlying type. */ type *unqualified () FINAL OVERRIDE { return m_other_type; } + virtual bool is_same_type_as (type *other) + { + return m_other_type->is_same_type_as (other->is_const ()); + } + + virtual type *is_const () { return m_other_type; } + void replay_into (replayer *) FINAL OVERRIDE; private: @@ -701,9 +710,16 @@ public: memento_of_get_volatile (type *other_type) : decorated_type (other_type) {} + virtual bool is_same_type_as (type *other) + { + return m_other_type->is_same_type_as (other->is_volatile ()); + } + /* Strip off the "volatile", giving the underlying type. */ type *unqualified () FINAL OVERRIDE { return m_other_type; } + virtual type *is_volatile () { return m_other_type; } + void replay_into (replayer *) FINAL OVERRIDE; private: diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h index a7fddf96db8..be4a41f8dad 100644 --- a/gcc/testsuite/jit.dg/all-non-failing-tests.h +++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h @@ -188,6 +188,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 @@ -408,6 +415,9 @@ const struct testcase testcases[] = { {"functions", create_code_functions, verify_code_functions}, + {"builtin-types", + create_code_builtin_types, + verify_code_builtin_types}, {"hello_world", create_code_hello_world, verify_code_hello_world}, 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..15b026c9593 --- /dev/null +++ b/gcc/testsuite/jit.dg/test-builtin-types.c @@ -0,0 +1,43 @@ +#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 *void_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID); + gcc_jit_type *const_void_type = + gcc_jit_type_get_const (gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID)); + gcc_jit_type *volatile_void_ptr = + gcc_jit_type_get_pointer (gcc_jit_type_get_volatile (const_void_type)); + 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.26.2.7.g19db9cfb68.dirty