From c867732ee36003759d479497c85135ecfc4a0cf3 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 | 11 +++++++++ gcc/testsuite/jit.dg/all-non-failing-tests.h | 7 ++++++ gcc/testsuite/jit.dg/test-link-section.c | 25 ++++++++++++++++++++ 10 files changed, 123 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..9e722c2bde1 100644 --- a/gcc/jit/libgccjit.map +++ b/gcc/jit/libgccjit.map @@ -205,3 +205,14 @@ LIBGCCJIT_ABI_15 { gcc_jit_extended_asm_add_clobber; gcc_jit_context_add_top_level_asm; } LIBGCCJIT_ABI_14; + +LIBGCCJIT_ABI_16 { +} LIBGCCJIT_ABI_15; + +LIBGCCJIT_ABI_17 { +} LIBGCCJIT_ABI_16; + +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