Hello David, One final ping on this ahead of Sunday's Stage 1 close, in case there's still bandwidth to get LIBGCCJIT_ABI_39 in before Stage 3.
The DCO sign-off issue has been resolved (that was me under an old handle), and the Linaro aarch64 issue was an unrelated issue in libstdc++ atomics which I haven't touched (jit only). Best, Vincent Li On Tue, Nov 10, 2026 at 21:58 Vincent Li <[email protected]> wrote: > Hello Mr. Malcolm, > > Just sending a polite ping on v5 as we approach the Stage 1 close. > > All feedback from v4 has been addressed, and testsuite regressions > are clean (the automated Linaro AArch64 failure on Patchwork appears > to be an unrelated baseline/target flake on libstdc++, as no > target-specific code > was touched and I only edited jit). > > Please let me know if there are any remaining adjustments needed for > trunk approval. > > Thanks, > Vincent Li > > On Sun, Nov 8, 2026 at 12:20 PM Vincent Li <[email protected]> wrote: > > > > The Linaro precommit bot flagged an aarch64 regression in > > libstdc++-dg/conformance.exp: 29_atomics/atomic/wait_notify/127757.cc. > > Looking at the artifact log, this looks like an execution > > timeout/flake under runner load; the patch touches only gcc/jit/ and > > introduces ABI 39 entry points. > > > > On Fri, Nov 6, 2026 at 11:13 PM Vincent Li <[email protected]> wrote: > > > > > > 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/compatibility.rst (LIBGCCJIT_ABI_39): Document. > > > * docs/topics/functions.rst (gcc_jit_block_get_address): > Document. > > > (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.exports: Add gcc_jit_block_get_address and > > > gcc_jit_block_end_with_indirect_jump. > > > * 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-error-block-address-global-init.c: New test. > > > * jit.dg/test-error-indirect-jump.c: New test. > > > * jit.dg/test-indirect-jump.c: New test. > > > > > > Signed-off-by: Vincent Li <[email protected]> > > > --- > > > v4 -> v5 > > > > > > Removed duplicate initializer flag check in > gcc_jit_global_set_initializer_rvalue > > > and redundant visit_children call in verify_valid_within_stmt > > > > > > 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 | 306 +++++++++++++++--- > > > gcc/jit/jit-recording.h | 62 +++- > > > gcc/jit/libgccjit.cc | 71 ++++ > > > gcc/jit/libgccjit.exports | 4 + > > > gcc/jit/libgccjit.h | 45 ++- > > > gcc/jit/libgccjit.map | 6 + > > > gcc/testsuite/jit.dg/all-non-failing-tests.h | 10 + > > > .../test-error-block-address-global-init.c | 79 +++++ > > > .../jit.dg/test-error-indirect-jump.c | 112 +++++++ > > > gcc/testsuite/jit.dg/test-indirect-jump.c | 109 +++++++ > > > 14 files changed, 859 insertions(+), 43 deletions(-) > > > create mode 100644 > gcc/testsuite/jit.dg/test-error-block-address-global-init.c > > > 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..b6c88fd62 100644 > > > --- a/gcc/jit/jit-recording.cc > > > +++ b/gcc/jit/jit-recording.cc > > > @@ -4103,25 +4103,36 @@ class rvalue_usage_validator : public > recording::rvalue_visitor > > > public: > > > rvalue_usage_validator (const char *api_funcname, > > > recording::context *ctxt, > > > - recording::statement *stmt); > > > - > > > + recording::statement *stmt, > > > + recording::lvalue *global = NULL); > > > void > > > visit (recording::rvalue *rvalue) final override; > > > > > > + bool > > > + has_errors () const > > > + { > > > + return m_has_errors; > > > + } > > > + > > > private: > > > const char *m_api_funcname; > > > recording::context *m_ctxt; > > > recording::statement *m_stmt; > > > + recording::lvalue *m_global; > > > + bool m_has_errors; > > > }; > > > > > > /* The trivial constructor for rvalue_usage_validator. */ > > > > > > rvalue_usage_validator::rvalue_usage_validator (const char > *api_funcname, > > > recording::context > *ctxt, > > > - recording::statement > *stmt) > > > + recording::statement > *stmt, > > > + recording::lvalue > *global) > > > : m_api_funcname (api_funcname), > > > m_ctxt (ctxt), > > > - m_stmt (stmt) > > > + m_stmt (stmt), > > > + m_global (global), > > > + m_has_errors (false) > > > { > > > } > > > > > > @@ -4130,43 +4141,88 @@ rvalue_usage_validator::rvalue_usage_validator > (const char *api_funcname, > > > void > > > rvalue_usage_validator::visit (recording::rvalue *rvalue) > > > { > > > - gcc_assert (m_stmt->get_block ()); > > > - recording::function *stmt_scope = m_stmt->get_block > ()->get_function (); > > > - > > > - /* Most rvalues don't have a scope (only locals and params). */ > > > - if (rvalue->get_scope ()) > > > + if (!m_stmt) > > > { > > > - if (rvalue->get_scope () != stmt_scope) > > > - m_ctxt->add_error > > > - (rvalue->get_loc (), > > > - "%s:" > > > - " rvalue %s (type: %s)" > > > - " has scope limited to function %s" > > > - " but was used within function %s" > > > - " (in statement: %s)", > > > - m_api_funcname, > > > - rvalue->get_debug_string (), > > > - rvalue->get_type ()->get_debug_string (), > > > - rvalue->get_scope ()->get_debug_string (), > > > - stmt_scope->get_debug_string (), > > > - m_stmt->get_debug_string ()); > > > + gcc_assert (m_global); > > > + if (rvalue->get_scope ()) > > > + { > > > + m_ctxt->add_error > > > + (rvalue->get_loc (), > > > + "%s:" > > > + " rvalue %s (type: %s)" > > > + " has scope limited to function %s" > > > + " but was used in initializer for global %s", > > > + m_api_funcname, > > > + rvalue->get_debug_string (), > > > + rvalue->get_type ()->get_debug_string (), > > > + rvalue->get_scope ()->get_debug_string (), > > > + m_global->get_debug_string ()); > > > + m_has_errors = true; > > > + } > > > + else if (rvalue->dyn_cast_param ()) > > > + { > > > + m_ctxt->add_error > > > + (rvalue->get_loc (), > > > + "%s:" > > > + " param %s (type: %s)" > > > + " was used in initializer for global %s" > > > + " but is not associated with any function", > > > + m_api_funcname, > > > + rvalue->get_debug_string (), > > > + rvalue->get_type ()->get_debug_string (), > > > + m_global->get_debug_string ()); > > > + m_has_errors = true; > > > + } > > > } > > > else > > > { > > > - if (rvalue->dyn_cast_param ()) > > > - m_ctxt->add_error > > > - (rvalue->get_loc (), > > > - "%s:" > > > - " param %s (type: %s)" > > > - " was used within function %s" > > > - " (in statement: %s)" > > > - " but is not associated with any function", > > > - m_api_funcname, > > > - rvalue->get_debug_string (), > > > - rvalue->get_type ()->get_debug_string (), > > > - stmt_scope->get_debug_string (), > > > - m_stmt->get_debug_string ()); > > > + gcc_assert (m_stmt->get_block ()); > > > + recording::function *stmt_scope = m_stmt->get_block > ()->get_function (); > > > + > > > + /* Most rvalues don't have a scope (only locals, params, and > > > + block addresses). */ > > > + if (rvalue->get_scope ()) > > > + { > > > + if (rvalue->get_scope () != stmt_scope) > > > + { > > > + m_ctxt->add_error > > > + (rvalue->get_loc (), > > > + "%s:" > > > + " rvalue %s (type: %s)" > > > + " has scope limited to function %s" > > > + " but was used within function %s" > > > + " (in statement: %s)", > > > + m_api_funcname, > > > + rvalue->get_debug_string (), > > > + rvalue->get_type ()->get_debug_string (), > > > + rvalue->get_scope ()->get_debug_string (), > > > + stmt_scope->get_debug_string (), > > > + m_stmt->get_debug_string ()); > > > + m_has_errors = true; > > > + } > > > + } > > > + else > > > + { > > > + if (rvalue->dyn_cast_param ()) > > > + { > > > + m_ctxt->add_error > > > + (rvalue->get_loc (), > > > + "%s:" > > > + " param %s (type: %s)" > > > + " was used within function %s" > > > + " (in statement: %s)" > > > + " but is not associated with any function", > > > + m_api_funcname, > > > + rvalue->get_debug_string (), > > > + rvalue->get_type ()->get_debug_string (), > > > + stmt_scope->get_debug_string (), > > > + m_stmt->get_debug_string ()); > > > + m_has_errors = true; > > > + } > > > + } > > > } > > > + > > > + rvalue->visit_children (this); > > > } > > > > > > /* Verify that it's valid to use this rvalue (and all expressions > > > @@ -4185,10 +4241,22 @@ recording::rvalue::verify_valid_within_stmt > (const char *api_funcname, statement > > > > > > /* Verify that it's OK to use this rvalue within s. */ > > > v.visit (this); > > > +} > > > + > > > +/* Verify that it's valid to use this rvalue (and all expressions > > > + in the tree below it) as the initializer for GLOBAL. */ > > > > > > - /* Traverse the expression tree below "this", verifying all rvalues > > > - within it. */ > > > - visit_children (&v); > > > +bool > > > +recording::rvalue::verify_valid_within_global_init (const char > *api_funcname, > > > + lvalue *global) > > > +{ > > > + rvalue_usage_validator v (api_funcname, > > > + global->get_context (), > > > + NULL, > > > + global); > > > + > > > + v.visit (this); > > > + return !v.has_errors (); > > > } > > > > > > /* Set the scope of this rvalue to be the given function. This can > only > > > @@ -5072,6 +5140,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 +5285,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 * > > > @@ -6099,7 +6201,8 @@ void > > > recording::ctor::visit_children (rvalue_visitor *v) > > > { > > > for (unsigned int i = 0; i < m_values.length (); i++) > > > - v->visit (m_values[i]); > > > + if (m_values[i]) > > > + v->visit (m_values[i]); > > > } > > > > > > recording::string * > > > @@ -7332,6 +7435,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 +7907,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..cbcbdf216 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; > > > } > > > @@ -1413,6 +1413,9 @@ public: > > > void > > > verify_valid_within_stmt (const char *api_funcname, statement *s); > > > > > > + bool verify_valid_within_global_init (const char *api_funcname, > > > + lvalue *global); > > > + > > > virtual void visit_children (rvalue_visitor *v) = 0; > > > > > > void set_scope (function *scope); > > > @@ -1682,6 +1685,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 +2437,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 +2688,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..b38f8961e 100644 > > > --- a/gcc/jit/libgccjit.cc > > > +++ b/gcc/jit/libgccjit.cc > > > @@ -1871,6 +1871,9 @@ gcc_jit_global_set_initializer_rvalue > (gcc_jit_lvalue *global, > > > "global variable already initialized: > %s", > > > global->get_debug_string ()); > > > > > > + if (!init_rvalue->verify_valid_within_global_init (__func__, > global)) > > > + return NULL; > > > + > > > /* The global need to know during playback that it will be > > > initialized. */ > > > gbl->set_flags (gcc::jit::GLOBAL_VAR_FLAGS_WILL_BE_RVAL_INIT); > > > @@ -2874,6 +2877,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 +3278,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.exports b/gcc/jit/libgccjit.exports > > > index fae095192..751918c45 100644 > > > --- a/gcc/jit/libgccjit.exports > > > +++ b/gcc/jit/libgccjit.exports > > > @@ -267,3 +267,7 @@ _gcc_jit_context_new_array_type_u64 > > > > > > # LIBGCCJIT_ABI_38 > > > _gcc_jit_type_is_floating_point > > > + > > > +# LIBGCCJIT_ABI_39 > > > +_gcc_jit_block_get_address > > > +_gcc_jit_block_end_with_indirect_jump > > > 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-block-address-global-init.c > b/gcc/testsuite/jit.dg/test-error-block-address-global-init.c > > > new file mode 100644 > > > index 000000000..1df8988ff > > > --- /dev/null > > > +++ b/gcc/testsuite/jit.dg/test-error-block-address-global-init.c > > > @@ -0,0 +1,79 @@ > > > +#include <stdlib.h> > > > +#include <stdio.h> > > > + > > > +#include "libgccjit.h" > > > +#include "harness.h" > > > + > > > +void > > > +create_code (gcc_jit_context *ctxt, void *user_data) > > > +{ > > > + gcc_jit_type *void_type = > > > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID); > > > + gcc_jit_type *void_ptr_type = > > > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR); > > > + > > > + gcc_jit_function *fn = > > > + gcc_jit_context_new_function (ctxt, NULL, > > > + GCC_JIT_FUNCTION_EXPORTED, > > > + void_type, > > > + "my_fn", > > > + 0, NULL, > > > + 0); > > > + gcc_jit_block *block = > > > + gcc_jit_function_new_block (fn, "target_block"); > > > + > > > + gcc_jit_rvalue *block_addr = > > > + gcc_jit_block_get_address (block, NULL); > > > + > > > + /* 1. Direct global initializer (should fail validation). */ > > > + gcc_jit_lvalue *global_ptr = > > > + gcc_jit_context_new_global (ctxt, NULL, > > > + GCC_JIT_GLOBAL_EXPORTED, > > > + void_ptr_type, > > > + "global_ptr"); > > > + CHECK_VALUE ( > > > + gcc_jit_global_set_initializer_rvalue (global_ptr, block_addr), > > > + NULL); > > > + > > > + /* 2. Nested inside an array constructor (should fail validation). > */ > > > + gcc_jit_type *array_type = > > > + gcc_jit_context_new_array_type (ctxt, NULL, void_ptr_type, 1); > > > + gcc_jit_lvalue *global_table = > > > + gcc_jit_context_new_global (ctxt, NULL, > > > + GCC_JIT_GLOBAL_EXPORTED, > > > + array_type, > > > + "global_table"); > > > + gcc_jit_rvalue *ctor = > > > + gcc_jit_context_new_array_constructor (ctxt, NULL, > > > + array_type, > > > + 1, &block_addr); > > > + CHECK_VALUE ( > > > + gcc_jit_global_set_initializer_rvalue (global_table, ctor), > > > + NULL); > > > + > > > + /* Consume ctor (and transitively block_addr) within my_fn so the > > > + generated reproducer reads the variables and avoids > > > + -Werror=unused-but-set-variable. */ > > > + gcc_jit_block_add_eval (block, NULL, ctor); > > > + gcc_jit_block_end_with_void_return (block, NULL); > > > +} > > > + > > > +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_global_set_initializer_rvalue:" > > > + " rvalue &&target_block (type: void *)" > > > + " has scope limited to function my_fn" > > > + " but was used in initializer for global global_ptr"); > > > + > > > + CHECK_STRING_VALUE ( > > > + gcc_jit_context_get_last_error (ctxt), > > > + "gcc_jit_global_set_initializer_rvalue:" > > > + " rvalue &&target_block (type: void *)" > > > + " has scope limited to function my_fn" > > > + " but was used in initializer for global global_table"); > > > +} > > > 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 > > > >
