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, &param_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
> >

Reply via email to