Reattaching file due to previous patch merge issues. Please alert me if anything happens again.
On Sun, Nov 1, 2026 at 3:58 PM Vincent Li <[email protected]> wrote: > > Thanks for the response! I believe I've got everything lined back up > according to your suggestions. > > Vincent Li is my legal name used for the DCO sign-off, and Marcus > Valette was just an old display handle on my Gmail account—fixed the > sender header for v2. Sorry for any confusion that may have caused. > > --------- >8 ------------------ > > From 0eff1430218fb1eb3768500f82a8998c31db7e75 Mon Sep 17 00:00:00 2001 > From: Vincent Li <[email protected]> > Date: Fri, 23 Oct 2026 13:23:48 -0400 > Subject: [PATCH v2] jit: Add support for computed gotos and block addresses > > This patch adds `gcc_jit_block_get_address` and > `gcc_jit_block_end_with_indirect_jump` > under ABI version LIBGCCJIT_ABI_39. This exposes GNU C > labels-as-values (`&&label`) > and indirect jumps (`goto *expr;`) in libgccjit, enabling JIT-compiled > interpreter > dispatch loops and state machines to implement direct-threaded code tables. > > Tested on x86_64-pc-linux-gnu. All 30 iterations of > jit.dg/test-indirect-jump.c > passed across -O0 to -O3. check_GNU_style.py reports 0 errors. > > gcc/jit/ChangeLog: > > * docs/topics/expressions.rst (gcc_jit_block_get_address): Document. > * docs/topics/functions.rst > (gcc_jit_block_end_with_indirect_jump): Document. > * jit-playback.cc (playback::block::get_address): New method. > (playback::block::add_indirect_jump): New method. > * jit-playback.h (playback::block::get_address): New method. > (playback::block::add_indirect_jump): New method. > * jit-recording.cc (recording::block::get_address): New method. > (recording::block::end_with_indirect_jump): New method. > (recording::get_block_address::replay_into): New method. > (recording::get_block_address::make_debug_string): New method. > (recording::get_block_address::write_reproducer): New method. > (recording::indirect_jump::replay_into): New method. > (recording::indirect_jump::get_successor_blocks): New method. > (recording::indirect_jump::make_debug_string): New method. > (recording::indirect_jump::write_reproducer): New method. > * jit-recording.h (class get_block_address): New class. > (class indirect_jump): New class. > (recording::block::get_address): New method. > (recording::block::end_with_indirect_jump): New method. > * libgccjit.cc (gcc_jit_block_get_address): New entrypoint. > (gcc_jit_block_end_with_indirect_jump): New entrypoint. > * libgccjit.h (LIBGCCJIT_HAVE_gcc_jit_block_get_address): New macro. > (LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump): New macro. > (gcc_jit_block_get_address): New declaration. > (gcc_jit_block_end_with_indirect_jump): New declaration. > * libgccjit.map (LIBGCCJIT_ABI_39): Add gcc_jit_block_get_address and > gcc_jit_block_end_with_indirect_jump. > > gcc/testsuite/ChangeLog: > > * jit.dg/all-non-failing-tests.h: Include test-indirect-jump.c. > * jit.dg/test-indirect-jump.c: New test. > > Signed-off-by: Vincent Li <[email protected]> > --- > gcc/jit/docs/topics/compatibility.rst | 8 + > gcc/jit/docs/topics/functions.rst | 40 +++++ > gcc/jit/jit-playback.cc | 43 +++++ > gcc/jit/jit-playback.h | 7 + > gcc/jit/jit-recording.cc | 157 ++++++++++++++++++ > gcc/jit/jit-recording.h | 59 ++++++- > gcc/jit/libgccjit.cc | 68 ++++++++ > gcc/jit/libgccjit.h | 45 ++++- > gcc/jit/libgccjit.map | 6 + > gcc/testsuite/jit.dg/all-non-failing-tests.h | 10 ++ > .../jit.dg/test-error-indirect-jump.c | 112 +++++++++++++ > gcc/testsuite/jit.dg/test-indirect-jump.c | 109 ++++++++++++ > 12 files changed, 661 insertions(+), 3 deletions(-) > create mode 100644 gcc/testsuite/jit.dg/test-error-indirect-jump.c > create mode 100644 gcc/testsuite/jit.dg/test-indirect-jump.c > > diff --git a/gcc/jit/docs/topics/compatibility.rst > b/gcc/jit/docs/topics/compatibility.rst > index e4a231e79..ca1a428f3 100644 > --- a/gcc/jit/docs/topics/compatibility.rst > +++ b/gcc/jit/docs/topics/compatibility.rst > @@ -489,3 +489,11 @@ information: > ``LIBGCCJIT_ABI_38`` covers the addition of > > * :func:`gcc_jit_type_is_floating_point` > + > + .. _LIBGCCJIT_ABI_39: > + > +``LIBGCCJIT_ABI_39`` > +----------------------- > +``LIBGCCJIT_ABI_39`` covers the addition of API entrypoints > + * :func:`gcc_jit_block_get_address` > + * :func:`gcc_jit_block_end_with_indirect_jump` > diff --git a/gcc/jit/docs/topics/functions.rst > b/gcc/jit/docs/topics/functions.rst > index 66d4b6b2f..67818881d 100644 > --- a/gcc/jit/docs/topics/functions.rst > +++ b/gcc/jit/docs/topics/functions.rst > @@ -466,6 +466,46 @@ Statements > > goto target; > > +.. function:: gcc_jit_rvalue *\ > + gcc_jit_block_get_address (gcc_jit_block *block,\ > + gcc_jit_location *loc) > + > + Get the address of a block as a ``void *`` rvalue, equivalent to GNU C's > + ``&&label`` extension. > + > + ``block`` must be non-NULL. > + > + This API entrypoint was added in :ref:`LIBGCCJIT_ABI_39`; you can test > + for its presence using > + > + .. code-block:: c > + > + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_get_address > + > +.. function:: void\ > + gcc_jit_block_end_with_indirect_jump (\ > + gcc_jit_block *block,\ > + gcc_jit_location *loc,\ > + gcc_jit_rvalue *target_address,\ > + int num_destinations,\ > + gcc_jit_block **destinations) > + > + Terminate a basic block by adding an indirect jump to ``target_address``, > + analogous to GNU C's ``goto *target_address;``. > + > + Here, ``target_address`` must be a pointer rvalue, and ``destinations`` > + must be an array of ``num_destinations`` candidate target blocks within > + the same function. Listing the candidate destination blocks is required > + so that ``libgccjit`` can validate block reachability when checking the > + function. > + > + This API entrypoint was added in ``LIBGCCJIT_ABI_39``; you can test for > its > + presence using: > + > + .. code-block:: c > + > + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump > + > .. function:: void\ > gcc_jit_block_end_with_return (gcc_jit_block *block,\ > gcc_jit_location *loc,\ > diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc > index 56c9413f8..c4c1ec8fd 100644 > --- a/gcc/jit/jit-playback.cc > +++ b/gcc/jit/jit-playback.cc > @@ -2547,6 +2547,49 @@ c_finish_goto_label (location_t loc, tree label) > > } > > +/* Take the address of a block as a void * rvalue (&&block). */ > + > +playback::rvalue * > +playback::block:: > +get_address (location *loc) > +{ > + tree label = as_label_decl (); > + TREE_USED (label) = 1; > + /* Also set during gimplification by gimplify_addr_expr, but marked > + explicitly here when constructing the ADDR_EXPR. */ > + FORCED_LABEL (label) = 1; > + > + tree addr = build1 (ADDR_EXPR, ptr_type_node, label); > + if (loc) > + set_tree_location (addr, loc); > + > + return new rvalue (m_func->m_ctxt, addr); > +} > + > +/* Add an indirect jump statement (goto *target_address;). */ > + > +void > +playback::block::add_indirect_jump (location *loc, > + rvalue *target_address, > + auto_vec <block *> *destinations) > +{ > + unsigned i; > + block *dest; > + FOR_EACH_VEC_ELT (*destinations, i, dest) > + { > + tree label = dest->as_label_decl (); > + TREE_USED (label) = 1; > + FORCED_LABEL (label) = 1; > + } > + > + tree target = target_address->as_tree (); > + target = fold_convert (ptr_type_node, target); > + tree stmt = build1 (GOTO_EXPR, void_type_node, target); > + if (loc) > + set_tree_location (stmt, loc); > + add_stmt (stmt); > +} > + > /* Add a return statement to the function's statement list. */ > > void > diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h > index ad3e41f3d..d32ed4d49 100644 > --- a/gcc/jit/jit-playback.h > +++ b/gcc/jit/jit-playback.h > @@ -692,6 +692,13 @@ public: > add_jump (location *loc, > block *target); > > + rvalue *get_address (location *loc); > + > + void > + add_indirect_jump (location *loc, > + rvalue *target_address, > + auto_vec <block *> *destinations); > + > void > add_return (location *loc, > rvalue *rvalue); > diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc > index e28e5f67c..337f14925 100644 > --- a/gcc/jit/jit-recording.cc > +++ b/gcc/jit/jit-recording.cc > @@ -5072,6 +5072,26 @@ recording::block::end_with_jump > (recording::location *loc, > return result; > } > > +/* Create a recording::end_with_indirect_jump instance and add > + it to the block's context's list of mementos, and to the > + block's list of statements. > + > + Implements the heart of gcc_jit_block_end_with_indirect_jump. */ > + > +recording::statement * > +recording::block::end_with_indirect_jump (location *loc, > + rvalue *target_address, > + int num_destinations, > + block **destinations) > +{ > + statement *result = new indirect_jump (this, loc, target_address, > + num_destinations, destinations); > + m_ctxt->record (result); > + m_statements.safe_push (result); > + m_has_been_terminated = true; > + return result; > +} > + > /* Create a recording::end_with_return instance and add it to > the block's context's list of mementos, and to the block's > list of statements. > @@ -5197,6 +5217,20 @@ recording::block::get_loc () const > return NULL; > } > > +/* Create a recording::get_address instance and add it to > + the block's context's list of mementos, and to the block's > + list of statements. > + > + Implements the heart of gcc_jit_block_get_address. */ > + > +recording::rvalue * > +recording::block::get_address (location *loc) > +{ > + recording::rvalue *result = new get_block_address (m_ctxt, loc, this); > + m_ctxt->record (result); > + return result; > +} > + > /* Get the first statement within a block, if any. */ > > recording::statement * > @@ -7332,6 +7366,45 @@ > recording::get_address_of_lvalue::write_reproducer (reproducer &r) > r.get_identifier (m_loc)); > } > > +/* The implementation of class gcc::jit::recording::get_block_address. */ > + > +/* Implementation of pure virtual hook recording::memento::replay_into > + for recording::get_block_address. */ > + > +void > +recording::get_block_address::replay_into (replayer *r) > +{ > + set_playback_obj ( > + m_block->playback_block ()-> > + get_address (playback_location (r, m_loc))); > +} > + > +/* Implementation of recording::memento::make_debug_string for > + getting the address of a block. */ > + > +recording::string * > +recording::get_block_address::make_debug_string () > +{ > + return string::from_printf (m_ctxt, > + "&&%s", > + m_block->get_debug_string ()); > +} > + > +/* Implementation of recording::memento::write_reproducer for > + get_block_address. */ > + > +void > +recording::get_block_address::write_reproducer (reproducer &r) > +{ > + const char *id = r.make_identifier (this, "address_of"); > + r.write (" gcc_jit_rvalue *%s =\n" > + " gcc_jit_block_get_address (%s,\n" > + " %s);\n", > + id, > + r.get_identifier (m_block), > + r.get_identifier (m_loc)); > +} > + > /* The implementation of class gcc::jit::recording::function_pointer. */ > > /* Implementation of pure virtual hook recording::memento::replay_into > @@ -7765,6 +7838,90 @@ recording::jump::write_reproducer (reproducer &r) > r.get_identifier (m_target)); > } > > +/* The implementation of class gcc::jit::recording::indirect_jump. */ > + > +/* gcc::jit::recording::indirect_jump's constructor. */ > + > +recording::indirect_jump::indirect_jump (block *b, > + location *loc, > + rvalue *target_address, > + int num_destinations, > + block **destinations) > +: statement (b, loc), > + m_target_address (target_address) > +{ > + m_destinations.reserve_exact (num_destinations); > + for (int i = 0; i < num_destinations; i++) > + m_destinations.quick_push (destinations[i]); > +} > + > +/* Implementation of pure virtual hook recording::memento::replay_into > + for recording::indirect_jump. */ > + > +void > +recording::indirect_jump::replay_into (replayer *r) > +{ > + auto_vec <playback::block *> pb_dests; > + pb_dests.reserve_exact (m_destinations.length ()); > + for (unsigned i = 0; i < m_destinations.length (); i++) > + pb_dests.quick_push (m_destinations[i]->playback_block ()); > + > + playback_block (get_block ()) > + ->add_indirect_jump (playback_location (r), > + m_target_address->playback_rvalue (), > + &pb_dests); > +} > + > +/* Override the poisoned default implementation of > + gcc::jit::recording::statement::get_successor_blocks. */ > + > +vec <recording::block *> > +recording::indirect_jump::get_successor_blocks () const > +{ > + vec <block *> result; > + result.create (m_destinations.length ()); > + for (unsigned i = 0; i < m_destinations.length (); i++) > + result.quick_push (m_destinations[i]); > + return result; > +} > + > +/* Implementation of recording::memento::make_debug_string for > + an indirect jump statement. */ > + > +recording::string * > +recording::indirect_jump::make_debug_string () > +{ > + return string::from_printf (m_ctxt, > + "goto *%s;", > + m_target_address->get_debug_string_parens > (PRECEDENCE_UNARY)); > +} > + > +/* Implementation of recording::memento::write_reproducer for > + indirect_jump statements. */ > + > +void > +recording::indirect_jump::write_reproducer (reproducer &r) > +{ > + r.make_identifier (this, "indirect_jump"); > + const char *dests_id = r.make_tmp_identifier ("destinations_for", this); > + r.write (" gcc_jit_block *%s[%i] = {\n", > + dests_id, > + m_destinations.length ()); > + for (unsigned i = 0; i < m_destinations.length (); i++) > + r.write (" %s,\n", r.get_identifier (m_destinations[i])); > + r.write (" };\n"); > + r.write (" gcc_jit_block_end_with_indirect_jump (%s,\n" > + " %s,\n" > + " %s,\n" > + " %i,\n" > + " %s);\n", > + r.get_identifier (get_block ()), > + r.get_identifier (get_loc ()), > + r.get_identifier_as_rvalue (m_target_address), > + m_destinations.length (), > + dests_id); > +} > + > /* The implementation of class gcc::jit::recording::return_. */ > > /* Implementation of pure virtual hook recording::memento::replay_into > diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h > index 2a5f23a05..952761dca 100644 > --- a/gcc/jit/jit-recording.h > +++ b/gcc/jit/jit-recording.h > @@ -966,7 +966,7 @@ public: > type *unqualified () final override { return m_other_type; } > > void replay_into (replayer *) final override; > - memento_of_get_aligned *dyn_cast_aligned_type () final override > + memento_of_get_aligned *dyn_cast_aligned_type () final override > { > return this; > } > @@ -1682,6 +1682,13 @@ public: > end_with_jump (location *loc, > block *target); > > + rvalue * get_address (location *loc); > + > + statement * end_with_indirect_jump (location *loc, > + rvalue *target_address, > + int num_destinations, > + block **destinations); > + > statement * > end_with_return (location *loc, > rvalue *rvalue); > @@ -2427,6 +2434,34 @@ private: > lvalue *m_lvalue; > }; > > +class get_block_address : public rvalue > +{ > +public: > + get_block_address (context *ctxt, > + location *loc, > + block *b) > + : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_VOID_PTR)), > + m_block (b) > + { > + set_scope (b->get_function ()); > + } > + > + void replay_into (replayer *r) final override; > + > + void visit_children (rvalue_visitor *) final override {} > + > +private: > + string * make_debug_string () final override; > + void write_reproducer (reproducer &r) final override; > + enum precedence get_precedence () const final override > + { > + return PRECEDENCE_UNARY; > + } > + > +private: > + block *m_block; > +}; > + > class function_pointer : public rvalue > { > public: > @@ -2650,6 +2685,28 @@ private: > block *m_target; > }; > > +class indirect_jump : public statement > +{ > +public: > + indirect_jump (block *b, > + location *loc, > + rvalue *target_address, > + int num_destinations, > + block **destinations); > + > + void replay_into (replayer *r) final override; > + > + vec <block *> get_successor_blocks () const final override; > + > +private: > + string * make_debug_string () final override; > + void write_reproducer (reproducer &r) final override; > + > +private: > + rvalue *m_target_address; > + auto_vec <block *> m_destinations; > +}; > + > class return_ : public statement > { > public: > diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc > index 5a874fc48..42c6fe828 100644 > --- a/gcc/jit/libgccjit.cc > +++ b/gcc/jit/libgccjit.cc > @@ -2874,6 +2874,23 @@ 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::block::get_address method in > + jit-recording.cc. */ > + > +gcc_jit_rvalue * > +gcc_jit_block_get_address (gcc_jit_block *block, > + gcc_jit_location *loc) > +{ > + RETURN_NULL_IF_FAIL (block, NULL, loc, "NULL block"); > + JIT_LOG_FUNC (block->get_context ()->get_logger ()); > + /* LOC can be NULL. */ > + > + return (gcc_jit_rvalue *)block->get_address (loc); > +} > + > /* Public entrypoint. See description in libgccjit.h. > > After error-checking, the real work is done by the > @@ -3258,6 +3275,57 @@ gcc_jit_block_end_with_jump (gcc_jit_block *block, > block->end_with_jump (loc, target); > } > > +/* Public entrypoint. See description in libgccjit.h. > + > + After error-checking, the real work is done by the > + gcc::jit::recording::block::end_with_indirect_jump method in > + jit-recording.cc. */ > + > +void > +gcc_jit_block_end_with_indirect_jump (gcc_jit_block *block, > + gcc_jit_location *loc, > + gcc_jit_rvalue *target_address, > + int num_destinations, > + gcc_jit_block **destinations) > +{ > + RETURN_IF_NOT_VALID_BLOCK (block, loc); > + gcc::jit::recording::context *ctxt = block->get_context (); > + JIT_LOG_FUNC (ctxt->get_logger ()); > + /* LOC can be NULL. */ > + RETURN_IF_FAIL (target_address, ctxt, loc, "NULL target_address"); > + RETURN_IF_FAIL_PRINTF1 ( > + target_address->get_type ()->is_pointer (), > + ctxt, loc, > + "target_address: %s is not of a pointer type", > + target_address->get_debug_string ()); > + RETURN_IF_FAIL (num_destinations >= 0, ctxt, loc, "num_destinations < 0"); > + if (num_destinations > 0) > + RETURN_IF_FAIL (destinations, ctxt, loc, "NULL destinations"); > + > + for (int i = 0; i < num_destinations; i++) > + { > + RETURN_IF_FAIL_PRINTF1 (destinations[i], ctxt, loc, > + "NULL destination block at index %d", i); > + RETURN_IF_FAIL_PRINTF4 ( > + block->get_function () == destinations[i]->get_function (), > + ctxt, loc, > + "destination block %d (%s) is not in the same function" > + " (function %s) as source block %s", > + i, > + destinations[i]->get_debug_string (), > + destinations[i]->get_function ()->get_debug_string (), > + block->get_debug_string ()); > + } > + > + gcc::jit::recording::statement *stmt = > + block->end_with_indirect_jump (loc, target_address, > + num_destinations, > + (gcc::jit::recording::block **)destinations); > + > + /* target_address must be valid to use within STMT. */ > + target_address->verify_valid_within_stmt (__func__, stmt); > +} > + > /* 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 2247c99de..272085986 100644 > --- a/gcc/jit/libgccjit.h > +++ b/gcc/jit/libgccjit.h > @@ -1455,16 +1455,31 @@ extern gcc_jit_rvalue * > gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue, > gcc_jit_location *loc); > > +#define LIBGCCJIT_HAVE_gcc_jit_block_get_address > + > +/* Taking the address of a block; analogous to: > + &&block > + in C. > + > + This API entrypoint was added in LIBGCCJIT_ABI_39; you can test for its > + presence using > + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_get_address > +*/ > +extern gcc_jit_rvalue * > +gcc_jit_block_get_address (gcc_jit_block *block, > + 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 */ > + #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); > + enum gcc_jit_tls_model model); > > #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section > > @@ -1592,6 +1607,32 @@ gcc_jit_block_end_with_jump (gcc_jit_block *block, > gcc_jit_location *loc, > gcc_jit_block *target); > > +#define LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump > + > +/* Terminate a block by adding an indirect jump to target_address. > + > + All possible indirect jump targets must be constrained to a fixed array. > + > + The candidate destination blocks must be listed in DESTINATIONS > + > + (of length NUM_DESTINATIONS) so that libgccjit can validate block > + > + reachability within the function. > + > + This is roughly equivalent to this C code: > + > + goto *target_address; > + > + This API entrypoint was added in LIBGCCJIT_ABI_39; you can test for its > + presence using > + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump. */ > +extern void > +gcc_jit_block_end_with_indirect_jump (gcc_jit_block *block, > + gcc_jit_location *loc, > + gcc_jit_rvalue *target_address, > + int num_destinations, > + gcc_jit_block **destinations); > + > /* Terminate a block by adding evaluation of an rvalue, returning the value. > > This is roughly equivalent to this C code: > diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map > index 78b6be9ff..9412700a2 100644 > --- a/gcc/jit/libgccjit.map > +++ b/gcc/jit/libgccjit.map > @@ -349,3 +349,9 @@ LIBGCCJIT_ABI_38 { > global: > gcc_jit_type_is_floating_point; > } LIBGCCJIT_ABI_37; > + > +LIBGCCJIT_ABI_39 { > + global: > + gcc_jit_block_get_address; > + gcc_jit_block_end_with_indirect_jump; > +} LIBGCCJIT_ABI_38; > diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h > b/gcc/testsuite/jit.dg/all-non-failing-tests.h > index e8f8463e8..f8202635e 100644 > --- a/gcc/testsuite/jit.dg/all-non-failing-tests.h > +++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h > @@ -269,6 +269,13 @@ > #undef create_code > #undef verify_code > > +/* test-indirect-jump.c */ > +#define create_code create_code_indirect_jump > +#define verify_code verify_code_indirect_jump > +#include "test-indirect-jump.c" > +#undef create_code > +#undef verify_code > + > /* test-link-section-assembler.c: This can't be in the testcases array as it > doesn't have a verify_code implementation. */ > > @@ -688,6 +695,9 @@ const struct testcase testcases[] = { > {"vector_perm", > create_code_vector_perm, > verify_code_vector_perm}, > + {"indirect_jump", > + create_code_indirect_jump, > + verify_code_indirect_jump}, > }; > > const int num_testcases = (sizeof (testcases) / sizeof (testcases[0])); > diff --git a/gcc/testsuite/jit.dg/test-error-indirect-jump.c > b/gcc/testsuite/jit.dg/test-error-indirect-jump.c > new file mode 100644 > index 000000000..8f40a3738 > --- /dev/null > +++ b/gcc/testsuite/jit.dg/test-error-indirect-jump.c > @@ -0,0 +1,112 @@ > +#include <stdlib.h> > +#include <stdio.h> > + > +#include "libgccjit.h" > +#include "harness.h" > + > +void > +create_code (gcc_jit_context *ctxt, void *user_data) > +{ > + /* Let's try to trigger every validation error on > + gcc_jit_block_get_address and gcc_jit_block_end_with_indirect_jump. */ > + gcc_jit_type *void_type = > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID); > + gcc_jit_type *int_type = > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); > + > + gcc_jit_function *fn1 = > + gcc_jit_context_new_function (ctxt, NULL, > + GCC_JIT_FUNCTION_EXPORTED, > + void_type, > + "fn1", > + 0, NULL, > + 0); > + gcc_jit_block *b_fn1 = > + gcc_jit_function_new_block (fn1, "b_fn1"); > + > + gcc_jit_function *fn2 = > + gcc_jit_context_new_function (ctxt, NULL, > + GCC_JIT_FUNCTION_EXPORTED, > + void_type, > + "fn2", > + 0, NULL, > + 0); > + gcc_jit_block *b_fn2 = > + gcc_jit_function_new_block (fn2, "b_fn2"); > + > + /* 1. Non-pointer target_address. */ > + gcc_jit_rvalue * non_ptr = > + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 42); > + gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, non_ptr, 0, NULL); > + CHECK_STRING_VALUE ( > + gcc_jit_context_get_last_error (ctxt), > + "gcc_jit_block_end_with_indirect_jump:" > + " target_address: (int)42 is not of a pointer type"); > + > + /* 2. Negative num_destinations. */ > + gcc_jit_rvalue *addr_fn1 = gcc_jit_block_get_address (b_fn1, NULL); > + gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, -1, NULL); > + CHECK_STRING_VALUE ( > + gcc_jit_context_get_last_error (ctxt), > + "gcc_jit_block_end_with_indirect_jump: num_destinations < 0"); > + > + /* 3. NULL destinations array when num_destinations > 0. */ > + gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1, NULL); > + CHECK_STRING_VALUE ( > + gcc_jit_context_get_last_error (ctxt), > + "gcc_jit_block_end_with_indirect_jump: NULL destinations"); > + > + /* 4. NULL element in destinations array. */ > + gcc_jit_block *null_dests[1] = { NULL }; > + gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1, > null_dests); > + CHECK_STRING_VALUE ( > + gcc_jit_context_get_last_error (ctxt), > + "gcc_jit_block_end_with_indirect_jump:" > + " NULL destination block at index 0"); > + > + /* 5. Destination block in wrong function. */ > + gcc_jit_block *wrong_fn_dests[1] = { b_fn2 }; > + gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1, > + wrong_fn_dests); > + CHECK_STRING_VALUE ( > + gcc_jit_context_get_last_error (ctxt), > + "gcc_jit_block_end_with_indirect_jump:" > + " destination block 0 (b_fn2) is not in the same function" > + " (function fn2) as source block b_fn1"); > + > + /* Terminate b_fn1 cleanly so function validation doesn't overwrite > + last_error with an "unterminated block" error during compile. */ > + gcc_jit_block_end_with_void_return (b_fn1, NULL); > + > + /* 6. Cross-function block address (addr_fn1 used inside fn2). */ > + gcc_jit_block *fn2_dests[1] = { b_fn2 }; > + gcc_jit_block_end_with_indirect_jump (b_fn2, NULL, addr_fn1, 1, > + fn2_dests); > + > + CHECK_STRING_VALUE ( > + gcc_jit_context_get_last_error (ctxt), > + "gcc_jit_block_end_with_indirect_jump:" > + " rvalue &&b_fn1 (type: void *) has scope limited to function fn1" > + " but was used within function fn2" > + " (in statement: goto *&&b_fn1;)"); > +} > + > +void > +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) > +{ > + CHECK_VALUE (result, NULL); > + > + CHECK_STRING_VALUE ( > + gcc_jit_context_get_first_error (ctxt), > + "gcc_jit_block_end_with_indirect_jump:" > + " target_address: (int)42 is not of a pointer type"); > + > + /* Verify that using a block address from fn1 inside fn2 was caught > + by verify_valid_within_stmt. */ > + CHECK_STRING_VALUE ( > + gcc_jit_context_get_last_error (ctxt), > + "gcc_jit_block_end_with_indirect_jump:" > + " rvalue &&b_fn1 (type: void *) has scope limited to function fn1" > + " but was used within function fn2" > + " (in statement: goto *&&b_fn1;)"); > +} > diff --git a/gcc/testsuite/jit.dg/test-indirect-jump.c > b/gcc/testsuite/jit.dg/test-indirect-jump.c > new file mode 100644 > index 000000000..f464a6edb > --- /dev/null > +++ b/gcc/testsuite/jit.dg/test-indirect-jump.c > @@ -0,0 +1,109 @@ > +#include <stdlib.h> > +#include <stdio.h> > + > +#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 > + test_indirect_jump (int idx) > + { > + void *targets[3]; > + targets[0] = &&b_zero; > + targets[1] = &&b_one; > + targets[2] = &&b_two; > + goto *targets[idx]; > + > + b_zero: > + return 10; > + b_one: > + return 20; > + b_two: > + return 30; > + } > + */ > + gcc_jit_type *int_type = > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); > + gcc_jit_type *void_ptr_type = > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR); > + gcc_jit_type *array_type = > + gcc_jit_context_new_array_type (ctxt, NULL, void_ptr_type, 3); > + > + gcc_jit_param *param_idx = > + gcc_jit_context_new_param (ctxt, NULL, int_type, "idx"); > + gcc_jit_function *func = > + gcc_jit_context_new_function (ctxt, NULL, > + GCC_JIT_FUNCTION_EXPORTED, > + int_type, > + "test_indirect_jump", > + 1, ¶m_idx, > + 0); > + > + gcc_jit_block *b_entry = gcc_jit_function_new_block (func, "entry"); > + gcc_jit_block *b_zero = gcc_jit_function_new_block (func, "b_zero"); > + gcc_jit_block *b_one = gcc_jit_function_new_block (func, "b_one"); > + gcc_jit_block *b_two = gcc_jit_function_new_block (func, "b_two"); > + > + gcc_jit_lvalue *targets = > + gcc_jit_function_new_local (func, NULL, array_type, "targets"); > + > + gcc_jit_block *blocks[3] = { b_zero, b_one, b_two }; > + for (int i = 0; i < 3; i++) > + { > + gcc_jit_rvalue *idx_val = > + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, i); > + gcc_jit_lvalue *elem = > + gcc_jit_context_new_array_access (ctxt, NULL, > + gcc_jit_lvalue_as_rvalue (targets), > + idx_val); > + gcc_jit_rvalue *blk_addr = > + gcc_jit_block_get_address (blocks[i], NULL); > + gcc_jit_block_add_assignment (b_entry, NULL, elem, blk_addr); > + } > + > + /* void *target_addr = targets[idx]; */ > + gcc_jit_lvalue *selected_elem = > + gcc_jit_context_new_array_access (ctxt, NULL, > + gcc_jit_lvalue_as_rvalue (targets), > + gcc_jit_param_as_rvalue (param_idx)); > + > + /* goto *targets[idx]; */ > + gcc_jit_block_end_with_indirect_jump ( > + b_entry, NULL, > + gcc_jit_lvalue_as_rvalue (selected_elem), > + 3, blocks); > + > + /* b_zero: return 10; */ > + gcc_jit_block_end_with_return ( > + b_zero, NULL, > + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 10)); > + > + /* b_one: return 20; */ > + gcc_jit_block_end_with_return ( > + b_one, NULL, > + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 20)); > + > + /* b_two: return 30; */ > + gcc_jit_block_end_with_return ( > + b_two, NULL, > + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 30)); > +} > + > +void > +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) > + > +{ > + typedef int (*fn_type) (int); > + CHECK_NON_NULL (result); > + > + fn_type test_indirect_jump = > + (fn_type)gcc_jit_result_get_code (result, "test_indirect_jump"); > + CHECK_NON_NULL (test_indirect_jump); > + > + CHECK_VALUE (test_indirect_jump (0), 10); > + CHECK_VALUE (test_indirect_jump (1), 20); > + CHECK_VALUE (test_indirect_jump (2), 30); > +} > -- > 2.56.0 > > On Sun, Oct 25, 2026 at 7:58 PM David Malcolm <[email protected]> wrote: > > > > On Fri, 2026-10-23 at 13:34 -0400, Marcus Valette wrote: > > > From b55719183abf5ff37373115b5929ebd6ca914258 Mon Sep 17 00:00:00 > > > 2001 > > > From: Vincent Li <[email protected]> > > > Date: Fri, 23 Oct 2026 13:23:48 -0400 > > > Subject: [PATCH] jit: Add support for computed gotos and block > > > addresses > > > > > > This patch adds `gcc_jit_block_get_address` and > > > `gcc_jit_block_end_with_indirect_jump` > > > under ABI version LIBGCCJIT_ABI_39. This exposes GNU C > > > labels-as-values (`&&label`) > > > and indirect jumps (`goto *expr;`) in libgccjit, enabling JIT- > > > compiled > > > interpreter > > > dispatch loops and state machines to implement direct-threaded code > > > tables. > > > > > > Tested on x86_64-pc-linux-gnu. All 30 iterations of jit.dg/test- > > > indirect-jump.c > > > passed across -O0 to -O3. check_GNU_style.py reports 0 errors. > > > > > > gcc/jit/ChangeLog: > > > > > > * docs/topics/expressions.rst (gcc_jit_block_get_address): > > > Document. > > > * docs/topics/functions.rst > > > (gcc_jit_block_end_with_indirect_jump): Document. > > > * jit-playback.cc (playback::block::get_address): New method. > > > (playback::block::add_indirect_jump): New method. > > > * jit-playback.h (playback::block::get_address): New method. > > > (playback::block::add_indirect_jump): New method. > > > * jit-recording.cc (recording::block::get_address): New method. > > > (recording::block::end_with_indirect_jump): New method. > > > (recording::get_block_address::replay_into): New method. > > > (recording::get_block_address::make_debug_string): New method. > > > (recording::get_block_address::write_reproducer): New method. > > > (recording::indirect_jump::replay_into): New method. > > > (recording::indirect_jump::get_successor_blocks): New method. > > > (recording::indirect_jump::make_debug_string): New method. > > > (recording::indirect_jump::write_reproducer): New method. > > > * jit-recording.h (class get_block_address): New class. > > > (class indirect_jump): New class. > > > (recording::block::get_address): New method. > > > (recording::block::end_with_indirect_jump): New method. > > > * libgccjit.cc (gcc_jit_block_get_address): New entrypoint. > > > (gcc_jit_block_end_with_indirect_jump): New entrypoint. > > > * libgccjit.h (LIBGCCJIT_HAVE_gcc_jit_block_get_address): New > > > macro. > > > (LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump): New macro. > > > (gcc_jit_block_get_address): New declaration. > > > (gcc_jit_block_end_with_indirect_jump): New declaration. > > > * libgccjit.map (LIBGCCJIT_ABI_39): Add gcc_jit_block_get_address > > > and > > > gcc_jit_block_end_with_indirect_jump. > > > > > > gcc/testsuite/ChangeLog: > > > > > > * jit.dg/all-non-failing-tests.h: Include test-indirect-jump.c. > > > * jit.dg/test-indirect-jump.c: New test. > > > > > > Signed-off-by: Vincent Li <[email protected]> > > > > > > Thanks for the patch. Overall it looks promising, but there are some > > minor issues. > > > > The From: header reads "Marcus Valette" while the patch author and > > Signed-off-by: both read "Vincent Li", albeit at the same gmail > > address. Who wrote this patch? (the DCO sign-off is standing in for > > copyright assignment here). > > > > I looked on https://gcc.sashiko.dev/ and for some reason I'm not seeing > > this patch there (perhaps because it was To: [email protected] and only > > CC: [email protected] ?) Given that, I had Claude code take a > > look at it; please forgive me for taking the liberty of pasting what it > > said verbatim, since its feedback seems correct to me: > > > > (begin quote): > > > > Verdict: good direction, needs a v2. The design follows the existing > > end_with_extended_asm_goto precedent closely, it applies cleanly to > > master, builds warning-free, and the new test passes including the > > reproducer round-trip. But there are two real defects — one of which is > > an ICE — plus a documentation claim that is factually wrong. > > > > Verification performed > > > > Applied to master @ 9f6f255b68b, built libgccjit.so, ran jit.exp=test- > > indirect-jump.c: 35 passes, 0 failures. The jit harness auto-generates > > and recompiles a reproducer per test, so write_reproducer is covered. > > ABI 39 is the correct next number — LIBGCCJIT_ABI_38 is the current tip > > in both libgccjit.map and compatibility.rst. > > > > I did not run test-combination.c / test-threads.c, which pick up the > > new test via all-non-failing-tests.h. Those should be run before > > commit. > > > > Blockers > > > > 1. ICE instead of a clean error: missing verify_valid_within_stmt > > > > gcc_jit_block_end_with_indirect_jump never calls target_address- > > >verify_valid_within_stmt (__func__, stmt). Every other statement > > entrypoint does — libgccjit.cc:3038, 3082-3083, 3139-3140, 3208, 3297. > > > > Passing a target_address scoped to a different function gives: > > > > internal compiler error: in expand_expr_real_1, at expr.cc:11811 > > > > The identical misuse via gcc_jit_block_end_with_return is diagnosed > > properly: > > > > gcc_jit_block_end_with_return: rvalue g1loc (type: int) has scope > > limited to function g1 but was used within function g2 (in statement: > > return g1loc;) > > > > Fix: capture the statement returned by end_with_indirect_jump and call > > verify_valid_within_stmt on it, as the neighbouring entrypoints do. > > > > 2. Cross-function block addresses silently accepted > > > > recording::get_block_address never calls set_scope (b->get_function > > ()), so m_scope stays NULL and the rvalue is treated as a global. > > Taking &&a_lbl in func_a and jumping to it from func_b produces no > > diagnostic at all. Confirmed via DUMP_INITIAL_GIMPLE: > > > > int func_b () > > { > > b_entry: > > tmp = &a_lbl; /* a_lbl lives in func_a */ > > goto tmp; > > ... > > } > > > > GNU C explicitly forbids jumping to a label in a different function. > > Calling set_scope in the constructor — the same mechanism locals and > > params use — turns this into a clean API error. > > > > 3. The documented rationale for destinations is wrong > > > > Both libgccjit.h and functions.rst say the array is needed "to allow > > GCC's middle-end to construct valid CFG edges." It isn't. Edges come > > from FORCED_LABEL, which gimplify.cc:20972 sets when the address is > > taken and tree-cfg.cc:1046 wires into abnormal edges for every computed > > goto. > > > > I tested a deliberately incomplete destinations list (two labels in the > > jump table, only one listed) at -O3: both targets still dispatch > > correctly, no diagnostic, correct results. > > > > The parameter is load-bearing — recording::function::validate walks > > get_successor_blocks for its reachability check, and without it > > legitimate targets get flagged "unreachable block". That is the honest > > justification and what the docs should say. As written, users are told > > the array is a safety requirement when under-listing is silently > > harmless and over-listing just force-marks extra labels. > > > > Should-fix > > > > - compatibility.rst has no LIBGCCJIT_ABI_39 section. Required for > > every ABI bump; also needed so the docs can use > > :ref:LIBGCCJIT_ABI_39instead of the plain ```LIBGCCJIT_ABI_39`` ``` > > literal the patch uses. The surrounding entries in expressions.rst use > > the :ref: form. > > - gcc_jit_block_get_address is documented in the wrong section. It > > lands at expressions.rst:806, inside Lvalues (which starts at > > line 778), between gcc_jit_lvalue_get_address and > > gcc_jit_lvalue_set_tls_model. It is neither an lvalue operation nor an > > lvalue method — it belongs with the block APIs in functions.rst, next > > to the new end_with_indirect_jump. > > - No error-path tests. The new entrypoints add five validation checks > > and none are covered. jit.dg/test-error-*.c is the convention. > > - Three unrelated hunks. Trailing-whitespace removal at jit- > > recording.h:966, and a comment-terminator plus re-indent of > > gcc_jit_lvalue_set_tls_model in libgccjit.h. Drop them or split into a > > separate cleanup patch — neither is in the ChangeLog. > > - all-non-failing-tests.h ordering. Both the #include block and the > > testcases[] entry are alphabetically sorted; the patch puts the include > > after test-switch.c and the array entry at the very end, rather than > > among the i entries. > > > > Minor > > > > - write_reproducer embeds literal tabs in the strings it emits, so > > generated reproducer files get tab-indented continuation lines. > > extended_asm_goto::write_reproducer uses spaces — match it. > > - indirect_jump::make_debug_string uses get_debug_string () rather > > than get_debug_string_parens (PRECEDENCE_UNARY), so goto *a + b; will > > render ambiguously. > > - playback::block::add_indirect_jump omits the convert > > (ptr_type_node, expr) that c_finish_goto_ptr performs. Not a > > correctness bug today — verify_gimple_goto accepts any POINTER_TYPE_P — > > but normalizing is cheaper than reasoning about named address spaces > > later. > > - The FORCED_LABEL assignment in get_address is redundant with > > gimplify.cc:20972. Harmless; worth a comment if kept. > > - RETURN_IF_FAIL (num_destinations > 0, ...) with message > > "num_destinations <= 0". end_with_extended_asm_goto permits >= 0; and > > the message should describe the problem, not restate the predicate. > > > > (end quote from AI) > > > > Hope this is constructive; thanks again for the patch > > Dave > > > > > > > > > > > > > > > --- > > > gcc/jit/docs/topics/expressions.rst | 14 ++ > > > gcc/jit/docs/topics/functions.rst | 21 +++ > > > gcc/jit/jit-playback.cc | 39 +++++ > > > gcc/jit/jit-playback.h | 7 + > > > gcc/jit/jit-recording.cc | 157 > > > +++++++++++++++++++ > > > gcc/jit/jit-recording.h | 57 ++++++- > > > gcc/jit/libgccjit.cc | 63 ++++++++ > > > gcc/jit/libgccjit.h | 39 ++++- > > > gcc/jit/libgccjit.map | 6 + > > > gcc/testsuite/jit.dg/all-non-failing-tests.h | 10 ++ > > > gcc/testsuite/jit.dg/test-indirect-jump.c | 108 +++++++++++++ > > > 11 files changed, 518 insertions(+), 3 deletions(-) > > > create mode 100644 gcc/testsuite/jit.dg/test-indirect-jump.c > > > > > > diff --git a/gcc/jit/docs/topics/expressions.rst > > > b/gcc/jit/docs/topics/expressions.rst > > > index 680ea1d86..0f9f705fe 100644 > > > --- a/gcc/jit/docs/topics/expressions.rst > > > +++ b/gcc/jit/docs/topics/expressions.rst > > > @@ -806,6 +806,20 @@ where the rvalue is computed by reading from the > > > storage area. > > > > > > in C. > > > > > > +.. function:: gcc_jit_rvalue * \ > > > + gcc_jit_block_get_address (gcc_jit_block *block, \ > > > + gcc_jit_location *loc) > > > + > > > + Get the address of a basic block as an rvalue of type ``void *``, > > > + analogous to GNU C's ``&&label``. > > > + > > > + This API entrypoint was added in ``LIBGCCJIT_ABI_39``; you can > > > test for its > > > + presence using: > > > + > > > + .. code-block:: c > > > + > > > + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_get_address > > > + > > > .. function:: void\ > > > gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue *lvalue,\ > > > enum gcc_jit_tls_model > > > model) > > > diff --git a/gcc/jit/docs/topics/functions.rst > > > b/gcc/jit/docs/topics/functions.rst > > > index 66d4b6b2f..1f2eefb1c 100644 > > > --- a/gcc/jit/docs/topics/functions.rst > > > +++ b/gcc/jit/docs/topics/functions.rst > > > @@ -466,6 +466,27 @@ Statements > > > > > > goto target; > > > > > > +.. function:: void\ > > > + gcc_jit_block_end_with_indirect_jump (\ > > > + gcc_jit_block *block,\ > > > + gcc_jit_location *loc,\ > > > + gcc_jit_rvalue *target_address,\ > > > + int num_destinations,\ > > > + gcc_jit_block **destinations) > > > + > > > + Terminate a basic block by adding an indirect jump to > > > ``target_address``, > > > + analogous to GNU C's ``goto *target_address;``. > > > + > > > + All possible destination blocks must be listed in the > > > ``destinations`` > > > + array to allow GCC's middle-end to construct valid CFG edges. > > > + > > > + This API entrypoint was added in ``LIBGCCJIT_ABI_39``; you can > > > test for its > > > + presence using: > > > + > > > + .. code-block:: c > > > + > > > + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump > > > + > > > .. function:: void\ > > > gcc_jit_block_end_with_return (gcc_jit_block *block,\ > > > gcc_jit_location *loc,\ > > > diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc > > > index 56c9413f8..66a1e8fef 100644 > > > --- a/gcc/jit/jit-playback.cc > > > +++ b/gcc/jit/jit-playback.cc > > > @@ -2547,6 +2547,45 @@ c_finish_goto_label (location_t loc, tree > > > label) > > > > > > } > > > > > > +/* Take the address of a block as a void * rvalue (&&block). */ > > > + > > > +playback::rvalue * > > > +playback::block:: > > > +get_address (location *loc) > > > +{ > > > + tree label = as_label_decl (); > > > + TREE_USED (label) = 1; > > > + FORCED_LABEL (label) = 1; > > > + > > > + tree addr = build1 (ADDR_EXPR, ptr_type_node, label); > > > + if (loc) > > > + set_tree_location (addr, loc); > > > + > > > + return new rvalue (m_func->m_ctxt, addr); > > > +} > > > + > > > +/* Add an indirect jump statement (goto *target_address;). */ > > > + > > > +void > > > +playback::block::add_indirect_jump (location *loc, > > > + rvalue *target_address, > > > + auto_vec <block *> *destinations) > > > +{ > > > + unsigned i; > > > + block *dest; > > > + FOR_EACH_VEC_ELT (*destinations, i, dest) > > > + { > > > + tree label = dest->as_label_decl (); > > > + TREE_USED (label) = 1; > > > + FORCED_LABEL (label) = 1; > > > + } > > > + > > > + tree stmt = build1 (GOTO_EXPR, void_type_node, target_address- > > > >as_tree ()); > > > + if (loc) > > > + set_tree_location (stmt, loc); > > > + add_stmt (stmt); > > > +} > > > + > > > /* Add a return statement to the function's statement list. */ > > > > > > void > > > diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h > > > index ad3e41f3d..d32ed4d49 100644 > > > --- a/gcc/jit/jit-playback.h > > > +++ b/gcc/jit/jit-playback.h > > > @@ -692,6 +692,13 @@ public: > > > add_jump (location *loc, > > > block *target); > > > > > > + rvalue *get_address (location *loc); > > > + > > > + void > > > + add_indirect_jump (location *loc, > > > + rvalue *target_address, > > > + auto_vec <block *> *destinations); > > > + > > > void > > > add_return (location *loc, > > > rvalue *rvalue); > > > diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc > > > index e28e5f67c..47983e06c 100644 > > > --- a/gcc/jit/jit-recording.cc > > > +++ b/gcc/jit/jit-recording.cc > > > @@ -5072,6 +5072,26 @@ recording::block::end_with_jump > > > (recording::location *loc, > > > return result; > > > } > > > > > > +/* Create a recording::end_with_indirect_jump instance and add > > > + it to the block's context's list of mementos, and to the > > > + block's list of statements. > > > + > > > + Implements the heart of gcc_jit_block_end_with_indirect_jump. */ > > > + > > > +recording::statement * > > > +recording::block::end_with_indirect_jump (location *loc, > > > + rvalue *target_address, > > > + int num_destinations, > > > + block **destinations) > > > +{ > > > + statement *result = new indirect_jump (this, loc, target_address, > > > + num_destinations, destinations); > > > + m_ctxt->record (result); > > > + m_statements.safe_push (result); > > > + m_has_been_terminated = true; > > > + return result; > > > +} > > > + > > > /* Create a recording::end_with_return instance and add it to > > > the block's context's list of mementos, and to the block's > > > list of statements. > > > @@ -5197,6 +5217,20 @@ recording::block::get_loc () const > > > return NULL; > > > } > > > > > > +/* Create a recording::get_address instance and add it to > > > + the block's context's list of mementos, and to the block's > > > + list of statements. > > > + > > > + Implements the heart of gcc_jit_block_get_address. */ > > > + > > > +recording::rvalue * > > > +recording::block::get_address (location *loc) > > > +{ > > > + recording::rvalue *result = new get_block_address (m_ctxt, loc, > > > this); > > > + m_ctxt->record (result); > > > + return result; > > > +} > > > + > > > /* Get the first statement within a block, if any. */ > > > > > > recording::statement * > > > @@ -7332,6 +7366,45 @@ > > > recording::get_address_of_lvalue::write_reproducer (reproducer &r) > > > r.get_identifier (m_loc)); > > > } > > > > > > +/* The implementation of class > > > gcc::jit::recording::get_block_address. */ > > > + > > > +/* Implementation of pure virtual hook > > > recording::memento::replay_into > > > + for recording::get_block_address. */ > > > + > > > +void > > > +recording::get_block_address::replay_into (replayer *r) > > > +{ > > > + set_playback_obj ( > > > + m_block->playback_block ()-> > > > + get_address (playback_location (r, m_loc))); > > > +} > > > + > > > +/* Implementation of recording::memento::make_debug_string for > > > + getting the address of a block. */ > > > + > > > +recording::string * > > > +recording::get_block_address::make_debug_string () > > > +{ > > > + return string::from_printf (m_ctxt, > > > + "&&%s", > > > + m_block->get_debug_string ()); > > > +} > > > + > > > +/* Implementation of recording::memento::write_reproducer for > > > + get_block_address. */ > > > + > > > +void > > > +recording::get_block_address::write_reproducer (reproducer &r) > > > +{ > > > + const char *id = r.make_identifier (this, "address_of"); > > > + r.write (" gcc_jit_rvalue *%s =\n" > > > + " gcc_jit_block_get_address (%s,\n" > > > + " %s);\n", > > > + id, > > > + r.get_identifier (m_block), > > > + r.get_identifier (m_loc)); > > > +} > > > + > > > /* The implementation of class > > > gcc::jit::recording::function_pointer. */ > > > > > > /* Implementation of pure virtual hook > > > recording::memento::replay_into > > > @@ -7765,6 +7838,90 @@ recording::jump::write_reproducer (reproducer > > > &r) > > > r.get_identifier (m_target)); > > > } > > > > > > +/* The implementation of class gcc::jit::recording::indirect_jump. > > > */ > > > + > > > +/* gcc::jit::recording::indirect_jump's constructor. */ > > > + > > > +recording::indirect_jump::indirect_jump (block *b, > > > + location *loc, > > > + rvalue *target_address, > > > + int num_destinations, > > > + block **destinations) > > > +: statement (b, loc), > > > + m_target_address (target_address) > > > +{ > > > + m_destinations.reserve_exact (num_destinations); > > > + for (int i = 0; i < num_destinations; i++) > > > + m_destinations.quick_push (destinations[i]); > > > +} > > > + > > > +/* Implementation of pure virtual hook > > > recording::memento::replay_into > > > + for recording::indirect_jump. */ > > > + > > > +void > > > +recording::indirect_jump::replay_into (replayer *r) > > > +{ > > > + auto_vec <playback::block *> pb_dests; > > > + pb_dests.reserve_exact (m_destinations.length ()); > > > + for (unsigned i = 0; i < m_destinations.length (); i++) > > > + pb_dests.quick_push (m_destinations[i]->playback_block ()); > > > + > > > + playback_block (get_block ()) > > > + ->add_indirect_jump (playback_location (r), > > > + m_target_address->playback_rvalue (), > > > + &pb_dests); > > > +} > > > + > > > +/* Override the poisoned default implementation of > > > + gcc::jit::recording::statement::get_successor_blocks. */ > > > + > > > +vec <recording::block *> > > > +recording::indirect_jump::get_successor_blocks () const > > > +{ > > > + vec <block *> result; > > > + result.create (m_destinations.length ()); > > > + for (unsigned i = 0; i < m_destinations.length (); i++) > > > + result.quick_push (m_destinations[i]); > > > + return result; > > > +} > > > + > > > +/* Implementation of recording::memento::make_debug_string for > > > + an indirect jump statement. */ > > > + > > > +recording::string * > > > +recording::indirect_jump::make_debug_string () > > > +{ > > > + return string::from_printf (m_ctxt, > > > + "goto *%s;", > > > + m_target_address->get_debug_string ()); > > > +} > > > + > > > +/* Implementation of recording::memento::write_reproducer for > > > + indirect_jump statements. */ > > > + > > > +void > > > +recording::indirect_jump::write_reproducer (reproducer &r) > > > +{ > > > + r.make_identifier (this, "indirect_jump"); > > > + const char *dests_id = r.make_tmp_identifier ("destinations_for", > > > this); > > > + r.write (" gcc_jit_block *%s[%i] = {\n", > > > + dests_id, > > > + m_destinations.length ()); > > > + for (unsigned i = 0; i < m_destinations.length (); i++) > > > + r.write (" %s,\n", r.get_identifier (m_destinations[i])); > > > + r.write (" };\n"); > > > + r.write (" gcc_jit_block_end_with_indirect_jump (%s,\n" > > > + " %s,\n" > > > + " %s,\n" > > > + " %i,\n" > > > + " %s);\n", > > > + r.get_identifier (get_block ()), > > > + r.get_identifier (get_loc ()), > > > + r.get_identifier_as_rvalue (m_target_address), > > > + m_destinations.length (), > > > + dests_id); > > > +} > > > + > > > /* The implementation of class gcc::jit::recording::return_. */ > > > > > > /* Implementation of pure virtual hook > > > recording::memento::replay_into > > > diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h > > > index 2a5f23a05..c500ea659 100644 > > > --- a/gcc/jit/jit-recording.h > > > +++ b/gcc/jit/jit-recording.h > > > @@ -966,7 +966,7 @@ public: > > > type *unqualified () final override { return m_other_type; } > > > > > > void replay_into (replayer *) final override; > > > - memento_of_get_aligned *dyn_cast_aligned_type () final override > > > + memento_of_get_aligned *dyn_cast_aligned_type () final override > > > { > > > return this; > > > } > > > @@ -1682,6 +1682,13 @@ public: > > > end_with_jump (location *loc, > > > block *target); > > > > > > + rvalue * get_address (location *loc); > > > + > > > + statement * end_with_indirect_jump (location *loc, > > > + rvalue *target_address, > > > + int num_destinations, > > > + block **destinations); > > > + > > > statement * > > > end_with_return (location *loc, > > > rvalue *rvalue); > > > @@ -2427,6 +2434,32 @@ private: > > > lvalue *m_lvalue; > > > }; > > > > > > +class get_block_address : public rvalue > > > +{ > > > +public: > > > + get_block_address (context *ctxt, > > > + location *loc, > > > + block *b) > > > + : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_VOID_PTR)), > > > + m_block (b) > > > + {} > > > + > > > + void replay_into (replayer *r) final override; > > > + > > > + void visit_children (rvalue_visitor *) final override {} > > > + > > > +private: > > > + string * make_debug_string () final override; > > > + void write_reproducer (reproducer &r) final override; > > > + enum precedence get_precedence () const final override > > > + { > > > + return PRECEDENCE_UNARY; > > > + } > > > + > > > +private: > > > + block *m_block; > > > +}; > > > + > > > class function_pointer : public rvalue > > > { > > > public: > > > @@ -2650,6 +2683,28 @@ private: > > > block *m_target; > > > }; > > > > > > +class indirect_jump : public statement > > > +{ > > > +public: > > > + indirect_jump (block *b, > > > + location *loc, > > > + rvalue *target_address, > > > + int num_destinations, > > > + block **destinations); > > > + > > > + void replay_into (replayer *r) final override; > > > + > > > + vec <block *> get_successor_blocks () const final override; > > > + > > > +private: > > > + string * make_debug_string () final override; > > > + void write_reproducer (reproducer &r) final override; > > > + > > > +private: > > > + rvalue *m_target_address; > > > + auto_vec <block *> m_destinations; > > > +}; > > > + > > > class return_ : public statement > > > { > > > public: > > > diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc > > > index 5a874fc48..4fac8c56b 100644 > > > --- a/gcc/jit/libgccjit.cc > > > +++ b/gcc/jit/libgccjit.cc > > > @@ -2874,6 +2874,23 @@ 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::block::get_address method in > > > + jit-recording.cc. */ > > > + > > > +gcc_jit_rvalue * > > > +gcc_jit_block_get_address (gcc_jit_block *block, > > > + gcc_jit_location *loc) > > > +{ > > > + RETURN_NULL_IF_FAIL (block, NULL, loc, "NULL block"); > > > + JIT_LOG_FUNC (block->get_context ()->get_logger ()); > > > + /* LOC can be NULL. */ > > > + > > > + return (gcc_jit_rvalue *)block->get_address (loc); > > > +} > > > + > > > /* Public entrypoint. See description in libgccjit.h. > > > > > > After error-checking, the real work is done by the > > > @@ -3258,6 +3275,52 @@ gcc_jit_block_end_with_jump (gcc_jit_block > > > *block, > > > block->end_with_jump (loc, target); > > > } > > > > > > +/* Public entrypoint. See description in libgccjit.h. > > > + > > > + After error-checking, the real work is done by the > > > + gcc::jit::recording::block::end_with_indirect_jump method in > > > + jit-recording.cc. */ > > > + > > > +void > > > +gcc_jit_block_end_with_indirect_jump (gcc_jit_block *block, > > > + gcc_jit_location *loc, > > > + gcc_jit_rvalue *target_address, > > > + int num_destinations, > > > + gcc_jit_block **destinations) > > > +{ > > > + RETURN_IF_NOT_VALID_BLOCK (block, loc); > > > + gcc::jit::recording::context *ctxt = block->get_context (); > > > + JIT_LOG_FUNC (ctxt->get_logger ()); > > > + /* LOC can be NULL. */ > > > + RETURN_IF_FAIL (target_address, ctxt, loc, "NULL target_address"); > > > + RETURN_IF_FAIL_PRINTF1 ( > > > + target_address->get_type ()->is_pointer (), > > > + ctxt, loc, > > > + "target_address: %s is not of a pointer type", > > > + target_address->get_debug_string ()); > > > + RETURN_IF_FAIL (num_destinations > 0, ctxt, loc, "num_destinations > > > <= 0"); > > > + RETURN_IF_FAIL (destinations, ctxt, loc, "NULL destinations"); > > > + > > > + for (int i = 0; i < num_destinations; i++) > > > + { > > > + RETURN_IF_FAIL_PRINTF1 (destinations[i], ctxt, loc, > > > + "NULL destination block at index %d", i); > > > + RETURN_IF_FAIL_PRINTF4 ( > > > + block->get_function () == destinations[i]->get_function (), > > > + ctxt, loc, > > > + "destination block %d (%s) is not in the same function" > > > + " (function %s) as source block %s", > > > + i, > > > + destinations[i]->get_debug_string (), > > > + destinations[i]->get_function ()->get_debug_string (), > > > + block->get_debug_string ()); > > > + } > > > + > > > + block->end_with_indirect_jump (loc, target_address, > > > + num_destinations, > > > + (gcc::jit::recording::block **)destinations); > > > +} > > > + > > > /* 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 2247c99de..9d00ba33a 100644 > > > --- a/gcc/jit/libgccjit.h > > > +++ b/gcc/jit/libgccjit.h > > > @@ -1455,16 +1455,31 @@ extern gcc_jit_rvalue * > > > gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue, > > > gcc_jit_location *loc); > > > > > > +#define LIBGCCJIT_HAVE_gcc_jit_block_get_address > > > + > > > +/* Taking the address of a block; analogous to: > > > + &&block > > > + in C. > > > + > > > + This API entrypoint was added in LIBGCCJIT_ABI_39; you can test > > > for its > > > + presence using > > > + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_get_address > > > +*/ > > > +extern gcc_jit_rvalue * > > > +gcc_jit_block_get_address (gcc_jit_block *block, > > > + 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 */ > > > + #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); > > > + enum gcc_jit_tls_model model); > > > > > > #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section > > > > > > @@ -1592,6 +1607,26 @@ gcc_jit_block_end_with_jump (gcc_jit_block > > > *block, > > > gcc_jit_location *loc, > > > gcc_jit_block *target); > > > > > > +#define LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump > > > + > > > +/* Terminate a block by adding an indirect jump to target_address. > > > + > > > + All possible indirect jump targets must be constrained to a fixed > > > array. > > > + > > > + This is roughly equivalent to this C code: > > > + > > > + goto *target_address; > > > + > > > + This API entrypoint was added in LIBGCCJIT_ABI_39; you can test > > > for its > > > + presence using > > > + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump. > > > */ > > > +extern void > > > +gcc_jit_block_end_with_indirect_jump (gcc_jit_block *block, > > > + gcc_jit_location *loc, > > > + gcc_jit_rvalue *target_address, > > > + int num_destinations, > > > + gcc_jit_block **destinations); > > > + > > > /* Terminate a block by adding evaluation of an rvalue, returning > > > the value. > > > > > > This is roughly equivalent to this C code: > > > diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map > > > index 78b6be9ff..9412700a2 100644 > > > --- a/gcc/jit/libgccjit.map > > > +++ b/gcc/jit/libgccjit.map > > > @@ -349,3 +349,9 @@ LIBGCCJIT_ABI_38 { > > > global: > > > gcc_jit_type_is_floating_point; > > > } LIBGCCJIT_ABI_37; > > > + > > > +LIBGCCJIT_ABI_39 { > > > + global: > > > + gcc_jit_block_get_address; > > > + gcc_jit_block_end_with_indirect_jump; > > > +} LIBGCCJIT_ABI_38; > > > diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h > > > b/gcc/testsuite/jit.dg/all-non-failing-tests.h > > > index e8f8463e8..5bf18a874 100644 > > > --- a/gcc/testsuite/jit.dg/all-non-failing-tests.h > > > +++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h > > > @@ -448,6 +448,13 @@ > > > #undef create_code > > > #undef verify_code > > > > > > +/* test-indirect-jump.c */ > > > +#define create_code create_code_indirect_jump > > > +#define verify_code verify_code_indirect_jump > > > +#include "test-indirect-jump.c" > > > +#undef create_code > > > +#undef verify_code > > > + > > > /* test-target-info.c: This can't be in the testcases array as it > > > is target-specific. */ > > > > > > @@ -688,6 +695,9 @@ const struct testcase testcases[] = { > > > {"vector_perm", > > > create_code_vector_perm, > > > verify_code_vector_perm}, > > > + {"indirect_jump", > > > + create_code_indirect_jump, > > > + verify_code_indirect_jump}, > > > }; > > > > > > const int num_testcases = (sizeof (testcases) / sizeof > > > (testcases[0])); > > > diff --git a/gcc/testsuite/jit.dg/test-indirect-jump.c > > > b/gcc/testsuite/jit.dg/test-indirect-jump.c > > > new file mode 100644 > > > index 000000000..3d407f7ea > > > --- /dev/null > > > +++ b/gcc/testsuite/jit.dg/test-indirect-jump.c > > > @@ -0,0 +1,108 @@ > > > +#include <stdlib.h> > > > +#include <stdio.h> > > > + > > > +#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 > > > + test_indirect_jump (int idx) > > > + { > > > + void *targets[3]; > > > + targets[0] = &&b_zero; > > > + targets[1] = &&b_one; > > > + targets[2] = &&b_two; > > > + goto *targets[idx]; > > > + > > > + b_zero: > > > + return 10; > > > + b_one: > > > + return 20; > > > + b_two: > > > + return 30; > > > + } > > > + */ > > > + gcc_jit_type *int_type = > > > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); > > > + gcc_jit_type *void_ptr_type = > > > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR); > > > + gcc_jit_type *array_type = > > > + gcc_jit_context_new_array_type (ctxt, NULL, void_ptr_type, 3); > > > + > > > + gcc_jit_param *param_idx = > > > + gcc_jit_context_new_param (ctxt, NULL, int_type, "idx"); > > > + gcc_jit_function *func = > > > + gcc_jit_context_new_function (ctxt, NULL, > > > + GCC_JIT_FUNCTION_EXPORTED, > > > + int_type, > > > + "test_indirect_jump", > > > + 1, ¶m_idx, > > > + 0); > > > + > > > + gcc_jit_block *b_entry = gcc_jit_function_new_block (func, > > > "entry"); > > > + gcc_jit_block *b_zero = gcc_jit_function_new_block (func, > > > "b_zero"); > > > + gcc_jit_block *b_one = gcc_jit_function_new_block (func, "b_one"); > > > + gcc_jit_block *b_two = gcc_jit_function_new_block (func, "b_two"); > > > + > > > + gcc_jit_lvalue *targets = > > > + gcc_jit_function_new_local (func, NULL, array_type, "targets"); > > > + > > > + gcc_jit_block *blocks[3] = { b_zero, b_one, b_two }; > > > + for (int i = 0; i < 3; i++) > > > + { > > > + gcc_jit_rvalue *idx_val = > > > + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, i); > > > + gcc_jit_lvalue *elem = > > > + gcc_jit_context_new_array_access (ctxt, NULL, > > > + gcc_jit_lvalue_as_rvalue (targets), > > > + idx_val); > > > + gcc_jit_rvalue *blk_addr = > > > + gcc_jit_block_get_address (blocks[i], NULL); > > > + gcc_jit_block_add_assignment (b_entry, NULL, elem, blk_addr); > > > + } > > > + > > > + /* void *target_addr = targets[idx]; */ > > > + gcc_jit_lvalue *selected_elem = > > > + gcc_jit_context_new_array_access (ctxt, NULL, > > > + gcc_jit_lvalue_as_rvalue (targets), > > > + gcc_jit_param_as_rvalue (param_idx)); > > > + > > > + /* goto *targets[idx]; */ > > > + gcc_jit_block_end_with_indirect_jump ( > > > + b_entry, NULL, > > > + gcc_jit_lvalue_as_rvalue (selected_elem), > > > + 3, blocks); > > > + > > > + /* b_zero: return 10; */ > > > + gcc_jit_block_end_with_return ( > > > + b_zero, NULL, > > > + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 10)); > > > + > > > + /* b_one: return 20; */ > > > + gcc_jit_block_end_with_return ( > > > + b_one, NULL, > > > + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 20)); > > > + > > > + /* b_two: return 30; */ > > > + gcc_jit_block_end_with_return ( > > > + b_two, NULL, > > > + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 30)); > > > +} > > > + > > > +void > > > +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) > > > +{ > > > + typedef int (*fn_type) (int); > > > + CHECK_NON_NULL (result); > > > + > > > + fn_type test_indirect_jump = > > > + (fn_type)gcc_jit_result_get_code (result, "test_indirect_jump"); > > > + CHECK_NON_NULL (test_indirect_jump); > > > + > > > + CHECK_VALUE (test_indirect_jump (0), 10); > > > + CHECK_VALUE (test_indirect_jump (1), 20); > > > + CHECK_VALUE (test_indirect_jump (2), 30); > > > +} > >
From 0eff1430218fb1eb3768500f82a8998c31db7e75 Mon Sep 17 00:00:00 2001 From: Vincent Li <[email protected]> Date: Fri, 23 Oct 2026 13:23:48 -0400 Subject: [PATCH v2] jit: Add support for computed gotos and block addresses This patch adds `gcc_jit_block_get_address` and `gcc_jit_block_end_with_indirect_jump` under ABI version LIBGCCJIT_ABI_39. This exposes GNU C labels-as-values (`&&label`) and indirect jumps (`goto *expr;`) in libgccjit, enabling JIT-compiled interpreter dispatch loops and state machines to implement direct-threaded code tables. Tested on x86_64-pc-linux-gnu. All 30 iterations of jit.dg/test-indirect-jump.c passed across -O0 to -O3. check_GNU_style.py reports 0 errors. gcc/jit/ChangeLog: * docs/topics/expressions.rst (gcc_jit_block_get_address): Document. * docs/topics/functions.rst (gcc_jit_block_end_with_indirect_jump): Document. * jit-playback.cc (playback::block::get_address): New method. (playback::block::add_indirect_jump): New method. * jit-playback.h (playback::block::get_address): New method. (playback::block::add_indirect_jump): New method. * jit-recording.cc (recording::block::get_address): New method. (recording::block::end_with_indirect_jump): New method. (recording::get_block_address::replay_into): New method. (recording::get_block_address::make_debug_string): New method. (recording::get_block_address::write_reproducer): New method. (recording::indirect_jump::replay_into): New method. (recording::indirect_jump::get_successor_blocks): New method. (recording::indirect_jump::make_debug_string): New method. (recording::indirect_jump::write_reproducer): New method. * jit-recording.h (class get_block_address): New class. (class indirect_jump): New class. (recording::block::get_address): New method. (recording::block::end_with_indirect_jump): New method. * libgccjit.cc (gcc_jit_block_get_address): New entrypoint. (gcc_jit_block_end_with_indirect_jump): New entrypoint. * libgccjit.h (LIBGCCJIT_HAVE_gcc_jit_block_get_address): New macro. (LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump): New macro. (gcc_jit_block_get_address): New declaration. (gcc_jit_block_end_with_indirect_jump): New declaration. * libgccjit.map (LIBGCCJIT_ABI_39): Add gcc_jit_block_get_address and gcc_jit_block_end_with_indirect_jump. gcc/testsuite/ChangeLog: * jit.dg/all-non-failing-tests.h: Include test-indirect-jump.c. * jit.dg/test-indirect-jump.c: New test. Signed-off-by: Vincent Li <[email protected]> --- gcc/jit/docs/topics/compatibility.rst | 8 + gcc/jit/docs/topics/functions.rst | 40 +++++ gcc/jit/jit-playback.cc | 43 +++++ gcc/jit/jit-playback.h | 7 + gcc/jit/jit-recording.cc | 157 ++++++++++++++++++ gcc/jit/jit-recording.h | 59 ++++++- gcc/jit/libgccjit.cc | 68 ++++++++ gcc/jit/libgccjit.h | 45 ++++- gcc/jit/libgccjit.map | 6 + gcc/testsuite/jit.dg/all-non-failing-tests.h | 10 ++ .../jit.dg/test-error-indirect-jump.c | 112 +++++++++++++ gcc/testsuite/jit.dg/test-indirect-jump.c | 109 ++++++++++++ 12 files changed, 661 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/jit.dg/test-error-indirect-jump.c create mode 100644 gcc/testsuite/jit.dg/test-indirect-jump.c diff --git a/gcc/jit/docs/topics/compatibility.rst b/gcc/jit/docs/topics/compatibility.rst index e4a231e79..ca1a428f3 100644 --- a/gcc/jit/docs/topics/compatibility.rst +++ b/gcc/jit/docs/topics/compatibility.rst @@ -489,3 +489,11 @@ information: ``LIBGCCJIT_ABI_38`` covers the addition of * :func:`gcc_jit_type_is_floating_point` + + .. _LIBGCCJIT_ABI_39: + +``LIBGCCJIT_ABI_39`` +----------------------- +``LIBGCCJIT_ABI_39`` covers the addition of API entrypoints + * :func:`gcc_jit_block_get_address` + * :func:`gcc_jit_block_end_with_indirect_jump` diff --git a/gcc/jit/docs/topics/functions.rst b/gcc/jit/docs/topics/functions.rst index 66d4b6b2f..67818881d 100644 --- a/gcc/jit/docs/topics/functions.rst +++ b/gcc/jit/docs/topics/functions.rst @@ -466,6 +466,46 @@ Statements goto target; +.. function:: gcc_jit_rvalue *\ + gcc_jit_block_get_address (gcc_jit_block *block,\ + gcc_jit_location *loc) + + Get the address of a block as a ``void *`` rvalue, equivalent to GNU C's + ``&&label`` extension. + + ``block`` must be non-NULL. + + This API entrypoint was added in :ref:`LIBGCCJIT_ABI_39`; you can test + for its presence using + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_get_address + +.. function:: void\ + gcc_jit_block_end_with_indirect_jump (\ + gcc_jit_block *block,\ + gcc_jit_location *loc,\ + gcc_jit_rvalue *target_address,\ + int num_destinations,\ + gcc_jit_block **destinations) + + Terminate a basic block by adding an indirect jump to ``target_address``, + analogous to GNU C's ``goto *target_address;``. + + Here, ``target_address`` must be a pointer rvalue, and ``destinations`` + must be an array of ``num_destinations`` candidate target blocks within + the same function. Listing the candidate destination blocks is required + so that ``libgccjit`` can validate block reachability when checking the + function. + + This API entrypoint was added in ``LIBGCCJIT_ABI_39``; you can test for its + presence using: + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump + .. function:: void\ gcc_jit_block_end_with_return (gcc_jit_block *block,\ gcc_jit_location *loc,\ diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc index 56c9413f8..c4c1ec8fd 100644 --- a/gcc/jit/jit-playback.cc +++ b/gcc/jit/jit-playback.cc @@ -2547,6 +2547,49 @@ c_finish_goto_label (location_t loc, tree label) } +/* Take the address of a block as a void * rvalue (&&block). */ + +playback::rvalue * +playback::block:: +get_address (location *loc) +{ + tree label = as_label_decl (); + TREE_USED (label) = 1; + /* Also set during gimplification by gimplify_addr_expr, but marked + explicitly here when constructing the ADDR_EXPR. */ + FORCED_LABEL (label) = 1; + + tree addr = build1 (ADDR_EXPR, ptr_type_node, label); + if (loc) + set_tree_location (addr, loc); + + return new rvalue (m_func->m_ctxt, addr); +} + +/* Add an indirect jump statement (goto *target_address;). */ + +void +playback::block::add_indirect_jump (location *loc, + rvalue *target_address, + auto_vec <block *> *destinations) +{ + unsigned i; + block *dest; + FOR_EACH_VEC_ELT (*destinations, i, dest) + { + tree label = dest->as_label_decl (); + TREE_USED (label) = 1; + FORCED_LABEL (label) = 1; + } + + tree target = target_address->as_tree (); + target = fold_convert (ptr_type_node, target); + tree stmt = build1 (GOTO_EXPR, void_type_node, target); + if (loc) + set_tree_location (stmt, loc); + add_stmt (stmt); +} + /* Add a return statement to the function's statement list. */ void diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h index ad3e41f3d..d32ed4d49 100644 --- a/gcc/jit/jit-playback.h +++ b/gcc/jit/jit-playback.h @@ -692,6 +692,13 @@ public: add_jump (location *loc, block *target); + rvalue *get_address (location *loc); + + void + add_indirect_jump (location *loc, + rvalue *target_address, + auto_vec <block *> *destinations); + void add_return (location *loc, rvalue *rvalue); diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc index e28e5f67c..337f14925 100644 --- a/gcc/jit/jit-recording.cc +++ b/gcc/jit/jit-recording.cc @@ -5072,6 +5072,26 @@ recording::block::end_with_jump (recording::location *loc, return result; } +/* Create a recording::end_with_indirect_jump instance and add + it to the block's context's list of mementos, and to the + block's list of statements. + + Implements the heart of gcc_jit_block_end_with_indirect_jump. */ + +recording::statement * +recording::block::end_with_indirect_jump (location *loc, + rvalue *target_address, + int num_destinations, + block **destinations) +{ + statement *result = new indirect_jump (this, loc, target_address, + num_destinations, destinations); + m_ctxt->record (result); + m_statements.safe_push (result); + m_has_been_terminated = true; + return result; +} + /* Create a recording::end_with_return instance and add it to the block's context's list of mementos, and to the block's list of statements. @@ -5197,6 +5217,20 @@ recording::block::get_loc () const return NULL; } +/* Create a recording::get_address instance and add it to + the block's context's list of mementos, and to the block's + list of statements. + + Implements the heart of gcc_jit_block_get_address. */ + +recording::rvalue * +recording::block::get_address (location *loc) +{ + recording::rvalue *result = new get_block_address (m_ctxt, loc, this); + m_ctxt->record (result); + return result; +} + /* Get the first statement within a block, if any. */ recording::statement * @@ -7332,6 +7366,45 @@ recording::get_address_of_lvalue::write_reproducer (reproducer &r) r.get_identifier (m_loc)); } +/* The implementation of class gcc::jit::recording::get_block_address. */ + +/* Implementation of pure virtual hook recording::memento::replay_into + for recording::get_block_address. */ + +void +recording::get_block_address::replay_into (replayer *r) +{ + set_playback_obj ( + m_block->playback_block ()-> + get_address (playback_location (r, m_loc))); +} + +/* Implementation of recording::memento::make_debug_string for + getting the address of a block. */ + +recording::string * +recording::get_block_address::make_debug_string () +{ + return string::from_printf (m_ctxt, + "&&%s", + m_block->get_debug_string ()); +} + +/* Implementation of recording::memento::write_reproducer for + get_block_address. */ + +void +recording::get_block_address::write_reproducer (reproducer &r) +{ + const char *id = r.make_identifier (this, "address_of"); + r.write (" gcc_jit_rvalue *%s =\n" + " gcc_jit_block_get_address (%s,\n" + " %s);\n", + id, + r.get_identifier (m_block), + r.get_identifier (m_loc)); +} + /* The implementation of class gcc::jit::recording::function_pointer. */ /* Implementation of pure virtual hook recording::memento::replay_into @@ -7765,6 +7838,90 @@ recording::jump::write_reproducer (reproducer &r) r.get_identifier (m_target)); } +/* The implementation of class gcc::jit::recording::indirect_jump. */ + +/* gcc::jit::recording::indirect_jump's constructor. */ + +recording::indirect_jump::indirect_jump (block *b, + location *loc, + rvalue *target_address, + int num_destinations, + block **destinations) +: statement (b, loc), + m_target_address (target_address) +{ + m_destinations.reserve_exact (num_destinations); + for (int i = 0; i < num_destinations; i++) + m_destinations.quick_push (destinations[i]); +} + +/* Implementation of pure virtual hook recording::memento::replay_into + for recording::indirect_jump. */ + +void +recording::indirect_jump::replay_into (replayer *r) +{ + auto_vec <playback::block *> pb_dests; + pb_dests.reserve_exact (m_destinations.length ()); + for (unsigned i = 0; i < m_destinations.length (); i++) + pb_dests.quick_push (m_destinations[i]->playback_block ()); + + playback_block (get_block ()) + ->add_indirect_jump (playback_location (r), + m_target_address->playback_rvalue (), + &pb_dests); +} + +/* Override the poisoned default implementation of + gcc::jit::recording::statement::get_successor_blocks. */ + +vec <recording::block *> +recording::indirect_jump::get_successor_blocks () const +{ + vec <block *> result; + result.create (m_destinations.length ()); + for (unsigned i = 0; i < m_destinations.length (); i++) + result.quick_push (m_destinations[i]); + return result; +} + +/* Implementation of recording::memento::make_debug_string for + an indirect jump statement. */ + +recording::string * +recording::indirect_jump::make_debug_string () +{ + return string::from_printf (m_ctxt, + "goto *%s;", + m_target_address->get_debug_string_parens (PRECEDENCE_UNARY)); +} + +/* Implementation of recording::memento::write_reproducer for + indirect_jump statements. */ + +void +recording::indirect_jump::write_reproducer (reproducer &r) +{ + r.make_identifier (this, "indirect_jump"); + const char *dests_id = r.make_tmp_identifier ("destinations_for", this); + r.write (" gcc_jit_block *%s[%i] = {\n", + dests_id, + m_destinations.length ()); + for (unsigned i = 0; i < m_destinations.length (); i++) + r.write (" %s,\n", r.get_identifier (m_destinations[i])); + r.write (" };\n"); + r.write (" gcc_jit_block_end_with_indirect_jump (%s,\n" + " %s,\n" + " %s,\n" + " %i,\n" + " %s);\n", + r.get_identifier (get_block ()), + r.get_identifier (get_loc ()), + r.get_identifier_as_rvalue (m_target_address), + m_destinations.length (), + dests_id); +} + /* The implementation of class gcc::jit::recording::return_. */ /* Implementation of pure virtual hook recording::memento::replay_into diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h index 2a5f23a05..952761dca 100644 --- a/gcc/jit/jit-recording.h +++ b/gcc/jit/jit-recording.h @@ -966,7 +966,7 @@ public: type *unqualified () final override { return m_other_type; } void replay_into (replayer *) final override; - memento_of_get_aligned *dyn_cast_aligned_type () final override + memento_of_get_aligned *dyn_cast_aligned_type () final override { return this; } @@ -1682,6 +1682,13 @@ public: end_with_jump (location *loc, block *target); + rvalue * get_address (location *loc); + + statement * end_with_indirect_jump (location *loc, + rvalue *target_address, + int num_destinations, + block **destinations); + statement * end_with_return (location *loc, rvalue *rvalue); @@ -2427,6 +2434,34 @@ private: lvalue *m_lvalue; }; +class get_block_address : public rvalue +{ +public: + get_block_address (context *ctxt, + location *loc, + block *b) + : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_VOID_PTR)), + m_block (b) + { + set_scope (b->get_function ()); + } + + void replay_into (replayer *r) final override; + + void visit_children (rvalue_visitor *) final override {} + +private: + string * make_debug_string () final override; + void write_reproducer (reproducer &r) final override; + enum precedence get_precedence () const final override + { + return PRECEDENCE_UNARY; + } + +private: + block *m_block; +}; + class function_pointer : public rvalue { public: @@ -2650,6 +2685,28 @@ private: block *m_target; }; +class indirect_jump : public statement +{ +public: + indirect_jump (block *b, + location *loc, + rvalue *target_address, + int num_destinations, + block **destinations); + + void replay_into (replayer *r) final override; + + vec <block *> get_successor_blocks () const final override; + +private: + string * make_debug_string () final override; + void write_reproducer (reproducer &r) final override; + +private: + rvalue *m_target_address; + auto_vec <block *> m_destinations; +}; + class return_ : public statement { public: diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc index 5a874fc48..42c6fe828 100644 --- a/gcc/jit/libgccjit.cc +++ b/gcc/jit/libgccjit.cc @@ -2874,6 +2874,23 @@ 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::block::get_address method in + jit-recording.cc. */ + +gcc_jit_rvalue * +gcc_jit_block_get_address (gcc_jit_block *block, + gcc_jit_location *loc) +{ + RETURN_NULL_IF_FAIL (block, NULL, loc, "NULL block"); + JIT_LOG_FUNC (block->get_context ()->get_logger ()); + /* LOC can be NULL. */ + + return (gcc_jit_rvalue *)block->get_address (loc); +} + /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the @@ -3258,6 +3275,57 @@ gcc_jit_block_end_with_jump (gcc_jit_block *block, block->end_with_jump (loc, target); } +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::block::end_with_indirect_jump method in + jit-recording.cc. */ + +void +gcc_jit_block_end_with_indirect_jump (gcc_jit_block *block, + gcc_jit_location *loc, + gcc_jit_rvalue *target_address, + int num_destinations, + gcc_jit_block **destinations) +{ + RETURN_IF_NOT_VALID_BLOCK (block, loc); + gcc::jit::recording::context *ctxt = block->get_context (); + JIT_LOG_FUNC (ctxt->get_logger ()); + /* LOC can be NULL. */ + RETURN_IF_FAIL (target_address, ctxt, loc, "NULL target_address"); + RETURN_IF_FAIL_PRINTF1 ( + target_address->get_type ()->is_pointer (), + ctxt, loc, + "target_address: %s is not of a pointer type", + target_address->get_debug_string ()); + RETURN_IF_FAIL (num_destinations >= 0, ctxt, loc, "num_destinations < 0"); + if (num_destinations > 0) + RETURN_IF_FAIL (destinations, ctxt, loc, "NULL destinations"); + + for (int i = 0; i < num_destinations; i++) + { + RETURN_IF_FAIL_PRINTF1 (destinations[i], ctxt, loc, + "NULL destination block at index %d", i); + RETURN_IF_FAIL_PRINTF4 ( + block->get_function () == destinations[i]->get_function (), + ctxt, loc, + "destination block %d (%s) is not in the same function" + " (function %s) as source block %s", + i, + destinations[i]->get_debug_string (), + destinations[i]->get_function ()->get_debug_string (), + block->get_debug_string ()); + } + + gcc::jit::recording::statement *stmt = + block->end_with_indirect_jump (loc, target_address, + num_destinations, + (gcc::jit::recording::block **)destinations); + + /* target_address must be valid to use within STMT. */ + target_address->verify_valid_within_stmt (__func__, stmt); +} + /* 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 2247c99de..272085986 100644 --- a/gcc/jit/libgccjit.h +++ b/gcc/jit/libgccjit.h @@ -1455,16 +1455,31 @@ extern gcc_jit_rvalue * gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue, gcc_jit_location *loc); +#define LIBGCCJIT_HAVE_gcc_jit_block_get_address + +/* Taking the address of a block; analogous to: + &&block + in C. + + This API entrypoint was added in LIBGCCJIT_ABI_39; you can test for its + presence using + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_get_address +*/ +extern gcc_jit_rvalue * +gcc_jit_block_get_address (gcc_jit_block *block, + 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 */ + #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); + enum gcc_jit_tls_model model); #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section @@ -1592,6 +1607,32 @@ gcc_jit_block_end_with_jump (gcc_jit_block *block, gcc_jit_location *loc, gcc_jit_block *target); +#define LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump + +/* Terminate a block by adding an indirect jump to target_address. + + All possible indirect jump targets must be constrained to a fixed array. + + The candidate destination blocks must be listed in DESTINATIONS + + (of length NUM_DESTINATIONS) so that libgccjit can validate block + + reachability within the function. + + This is roughly equivalent to this C code: + + goto *target_address; + + This API entrypoint was added in LIBGCCJIT_ABI_39; you can test for its + presence using + #ifdef LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump. */ +extern void +gcc_jit_block_end_with_indirect_jump (gcc_jit_block *block, + gcc_jit_location *loc, + gcc_jit_rvalue *target_address, + int num_destinations, + gcc_jit_block **destinations); + /* Terminate a block by adding evaluation of an rvalue, returning the value. This is roughly equivalent to this C code: diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map index 78b6be9ff..9412700a2 100644 --- a/gcc/jit/libgccjit.map +++ b/gcc/jit/libgccjit.map @@ -349,3 +349,9 @@ LIBGCCJIT_ABI_38 { global: gcc_jit_type_is_floating_point; } LIBGCCJIT_ABI_37; + +LIBGCCJIT_ABI_39 { + global: + gcc_jit_block_get_address; + gcc_jit_block_end_with_indirect_jump; +} LIBGCCJIT_ABI_38; diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h index e8f8463e8..f8202635e 100644 --- a/gcc/testsuite/jit.dg/all-non-failing-tests.h +++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h @@ -269,6 +269,13 @@ #undef create_code #undef verify_code +/* test-indirect-jump.c */ +#define create_code create_code_indirect_jump +#define verify_code verify_code_indirect_jump +#include "test-indirect-jump.c" +#undef create_code +#undef verify_code + /* test-link-section-assembler.c: This can't be in the testcases array as it doesn't have a verify_code implementation. */ @@ -688,6 +695,9 @@ const struct testcase testcases[] = { {"vector_perm", create_code_vector_perm, verify_code_vector_perm}, + {"indirect_jump", + create_code_indirect_jump, + verify_code_indirect_jump}, }; const int num_testcases = (sizeof (testcases) / sizeof (testcases[0])); diff --git a/gcc/testsuite/jit.dg/test-error-indirect-jump.c b/gcc/testsuite/jit.dg/test-error-indirect-jump.c new file mode 100644 index 000000000..8f40a3738 --- /dev/null +++ b/gcc/testsuite/jit.dg/test-error-indirect-jump.c @@ -0,0 +1,112 @@ +#include <stdlib.h> +#include <stdio.h> + +#include "libgccjit.h" +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + /* Let's try to trigger every validation error on + gcc_jit_block_get_address and gcc_jit_block_end_with_indirect_jump. */ + gcc_jit_type *void_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID); + gcc_jit_type *int_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + + gcc_jit_function *fn1 = + gcc_jit_context_new_function (ctxt, NULL, + GCC_JIT_FUNCTION_EXPORTED, + void_type, + "fn1", + 0, NULL, + 0); + gcc_jit_block *b_fn1 = + gcc_jit_function_new_block (fn1, "b_fn1"); + + gcc_jit_function *fn2 = + gcc_jit_context_new_function (ctxt, NULL, + GCC_JIT_FUNCTION_EXPORTED, + void_type, + "fn2", + 0, NULL, + 0); + gcc_jit_block *b_fn2 = + gcc_jit_function_new_block (fn2, "b_fn2"); + + /* 1. Non-pointer target_address. */ + gcc_jit_rvalue * non_ptr = + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 42); + gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, non_ptr, 0, NULL); + CHECK_STRING_VALUE ( + gcc_jit_context_get_last_error (ctxt), + "gcc_jit_block_end_with_indirect_jump:" + " target_address: (int)42 is not of a pointer type"); + + /* 2. Negative num_destinations. */ + gcc_jit_rvalue *addr_fn1 = gcc_jit_block_get_address (b_fn1, NULL); + gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, -1, NULL); + CHECK_STRING_VALUE ( + gcc_jit_context_get_last_error (ctxt), + "gcc_jit_block_end_with_indirect_jump: num_destinations < 0"); + + /* 3. NULL destinations array when num_destinations > 0. */ + gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1, NULL); + CHECK_STRING_VALUE ( + gcc_jit_context_get_last_error (ctxt), + "gcc_jit_block_end_with_indirect_jump: NULL destinations"); + + /* 4. NULL element in destinations array. */ + gcc_jit_block *null_dests[1] = { NULL }; + gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1, null_dests); + CHECK_STRING_VALUE ( + gcc_jit_context_get_last_error (ctxt), + "gcc_jit_block_end_with_indirect_jump:" + " NULL destination block at index 0"); + + /* 5. Destination block in wrong function. */ + gcc_jit_block *wrong_fn_dests[1] = { b_fn2 }; + gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1, + wrong_fn_dests); + CHECK_STRING_VALUE ( + gcc_jit_context_get_last_error (ctxt), + "gcc_jit_block_end_with_indirect_jump:" + " destination block 0 (b_fn2) is not in the same function" + " (function fn2) as source block b_fn1"); + + /* Terminate b_fn1 cleanly so function validation doesn't overwrite + last_error with an "unterminated block" error during compile. */ + gcc_jit_block_end_with_void_return (b_fn1, NULL); + + /* 6. Cross-function block address (addr_fn1 used inside fn2). */ + gcc_jit_block *fn2_dests[1] = { b_fn2 }; + gcc_jit_block_end_with_indirect_jump (b_fn2, NULL, addr_fn1, 1, + fn2_dests); + + CHECK_STRING_VALUE ( + gcc_jit_context_get_last_error (ctxt), + "gcc_jit_block_end_with_indirect_jump:" + " rvalue &&b_fn1 (type: void *) has scope limited to function fn1" + " but was used within function fn2" + " (in statement: goto *&&b_fn1;)"); +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) +{ + CHECK_VALUE (result, NULL); + + CHECK_STRING_VALUE ( + gcc_jit_context_get_first_error (ctxt), + "gcc_jit_block_end_with_indirect_jump:" + " target_address: (int)42 is not of a pointer type"); + + /* Verify that using a block address from fn1 inside fn2 was caught + by verify_valid_within_stmt. */ + CHECK_STRING_VALUE ( + gcc_jit_context_get_last_error (ctxt), + "gcc_jit_block_end_with_indirect_jump:" + " rvalue &&b_fn1 (type: void *) has scope limited to function fn1" + " but was used within function fn2" + " (in statement: goto *&&b_fn1;)"); +} diff --git a/gcc/testsuite/jit.dg/test-indirect-jump.c b/gcc/testsuite/jit.dg/test-indirect-jump.c new file mode 100644 index 000000000..f464a6edb --- /dev/null +++ b/gcc/testsuite/jit.dg/test-indirect-jump.c @@ -0,0 +1,109 @@ +#include <stdlib.h> +#include <stdio.h> + +#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 + test_indirect_jump (int idx) + { + void *targets[3]; + targets[0] = &&b_zero; + targets[1] = &&b_one; + targets[2] = &&b_two; + goto *targets[idx]; + + b_zero: + return 10; + b_one: + return 20; + b_two: + return 30; + } + */ + gcc_jit_type *int_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + gcc_jit_type *void_ptr_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR); + gcc_jit_type *array_type = + gcc_jit_context_new_array_type (ctxt, NULL, void_ptr_type, 3); + + gcc_jit_param *param_idx = + gcc_jit_context_new_param (ctxt, NULL, int_type, "idx"); + gcc_jit_function *func = + gcc_jit_context_new_function (ctxt, NULL, + GCC_JIT_FUNCTION_EXPORTED, + int_type, + "test_indirect_jump", + 1, ¶m_idx, + 0); + + gcc_jit_block *b_entry = gcc_jit_function_new_block (func, "entry"); + gcc_jit_block *b_zero = gcc_jit_function_new_block (func, "b_zero"); + gcc_jit_block *b_one = gcc_jit_function_new_block (func, "b_one"); + gcc_jit_block *b_two = gcc_jit_function_new_block (func, "b_two"); + + gcc_jit_lvalue *targets = + gcc_jit_function_new_local (func, NULL, array_type, "targets"); + + gcc_jit_block *blocks[3] = { b_zero, b_one, b_two }; + for (int i = 0; i < 3; i++) + { + gcc_jit_rvalue *idx_val = + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, i); + gcc_jit_lvalue *elem = + gcc_jit_context_new_array_access (ctxt, NULL, + gcc_jit_lvalue_as_rvalue (targets), + idx_val); + gcc_jit_rvalue *blk_addr = + gcc_jit_block_get_address (blocks[i], NULL); + gcc_jit_block_add_assignment (b_entry, NULL, elem, blk_addr); + } + + /* void *target_addr = targets[idx]; */ + gcc_jit_lvalue *selected_elem = + gcc_jit_context_new_array_access (ctxt, NULL, + gcc_jit_lvalue_as_rvalue (targets), + gcc_jit_param_as_rvalue (param_idx)); + + /* goto *targets[idx]; */ + gcc_jit_block_end_with_indirect_jump ( + b_entry, NULL, + gcc_jit_lvalue_as_rvalue (selected_elem), + 3, blocks); + + /* b_zero: return 10; */ + gcc_jit_block_end_with_return ( + b_zero, NULL, + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 10)); + + /* b_one: return 20; */ + gcc_jit_block_end_with_return ( + b_one, NULL, + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 20)); + + /* b_two: return 30; */ + gcc_jit_block_end_with_return ( + b_two, NULL, + gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 30)); +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) + +{ + typedef int (*fn_type) (int); + CHECK_NON_NULL (result); + + fn_type test_indirect_jump = + (fn_type)gcc_jit_result_get_code (result, "test_indirect_jump"); + CHECK_NON_NULL (test_indirect_jump); + + CHECK_VALUE (test_indirect_jump (0), 10); + CHECK_VALUE (test_indirect_jump (1), 20); + CHECK_VALUE (test_indirect_jump (2), 30); +} -- 2.56.0
