diff --git a/NOTICE b/NOTICE index d724b25191b..4ff7b4cfb28 100644 --- a/NOTICE +++ b/NOTICE @@ -20,5 +20,3 @@ The following files and directories come partially or entirely from rustc_codege * test.sh * build_sysroot * .github/workflows - -The libgccjit patches in the gcc-patches directory are licensed under the GPLv3 license. diff --git a/gcc-patches/0001-This-patch-handles-truncation-and-extension-for-cast.patch b/gcc-patches/0001-This-patch-handles-truncation-and-extension-for-cast.patch deleted file mode 100644 index e415d333c3f..00000000000 --- a/gcc-patches/0001-This-patch-handles-truncation-and-extension-for-cast.patch +++ /dev/null @@ -1,182 +0,0 @@ -From 140333077a4c5f8ce80f7e5716eecc90781594fa Mon Sep 17 00:00:00 2001 -From: Antoni Boucher -Date: Sun, 5 Jul 2020 19:07:30 -0400 -Subject: [PATCH] This patch handles truncation and extension for casts in jit. - -2020-07-12 Antoni Boucher - -gcc/jit/ - PR target/95498 - * jit-playback.c: Add support to handle truncation and extension - in the convert function. - -gcc/testsuite/ - PR target/95498 - * jit.dg/all-non-failing-tests.h: New test. - * jit.dg/test-cast.c: New test. ---- - gcc/jit/jit-playback.c | 39 ++++++++---- - gcc/testsuite/jit.dg/all-non-failing-tests.h | 10 +++ - gcc/testsuite/jit.dg/test-cast.c | 66 ++++++++++++++++++++ - 3 files changed, 104 insertions(+), 11 deletions(-) - create mode 100644 gcc/testsuite/jit.dg/test-cast.c - -diff --git a/gcc/jit/jit-playback.c b/gcc/jit/jit-playback.c -index 0fddf04da87..4f4a1080c36 100644 ---- a/gcc/jit/jit-playback.c -+++ b/gcc/jit/jit-playback.c -@@ -61,22 +61,39 @@ along with GCC; see the file COPYING3. If not see - - /* gcc::jit::playback::context::build_cast uses the convert.h API, - which in turn requires the frontend to provide a "convert" -- function, apparently as a fallback. -- -- Hence we provide this dummy one, with the requirement that any casts -- are handled before reaching this. */ -+ function, apparently as a fallback for casts that can be simplified -+ (truncation, extension). */ - extern tree convert (tree type, tree expr); - - tree - convert (tree dst_type, tree expr) - { -- gcc_assert (gcc::jit::active_playback_ctxt); -- gcc::jit::active_playback_ctxt->add_error (NULL, "unhandled conversion"); -- fprintf (stderr, "input expression:\n"); -- debug_tree (expr); -- fprintf (stderr, "requested type:\n"); -- debug_tree (dst_type); -- return error_mark_node; -+ tree t_ret = NULL; -+ t_ret = targetm.convert_to_type (dst_type, expr); -+ if (t_ret) -+ return t_ret; -+ enum tree_code dst_code = TREE_CODE (dst_type); -+ switch (dst_code) -+ { -+ case INTEGER_TYPE: -+ case ENUMERAL_TYPE: -+ t_ret = convert_to_integer (dst_type, expr); -+ goto maybe_fold; -+ -+ default: -+ gcc_assert (gcc::jit::active_playback_ctxt); -+ gcc::jit::active_playback_ctxt->add_error (NULL, "unhandled conversion"); -+ fprintf (stderr, "input expression:\n"); -+ debug_tree (expr); -+ fprintf (stderr, "requested type:\n"); -+ debug_tree (dst_type); -+ return error_mark_node; -+ -+ maybe_fold: -+ if (TREE_CODE (t_ret) != C_MAYBE_CONST_EXPR) -+ t_ret = fold (t_ret); -+ return t_ret; -+ } - } - - namespace gcc { -diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h -index 632ab8cfb2e..a1481699b16 100644 ---- a/gcc/testsuite/jit.dg/all-non-failing-tests.h -+++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h -@@ -98,6 +98,13 @@ - #undef create_code - #undef verify_code - -+/* test-cast.c */ -+#define create_code create_code_cast -+#define verify_code verify_code_cast -+#include "test-cast.c" -+#undef create_code -+#undef verify_code -+ - /* test-compound-assignment.c */ - #define create_code create_code_compound_assignment - #define verify_code verify_code_compound_assignment -@@ -354,6 +361,9 @@ const struct testcase testcases[] = { - {"calling_internal_function", - create_code_calling_internal_function, - verify_code_calling_internal_function}, -+ {"cast", -+ create_code_cast, -+ verify_code_cast}, - {"compound_assignment", - create_code_compound_assignment, - verify_code_compound_assignment}, -diff --git a/gcc/testsuite/jit.dg/test-cast.c b/gcc/testsuite/jit.dg/test-cast.c -new file mode 100644 -index 00000000000..2b1e385ae40 ---- /dev/null -+++ b/gcc/testsuite/jit.dg/test-cast.c -@@ -0,0 +1,66 @@ -+#include -+#include -+#include -+ -+#include "libgccjit.h" -+ -+#include "harness.h" -+ -+void -+create_code (gcc_jit_context *ctxt, void *user_data) -+{ -+ /* Let's try to inject the equivalent of: -+char -+my_casts (int x) -+{ -+ return (char)(long) x; -+} -+ */ -+ gcc_jit_type *int_type = -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); -+ gcc_jit_type *long_type = -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_LONG); -+ gcc_jit_type *return_type = -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_CHAR); -+ -+ gcc_jit_param *x = -+ gcc_jit_context_new_param ( -+ ctxt, -+ NULL, -+ int_type, "x"); -+ gcc_jit_param *params[1] = {x}; -+ gcc_jit_function *func = -+ gcc_jit_context_new_function (ctxt, -+ NULL, -+ GCC_JIT_FUNCTION_EXPORTED, -+ return_type, -+ "my_casts", -+ 1, params, 0); -+ -+ gcc_jit_block *initial = -+ gcc_jit_function_new_block (func, "initial"); -+ -+ gcc_jit_block_end_with_return(initial, NULL, -+ gcc_jit_context_new_cast(ctxt, -+ NULL, -+ gcc_jit_context_new_cast(ctxt, -+ NULL, -+ gcc_jit_param_as_rvalue(x), -+ long_type -+ ), -+ return_type -+ )); -+} -+ -+void -+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) -+{ -+ typedef int (*my_casts_fn_type) (int); -+ CHECK_NON_NULL (result); -+ my_casts_fn_type my_casts = -+ (my_casts_fn_type)gcc_jit_result_get_code (result, "my_casts"); -+ CHECK_NON_NULL (my_casts); -+ char val = my_casts (10); -+ note ("my_casts returned: %d", val); -+ CHECK_VALUE (val, 10); -+} --- -2.27.0 - - \ No newline at end of file diff --git a/gcc-patches/0002-This-patch-add-some-reflection-functions-in-the-jit-.patch b/gcc-patches/0002-This-patch-add-some-reflection-functions-in-the-jit-.patch deleted file mode 100644 index a8d9e1b7458..00000000000 --- a/gcc-patches/0002-This-patch-add-some-reflection-functions-in-the-jit-.patch +++ /dev/null @@ -1,910 +0,0 @@ -From 6f2d37a67ad9ad72eaf3f17f4d20a5be5a093ac4 Mon Sep 17 00:00:00 2001 -From: Antoni Boucher -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 - - gcc/jit/ - PR target/96889 - * docs/topics/compatibility.rst (LIBGCCJIT_ABI_16): 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 - * docs/topics/types.rst: Add documentation for the functions - 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, - and gcc_jit_struct_get_field_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_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): 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_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): 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_16): 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 | 43 +++- - gcc/jit/docs/topics/functions.rst | 26 ++ - gcc/jit/docs/topics/types.rst | 122 +++++++++ - gcc/jit/jit-recording.h | 7 + - gcc/jit/libgccjit.c | 256 +++++++++++++++++++ - gcc/jit/libgccjit.h | 89 +++++++ - gcc/jit/libgccjit.map | 21 ++ - gcc/testsuite/jit.dg/all-non-failing-tests.h | 10 + - gcc/testsuite/jit.dg/test-reflection.c | 95 +++++++ - 9 files changed, 668 insertions(+), 1 deletion(-) - 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 239b6aa1a92..cec40ca508c 100644 ---- a/gcc/jit/docs/topics/compatibility.rst -+++ b/gcc/jit/docs/topics/compatibility.rst -@@ -230,7 +230,7 @@ entrypoints: - .. _LIBGCCJIT_ABI_15: - - ``LIBGCCJIT_ABI_15`` ------------------------- -+-------------------- - ``LIBGCCJIT_ABI_15`` covers the addition of API entrypoints for directly - embedding assembler instructions: - -@@ -243,3 +243,44 @@ 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_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 b2d9239aa0a..950da4e5a76 100644 ---- a/gcc/jit/docs/topics/functions.rst -+++ b/gcc/jit/docs/topics/functions.rst -@@ -171,6 +171,32 @@ 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. -+ -+ 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_15`; you can test for their presence -+ using -+ -+ .. code-block:: c -+ -+ #ifdef LIBGCCJIT_HAVE_REFLECTION -+ -+ .. type:: gcc_jit_case -+ - Blocks - ------ - .. type:: gcc_jit_block -diff --git a/gcc/jit/docs/topics/types.rst b/gcc/jit/docs/topics/types.rst -index 831f11b679a..73cdca11c3b 100644 ---- a/gcc/jit/docs/topics/types.rst -+++ b/gcc/jit/docs/topics/types.rst -@@ -345,3 +345,125 @@ Function pointer types - - 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_is_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_is_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:: ssize_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_is_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:: ssize_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:: ssize_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_is_array` -+ -+ * :c:func:`gcc_jit_type_is_bool` -+ -+ * :c:func:`gcc_jit_type_is_function_ptr_type` -+ -+ * :c:func:`gcc_jit_type_is_integral` -+ -+ * :c:func:`gcc_jit_type_is_pointer` -+ -+ * :c:func:`gcc_jit_type_is_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_15`; you can test for their presence -+ using -+ -+ .. code-block:: c -+ -+ #ifdef LIBGCCJIT_HAVE_REFLECTION -+ -+ .. type:: gcc_jit_case -diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h -index 03fa1160cf0..4a994fe7094 100644 ---- a/gcc/jit/jit-recording.h -+++ b/gcc/jit/jit-recording.h -@@ -546,7 +546,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 -@@ -663,6 +665,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; -@@ -745,6 +748,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; -@@ -951,6 +956,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 0cc650f9810..b0cbd3a2b6a 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 - { - }; -@@ -515,6 +523,194 @@ 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"); -+ -+ 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. */ -+ -+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 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 -@@ -736,6 +932,37 @@ 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, -+ 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"); -+ RETURN_NULL_IF_FAIL ((int) 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 -@@ -1017,6 +1244,35 @@ gcc_jit_function_get_param (gcc_jit_function *func, int index) - return static_cast (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_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 -diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h -index 5c722c2c57f..1e5c5c169cb 100644 ---- a/gcc/jit/libgccjit.h -+++ b/gcc/jit/libgccjit.h -@@ -61,6 +61,8 @@ typedef struct gcc_jit_result gcc_jit_result; - +- 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 -@@ -97,6 +99,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. */ -@@ -654,6 +662,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, -+ size_t 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, -@@ -1621,6 +1638,78 @@ gcc_jit_context_add_top_level_asm (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_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, -+ 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_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 337ea6c7fe4..84358763cd6 100644 ---- a/gcc/jit/libgccjit.map -+++ b/gcc/jit/libgccjit.map -@@ -205,3 +205,24 @@ LIBGCCJIT_ABI_15 { - 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_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_15; -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..46ab2c3e887 ---- /dev/null -+++ b/gcc/testsuite/jit.dg/test-reflection.c -@@ -0,0 +1,95 @@ -+#include -+#include -+ -+#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); -+ CHECK (!gcc_jit_type_is_function_ptr_type (int64)); -+ 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); -+ 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_is_array(double_type)); -+ gcc_jit_type* array_type = gcc_jit_context_new_array_type(ctxt, NULL, double_type, 1); -+ CHECK_VALUE (gcc_jit_type_is_array(array_type), double_type); -+} -+ --- -2.31.1 - diff --git a/gcc-patches/0003-Add-support-for-types-used-by-atomic-builtins-PR9606.patch b/gcc-patches/0003-Add-support-for-types-used-by-atomic-builtins-PR9606.patch deleted file mode 100644 index 74b1377d122..00000000000 --- a/gcc-patches/0003-Add-support-for-types-used-by-atomic-builtins-PR9606.patch +++ /dev/null @@ -1,141 +0,0 @@ -From 0ce53d373ffba9f3f80a2d2b4e1a7d724ba31b7d 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. - 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 ---- - gcc/jit/jit-builtins.c | 10 ++--- - gcc/jit/jit-recording.c | 14 ++++++- - gcc/testsuite/jit.dg/all-non-failing-tests.h | 7 ++++ - gcc/testsuite/jit.dg/test-builtin-types.c | 41 ++++++++++++++++++++ - 4 files changed, 65 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..de876ff9fa6 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->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/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h -index 4202eb7798b..dfc6596358c 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 -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 - diff --git a/gcc-patches/0004-Add-support-for-sized-integer-types-including-128-bi.patch b/gcc-patches/0004-Add-support-for-sized-integer-types-including-128-bi.patch deleted file mode 100644 index c18da4c8f4b..00000000000 --- a/gcc-patches/0004-Add-support-for-sized-integer-types-including-128-bi.patch +++ /dev/null @@ -1,416 +0,0 @@ -From f41a659255180e29f57f48d6fe38a552f4dda0a2 Mon Sep 17 00:00:00 2001 -From: Antoni Boucher -Date: Mon, 10 May 2021 19:43:02 -0400 -Subject: [PATCH] Add support for sized integer types, including 128-bit - integers [PR95325] - -2021-05-18 Antoni Boucher - - gcc/jit/ - PR target/95325 - * docs/topics/types.rst: Add documentation for the new types - GCC_JIT_TYPE_UINT8_T, GCC_JIT_TYPE_UINT16_T, - GCC_JIT_TYPE_UINT32_T, GCC_JIT_TYPE_UINT64_T, - GCC_JIT_TYPE_UINT128_T, GCC_JIT_TYPE_INT8_T, GCC_JIT_TYPE_INT16_T, - GCC_JIT_TYPE_INT32_T, GCC_JIT_TYPE_INT64_T, GCC_JIT_TYPE_INT128_T. - * jit-builtins.c: Add support for BT_UINT128. - * jit-playback.c: Add support for the sized integer types. - * jit-recording.c: Add support for the sized integer types. - * libgccjit.h (GCC_JIT_TYPE_UINT8_T, GCC_JIT_TYPE_UINT16_T, - GCC_JIT_TYPE_UINT32_T, GCC_JIT_TYPE_UINT64_T, - GCC_JIT_TYPE_UINT128_T, GCC_JIT_TYPE_INT8_T, GCC_JIT_TYPE_INT16_T, - GCC_JIT_TYPE_INT32_T, GCC_JIT_TYPE_INT64_T, GCC_JIT_TYPE_INT128_T): - New enum variants for gcc_jit_types. - gcc/testsuite/ - PR target/95325 - * jit.dg/test-types.c: Add tests for sized integer types. ---- - gcc/jit/docs/topics/types.rst | 10 +++ - gcc/jit/jit-builtins.c | 1 + - gcc/jit/jit-playback.c | 21 ++++++ - gcc/jit/jit-recording.c | 77 +++++++++++++++++++++ - gcc/jit/libgccjit.h | 11 +++ - gcc/testsuite/jit.dg/test-types.c | 111 ++++++++++++++++++++++++++++++ - 6 files changed, 231 insertions(+) - -diff --git a/gcc/jit/docs/topics/types.rst b/gcc/jit/docs/topics/types.rst -index 831f11b679a..68accacca45 100644 ---- a/gcc/jit/docs/topics/types.rst -+++ b/gcc/jit/docs/topics/types.rst -@@ -76,6 +76,16 @@ Standard types - :c:data:`GCC_JIT_TYPE_UNSIGNED_LONG` C's ``unsigned long`` - :c:data:`GCC_JIT_TYPE_LONG_LONG` C99's ``long long`` (signed) - :c:data:`GCC_JIT_TYPE_UNSIGNED_LONG_LONG` C99's ``unsigned long long`` -+ :c:data:`GCC_JIT_TYPE_UINT8_T` C99's ``uint8_t`` -+ :c:data:`GCC_JIT_TYPE_UINT16_T` C99's ``uint16_t`` -+ :c:data:`GCC_JIT_TYPE_UINT32_T` C99's ``uint32_t`` -+ :c:data:`GCC_JIT_TYPE_UINT64_T` C99's ``uint64_t`` -+ :c:data:`GCC_JIT_TYPE_UINT128_T` C99's ``__uint128_t`` -+ :c:data:`GCC_JIT_TYPE_INT8_T` C99's ``int8_t`` -+ :c:data:`GCC_JIT_TYPE_INT16_T` C99's ``int16_t`` -+ :c:data:`GCC_JIT_TYPE_INT32_T` C99's ``int32_t`` -+ :c:data:`GCC_JIT_TYPE_INT64_T` C99's ``int64_t`` -+ :c:data:`GCC_JIT_TYPE_INT128_T` C99's ``__int128_t`` - :c:data:`GCC_JIT_TYPE_FLOAT` - :c:data:`GCC_JIT_TYPE_DOUBLE` - :c:data:`GCC_JIT_TYPE_LONG_DOUBLE` -diff --git a/gcc/jit/jit-builtins.c b/gcc/jit/jit-builtins.c -index 1ea96f4e025..27f3eec3e54 100644 ---- a/gcc/jit/jit-builtins.c -+++ b/gcc/jit/jit-builtins.c -@@ -483,6 +483,7 @@ builtins_manager::make_primitive_type (enum jit_builtin_type type_id) - case BT_UINT16: return m_ctxt->get_int_type (2, false); - case BT_UINT32: return m_ctxt->get_int_type (4, false); - case BT_UINT64: return m_ctxt->get_int_type (8, false); -+ case BT_UINT128: return m_ctxt->get_int_type (16, false); - // case BT_WORD: - // case BT_UNWINDWORD: - case BT_FLOAT: return m_ctxt->get_type (GCC_JIT_TYPE_FLOAT); -diff --git a/gcc/jit/jit-playback.c b/gcc/jit/jit-playback.c -index c6136301243..40630aa1ab8 100644 ---- a/gcc/jit/jit-playback.c -+++ b/gcc/jit/jit-playback.c -@@ -193,6 +193,27 @@ get_tree_node_for_type (enum gcc_jit_types type_) - case GCC_JIT_TYPE_UNSIGNED_INT: - return unsigned_type_node; - -+ case GCC_JIT_TYPE_UINT8_T: -+ return unsigned_intQI_type_node; -+ case GCC_JIT_TYPE_UINT16_T: -+ return uint16_type_node; -+ case GCC_JIT_TYPE_UINT32_T: -+ return uint32_type_node; -+ case GCC_JIT_TYPE_UINT64_T: -+ return uint64_type_node; -+ case GCC_JIT_TYPE_UINT128_T: -+ return uint128_type_node; -+ case GCC_JIT_TYPE_INT8_T: -+ return intQI_type_node; -+ case GCC_JIT_TYPE_INT16_T: -+ return intHI_type_node; -+ case GCC_JIT_TYPE_INT32_T: -+ return intSI_type_node; -+ case GCC_JIT_TYPE_INT64_T: -+ return intDI_type_node; -+ case GCC_JIT_TYPE_INT128_T: -+ return intTI_type_node; -+ - case GCC_JIT_TYPE_LONG: - return long_integer_type_node; - case GCC_JIT_TYPE_UNSIGNED_LONG: -diff --git a/gcc/jit/jit-recording.c b/gcc/jit/jit-recording.c -index 117ff70114c..3848e5da138 100644 ---- a/gcc/jit/jit-recording.c -+++ b/gcc/jit/jit-recording.c -@@ -822,6 +822,10 @@ recording::context::get_int_type (int num_bytes, int is_signed) - return get_type (is_signed - ? GCC_JIT_TYPE_LONG_LONG - : GCC_JIT_TYPE_UNSIGNED_LONG_LONG); -+ if (num_bits == 128) -+ return get_type (is_signed -+ ? GCC_JIT_TYPE_INT128_T -+ : GCC_JIT_TYPE_UINT128_T); - - /* Some other size, not corresponding to the C int types. */ - /* To be written: support arbitrary other sizes, sharing by -@@ -2247,6 +2251,18 @@ recording::memento_of_get_type::get_size () - case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: - size = LONG_LONG_TYPE_SIZE; - break; -+ case GCC_JIT_TYPE_UINT8_T: -+ case GCC_JIT_TYPE_UINT16_T: -+ case GCC_JIT_TYPE_UINT32_T: -+ case GCC_JIT_TYPE_UINT64_T: -+ case GCC_JIT_TYPE_UINT128_T: -+ case GCC_JIT_TYPE_INT8_T: -+ case GCC_JIT_TYPE_INT16_T: -+ case GCC_JIT_TYPE_INT32_T: -+ case GCC_JIT_TYPE_INT64_T: -+ case GCC_JIT_TYPE_INT128_T: -+ size = 128; -+ break; - case GCC_JIT_TYPE_FLOAT: - size = FLOAT_TYPE_SIZE; - break; -@@ -2295,6 +2311,16 @@ recording::memento_of_get_type::dereference () - case GCC_JIT_TYPE_UNSIGNED_LONG: - case GCC_JIT_TYPE_LONG_LONG: - case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: -+ case GCC_JIT_TYPE_UINT8_T: -+ case GCC_JIT_TYPE_UINT16_T: -+ case GCC_JIT_TYPE_UINT32_T: -+ case GCC_JIT_TYPE_UINT64_T: -+ case GCC_JIT_TYPE_UINT128_T: -+ case GCC_JIT_TYPE_INT8_T: -+ case GCC_JIT_TYPE_INT16_T: -+ case GCC_JIT_TYPE_INT32_T: -+ case GCC_JIT_TYPE_INT64_T: -+ case GCC_JIT_TYPE_INT128_T: - case GCC_JIT_TYPE_FLOAT: - case GCC_JIT_TYPE_DOUBLE: - case GCC_JIT_TYPE_LONG_DOUBLE: -@@ -2347,6 +2373,16 @@ recording::memento_of_get_type::is_int () const - case GCC_JIT_TYPE_UNSIGNED_LONG: - case GCC_JIT_TYPE_LONG_LONG: - case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: -+ case GCC_JIT_TYPE_UINT8_T: -+ case GCC_JIT_TYPE_UINT16_T: -+ case GCC_JIT_TYPE_UINT32_T: -+ case GCC_JIT_TYPE_UINT64_T: -+ case GCC_JIT_TYPE_UINT128_T: -+ case GCC_JIT_TYPE_INT8_T: -+ case GCC_JIT_TYPE_INT16_T: -+ case GCC_JIT_TYPE_INT32_T: -+ case GCC_JIT_TYPE_INT64_T: -+ case GCC_JIT_TYPE_INT128_T: - return true; - - case GCC_JIT_TYPE_FLOAT: -@@ -2400,6 +2436,16 @@ recording::memento_of_get_type::is_float () const - case GCC_JIT_TYPE_UNSIGNED_LONG: - case GCC_JIT_TYPE_LONG_LONG: - case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: -+ case GCC_JIT_TYPE_UINT8_T: -+ case GCC_JIT_TYPE_UINT16_T: -+ case GCC_JIT_TYPE_UINT32_T: -+ case GCC_JIT_TYPE_UINT64_T: -+ case GCC_JIT_TYPE_UINT128_T: -+ case GCC_JIT_TYPE_INT8_T: -+ case GCC_JIT_TYPE_INT16_T: -+ case GCC_JIT_TYPE_INT32_T: -+ case GCC_JIT_TYPE_INT64_T: -+ case GCC_JIT_TYPE_INT128_T: - return false; - - case GCC_JIT_TYPE_FLOAT: -@@ -2453,6 +2499,16 @@ recording::memento_of_get_type::is_bool () const - case GCC_JIT_TYPE_UNSIGNED_LONG: - case GCC_JIT_TYPE_LONG_LONG: - case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: -+ case GCC_JIT_TYPE_UINT8_T: -+ case GCC_JIT_TYPE_UINT16_T: -+ case GCC_JIT_TYPE_UINT32_T: -+ case GCC_JIT_TYPE_UINT64_T: -+ case GCC_JIT_TYPE_UINT128_T: -+ case GCC_JIT_TYPE_INT8_T: -+ case GCC_JIT_TYPE_INT16_T: -+ case GCC_JIT_TYPE_INT32_T: -+ case GCC_JIT_TYPE_INT64_T: -+ case GCC_JIT_TYPE_INT128_T: - return false; - - case GCC_JIT_TYPE_FLOAT: -@@ -2511,6 +2567,17 @@ static const char * const get_type_strings[] = { - "long long", /* GCC_JIT_TYPE_LONG_LONG */ - "unsigned long long", /* GCC_JIT_TYPE_UNSIGNED_LONG_LONG */ - -+ "__uint8_t", /* GCC_JIT_TYPE_UINT8_T */ -+ "__uint16_t", /* GCC_JIT_TYPE_UINT16_T */ -+ "__uint32_t", /* GCC_JIT_TYPE_UINT32_T */ -+ "__uint64_t", /* GCC_JIT_TYPE_UINT64_T */ -+ "__uint128_t", /* GCC_JIT_TYPE_UINT128_T */ -+ "__int8_t", /* GCC_JIT_TYPE_INT8_T */ -+ "__int16_t", /* GCC_JIT_TYPE_INT16_T */ -+ "__int32_t", /* GCC_JIT_TYPE_INT32_T */ -+ "__int64_t", /* GCC_JIT_TYPE_INT64_T */ -+ "__int128_t", /* GCC_JIT_TYPE_INT128_T */ -+ - "float", /* GCC_JIT_TYPE_FLOAT */ - "double", /* GCC_JIT_TYPE_DOUBLE */ - "long double", /* GCC_JIT_TYPE_LONG_DOUBLE */ -@@ -2551,6 +2618,16 @@ static const char * const get_type_enum_strings[] = { - "GCC_JIT_TYPE_UNSIGNED_LONG", - "GCC_JIT_TYPE_LONG_LONG", - "GCC_JIT_TYPE_UNSIGNED_LONG_LONG", -+ "GCC_JIT_TYPE_UINT8_T", -+ "GCC_JIT_TYPE_UINT16_T", -+ "GCC_JIT_TYPE_UINT32_T", -+ "GCC_JIT_TYPE_UINT64_T", -+ "GCC_JIT_TYPE_UINT128_T", -+ "GCC_JIT_TYPE_INT8_T", -+ "GCC_JIT_TYPE_INT16_T", -+ "GCC_JIT_TYPE_INT32_T", -+ "GCC_JIT_TYPE_INT64_T", -+ "GCC_JIT_TYPE_INT128_T", - "GCC_JIT_TYPE_FLOAT", - "GCC_JIT_TYPE_DOUBLE", - "GCC_JIT_TYPE_LONG_DOUBLE", -diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h -index 5c722c2c57f..5d88033a2ab 100644 ---- a/gcc/jit/libgccjit.h -+++ b/gcc/jit/libgccjit.h -@@ -548,6 +548,17 @@ enum gcc_jit_types - GCC_JIT_TYPE_LONG_LONG, /* signed */ - GCC_JIT_TYPE_UNSIGNED_LONG_LONG, - -+ GCC_JIT_TYPE_UINT8_T, -+ GCC_JIT_TYPE_UINT16_T, -+ GCC_JIT_TYPE_UINT32_T, -+ GCC_JIT_TYPE_UINT64_T, -+ GCC_JIT_TYPE_UINT128_T, -+ GCC_JIT_TYPE_INT8_T, -+ GCC_JIT_TYPE_INT16_T, -+ GCC_JIT_TYPE_INT32_T, -+ GCC_JIT_TYPE_INT64_T, -+ GCC_JIT_TYPE_INT128_T, -+ - /* Floating-point types */ - - GCC_JIT_TYPE_FLOAT, -diff --git a/gcc/testsuite/jit.dg/test-types.c b/gcc/testsuite/jit.dg/test-types.c -index 8debcd7eb82..9c66284f193 100644 ---- a/gcc/testsuite/jit.dg/test-types.c -+++ b/gcc/testsuite/jit.dg/test-types.c -@@ -1,3 +1,4 @@ -+#include - #include - #include - #include -@@ -29,6 +30,18 @@ struct zoo - long long m_long_long; - unsigned long long m_unsigned_long_long; - -+ uint8_t m_u8; -+ uint16_t m_u16; -+ uint32_t m_u32; -+ uint64_t m_u64; -+ __uint128_t m_u128; -+ -+ int8_t m_i8; -+ int16_t m_i16; -+ int32_t m_i32; -+ int64_t m_i64; -+ __int128_t m_i128; -+ - int m_sized_int_type; - - float m_float; -@@ -101,6 +114,28 @@ create_code (gcc_jit_context *ctxt, void *user_data) - gcc_jit_field *field_m_unsigned_long_long = - CREATE_FIELD (GCC_JIT_TYPE_UNSIGNED_LONG_LONG, "m_unsigned_long_long"); - -+ gcc_jit_field *field_m_u8 = -+ CREATE_FIELD (GCC_JIT_TYPE_UINT8_T, "m_u8"); -+ gcc_jit_field *field_m_u16 = -+ CREATE_FIELD (GCC_JIT_TYPE_UINT16_T, "m_u16"); -+ gcc_jit_field *field_m_u32 = -+ CREATE_FIELD (GCC_JIT_TYPE_UINT32_T, "m_u32"); -+ gcc_jit_field *field_m_u64 = -+ CREATE_FIELD (GCC_JIT_TYPE_UINT64_T, "m_u64"); -+ gcc_jit_field *field_m_u128 = -+ CREATE_FIELD (GCC_JIT_TYPE_UINT128_T, "m_u128"); -+ -+ gcc_jit_field *field_m_i8 = -+ CREATE_FIELD (GCC_JIT_TYPE_INT8_T, "m_i8"); -+ gcc_jit_field *field_m_i16 = -+ CREATE_FIELD (GCC_JIT_TYPE_INT16_T, "m_i16"); -+ gcc_jit_field *field_m_i32 = -+ CREATE_FIELD (GCC_JIT_TYPE_INT32_T, "m_i32"); -+ gcc_jit_field *field_m_i64 = -+ CREATE_FIELD (GCC_JIT_TYPE_INT64_T, "m_i64"); -+ gcc_jit_field *field_m_i128 = -+ CREATE_FIELD (GCC_JIT_TYPE_INT128_T, "m_i128"); -+ - /* Signed int type with sizeof (int): */ - gcc_jit_type *sized_int_type = - gcc_jit_context_get_int_type (ctxt, sizeof (int), 1); -@@ -147,6 +182,18 @@ create_code (gcc_jit_context *ctxt, void *user_data) - field_m_long_long, - field_m_unsigned_long_long, - -+ field_m_u8, -+ field_m_u16, -+ field_m_u32, -+ field_m_u64, -+ field_m_u128, -+ -+ field_m_i8, -+ field_m_i16, -+ field_m_i32, -+ field_m_i64, -+ field_m_i128, -+ - field_m_sized_int_type, - - field_m_float, -@@ -266,6 +313,58 @@ create_code (gcc_jit_context *ctxt, void *user_data) - gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UNSIGNED_LONG_LONG), - 123456789)) - -+ ASSIGN(field_m_u8, -+ gcc_jit_context_new_rvalue_from_int ( -+ ctxt, -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UINT8_T), -+ 123)) -+ ASSIGN(field_m_u16, -+ gcc_jit_context_new_rvalue_from_int ( -+ ctxt, -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UINT16_T), -+ 12345)) -+ ASSIGN(field_m_u32, -+ gcc_jit_context_new_rvalue_from_int ( -+ ctxt, -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UINT32_T), -+ 123456789)) -+ ASSIGN(field_m_u64, -+ gcc_jit_context_new_rvalue_from_int ( -+ ctxt, -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UINT64_T), -+ 123456789)) -+ ASSIGN(field_m_u128, -+ gcc_jit_context_new_rvalue_from_int ( -+ ctxt, -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UINT128_T), -+ 123456789)) -+ -+ ASSIGN(field_m_i8, -+ gcc_jit_context_new_rvalue_from_int ( -+ ctxt, -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT8_T), -+ -1)) -+ ASSIGN(field_m_i16, -+ gcc_jit_context_new_rvalue_from_int ( -+ ctxt, -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT16_T), -+ -2)) -+ ASSIGN(field_m_i32, -+ gcc_jit_context_new_rvalue_from_int ( -+ ctxt, -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT32_T), -+ -3)) -+ ASSIGN(field_m_i64, -+ gcc_jit_context_new_rvalue_from_int ( -+ ctxt, -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT64_T), -+ -4)) -+ ASSIGN(field_m_i128, -+ gcc_jit_context_new_rvalue_from_int ( -+ ctxt, -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT128_T), -+ -5)) -+ - ASSIGN(field_m_sized_int_type, - gcc_jit_context_new_rvalue_from_int ( - ctxt, -@@ -347,6 +446,18 @@ verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) - CHECK_VALUE (z.m_long_long, -42); - CHECK_VALUE (z.m_unsigned_long_long, 123456789); - -+ CHECK_VALUE (z.m_u8, 123); -+ CHECK_VALUE (z.m_u16, 12345); -+ CHECK_VALUE (z.m_u32, 123456789); -+ CHECK_VALUE (z.m_u64, 123456789); -+ CHECK_VALUE (z.m_u128, 123456789); -+ -+ CHECK_VALUE (z.m_i8, -1); -+ CHECK_VALUE (z.m_i16, -2); -+ CHECK_VALUE (z.m_i32, -3); -+ CHECK_VALUE (z.m_i64, -4); -+ CHECK_VALUE (z.m_i128, -5); -+ - CHECK_VALUE (z.m_sized_int_type, 500); - - CHECK_VALUE (z.m_float, 3.141f); --- -2.31.1 - diff --git a/gcc-patches/0005-Add-support-for-TLS-variable-PR95415.patch b/gcc-patches/0005-Add-support-for-TLS-variable-PR95415.patch deleted file mode 100644 index 95c1813eb6c..00000000000 --- a/gcc-patches/0005-Add-support-for-TLS-variable-PR95415.patch +++ /dev/null @@ -1,374 +0,0 @@ -From 5c781291423975de78d34e808d0ddbe28ea989d7 Mon Sep 17 00:00:00 2001 -From: Antoni Boucher -Date: Tue, 11 May 2021 19:23:54 -0400 -Subject: [PATCH] Add support for TLS variable [PR95415] - -2021-05-18 Antoni Boucher - - gcc/jit/ - PR target/95415 - * docs/topics/compatibility.rst (LIBGCCJIT_ABI_17): New ABI - tag. - * docs/topics/expressions.rst: Add document for the function - gcc_jit_lvalue_set_tls_model. - * jit-playback.h: New function (set_tls_model) and make - rvalue::m_inner public. - * jit-recording.c: New function (set_tls_model), new - variables (tls_models and tls_model_enum_strings) and support - for setting the tls model. - * jit-recording.h: New function (set_tls_model) and new - field m_tls_model. - * libgccjit.c: New function (gcc_jit_lvalue_set_tls_model). - * libgccjit.h: New function (gcc_jit_lvalue_set_tls_model) - and new enum (gcc_jit_tls_model). - * libgccjit.map (LIBGCCJIT_ABI_17): New ABI tag. - - gcc/testsuite/ - PR target/95415 - * jit.dg/all-non-failing-tests.h: Add test-tls.c. - * jit.dg/test-tls.c: New test. ---- - gcc/jit/docs/topics/compatibility.rst | 9 +++++ - gcc/jit/docs/topics/expressions.rst | 28 +++++++++++++ - gcc/jit/jit-playback.h | 8 ++++ - gcc/jit/jit-recording.c | 41 ++++++++++++++++++-- - gcc/jit/jit-recording.h | 7 +++- - gcc/jit/libgccjit.c | 18 +++++++++ - gcc/jit/libgccjit.h | 21 ++++++++++ - gcc/jit/libgccjit.map | 5 +++ - gcc/testsuite/jit.dg/all-non-failing-tests.h | 7 ++++ - gcc/testsuite/jit.dg/test-tls.c | 29 ++++++++++++++ - 10 files changed, 169 insertions(+), 4 deletions(-) - create mode 100644 gcc/testsuite/jit.dg/test-tls.c - -diff --git a/gcc/jit/docs/topics/compatibility.rst b/gcc/jit/docs/topics/compatibility.rst -index 239b6aa1a92..d10bc1df080 100644 ---- a/gcc/jit/docs/topics/compatibility.rst -+++ b/gcc/jit/docs/topics/compatibility.rst -@@ -243,3 +243,12 @@ 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_17: -+ -+``LIBGCCJIT_ABI_17`` -+----------------------- -+``LIBGCCJIT_ABI_17`` covers the addition of an API entrypoint to set the -+thread-local storage model of a variable: -+ -+ * :func:`gcc_jit_lvalue_set_tls_model` -diff --git a/gcc/jit/docs/topics/expressions.rst b/gcc/jit/docs/topics/expressions.rst -index 396259ef07e..68defd6a311 100644 ---- a/gcc/jit/docs/topics/expressions.rst -+++ b/gcc/jit/docs/topics/expressions.rst -@@ -539,6 +539,34 @@ where the rvalue is computed by reading from the storage area. - - in C. - -+.. function:: void\ -+ gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue *lvalue,\ -+ enum gcc_jit_tls_model model) -+ -+ Make a variable a thread-local variable. -+ -+ The "model" parameter determines the thread-local storage model of the "lvalue": -+ -+ .. type:: enum gcc_jit_tls_model -+ -+ .. c:macro:: GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC -+ -+ .. c:macro:: GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC -+ -+ .. c:macro:: GCC_JIT_TLS_MODEL_INITIAL_EXEC -+ -+ .. c:macro:: GCC_JIT_TLS_MODEL_LOCAL_EXEC -+ -+ .. c:macro:: GCC_JIT_TLS_MODEL_DEFAULT -+ -+ This is analogous to: -+ -+ .. code-block:: c -+ -+ _Thread_local int foo; -+ -+ in C. -+ - Global variables - **************** - -diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h -index 825a3e172e9..654a9c472d4 100644 ---- a/gcc/jit/jit-playback.h -+++ b/gcc/jit/jit-playback.h -@@ -650,6 +650,8 @@ public: - - private: - context *m_ctxt; -+ -+protected: - tree m_inner; - }; - -@@ -670,6 +672,12 @@ public: - rvalue * - get_address (location *loc); - -+ void -+ set_tls_model (enum tls_model tls_model) -+ { -+ set_decl_tls_model (m_inner, tls_model); -+ } -+ - private: - bool mark_addressable (location *loc); - }; -diff --git a/gcc/jit/jit-recording.c b/gcc/jit/jit-recording.c -index 117ff70114c..64f3ae2d8f9 100644 ---- a/gcc/jit/jit-recording.c -+++ b/gcc/jit/jit-recording.c -@@ -3713,6 +3713,12 @@ recording::lvalue::get_address (recording::location *loc) - return result; - } - -+void -+recording::lvalue::set_tls_model (enum gcc_jit_tls_model model) -+{ -+ m_tls_model = model; -+} -+ - /* The implementation of class gcc::jit::recording::param. */ - - /* Implementation of pure virtual hook recording::memento::replay_into -@@ -4539,6 +4545,15 @@ recording::block::dump_edges_to_dot (pretty_printer *pp) - # pragma GCC diagnostic pop - #endif - -+namespace recording { -+static const enum tls_model tls_models[] = { -+ TLS_MODEL_GLOBAL_DYNAMIC, /* GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC */ -+ TLS_MODEL_LOCAL_DYNAMIC, /* GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC */ -+ TLS_MODEL_INITIAL_EXEC, /* GCC_JIT_TLS_MODEL_INITIAL_EXEC */ -+ TLS_MODEL_LOCAL_EXEC, /* GCC_JIT_TLS_MODEL_LOCAL_EXEC */ -+}; -+} /* namespace recording */ -+ - /* The implementation of class gcc::jit::recording::global. */ - - /* Implementation of pure virtual hook recording::memento::replay_into -@@ -4547,8 +4562,7 @@ recording::block::dump_edges_to_dot (pretty_printer *pp) - void - recording::global::replay_into (replayer *r) - { -- set_playback_obj ( -- m_initializer -+ playback::lvalue *global = m_initializer - ? r->new_global_initialized (playback_location (r, m_loc), - m_kind, - m_type->playback_type (), -@@ -4560,7 +4574,12 @@ recording::global::replay_into (replayer *r) - : r->new_global (playback_location (r, m_loc), - m_kind, - m_type->playback_type (), -- playback_string (m_name))); -+ playback_string (m_name)); -+ if (m_tls_model != GCC_JIT_TLS_MODEL_DEFAULT) -+ { -+ global->set_tls_model (recording::tls_models[m_tls_model]); -+ } -+ set_playback_obj (global); - } - - /* Override the default implementation of -@@ -4658,6 +4677,14 @@ recording::global::write_initializer_reproducer (const char *id, reproducer &r) - - /* Implementation of recording::memento::write_reproducer for globals. */ - -+static const char * const tls_model_enum_strings[] = { -+ "GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC", -+ "GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC", -+ "GCC_JIT_TLS_MODEL_INITIAL_EXEC", -+ "GCC_JIT_TLS_MODEL_LOCAL_EXEC", -+ "GCC_JIT_TLS_MODEL_DEFAULT", -+}; -+ - void - recording::global::write_reproducer (reproducer &r) - { -@@ -4675,6 +4702,14 @@ recording::global::write_reproducer (reproducer &r) - r.get_identifier_as_type (get_type ()), - m_name->get_debug_string ()); - -+ if (m_tls_model) -+ { -+ r.write (" gcc_jit_lvalue_set_tls_model (%s, /* gcc_jit_lvalue *lvalue */\n" -+ " %s); /* enum gcc_jit_tls_model model */\n", -+ id, -+ tls_model_enum_strings[m_tls_model]); -+ } -+ - if (m_initializer) - switch (m_type->dereference ()->get_size ()) - { -diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h -index 03fa1160cf0..893bf72dd31 100644 ---- a/gcc/jit/jit-recording.h -+++ b/gcc/jit/jit-recording.h -@@ -1105,7 +1105,8 @@ public: - lvalue (context *ctxt, - location *loc, - type *type_) -- : rvalue (ctxt, loc, type_) -+ : rvalue (ctxt, loc, type_), -+ m_tls_model (GCC_JIT_TLS_MODEL_DEFAULT) - {} - - playback::lvalue * -@@ -1127,6 +1128,10 @@ public: - const char *access_as_rvalue (reproducer &r) OVERRIDE; - virtual const char *access_as_lvalue (reproducer &r); - virtual bool is_global () const { return false; } -+ void set_tls_model (enum gcc_jit_tls_model model); -+ -+protected: -+ enum gcc_jit_tls_model m_tls_model; - }; - - class param : public lvalue -diff --git a/gcc/jit/libgccjit.c b/gcc/jit/libgccjit.c -index 0cc650f9810..768b99499cf 100644 ---- a/gcc/jit/libgccjit.c -+++ b/gcc/jit/libgccjit.c -@@ -1953,6 +1953,24 @@ gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue, - return (gcc_jit_rvalue *)lvalue->get_address (loc); - } - -+/* Public entrypoint. See description in libgccjit.h. -+ -+ After error-checking, the real work is done by the -+ gcc::jit::recording::lvalue::set_tls_model method in jit-recording.c. */ -+ -+void -+gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue *lvalue, -+ enum gcc_jit_tls_model model) -+{ -+ RETURN_IF_FAIL (lvalue, NULL, NULL, "NULL lvalue"); -+ JIT_LOG_FUNC (lvalue->get_context ()->get_logger ()); -+ RETURN_IF_FAIL_PRINTF1 (lvalue->is_global (), NULL, NULL, -+ "lvalue \"%s\" not a global", -+ lvalue->get_debug_string ()); -+ -+ lvalue->set_tls_model (model); -+} -+ - /* 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 5c722c2c57f..2a52b351a49 100644 ---- a/gcc/jit/libgccjit.h -+++ b/gcc/jit/libgccjit.h -@@ -722,6 +722,16 @@ enum gcc_jit_function_kind - GCC_JIT_FUNCTION_ALWAYS_INLINE - }; - -+/* Thread local storage model. */ -+enum gcc_jit_tls_model -+{ -+ GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC, -+ GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC, -+ GCC_JIT_TLS_MODEL_INITIAL_EXEC, -+ GCC_JIT_TLS_MODEL_LOCAL_EXEC, -+ GCC_JIT_TLS_MODEL_DEFAULT, -+}; -+ - /* Create a function. */ - extern gcc_jit_function * - gcc_jit_context_new_function (gcc_jit_context *ctxt, -@@ -1072,6 +1082,17 @@ extern gcc_jit_rvalue * - gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue, - gcc_jit_location *loc); - -+#define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model -+ -+/* Set the thread-local storage model of a global variable -+ -+ This API entrypoint was added in LIBGCCJIT_ABI_17; you can test for its -+ presence using -+ #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model */ -+extern void -+gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue *lvalue, -+ enum gcc_jit_tls_model model); -+ - extern gcc_jit_lvalue * - gcc_jit_function_new_local (gcc_jit_function *func, - gcc_jit_location *loc, -diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map -index 337ea6c7fe4..601817ae6e2 100644 ---- a/gcc/jit/libgccjit.map -+++ b/gcc/jit/libgccjit.map -@@ -205,3 +205,8 @@ LIBGCCJIT_ABI_15 { - gcc_jit_extended_asm_add_clobber; - gcc_jit_context_add_top_level_asm; - } LIBGCCJIT_ABI_14; -+ -+LIBGCCJIT_ABI_17 { -+ global: -+ gcc_jit_lvalue_set_tls_model; -+} LIBGCCJIT_ABI_16; -diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h -index 4202eb7798b..c2d87a30cca 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-tls.c */ -+#define create_code create_code_tls -+#define verify_code verify_code_tls -+#include "test-tls.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 -diff --git a/gcc/testsuite/jit.dg/test-tls.c b/gcc/testsuite/jit.dg/test-tls.c -new file mode 100644 -index 00000000000..d4508b16c1e ---- /dev/null -+++ b/gcc/testsuite/jit.dg/test-tls.c -@@ -0,0 +1,29 @@ -+#include -+#include -+#include -+#include -+ -+#include "libgccjit.h" -+ -+#include "harness.h" -+ -+void -+create_code (gcc_jit_context *ctxt, void *user_data) -+{ -+ /* Let's try to inject the equivalent of: -+ -+ _Thread_local int foo; -+ */ -+ gcc_jit_type *int_type = -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); -+ -+ gcc_jit_lvalue *foo = -+ gcc_jit_context_new_global ( -+ ctxt, NULL, GCC_JIT_GLOBAL_EXPORTED, int_type, "foo"); -+ gcc_jit_lvalue_set_tls_model (foo, GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC); -+} -+ -+void -+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) -+{ -+} --- -2.31.1 - diff --git a/gcc-patches/0006-Add-support-for-setting-the-link-section-of-global-v.patch b/gcc-patches/0006-Add-support-for-setting-the-link-section-of-global-v.patch deleted file mode 100644 index cef1ab0c36b..00000000000 --- a/gcc-patches/0006-Add-support-for-setting-the-link-section-of-global-v.patch +++ /dev/null @@ -1,300 +0,0 @@ -From bebaeb975d7bc2d099fd827e6724d35933ee25ad Mon Sep 17 00:00:00 2001 -From: Antoni Boucher -Date: Wed, 12 May 2021 07:57:54 -0400 -Subject: [PATCH] Add support for setting the link section of global variables - [PR100688] - -2021-05-19 Antoni Boucher - - gcc/jit/ - PR target/100688 - * docs/topics/compatibility.rst (LIBGCCJIT_ABI_18): New ABI - tag. - * docs/topics/expressions.rst: Add documentation for the - function gcc_jit_lvalue_set_link_section. - * jit-playback.h: New function (set_link_section) and - rvalue::m_inner protected. - * jit-recording.c: New function (set_link_section) and - support for setting the link section. - * jit-recording.h: New function (set_link_section) and new - field m_link_section. - * libgccjit.c: New function (gcc_jit_lvalue_set_link_section). - * libgccjit.h: New function (gcc_jit_lvalue_set_link_section). - * libgccjit.map (LIBGCCJIT_ABI_18): New ABI tag. - - gcc/testsuite/ - PR target/100688 - * jit.dg/all-non-failing-tests.h: Add test-link-section.c. - * jit.dg/test-link_section.c: New test. ---- - gcc/jit/docs/topics/compatibility.rst | 9 +++++++ - gcc/jit/docs/topics/expressions.rst | 12 ++++++++++ - gcc/jit/jit-playback.h | 8 +++++++ - gcc/jit/jit-recording.c | 23 +++++++++++++++--- - gcc/jit/jit-recording.h | 7 +++++- - gcc/jit/libgccjit.c | 12 ++++++++++ - gcc/jit/libgccjit.h | 13 ++++++++++ - gcc/jit/libgccjit.map | 5 ++++ - gcc/testsuite/jit.dg/all-non-failing-tests.h | 7 ++++++ - gcc/testsuite/jit.dg/test-link-section.c | 25 ++++++++++++++++++++ - 10 files changed, 117 insertions(+), 4 deletions(-) - create mode 100644 gcc/testsuite/jit.dg/test-link-section.c - -diff --git a/gcc/jit/docs/topics/compatibility.rst b/gcc/jit/docs/topics/compatibility.rst -index 239b6aa1a92..94e3127f049 100644 ---- a/gcc/jit/docs/topics/compatibility.rst -+++ b/gcc/jit/docs/topics/compatibility.rst -@@ -243,3 +243,12 @@ 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_18: -+ -+``LIBGCCJIT_ABI_18`` -+----------------------- -+``LIBGCCJIT_ABI_18`` covers the addition of an API entrypoint to set the link -+section of a variable: -+ -+ * :func:`gcc_jit_lvalue_set_link_section` -diff --git a/gcc/jit/docs/topics/expressions.rst b/gcc/jit/docs/topics/expressions.rst -index 396259ef07e..b39f6c02527 100644 ---- a/gcc/jit/docs/topics/expressions.rst -+++ b/gcc/jit/docs/topics/expressions.rst -@@ -539,6 +539,18 @@ where the rvalue is computed by reading from the storage area. - - in C. - -+.. function:: void -+ gcc_jit_lvalue_set_link_section (gcc_jit_lvalue *lvalue, -+ const char *name) -+ -+ Set the link section of a variable; analogous to: -+ -+ .. code-block:: c -+ -+ int variable __attribute__((section(".section"))); -+ -+ in C. -+ - Global variables - **************** - -diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h -index 825a3e172e9..8b0f65e87e8 100644 ---- a/gcc/jit/jit-playback.h -+++ b/gcc/jit/jit-playback.h -@@ -650,6 +650,8 @@ public: - - private: - context *m_ctxt; -+ -+protected: - tree m_inner; - }; - -@@ -670,6 +672,12 @@ public: - rvalue * - get_address (location *loc); - -+ void -+ set_link_section (const char* name) -+ { -+ set_decl_section_name (m_inner, name); -+ } -+ - private: - bool mark_addressable (location *loc); - }; -diff --git a/gcc/jit/jit-recording.c b/gcc/jit/jit-recording.c -index 117ff70114c..214e6f487fe 100644 ---- a/gcc/jit/jit-recording.c -+++ b/gcc/jit/jit-recording.c -@@ -3713,6 +3713,11 @@ recording::lvalue::get_address (recording::location *loc) - return result; - } - -+void recording::lvalue::set_link_section (const char *name) -+{ -+ m_link_section = new_string (name); -+} -+ - /* The implementation of class gcc::jit::recording::param. */ - - /* Implementation of pure virtual hook recording::memento::replay_into -@@ -4547,8 +4552,7 @@ recording::block::dump_edges_to_dot (pretty_printer *pp) - void - recording::global::replay_into (replayer *r) - { -- set_playback_obj ( -- m_initializer -+ playback::lvalue *global = m_initializer - ? r->new_global_initialized (playback_location (r, m_loc), - m_kind, - m_type->playback_type (), -@@ -4560,7 +4564,12 @@ recording::global::replay_into (replayer *r) - : r->new_global (playback_location (r, m_loc), - m_kind, - m_type->playback_type (), -- playback_string (m_name))); -+ playback_string (m_name)); -+ if (m_link_section != NULL) -+ { -+ global->set_link_section (m_link_section->c_str ()); -+ } -+ set_playback_obj (global); - } - - /* Override the default implementation of -@@ -4675,6 +4684,14 @@ recording::global::write_reproducer (reproducer &r) - r.get_identifier_as_type (get_type ()), - m_name->get_debug_string ()); - -+ if (m_link_section != NULL) -+ { -+ r.write (" gcc_jit_lvalue_set_link_section (%s, /* gcc_jit_lvalue *lvalue */\n" -+ " \"%s\"); /* */\n", -+ id, -+ m_link_section->c_str ()); -+ } -+ - if (m_initializer) - switch (m_type->dereference ()->get_size ()) - { -diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h -index 03fa1160cf0..8ca82c928b8 100644 ---- a/gcc/jit/jit-recording.h -+++ b/gcc/jit/jit-recording.h -@@ -1105,7 +1105,8 @@ public: - lvalue (context *ctxt, - location *loc, - type *type_) -- : rvalue (ctxt, loc, type_) -+ : rvalue (ctxt, loc, type_), -+ m_link_section (NULL) - {} - - playback::lvalue * -@@ -1127,6 +1128,10 @@ public: - const char *access_as_rvalue (reproducer &r) OVERRIDE; - virtual const char *access_as_lvalue (reproducer &r); - virtual bool is_global () const { return false; } -+ void set_link_section (const char *name); -+ -+protected: -+ string *m_link_section; - }; - - class param : public lvalue -diff --git a/gcc/jit/libgccjit.c b/gcc/jit/libgccjit.c -index 7fa948007ad..bd4ca6dc18f 100644 ---- a/gcc/jit/libgccjit.c -+++ b/gcc/jit/libgccjit.c -@@ -1953,6 +1953,18 @@ gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue, - return (gcc_jit_rvalue *)lvalue->get_address (loc); - } - -+/* Public entrypoint. See description in libgccjit.h. -+ -+ After error-checking, the real work is done by the -+ gcc::jit::recording::lvalue::set_section method in jit-recording.c. */ -+void -+gcc_jit_lvalue_set_link_section (gcc_jit_lvalue *lvalue, -+ const char *name) -+{ -+ RETURN_IF_FAIL (name, NULL, NULL, "NULL name"); -+ lvalue->set_link_section (name); -+} -+ - /* 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 5c722c2c57f..21553ede3de 100644 ---- a/gcc/jit/libgccjit.h -+++ b/gcc/jit/libgccjit.h -@@ -1072,6 +1072,19 @@ extern gcc_jit_rvalue * - gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue, - gcc_jit_location *loc); - -+#define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section -+ -+/* Set the link section of a global variable; analogous to: -+ __attribute__((section("section_name"))) -+ in C. -+ -+ This API entrypoint was added in LIBGCCJIT_ABI_18; you can test for its -+ presence using -+ #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model */ -+extern void -+gcc_jit_lvalue_set_link_section (gcc_jit_lvalue *lvalue, -+ const char *name); -+ - extern gcc_jit_lvalue * - gcc_jit_function_new_local (gcc_jit_function *func, - gcc_jit_location *loc, -diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map -index 337ea6c7fe4..a5f7ee993aa 100644 ---- a/gcc/jit/libgccjit.map -+++ b/gcc/jit/libgccjit.map -@@ -205,3 +205,8 @@ LIBGCCJIT_ABI_15 { - gcc_jit_extended_asm_add_clobber; - gcc_jit_context_add_top_level_asm; - } LIBGCCJIT_ABI_14; -+ -+LIBGCCJIT_ABI_18 { -+ global: -+ gcc_jit_lvalue_set_link_section; -+} LIBGCCJIT_ABI_17; -diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h -index 4202eb7798b..7e3b59dee0d 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-link-section.c */ -+#define create_code create_code_link_section -+#define verify_code verify_code_link_section -+#include "test-link-section.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 -diff --git a/gcc/testsuite/jit.dg/test-link-section.c b/gcc/testsuite/jit.dg/test-link-section.c -new file mode 100644 -index 00000000000..546c1e95b92 ---- /dev/null -+++ b/gcc/testsuite/jit.dg/test-link-section.c -@@ -0,0 +1,25 @@ -+#include -+#include -+ -+#include "libgccjit.h" -+ -+#include "harness.h" -+ -+void -+create_code (gcc_jit_context *ctxt, void *user_data) -+{ -+ /* Let's try to inject the equivalent of: -+ int foo __attribute__((section(".section"))); -+ */ -+ gcc_jit_type *int_type = -+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); -+ gcc_jit_lvalue *foo = -+ gcc_jit_context_new_global ( -+ ctxt, NULL, GCC_JIT_GLOBAL_EXPORTED, int_type, "foo"); -+ gcc_jit_lvalue_set_link_section(foo, "section"); -+} -+ -+extern void -+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) -+{ -+} --- -2.31.1 - diff --git a/gcc-patches/0007-Add-function-to-set-the-initial-value-of-a-global-va.patch b/gcc-patches/0007-Add-function-to-set-the-initial-value-of-a-global-va.patch deleted file mode 100644 index df76c7c525c..00000000000 --- a/gcc-patches/0007-Add-function-to-set-the-initial-value-of-a-global-va.patch +++ /dev/null @@ -1,363 +0,0 @@ -From 08830fb1c57882b197dce60658d87dba29067d3d Mon Sep 17 00:00:00 2001 -From: Antoni Boucher -Date: Sat, 15 May 2021 10:54:36 -0400 -Subject: [PATCH] Add function to set the initial value of a global variable - [PR96089] - -2021-05-20 Antoni Boucher - - gcc/jit/ - PR target/96089 - * docs/topics/compatibility.rst (LIBGCCJIT_ABI_19): New ABI - tag. - * docs/topics/expressions.rst: Add documentation for the - function gcc_jit_global_set_initializer_value. - * jit-playback.c: New function (new_global_with_value). - * jit-playback.h: New function (new_global_with_value). - * jit-recording.c: Add support for setting a value to a - global variable. - * jit-recording.h: New function (set_initializer_value) and - new field m_initializer_value. - * libgccjit.c: New macro RETURN_IF_FAIL_PRINTF5 and new - function (gcc_jit_global_set_initializer_value). - * libgccjit.h: New function (gcc_jit_global_set_initializer_value). - * libgccjit.map (LIBGCCJIT_ABI_19): New ABI tag. - - gcc/testsuite/ - PR target/96089 - * jit.dg/test-global-set-initializer.c: Add test for the new - function (gcc_jit_global_set_initializer_value). ---- - gcc/jit/docs/topics/compatibility.rst | 9 ++++ - gcc/jit/docs/topics/expressions.rst | 14 ++++++ - gcc/jit/jit-playback.c | 18 ++++++++ - gcc/jit/jit-playback.h | 7 +++ - gcc/jit/jit-recording.c | 34 ++++++++++++--- - gcc/jit/jit-recording.h | 8 ++++ - gcc/jit/libgccjit.c | 43 +++++++++++++++++++ - gcc/jit/libgccjit.h | 13 ++++++ - gcc/jit/libgccjit.map | 5 +++ - .../jit.dg/test-global-set-initializer.c | 15 +++++++ - 10 files changed, 160 insertions(+), 6 deletions(-) - -diff --git a/gcc/jit/docs/topics/compatibility.rst b/gcc/jit/docs/topics/compatibility.rst -index 239b6aa1a92..666eb3a1c51 100644 ---- a/gcc/jit/docs/topics/compatibility.rst -+++ b/gcc/jit/docs/topics/compatibility.rst -@@ -243,3 +243,12 @@ 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_19: -+ -+``LIBGCCJIT_ABI_19`` -+----------------------- -+``LIBGCCJIT_ABI_19`` covers the addition of an API entrypoint to set the value -+of a global variable: -+ -+ * :func:`gcc_jit_global_set_initializer_value` -diff --git a/gcc/jit/docs/topics/expressions.rst b/gcc/jit/docs/topics/expressions.rst -index 396259ef07e..f638cb68fdd 100644 ---- a/gcc/jit/docs/topics/expressions.rst -+++ b/gcc/jit/docs/topics/expressions.rst -@@ -603,6 +603,20 @@ Global variables - - #ifdef LIBGCCJIT_HAVE_gcc_jit_global_set_initializer - -+.. function:: void -+ gcc_jit_global_set_initializer_value (gcc_jit_lvalue *global,\ -+ gcc_jit_rvalue *value) -+ -+ Set an initializer for ``global`` using the specified value. -+ ``global`` must be the same type as ``value``. -+ -+ This entrypoint was added in :ref:`LIBGCCJIT_ABI_19`; you can test for -+ its presence using -+ -+ .. code-block:: c -+ -+ #ifdef LIBGCCJIT_HAVE_gcc_jit_global_set_initializer_value -+ - Working with pointers, structs and unions - ----------------------------------------- - -diff --git a/gcc/jit/jit-playback.c b/gcc/jit/jit-playback.c -index c6136301243..d86701a8ae6 100644 ---- a/gcc/jit/jit-playback.c -+++ b/gcc/jit/jit-playback.c -@@ -664,6 +664,24 @@ new_global_initialized (location *loc, - return global_finalize_lvalue (inner); - } - -+playback::lvalue * -+playback::context:: -+new_global_with_value (location *loc, -+ enum gcc_jit_global_kind kind, -+ type *type, -+ playback::rvalue *value, -+ const char *name) -+{ -+ tree inner = global_new_decl (loc, kind, type, name); -+ -+ tree inner_type = type->as_tree (); -+ tree initial = value->as_tree (); -+ gcc_assert (TREE_CONSTANT (initial)); -+ DECL_INITIAL (inner) = initial; -+ -+ return global_finalize_lvalue (inner); -+} -+ - /* Implementation of the various - gcc::jit::playback::context::new_rvalue_from_const - methods. -diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h -index 825a3e172e9..958284df539 100644 ---- a/gcc/jit/jit-playback.h -+++ b/gcc/jit/jit-playback.h -@@ -120,6 +120,13 @@ public: - const void *initializer, - const char *name); - -+ lvalue* -+ new_global_with_value (location *loc, -+ enum gcc_jit_global_kind kind, -+ type *type, -+ rvalue *value, -+ const char *name); -+ - template - rvalue * - new_rvalue_from_const (type *type, -diff --git a/gcc/jit/jit-recording.c b/gcc/jit/jit-recording.c -index 117ff70114c..a26e4928084 100644 ---- a/gcc/jit/jit-recording.c -+++ b/gcc/jit/jit-recording.c -@@ -4547,20 +4547,34 @@ recording::block::dump_edges_to_dot (pretty_printer *pp) - void - recording::global::replay_into (replayer *r) - { -- set_playback_obj ( -- m_initializer -- ? r->new_global_initialized (playback_location (r, m_loc), -+ playback::lvalue * obj; -+ if (m_initializer) -+ { -+ obj = r->new_global_initialized (playback_location (r, m_loc), - m_kind, - m_type->playback_type (), - m_type->dereference ()->get_size (), - m_initializer_num_bytes - / m_type->dereference ()->get_size (), - m_initializer, -- playback_string (m_name)) -- : r->new_global (playback_location (r, m_loc), -+ playback_string (m_name)); -+ } -+ else if (m_initializer_value) -+ { -+ obj = r->new_global_with_value (playback_location (r, m_loc), -+ m_kind, -+ m_type->playback_type (), -+ m_initializer_value->playback_rvalue (), -+ playback_string (m_name)); -+ } -+ else -+ { -+ obj = r->new_global (playback_location (r, m_loc), - m_kind, - m_type->playback_type (), -- playback_string (m_name))); -+ playback_string (m_name)); -+ } -+ set_playback_obj (obj); - } - - /* Override the default implementation of -@@ -4675,6 +4689,14 @@ recording::global::write_reproducer (reproducer &r) - r.get_identifier_as_type (get_type ()), - m_name->get_debug_string ()); - -+ if (m_initializer_value) -+ { -+ r.write (" gcc_jit_global_set_initializer_value (%s, /* gcc_jit_lvalue *global */\n" -+ " %s/* gcc_jit_rvalue *value */);\n", -+ id, -+ r.get_identifier_as_rvalue (m_initializer_value)); -+ } -+ - if (m_initializer) - switch (m_type->dereference ()->get_size ()) - { -diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h -index 03fa1160cf0..61de2e1dcd4 100644 ---- a/gcc/jit/jit-recording.h -+++ b/gcc/jit/jit-recording.h -@@ -1360,6 +1360,7 @@ public: - m_name (name) - { - m_initializer = NULL; -+ m_initializer_value = NULL; - m_initializer_num_bytes = 0; - } - ~global () -@@ -1386,6 +1387,12 @@ public: - m_initializer_num_bytes = num_bytes; - } - -+ void -+ set_initializer_value (rvalue* value) -+ { -+ m_initializer_value = value; -+ } -+ - private: - string * make_debug_string () FINAL OVERRIDE { return m_name; } - template -@@ -1400,6 +1407,7 @@ private: - enum gcc_jit_global_kind m_kind; - string *m_name; - void *m_initializer; -+ rvalue *m_initializer_value; - size_t m_initializer_num_bytes; - }; - -diff --git a/gcc/jit/libgccjit.c b/gcc/jit/libgccjit.c -index 7fa948007ad..b7fd4d9bebb 100644 ---- a/gcc/jit/libgccjit.c -+++ b/gcc/jit/libgccjit.c -@@ -269,6 +269,17 @@ struct gcc_jit_extended_asm : public gcc::jit::recording::extended_asm - } \ - JIT_END_STMT - -+#define RETURN_IF_FAIL_PRINTF5(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, \ -+ A4) \ -+ JIT_BEGIN_STMT \ -+ if (!(TEST_EXPR)) \ -+ { \ -+ jit_error ((CTXT), (LOC), "%s: " ERR_FMT, \ -+ __func__, (A0), (A1), (A2), (A3), (A4)); \ -+ return; \ -+ } \ -+ JIT_END_STMT -+ - /* Check that BLOCK is non-NULL, and that it's OK to add statements to - it. This will fail if BLOCK has already been terminated by some - kind of jump or a return. */ -@@ -1161,6 +1172,38 @@ gcc_jit_global_set_initializer (gcc_jit_lvalue *global, - return global; - } - -+/* Public entrypoint. See description in libgccjit.h. -+ -+ After error-checking, the real work is done by the -+ gcc::jit::recording::global::set_initializer_value method, in -+ jit-recording.c. */ -+ -+void -+gcc_jit_global_set_initializer_value (gcc_jit_lvalue *global, -+ gcc_jit_rvalue *value) -+{ -+ RETURN_IF_FAIL (global, NULL, NULL, "NULL global"); -+ RETURN_IF_FAIL (value, NULL, NULL, "NULL value"); -+ RETURN_IF_FAIL_PRINTF1 (global->is_global (), NULL, NULL, -+ "lvalue \"%s\" not a global", -+ global->get_debug_string ()); -+ -+ RETURN_IF_FAIL_PRINTF5 ( -+ compatible_types (global->get_type (), -+ value->get_type ()), -+ NULL, NULL, -+ "mismatching types for global \"%s\":" -+ " assignment to global %s (type: %s) from %s (type: %s)", -+ global->get_debug_string (), -+ global->get_debug_string (), -+ global->get_type ()->get_debug_string (), -+ value->get_debug_string (), -+ value->get_type ()->get_debug_string ()); -+ -+ reinterpret_cast (global) -+ ->set_initializer_value (value); -+} -+ - /* Public entrypoint. See description in libgccjit.h. - - After error-checking, this calls the trivial -diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h -index 5c722c2c57f..98762d05271 100644 ---- a/gcc/jit/libgccjit.h -+++ b/gcc/jit/libgccjit.h -@@ -810,6 +810,19 @@ gcc_jit_global_set_initializer (gcc_jit_lvalue *global, - const void *blob, - size_t num_bytes); - -+#define LIBGCCJIT_HAVE_gcc_jit_global_set_initializer_value -+ -+/* Set an initial value for a global, which must be a constant. -+ -+ This API entrypoint was added in LIBGCCJIT_ABI_19; you can test for its -+ presence using -+ #ifdef LIBGCCJIT_HAVE_gcc_jit_global_set_initializer_value -+*/ -+ -+extern void -+gcc_jit_global_set_initializer_value (gcc_jit_lvalue *global, -+ gcc_jit_rvalue *value); -+ - /* Upcasting. */ - extern gcc_jit_object * - gcc_jit_lvalue_as_object (gcc_jit_lvalue *lvalue); -diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map -index 337ea6c7fe4..69b3e79578b 100644 ---- a/gcc/jit/libgccjit.map -+++ b/gcc/jit/libgccjit.map -@@ -205,3 +205,8 @@ LIBGCCJIT_ABI_15 { - gcc_jit_extended_asm_add_clobber; - gcc_jit_context_add_top_level_asm; - } LIBGCCJIT_ABI_14; -+ -+LIBGCCJIT_ABI_19 { -+ global: -+ gcc_jit_global_set_initializer_value; -+} LIBGCCJIT_ABI_18; -diff --git a/gcc/testsuite/jit.dg/test-global-set-initializer.c b/gcc/testsuite/jit.dg/test-global-set-initializer.c -index d38aba7d73f..418ed7dcf3f 100644 ---- a/gcc/testsuite/jit.dg/test-global-set-initializer.c -+++ b/gcc/testsuite/jit.dg/test-global-set-initializer.c -@@ -21,6 +21,7 @@ create_code (gcc_jit_context *ctxt, void *user_data) - signed char bin_blob1[] = { 0xc, 0xa, 0xf, 0xf, 0xe }; - unsigned bin_blob2[] = { 0x3, 0x2, 0x1, 0x0, 0x1, 0x2, 0x3 }; - unsigned char bin_blob3[4096]... -+ unsigned int integer = 42; - */ - gcc_jit_type *unsigned_char_type = - gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UNSIGNED_CHAR); -@@ -56,6 +57,16 @@ create_code (gcc_jit_context *ctxt, void *user_data) - sizeof (test_blob3)), - "bin_blob3"); - gcc_jit_global_set_initializer (glob, test_blob3, sizeof (test_blob3)); -+ -+ gcc_jit_rvalue *forty_two = gcc_jit_context_new_rvalue_from_int ( -+ ctxt, unsigned_type, 42); -+ -+ glob = -+ gcc_jit_context_new_global ( -+ ctxt, NULL, GCC_JIT_GLOBAL_EXPORTED, -+ unsigned_type, -+ "integer"); -+ gcc_jit_global_set_initializer_value (glob, forty_two); - } - - void -@@ -75,4 +86,8 @@ verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) - CHECK_NON_NULL (glob); - CHECK_VALUE (memcmp (test_blob3, glob, sizeof (test_blob3)), 0); - -+ glob = gcc_jit_result_get_global (result, "integer"); -+ CHECK_NON_NULL (glob); -+ int *value = glob; -+ CHECK_VALUE (*value, 42); - } --- -2.31.1 - diff --git a/gpl-3.0.txt b/gpl-3.0.txt deleted file mode 100644 index f288702d2fa..00000000000 --- a/gpl-3.0.txt +++ /dev/null @@ -1,674 +0,0 @@ - GNU GENERAL PUBLIC LICENSE - Version 3, 29 June 2007 - - Copyright (C) 2007 Free Software Foundation, Inc. - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The GNU General Public License is a free, copyleft license for -software and other kinds of works. - - The licenses for most software and other practical works are designed -to take away your freedom to share and change the works. By contrast, -the GNU General Public License is intended to guarantee your freedom to -share and change all versions of a program--to make sure it remains free -software for all its users. We, the Free Software Foundation, use the -GNU General Public License for most of our software; it applies also to -any other work released this way by its authors. You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -them if you wish), that you receive source code or can get it if you -want it, that you can change the software or use pieces of it in new -free programs, and that you know you can do these things. - - To protect your rights, we need to prevent others from denying you -these rights or asking you to surrender the rights. Therefore, you have -certain responsibilities if you distribute copies of the software, or if -you modify it: responsibilities to respect the freedom of others. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must pass on to the recipients the same -freedoms that you received. You must make sure that they, too, receive -or can get the source code. And you must show them these terms so they -know their rights. - - Developers that use the GNU GPL protect your rights with two steps: -(1) assert copyright on the software, and (2) offer you this License -giving you legal permission to copy, distribute and/or modify it. - - For the developers' and authors' protection, the GPL clearly explains -that there is no warranty for this free software. For both users' and -authors' sake, the GPL requires that modified versions be marked as -changed, so that their problems will not be attributed erroneously to -authors of previous versions. - - Some devices are designed to deny users access to install or run -modified versions of the software inside them, although the manufacturer -can do so. This is fundamentally incompatible with the aim of -protecting users' freedom to change the software. The systematic -pattern of such abuse occurs in the area of products for individuals to -use, which is precisely where it is most unacceptable. Therefore, we -have designed this version of the GPL to prohibit the practice for those -products. If such problems arise substantially in other domains, we -stand ready to extend this provision to those domains in future versions -of the GPL, as needed to protect the freedom of users. - - Finally, every program is threatened constantly by software patents. -States should not allow patents to restrict development and use of -software on general-purpose computers, but in those that do, we wish to -avoid the special danger that patents applied to a free program could -make it effectively proprietary. To prevent this, the GPL assures that -patents cannot be used to render the program non-free. - - The precise terms and conditions for copying, distribution and -modification follow. - - TERMS AND CONDITIONS - - 0. Definitions. - - "This License" refers to version 3 of the GNU General Public License. - - "Copyright" also means copyright-like laws that apply to other kinds of -works, such as semiconductor masks. - - "The Program" refers to any copyrightable work licensed under this -License. Each licensee is addressed as "you". "Licensees" and -"recipients" may be individuals or organizations. - - To "modify" a work means to copy from or adapt all or part of the work -in a fashion requiring copyright permission, other than the making of an -exact copy. The resulting work is called a "modified version" of the -earlier work or a work "based on" the earlier work. - - A "covered work" means either the unmodified Program or a work based -on the Program. - - To "propagate" a work means to do anything with it that, without -permission, would make you directly or secondarily liable for -infringement under applicable copyright law, except executing it on a -computer or modifying a private copy. Propagation includes copying, -distribution (with or without modification), making available to the -public, and in some countries other activities as well. - - To "convey" a work means any kind of propagation that enables other -parties to make or receive copies. Mere interaction with a user through -a computer network, with no transfer of a copy, is not conveying. - - An interactive user interface displays "Appropriate Legal Notices" -to the extent that it includes a convenient and prominently visible -feature that (1) displays an appropriate copyright notice, and (2) -tells the user that there is no warranty for the work (except to the -extent that warranties are provided), that licensees may convey the -work under this License, and how to view a copy of this License. If -the interface presents a list of user commands or options, such as a -menu, a prominent item in the list meets this criterion. - - 1. Source Code. - - The "source code" for a work means the preferred form of the work -for making modifications to it. "Object code" means any non-source -form of a work. - - A "Standard Interface" means an interface that either is an official -standard defined by a recognized standards body, or, in the case of -interfaces specified for a particular programming language, one that -is widely used among developers working in that language. - - The "System Libraries" of an executable work include anything, other -than the work as a whole, that (a) is included in the normal form of -packaging a Major Component, but which is not part of that Major -Component, and (b) serves only to enable use of the work with that -Major Component, or to implement a Standard Interface for which an -implementation is available to the public in source code form. A -"Major Component", in this context, means a major essential component -(kernel, window system, and so on) of the specific operating system -(if any) on which the executable work runs, or a compiler used to -produce the work, or an object code interpreter used to run it. - - The "Corresponding Source" for a work in object code form means all -the source code needed to generate, install, and (for an executable -work) run the object code and to modify the work, including scripts to -control those activities. However, it does not include the work's -System Libraries, or general-purpose tools or generally available free -programs which are used unmodified in performing those activities but -which are not part of the work. For example, Corresponding Source -includes interface definition files associated with source files for -the work, and the source code for shared libraries and dynamically -linked subprograms that the work is specifically designed to require, -such as by intimate data communication or control flow between those -subprograms and other parts of the work. - - The Corresponding Source need not include anything that users -can regenerate automatically from other parts of the Corresponding -Source. - - The Corresponding Source for a work in source code form is that -same work. - - 2. Basic Permissions. - - All rights granted under this License are granted for the term of -copyright on the Program, and are irrevocable provided the stated -conditions are met. This License explicitly affirms your unlimited -permission to run the unmodified Program. The output from running a -covered work is covered by this License only if the output, given its -content, constitutes a covered work. This License acknowledges your -rights of fair use or other equivalent, as provided by copyright law. - - You may make, run and propagate covered works that you do not -convey, without conditions so long as your license otherwise remains -in force. You may convey covered works to others for the sole purpose -of having them make modifications exclusively for you, or provide you -with facilities for running those works, provided that you comply with -the terms of this License in conveying all material for which you do -not control copyright. Those thus making or running the covered works -for you must do so exclusively on your behalf, under your direction -and control, on terms that prohibit them from making any copies of -your copyrighted material outside their relationship with you. - - Conveying under any other circumstances is permitted solely under -the conditions stated below. Sublicensing is not allowed; section 10 -makes it unnecessary. - - 3. Protecting Users' Legal Rights From Anti-Circumvention Law. - - No covered work shall be deemed part of an effective technological -measure under any applicable law fulfilling obligations under article -11 of the WIPO copyright treaty adopted on 20 December 1996, or -similar laws prohibiting or restricting circumvention of such -measures. - - When you convey a covered work, you waive any legal power to forbid -circumvention of technological measures to the extent such circumvention -is effected by exercising rights under this License with respect to -the covered work, and you disclaim any intention to limit operation or -modification of the work as a means of enforcing, against the work's -users, your or third parties' legal rights to forbid circumvention of -technological measures. - - 4. Conveying Verbatim Copies. - - You may convey verbatim copies of the Program's source code as you -receive it, in any medium, provided that you conspicuously and -appropriately publish on each copy an appropriate copyright notice; -keep intact all notices stating that this License and any -non-permissive terms added in accord with section 7 apply to the code; -keep intact all notices of the absence of any warranty; and give all -recipients a copy of this License along with the Program. - - You may charge any price or no price for each copy that you convey, -and you may offer support or warranty protection for a fee. - - 5. Conveying Modified Source Versions. - - You may convey a work based on the Program, or the modifications to -produce it from the Program, in the form of source code under the -terms of section 4, provided that you also meet all of these conditions: - - a) The work must carry prominent notices stating that you modified - it, and giving a relevant date. - - b) The work must carry prominent notices stating that it is - released under this License and any conditions added under section - 7. This requirement modifies the requirement in section 4 to - "keep intact all notices". - - c) You must license the entire work, as a whole, under this - License to anyone who comes into possession of a copy. This - License will therefore apply, along with any applicable section 7 - additional terms, to the whole of the work, and all its parts, - regardless of how they are packaged. This License gives no - permission to license the work in any other way, but it does not - invalidate such permission if you have separately received it. - - d) If the work has interactive user interfaces, each must display - Appropriate Legal Notices; however, if the Program has interactive - interfaces that do not display Appropriate Legal Notices, your - work need not make them do so. - - A compilation of a covered work with other separate and independent -works, which are not by their nature extensions of the covered work, -and which are not combined with it such as to form a larger program, -in or on a volume of a storage or distribution medium, is called an -"aggregate" if the compilation and its resulting copyright are not -used to limit the access or legal rights of the compilation's users -beyond what the individual works permit. Inclusion of a covered work -in an aggregate does not cause this License to apply to the other -parts of the aggregate. - - 6. Conveying Non-Source Forms. - - You may convey a covered work in object code form under the terms -of sections 4 and 5, provided that you also convey the -machine-readable Corresponding Source under the terms of this License, -in one of these ways: - - a) Convey the object code in, or embodied in, a physical product - (including a physical distribution medium), accompanied by the - Corresponding Source fixed on a durable physical medium - customarily used for software interchange. - - b) Convey the object code in, or embodied in, a physical product - (including a physical distribution medium), accompanied by a - written offer, valid for at least three years and valid for as - long as you offer spare parts or customer support for that product - model, to give anyone who possesses the object code either (1) a - copy of the Corresponding Source for all the software in the - product that is covered by this License, on a durable physical - medium customarily used for software interchange, for a price no - more than your reasonable cost of physically performing this - conveying of source, or (2) access to copy the - Corresponding Source from a network server at no charge. - - c) Convey individual copies of the object code with a copy of the - written offer to provide the Corresponding Source. This - alternative is allowed only occasionally and noncommercially, and - only if you received the object code with such an offer, in accord - with subsection 6b. - - d) Convey the object code by offering access from a designated - place (gratis or for a charge), and offer equivalent access to the - Corresponding Source in the same way through the same place at no - further charge. You need not require recipients to copy the - Corresponding Source along with the object code. If the place to - copy the object code is a network server, the Corresponding Source - may be on a different server (operated by you or a third party) - that supports equivalent copying facilities, provided you maintain - clear directions next to the object code saying where to find the - Corresponding Source. Regardless of what server hosts the - Corresponding Source, you remain obligated to ensure that it is - available for as long as needed to satisfy these requirements. - - e) Convey the object code using peer-to-peer transmission, provided - you inform other peers where the object code and Corresponding - Source of the work are being offered to the general public at no - charge under subsection 6d. - - A separable portion of the object code, whose source code is excluded -from the Corresponding Source as a System Library, need not be -included in conveying the object code work. - - A "User Product" is either (1) a "consumer product", which means any -tangible personal property which is normally used for personal, family, -or household purposes, or (2) anything designed or sold for incorporation -into a dwelling. In determining whether a product is a consumer product, -doubtful cases shall be resolved in favor of coverage. For a particular -product received by a particular user, "normally used" refers to a -typical or common use of that class of product, regardless of the status -of the particular user or of the way in which the particular user -actually uses, or expects or is expected to use, the product. A product -is a consumer product regardless of whether the product has substantial -commercial, industrial or non-consumer uses, unless such uses represent -the only significant mode of use of the product. - - "Installation Information" for a User Product means any methods, -procedures, authorization keys, or other information required to install -and execute modified versions of a covered work in that User Product from -a modified version of its Corresponding Source. The information must -suffice to ensure that the continued functioning of the modified object -code is in no case prevented or interfered with solely because -modification has been made. - - If you convey an object code work under this section in, or with, or -specifically for use in, a User Product, and the conveying occurs as -part of a transaction in which the right of possession and use of the -User Product is transferred to the recipient in perpetuity or for a -fixed term (regardless of how the transaction is characterized), the -Corresponding Source conveyed under this section must be accompanied -by the Installation Information. But this requirement does not apply -if neither you nor any third party retains the ability to install -modified object code on the User Product (for example, the work has -been installed in ROM). - - The requirement to provide Installation Information does not include a -requirement to continue to provide support service, warranty, or updates -for a work that has been modified or installed by the recipient, or for -the User Product in which it has been modified or installed. Access to a -network may be denied when the modification itself materially and -adversely affects the operation of the network or violates the rules and -protocols for communication across the network. - - Corresponding Source conveyed, and Installation Information provided, -in accord with this section must be in a format that is publicly -documented (and with an implementation available to the public in -source code form), and must require no special password or key for -unpacking, reading or copying. - - 7. Additional Terms. - - "Additional permissions" are terms that supplement the terms of this -License by making exceptions from one or more of its conditions. -Additional permissions that are applicable to the entire Program shall -be treated as though they were included in this License, to the extent -that they are valid under applicable law. If additional permissions -apply only to part of the Program, that part may be used separately -under those permissions, but the entire Program remains governed by -this License without regard to the additional permissions. - - When you convey a copy of a covered work, you may at your option -remove any additional permissions from that copy, or from any part of -it. (Additional permissions may be written to require their own -removal in certain cases when you modify the work.) You may place -additional permissions on material, added by you to a covered work, -for which you have or can give appropriate copyright permission. - - Notwithstanding any other provision of this License, for material you -add to a covered work, you may (if authorized by the copyright holders of -that material) supplement the terms of this License with terms: - - a) Disclaiming warranty or limiting liability differently from the - terms of sections 15 and 16 of this License; or - - b) Requiring preservation of specified reasonable legal notices or - author attributions in that material or in the Appropriate Legal - Notices displayed by works containing it; or - - c) Prohibiting misrepresentation of the origin of that material, or - requiring that modified versions of such material be marked in - reasonable ways as different from the original version; or - - d) Limiting the use for publicity purposes of names of licensors or - authors of the material; or - - e) Declining to grant rights under trademark law for use of some - trade names, trademarks, or service marks; or - - f) Requiring indemnification of licensors and authors of that - material by anyone who conveys the material (or modified versions of - it) with contractual assumptions of liability to the recipient, for - any liability that these contractual assumptions directly impose on - those licensors and authors. - - All other non-permissive additional terms are considered "further -restrictions" within the meaning of section 10. If the Program as you -received it, or any part of it, contains a notice stating that it is -governed by this License along with a term that is a further -restriction, you may remove that term. If a license document contains -a further restriction but permits relicensing or conveying under this -License, you may add to a covered work material governed by the terms -of that license document, provided that the further restriction does -not survive such relicensing or conveying. - - If you add terms to a covered work in accord with this section, you -must place, in the relevant source files, a statement of the -additional terms that apply to those files, or a notice indicating -where to find the applicable terms. - - Additional terms, permissive or non-permissive, may be stated in the -form of a separately written license, or stated as exceptions; -the above requirements apply either way. - - 8. Termination. - - You may not propagate or modify a covered work except as expressly -provided under this License. Any attempt otherwise to propagate or -modify it is void, and will automatically terminate your rights under -this License (including any patent licenses granted under the third -paragraph of section 11). - - However, if you cease all violation of this License, then your -license from a particular copyright holder is reinstated (a) -provisionally, unless and until the copyright holder explicitly and -finally terminates your license, and (b) permanently, if the copyright -holder fails to notify you of the violation by some reasonable means -prior to 60 days after the cessation. - - Moreover, your license from a particular copyright holder is -reinstated permanently if the copyright holder notifies you of the -violation by some reasonable means, this is the first time you have -received notice of violation of this License (for any work) from that -copyright holder, and you cure the violation prior to 30 days after -your receipt of the notice. - - Termination of your rights under this section does not terminate the -licenses of parties who have received copies or rights from you under -this License. If your rights have been terminated and not permanently -reinstated, you do not qualify to receive new licenses for the same -material under section 10. - - 9. Acceptance Not Required for Having Copies. - - You are not required to accept this License in order to receive or -run a copy of the Program. Ancillary propagation of a covered work -occurring solely as a consequence of using peer-to-peer transmission -to receive a copy likewise does not require acceptance. However, -nothing other than this License grants you permission to propagate or -modify any covered work. These actions infringe copyright if you do -not accept this License. Therefore, by modifying or propagating a -covered work, you indicate your acceptance of this License to do so. - - 10. Automatic Licensing of Downstream Recipients. - - Each time you convey a covered work, the recipient automatically -receives a license from the original licensors, to run, modify and -propagate that work, subject to this License. You are not responsible -for enforcing compliance by third parties with this License. - - An "entity transaction" is a transaction transferring control of an -organization, or substantially all assets of one, or subdividing an -organization, or merging organizations. If propagation of a covered -work results from an entity transaction, each party to that -transaction who receives a copy of the work also receives whatever -licenses to the work the party's predecessor in interest had or could -give under the previous paragraph, plus a right to possession of the -Corresponding Source of the work from the predecessor in interest, if -the predecessor has it or can get it with reasonable efforts. - - You may not impose any further restrictions on the exercise of the -rights granted or affirmed under this License. For example, you may -not impose a license fee, royalty, or other charge for exercise of -rights granted under this License, and you may not initiate litigation -(including a cross-claim or counterclaim in a lawsuit) alleging that -any patent claim is infringed by making, using, selling, offering for -sale, or importing the Program or any portion of it. - - 11. Patents. - - A "contributor" is a copyright holder who authorizes use under this -License of the Program or a work on which the Program is based. The -work thus licensed is called the contributor's "contributor version". - - A contributor's "essential patent claims" are all patent claims -owned or controlled by the contributor, whether already acquired or -hereafter acquired, that would be infringed by some manner, permitted -by this License, of making, using, or selling its contributor version, -but do not include claims that would be infringed only as a -consequence of further modification of the contributor version. For -purposes of this definition, "control" includes the right to grant -patent sublicenses in a manner consistent with the requirements of -this License. - - Each contributor grants you a non-exclusive, worldwide, royalty-free -patent license under the contributor's essential patent claims, to -make, use, sell, offer for sale, import and otherwise run, modify and -propagate the contents of its contributor version. - - In the following three paragraphs, a "patent license" is any express -agreement or commitment, however denominated, not to enforce a patent -(such as an express permission to practice a patent or covenant not to -sue for patent infringement). To "grant" such a patent license to a -party means to make such an agreement or commitment not to enforce a -patent against the party. - - If you convey a covered work, knowingly relying on a patent license, -and the Corresponding Source of the work is not available for anyone -to copy, free of charge and under the terms of this License, through a -publicly available network server or other readily accessible means, -then you must either (1) cause the Corresponding Source to be so -available, or (2) arrange to deprive yourself of the benefit of the -patent license for this particular work, or (3) arrange, in a manner -consistent with the requirements of this License, to extend the patent -license to downstream recipients. "Knowingly relying" means you have -actual knowledge that, but for the patent license, your conveying the -covered work in a country, or your recipient's use of the covered work -in a country, would infringe one or more identifiable patents in that -country that you have reason to believe are valid. - - If, pursuant to or in connection with a single transaction or -arrangement, you convey, or propagate by procuring conveyance of, a -covered work, and grant a patent license to some of the parties -receiving the covered work authorizing them to use, propagate, modify -or convey a specific copy of the covered work, then the patent license -you grant is automatically extended to all recipients of the covered -work and works based on it. - - A patent license is "discriminatory" if it does not include within -the scope of its coverage, prohibits the exercise of, or is -conditioned on the non-exercise of one or more of the rights that are -specifically granted under this License. You may not convey a covered -work if you are a party to an arrangement with a third party that is -in the business of distributing software, under which you make payment -to the third party based on the extent of your activity of conveying -the work, and under which the third party grants, to any of the -parties who would receive the covered work from you, a discriminatory -patent license (a) in connection with copies of the covered work -conveyed by you (or copies made from those copies), or (b) primarily -for and in connection with specific products or compilations that -contain the covered work, unless you entered into that arrangement, -or that patent license was granted, prior to 28 March 2007. - - Nothing in this License shall be construed as excluding or limiting -any implied license or other defenses to infringement that may -otherwise be available to you under applicable patent law. - - 12. No Surrender of Others' Freedom. - - If conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot convey a -covered work so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you may -not convey it at all. For example, if you agree to terms that obligate you -to collect a royalty for further conveying from those to whom you convey -the Program, the only way you could satisfy both those terms and this -License would be to refrain entirely from conveying the Program. - - 13. Use with the GNU Affero General Public License. - - Notwithstanding any other provision of this License, you have -permission to link or combine any covered work with a work licensed -under version 3 of the GNU Affero General Public License into a single -combined work, and to convey the resulting work. The terms of this -License will continue to apply to the part which is the covered work, -but the special requirements of the GNU Affero General Public License, -section 13, concerning interaction through a network will apply to the -combination as such. - - 14. Revised Versions of this License. - - The Free Software Foundation may publish revised and/or new versions of -the GNU General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - - Each version is given a distinguishing version number. If the -Program specifies that a certain numbered version of the GNU General -Public License "or any later version" applies to it, you have the -option of following the terms and conditions either of that numbered -version or of any later version published by the Free Software -Foundation. If the Program does not specify a version number of the -GNU General Public License, you may choose any version ever published -by the Free Software Foundation. - - If the Program specifies that a proxy can decide which future -versions of the GNU General Public License can be used, that proxy's -public statement of acceptance of a version permanently authorizes you -to choose that version for the Program. - - Later license versions may give you additional or different -permissions. However, no additional obligations are imposed on any -author or copyright holder as a result of your choosing to follow a -later version. - - 15. Disclaimer of Warranty. - - THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY -APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT -HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY -OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, -THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM -IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF -ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. Limitation of Liability. - - IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS -THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY -GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE -USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF -DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD -PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), -EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF -SUCH DAMAGES. - - 17. Interpretation of Sections 15 and 16. - - If the disclaimer of warranty and limitation of liability provided -above cannot be given local legal effect according to their terms, -reviewing courts shall apply local law that most closely approximates -an absolute waiver of all civil liability in connection with the -Program, unless a warranty or assumption of liability accompanies a -copy of the Program in return for a fee. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -state the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . - -Also add information on how to contact you by electronic and paper mail. - - If the program does terminal interaction, make it output a short -notice like this when it starts in an interactive mode: - - Copyright (C) - This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, your program's commands -might be different; for a GUI interface, you would use an "about box". - - You should also get your employer (if you work as a programmer) or school, -if any, to sign a "copyright disclaimer" for the program, if necessary. -For more information on this, and how to apply and follow the GNU GPL, see -. - - The GNU General Public License does not permit incorporating your program -into proprietary programs. If your program is a subroutine library, you -may consider it more useful to permit linking proprietary applications with -the library. If this is what you want to do, use the GNU Lesser General -Public License instead of this License. But first, please read -. diff --git a/test.sh b/test.sh index e92c37bcac9..73c9fc5f54b 100755 --- a/test.sh +++ b/test.sh @@ -1,5 +1,7 @@ #!/bin/bash +# TODO: rewrite to cargo-make or something like that to only rebuild the sysroot when needed? + #set -x set -e