Reattaching file due to previous patch merge issues. Please alert me
if anything happens again.

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

This patch adds `gcc_jit_block_get_address` and `gcc_jit_block_end_with_indirect_jump`
under ABI version LIBGCCJIT_ABI_39. This exposes GNU C labels-as-values (`&&label`)
and indirect jumps (`goto *expr;`) in libgccjit, enabling JIT-compiled interpreter
dispatch loops and state machines to implement direct-threaded code tables.

Tested on x86_64-pc-linux-gnu. All 30 iterations of jit.dg/test-indirect-jump.c
passed across -O0 to -O3. check_GNU_style.py reports 0 errors.

gcc/jit/ChangeLog:

	* docs/topics/expressions.rst (gcc_jit_block_get_address): Document.
	* docs/topics/functions.rst (gcc_jit_block_end_with_indirect_jump): Document.
	* jit-playback.cc (playback::block::get_address): New method.
	(playback::block::add_indirect_jump): New method.
	* jit-playback.h (playback::block::get_address): New method.
	(playback::block::add_indirect_jump): New method.
	* jit-recording.cc (recording::block::get_address): New method.
	(recording::block::end_with_indirect_jump): New method.
	(recording::get_block_address::replay_into): New method.
	(recording::get_block_address::make_debug_string): New method.
	(recording::get_block_address::write_reproducer): New method.
	(recording::indirect_jump::replay_into): New method.
	(recording::indirect_jump::get_successor_blocks): New method.
	(recording::indirect_jump::make_debug_string): New method.
	(recording::indirect_jump::write_reproducer): New method.
	* jit-recording.h (class get_block_address): New class.
	(class indirect_jump): New class.
	(recording::block::get_address): New method.
	(recording::block::end_with_indirect_jump): New method.
	* libgccjit.cc (gcc_jit_block_get_address): New entrypoint.
	(gcc_jit_block_end_with_indirect_jump): New entrypoint.
	* libgccjit.h (LIBGCCJIT_HAVE_gcc_jit_block_get_address): New macro.
	(LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump): New macro.
	(gcc_jit_block_get_address): New declaration.
	(gcc_jit_block_end_with_indirect_jump): New declaration.
	* libgccjit.map (LIBGCCJIT_ABI_39): Add gcc_jit_block_get_address and
	gcc_jit_block_end_with_indirect_jump.

gcc/testsuite/ChangeLog:

	* jit.dg/all-non-failing-tests.h: Include test-indirect-jump.c.
	* jit.dg/test-indirect-jump.c: New test.

Signed-off-by: Vincent Li <[email protected]>
---
 gcc/jit/docs/topics/compatibility.rst         |   8 +
 gcc/jit/docs/topics/functions.rst             |  40 +++++
 gcc/jit/jit-playback.cc                       |  43 +++++
 gcc/jit/jit-playback.h                        |   7 +
 gcc/jit/jit-recording.cc                      | 157 ++++++++++++++++++
 gcc/jit/jit-recording.h                       |  59 ++++++-
 gcc/jit/libgccjit.cc                          |  68 ++++++++
 gcc/jit/libgccjit.h                           |  45 ++++-
 gcc/jit/libgccjit.map                         |   6 +
 gcc/testsuite/jit.dg/all-non-failing-tests.h  |  10 ++
 .../jit.dg/test-error-indirect-jump.c         | 112 +++++++++++++
 gcc/testsuite/jit.dg/test-indirect-jump.c     | 109 ++++++++++++
 12 files changed, 661 insertions(+), 3 deletions(-)
 create mode 100644 gcc/testsuite/jit.dg/test-error-indirect-jump.c
 create mode 100644 gcc/testsuite/jit.dg/test-indirect-jump.c

diff --git a/gcc/jit/docs/topics/compatibility.rst b/gcc/jit/docs/topics/compatibility.rst
index e4a231e79..ca1a428f3 100644
--- a/gcc/jit/docs/topics/compatibility.rst
+++ b/gcc/jit/docs/topics/compatibility.rst
@@ -489,3 +489,11 @@ information:
 ``LIBGCCJIT_ABI_38`` covers the addition of
 
  * :func:`gcc_jit_type_is_floating_point`
+
+   .. _LIBGCCJIT_ABI_39:
+
+``LIBGCCJIT_ABI_39``
+-----------------------
+``LIBGCCJIT_ABI_39`` covers the addition of API entrypoints
+ * :func:`gcc_jit_block_get_address` 
+ * :func:`gcc_jit_block_end_with_indirect_jump`
diff --git a/gcc/jit/docs/topics/functions.rst b/gcc/jit/docs/topics/functions.rst
index 66d4b6b2f..67818881d 100644
--- a/gcc/jit/docs/topics/functions.rst
+++ b/gcc/jit/docs/topics/functions.rst
@@ -466,6 +466,46 @@ Statements
 
       goto target;
 
+.. function:: gcc_jit_rvalue *\
+              gcc_jit_block_get_address (gcc_jit_block *block,\
+                                         gcc_jit_location *loc)
+
+   Get the address of a block as a ``void *`` rvalue, equivalent to GNU C's
+   ``&&label`` extension.
+
+   ``block`` must be non-NULL.
+
+   This API entrypoint was added in :ref:`LIBGCCJIT_ABI_39`; you can test
+   for its presence using
+
+   .. code-block:: c
+
+      #ifdef LIBGCCJIT_HAVE_gcc_jit_block_get_address
+
+.. function:: void\
+	      gcc_jit_block_end_with_indirect_jump (\
+	      gcc_jit_block *block,\
+	      gcc_jit_location *loc,\
+	      gcc_jit_rvalue *target_address,\
+	      int num_destinations,\
+	      gcc_jit_block **destinations)
+
+   Terminate a basic block by adding an indirect jump to ``target_address``,
+   analogous to GNU C's ``goto *target_address;``.
+
+   Here, ``target_address`` must be a pointer rvalue, and ``destinations``
+   must be an array of ``num_destinations`` candidate target blocks within
+   the same function.  Listing the candidate destination blocks is required
+   so that ``libgccjit`` can validate block reachability when checking the
+   function.
+
+   This API entrypoint was added in ``LIBGCCJIT_ABI_39``; you can test for its
+   presence using:
+
+   .. code-block:: c
+
+      #ifdef LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump
+
 .. function:: void\
               gcc_jit_block_end_with_return (gcc_jit_block *block,\
                                              gcc_jit_location *loc,\
diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc
index 56c9413f8..c4c1ec8fd 100644
--- a/gcc/jit/jit-playback.cc
+++ b/gcc/jit/jit-playback.cc
@@ -2547,6 +2547,49 @@ c_finish_goto_label (location_t loc, tree label)
 
 }
 
+/* Take the address of a block as a void * rvalue (&&block).  */
+
+playback::rvalue *
+playback::block::
+get_address (location *loc)
+{
+  tree label = as_label_decl ();
+  TREE_USED (label) = 1;
+  /* Also set during gimplification by gimplify_addr_expr, but marked
+     explicitly here when constructing the ADDR_EXPR.  */
+  FORCED_LABEL (label) = 1;
+
+  tree addr = build1 (ADDR_EXPR, ptr_type_node, label);
+  if (loc)
+    set_tree_location (addr, loc);
+
+  return new rvalue (m_func->m_ctxt, addr);
+}
+
+/* Add an indirect jump statement (goto *target_address;).  */
+
+void
+playback::block::add_indirect_jump (location *loc,
+				    rvalue *target_address,
+				    auto_vec <block *> *destinations)
+{
+  unsigned i;
+  block *dest;
+  FOR_EACH_VEC_ELT (*destinations, i, dest)
+    {
+      tree label = dest->as_label_decl ();
+      TREE_USED (label) = 1;
+      FORCED_LABEL (label) = 1;
+    }
+
+  tree target = target_address->as_tree ();
+  target = fold_convert (ptr_type_node, target);
+  tree stmt = build1 (GOTO_EXPR, void_type_node, target);
+  if (loc)
+    set_tree_location (stmt, loc);
+  add_stmt (stmt);
+}
+
 /* Add a return statement to the function's statement list.  */
 
 void
diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h
index ad3e41f3d..d32ed4d49 100644
--- a/gcc/jit/jit-playback.h
+++ b/gcc/jit/jit-playback.h
@@ -692,6 +692,13 @@ public:
   add_jump (location *loc,
 	    block *target);
 
+  rvalue *get_address (location *loc);
+
+  void
+  add_indirect_jump (location *loc,
+		     rvalue *target_address,
+		     auto_vec <block *> *destinations);
+
   void
   add_return (location *loc,
 	      rvalue *rvalue);
diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc
index e28e5f67c..337f14925 100644
--- a/gcc/jit/jit-recording.cc
+++ b/gcc/jit/jit-recording.cc
@@ -5072,6 +5072,26 @@ recording::block::end_with_jump (recording::location *loc,
   return result;
 }
 
+/* Create a recording::end_with_indirect_jump instance and add
+   it to the block's context's list of mementos, and to the
+   block's list of statements.
+
+   Implements the heart of gcc_jit_block_end_with_indirect_jump.  */
+
+recording::statement *
+recording::block::end_with_indirect_jump (location *loc,
+					  rvalue *target_address,
+					  int num_destinations,
+					  block **destinations)
+{
+  statement *result = new indirect_jump (this, loc, target_address,
+					 num_destinations, destinations);
+  m_ctxt->record (result);
+  m_statements.safe_push (result);
+  m_has_been_terminated = true;
+  return result;
+}
+
 /* Create a recording::end_with_return instance and add it to
    the block's context's list of mementos, and to the block's
    list of statements.
@@ -5197,6 +5217,20 @@ recording::block::get_loc () const
     return NULL;
 }
 
+/* Create a recording::get_address instance and add it to
+   the block's context's list of mementos, and to the block's
+   list of statements.
+
+   Implements the heart of gcc_jit_block_get_address.  */
+
+recording::rvalue *
+recording::block::get_address (location *loc)
+{
+  recording::rvalue *result = new get_block_address (m_ctxt, loc, this);
+  m_ctxt->record (result);
+  return result;
+}
+
 /* Get the first statement within a block, if any.  */
 
 recording::statement *
@@ -7332,6 +7366,45 @@ recording::get_address_of_lvalue::write_reproducer (reproducer &r)
 	   r.get_identifier (m_loc));
 }
 
+/* The implementation of class gcc::jit::recording::get_block_address.  */
+
+/* Implementation of pure virtual hook recording::memento::replay_into
+   for recording::get_block_address.  */
+
+void
+recording::get_block_address::replay_into (replayer *r)
+{
+  set_playback_obj (
+    m_block->playback_block ()->
+      get_address (playback_location (r, m_loc)));
+}
+
+/* Implementation of recording::memento::make_debug_string for
+   getting the address of a block.  */
+
+recording::string *
+recording::get_block_address::make_debug_string ()
+{
+  return string::from_printf (m_ctxt,
+			      "&&%s",
+			      m_block->get_debug_string ());
+}
+
+/* Implementation of recording::memento::write_reproducer for
+   get_block_address.  */
+
+void
+recording::get_block_address::write_reproducer (reproducer &r)
+{
+  const char *id = r.make_identifier (this, "address_of");
+  r.write ("  gcc_jit_rvalue *%s =\n"
+	   "    gcc_jit_block_get_address (%s,\n"
+	   "				   %s);\n",
+	   id,
+	   r.get_identifier (m_block),
+	   r.get_identifier (m_loc));
+}
+
 /* The implementation of class gcc::jit::recording::function_pointer.  */
 
 /* Implementation of pure virtual hook recording::memento::replay_into
@@ -7765,6 +7838,90 @@ recording::jump::write_reproducer (reproducer &r)
 	   r.get_identifier (m_target));
 }
 
+/* The implementation of class gcc::jit::recording::indirect_jump.  */
+
+/* gcc::jit::recording::indirect_jump's constructor.  */
+
+recording::indirect_jump::indirect_jump (block *b,
+					 location *loc,
+					 rvalue *target_address,
+					 int num_destinations,
+					 block **destinations)
+: statement (b, loc),
+  m_target_address (target_address)
+{
+  m_destinations.reserve_exact (num_destinations);
+  for (int i = 0; i < num_destinations; i++)
+    m_destinations.quick_push (destinations[i]);
+}
+
+/* Implementation of pure virtual hook recording::memento::replay_into
+   for recording::indirect_jump.  */
+
+void
+recording::indirect_jump::replay_into (replayer *r)
+{
+  auto_vec <playback::block *> pb_dests;
+  pb_dests.reserve_exact (m_destinations.length ());
+  for (unsigned i = 0; i < m_destinations.length (); i++)
+    pb_dests.quick_push (m_destinations[i]->playback_block ());
+
+  playback_block (get_block ())
+    ->add_indirect_jump (playback_location (r),
+			 m_target_address->playback_rvalue (),
+			 &pb_dests);
+}
+
+/* Override the poisoned default implementation of
+   gcc::jit::recording::statement::get_successor_blocks.  */
+
+vec <recording::block *>
+recording::indirect_jump::get_successor_blocks () const
+{
+  vec <block *> result;
+  result.create (m_destinations.length ());
+  for (unsigned i = 0; i < m_destinations.length (); i++)
+    result.quick_push (m_destinations[i]);
+  return result;
+}
+
+/* Implementation of recording::memento::make_debug_string for
+   an indirect jump statement.  */
+
+recording::string *
+recording::indirect_jump::make_debug_string ()
+{
+  return string::from_printf (m_ctxt,
+			      "goto *%s;",
+			      m_target_address->get_debug_string_parens (PRECEDENCE_UNARY));
+}
+
+/* Implementation of recording::memento::write_reproducer for
+   indirect_jump statements.  */
+
+void
+recording::indirect_jump::write_reproducer (reproducer &r)
+{
+  r.make_identifier (this, "indirect_jump");
+  const char *dests_id = r.make_tmp_identifier ("destinations_for", this);
+  r.write ("  gcc_jit_block *%s[%i] = {\n",
+	   dests_id,
+	   m_destinations.length ());
+  for (unsigned i = 0; i < m_destinations.length (); i++)
+    r.write ("    %s,\n", r.get_identifier (m_destinations[i]));
+  r.write ("  };\n");
+  r.write ("  gcc_jit_block_end_with_indirect_jump (%s,\n"
+	   "					    %s,\n"
+	   "					    %s,\n"
+	   "					    %i,\n"
+	   "					    %s);\n",
+	   r.get_identifier (get_block ()),
+	   r.get_identifier (get_loc ()),
+	   r.get_identifier_as_rvalue (m_target_address),
+	   m_destinations.length (),
+	   dests_id);
+}
+
 /* The implementation of class gcc::jit::recording::return_.  */
 
 /* Implementation of pure virtual hook recording::memento::replay_into
diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h
index 2a5f23a05..952761dca 100644
--- a/gcc/jit/jit-recording.h
+++ b/gcc/jit/jit-recording.h
@@ -966,7 +966,7 @@ public:
   type *unqualified () final override { return m_other_type; }
 
   void replay_into (replayer *) final override;
-  memento_of_get_aligned *dyn_cast_aligned_type () final override 
+  memento_of_get_aligned *dyn_cast_aligned_type () final override
   {
     return this;
   }
@@ -1682,6 +1682,13 @@ public:
   end_with_jump (location *loc,
 		 block *target);
 
+  rvalue * get_address (location *loc);
+
+  statement * end_with_indirect_jump (location *loc,
+				     rvalue *target_address,
+				     int num_destinations,
+				     block **destinations);
+
   statement *
   end_with_return (location *loc,
 		   rvalue *rvalue);
@@ -2427,6 +2434,34 @@ private:
   lvalue *m_lvalue;
 };
 
+class get_block_address : public rvalue
+{
+public:
+  get_block_address (context *ctxt,
+		 location *loc,
+		 block *b)
+  : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_VOID_PTR)),
+    m_block (b)
+  {
+    set_scope (b->get_function ());
+  }
+
+  void replay_into (replayer *r) final override;
+
+  void visit_children (rvalue_visitor *) final override {}
+
+private:
+  string * make_debug_string () final override;
+  void write_reproducer (reproducer &r) final override;
+  enum precedence get_precedence () const final override
+  {
+    return PRECEDENCE_UNARY;
+  }
+
+private:
+  block *m_block;
+};
+
 class function_pointer : public rvalue
 {
 public:
@@ -2650,6 +2685,28 @@ private:
   block *m_target;
 };
 
+class indirect_jump : public statement
+{
+public:
+  indirect_jump (block *b,
+		 location *loc,
+		 rvalue *target_address,
+		 int num_destinations,
+		 block **destinations);
+
+  void replay_into (replayer *r) final override;
+
+  vec <block *> get_successor_blocks () const final override;
+
+private:
+  string * make_debug_string () final override;
+  void write_reproducer (reproducer &r) final override;
+
+private:
+  rvalue *m_target_address;
+  auto_vec <block *> m_destinations;
+};
+
 class return_ : public statement
 {
 public:
diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc
index 5a874fc48..42c6fe828 100644
--- a/gcc/jit/libgccjit.cc
+++ b/gcc/jit/libgccjit.cc
@@ -2874,6 +2874,23 @@ gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue,
   return (gcc_jit_rvalue *)lvalue->get_address (loc);
 }
 
+/* Public entrypoint.  See description in libgccjit.h.
+
+   After error-checking, the real work is done by the
+   gcc::jit::recording::block::get_address method in
+   jit-recording.cc.  */
+
+gcc_jit_rvalue *
+gcc_jit_block_get_address (gcc_jit_block *block,
+			   gcc_jit_location *loc)
+{
+  RETURN_NULL_IF_FAIL (block, NULL, loc, "NULL block");
+  JIT_LOG_FUNC (block->get_context ()->get_logger ());
+  /* LOC can be NULL.  */
+
+  return (gcc_jit_rvalue *)block->get_address (loc);
+}
+
 /* Public entrypoint.  See description in libgccjit.h.
 
    After error-checking, the real work is done by the
@@ -3258,6 +3275,57 @@ gcc_jit_block_end_with_jump (gcc_jit_block *block,
   block->end_with_jump (loc, target);
 }
 
+/* Public entrypoint.  See description in libgccjit.h.
+
+   After error-checking, the real work is done by the
+   gcc::jit::recording::block::end_with_indirect_jump method in
+   jit-recording.cc.  */
+
+void
+gcc_jit_block_end_with_indirect_jump (gcc_jit_block *block,
+				      gcc_jit_location *loc,
+				      gcc_jit_rvalue *target_address,
+				      int num_destinations,
+				      gcc_jit_block **destinations)
+{
+  RETURN_IF_NOT_VALID_BLOCK (block, loc);
+  gcc::jit::recording::context *ctxt = block->get_context ();
+  JIT_LOG_FUNC (ctxt->get_logger ());
+  /* LOC can be NULL.  */
+  RETURN_IF_FAIL (target_address, ctxt, loc, "NULL target_address");
+  RETURN_IF_FAIL_PRINTF1 (
+    target_address->get_type ()->is_pointer (),
+    ctxt, loc,
+    "target_address: %s is not of a pointer type",
+    target_address->get_debug_string ());
+  RETURN_IF_FAIL (num_destinations >= 0, ctxt, loc, "num_destinations < 0");
+  if (num_destinations > 0)
+    RETURN_IF_FAIL (destinations, ctxt, loc, "NULL destinations");
+
+  for (int i = 0; i < num_destinations; i++)
+    {
+      RETURN_IF_FAIL_PRINTF1 (destinations[i], ctxt, loc,
+			      "NULL destination block at index %d", i);
+      RETURN_IF_FAIL_PRINTF4 (
+	block->get_function () == destinations[i]->get_function (),
+	ctxt, loc,
+	"destination block %d (%s) is not in the same function"
+	" (function %s) as source block %s",
+	i,
+	destinations[i]->get_debug_string (),
+	destinations[i]->get_function ()->get_debug_string (),
+	block->get_debug_string ());
+    }
+
+  gcc::jit::recording::statement *stmt =
+    block->end_with_indirect_jump (loc, target_address,
+				   num_destinations,
+				   (gcc::jit::recording::block **)destinations);
+
+  /* target_address must be valid to use within STMT.  */
+  target_address->verify_valid_within_stmt (__func__, stmt);
+}
+
 /* Public entrypoint.  See description in libgccjit.h.
 
    After error-checking, the real work is done by the
diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h
index 2247c99de..272085986 100644
--- a/gcc/jit/libgccjit.h
+++ b/gcc/jit/libgccjit.h
@@ -1455,16 +1455,31 @@ extern gcc_jit_rvalue *
 gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue,
 			    gcc_jit_location *loc);
 
+#define LIBGCCJIT_HAVE_gcc_jit_block_get_address
+
+/* Taking the address of a block; analogous to:
+     &&block
+   in C.
+
+   This API entrypoint was added in LIBGCCJIT_ABI_39; you can test for its
+   presence using
+      #ifdef LIBGCCJIT_HAVE_gcc_jit_block_get_address
+*/
+extern gcc_jit_rvalue *
+gcc_jit_block_get_address (gcc_jit_block *block,
+			   gcc_jit_location *loc);
+
 #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model
 
 /* Set the thread-local storage model of a global variable
 
    This API entrypoint was added in LIBGCCJIT_ABI_17; you can test for its
    presence using
-     #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model  */
+     #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model
+*/
 extern void
 gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue *lvalue,
-			    enum gcc_jit_tls_model model);
+			      enum gcc_jit_tls_model model);
 
 #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section
 
@@ -1592,6 +1607,32 @@ gcc_jit_block_end_with_jump (gcc_jit_block *block,
 			     gcc_jit_location *loc,
 			     gcc_jit_block *target);
 
+#define LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump
+
+/* Terminate a block by adding an indirect jump to target_address.
+
+   All possible indirect jump targets must be constrained to a fixed array.
+
+   The candidate destination blocks must be listed in DESTINATIONS
+
+   (of length NUM_DESTINATIONS) so that libgccjit can validate block
+
+   reachability within the function.
+
+   This is roughly equivalent to this C code:
+
+      goto *target_address;
+
+   This API entrypoint was added in LIBGCCJIT_ABI_39; you can test for its
+   presence using
+      #ifdef LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump.  */
+extern void
+gcc_jit_block_end_with_indirect_jump (gcc_jit_block *block,
+				      gcc_jit_location *loc,
+				      gcc_jit_rvalue *target_address,
+				      int num_destinations,
+				      gcc_jit_block **destinations);
+
 /* Terminate a block by adding evaluation of an rvalue, returning the value.
 
    This is roughly equivalent to this C code:
diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map
index 78b6be9ff..9412700a2 100644
--- a/gcc/jit/libgccjit.map
+++ b/gcc/jit/libgccjit.map
@@ -349,3 +349,9 @@ LIBGCCJIT_ABI_38 {
   global:
     gcc_jit_type_is_floating_point;
 } LIBGCCJIT_ABI_37;
+
+LIBGCCJIT_ABI_39 {
+  global:
+    gcc_jit_block_get_address;
+    gcc_jit_block_end_with_indirect_jump;
+} LIBGCCJIT_ABI_38;
diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h
index e8f8463e8..f8202635e 100644
--- a/gcc/testsuite/jit.dg/all-non-failing-tests.h
+++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h
@@ -269,6 +269,13 @@
 #undef create_code
 #undef verify_code
 
+/* test-indirect-jump.c */
+#define create_code create_code_indirect_jump
+#define verify_code verify_code_indirect_jump
+#include "test-indirect-jump.c"
+#undef create_code
+#undef verify_code
+
 /* test-link-section-assembler.c: This can't be in the testcases array as it
    doesn't have a verify_code implementation.  */
 
@@ -688,6 +695,9 @@ const struct testcase testcases[] = {
   {"vector_perm",
    create_code_vector_perm,
    verify_code_vector_perm},
+  {"indirect_jump",
+   create_code_indirect_jump,
+   verify_code_indirect_jump},
 };
 
 const int num_testcases = (sizeof (testcases) / sizeof (testcases[0]));
diff --git a/gcc/testsuite/jit.dg/test-error-indirect-jump.c b/gcc/testsuite/jit.dg/test-error-indirect-jump.c
new file mode 100644
index 000000000..8f40a3738
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-error-indirect-jump.c
@@ -0,0 +1,112 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "libgccjit.h"
+#include "harness.h"
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+  /* Let's try to trigger every validation error on
+     gcc_jit_block_get_address and gcc_jit_block_end_with_indirect_jump.  */
+  gcc_jit_type *void_type =
+    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
+  gcc_jit_type *int_type =
+    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+
+  gcc_jit_function *fn1 =
+    gcc_jit_context_new_function (ctxt, NULL,
+				  GCC_JIT_FUNCTION_EXPORTED,
+				  void_type,
+				  "fn1",
+				  0, NULL,
+				  0);
+  gcc_jit_block *b_fn1 =
+    gcc_jit_function_new_block (fn1, "b_fn1");
+
+  gcc_jit_function *fn2 =
+    gcc_jit_context_new_function (ctxt, NULL,
+				  GCC_JIT_FUNCTION_EXPORTED,
+				  void_type,
+				  "fn2",
+				  0, NULL,
+				  0);
+  gcc_jit_block *b_fn2 =
+    gcc_jit_function_new_block (fn2, "b_fn2");
+
+  /* 1. Non-pointer target_address.  */
+  gcc_jit_rvalue * non_ptr =
+    gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 42);
+  gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, non_ptr, 0, NULL);
+  CHECK_STRING_VALUE (
+    gcc_jit_context_get_last_error (ctxt),
+    "gcc_jit_block_end_with_indirect_jump:"
+    " target_address: (int)42 is not of a pointer type");
+
+  /* 2. Negative num_destinations.  */
+  gcc_jit_rvalue *addr_fn1 = gcc_jit_block_get_address (b_fn1, NULL);
+  gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, -1, NULL);
+  CHECK_STRING_VALUE (
+    gcc_jit_context_get_last_error (ctxt),
+    "gcc_jit_block_end_with_indirect_jump: num_destinations < 0");
+
+  /* 3. NULL destinations array when num_destinations > 0.  */
+  gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1, NULL);
+  CHECK_STRING_VALUE (
+    gcc_jit_context_get_last_error (ctxt),
+    "gcc_jit_block_end_with_indirect_jump: NULL destinations");
+
+  /* 4. NULL element in destinations array.  */
+  gcc_jit_block *null_dests[1] = { NULL };
+  gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1, null_dests);
+  CHECK_STRING_VALUE (
+    gcc_jit_context_get_last_error (ctxt),
+    "gcc_jit_block_end_with_indirect_jump:"
+    " NULL destination block at index 0");
+
+  /* 5. Destination block in wrong function.  */
+  gcc_jit_block *wrong_fn_dests[1] = { b_fn2 };
+  gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1,
+					wrong_fn_dests);
+  CHECK_STRING_VALUE (
+    gcc_jit_context_get_last_error (ctxt),
+    "gcc_jit_block_end_with_indirect_jump:"
+    " destination block 0 (b_fn2) is not in the same function"
+    " (function fn2) as source block b_fn1");
+
+  /* Terminate b_fn1 cleanly so function validation doesn't overwrite
+     last_error with an "unterminated block" error during compile.  */
+  gcc_jit_block_end_with_void_return (b_fn1, NULL);
+
+  /* 6. Cross-function block address (addr_fn1 used inside fn2).  */
+  gcc_jit_block *fn2_dests[1] = { b_fn2 };
+  gcc_jit_block_end_with_indirect_jump (b_fn2, NULL, addr_fn1, 1,
+					fn2_dests);
+
+  CHECK_STRING_VALUE (
+    gcc_jit_context_get_last_error (ctxt),
+    "gcc_jit_block_end_with_indirect_jump:"
+    " rvalue &&b_fn1 (type: void *) has scope limited to function fn1"
+    " but was used within function fn2"
+    " (in statement: goto *&&b_fn1;)");
+}
+
+void
+verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
+{
+  CHECK_VALUE (result, NULL);
+
+  CHECK_STRING_VALUE (
+    gcc_jit_context_get_first_error (ctxt),
+    "gcc_jit_block_end_with_indirect_jump:"
+    " target_address: (int)42 is not of a pointer type");
+
+  /* Verify that using a block address from fn1 inside fn2 was caught
+     by verify_valid_within_stmt.  */
+  CHECK_STRING_VALUE (
+    gcc_jit_context_get_last_error (ctxt),
+    "gcc_jit_block_end_with_indirect_jump:"
+    " rvalue &&b_fn1 (type: void *) has scope limited to function fn1"
+    " but was used within function fn2"
+    " (in statement: goto *&&b_fn1;)");
+}
diff --git a/gcc/testsuite/jit.dg/test-indirect-jump.c b/gcc/testsuite/jit.dg/test-indirect-jump.c
new file mode 100644
index 000000000..f464a6edb
--- /dev/null
+++ b/gcc/testsuite/jit.dg/test-indirect-jump.c
@@ -0,0 +1,109 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "libgccjit.h"
+#include "harness.h"
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+  /* Let's try to inject the equivalent of:
+     int
+     test_indirect_jump (int idx)
+     {
+       void *targets[3];
+       targets[0] = &&b_zero;
+       targets[1] = &&b_one;
+       targets[2] = &&b_two;
+       goto *targets[idx];
+
+     b_zero:
+       return 10;
+     b_one:
+       return 20;
+     b_two:
+       return 30;
+     }
+  */
+  gcc_jit_type *int_type =
+    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+  gcc_jit_type *void_ptr_type =
+    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR);
+  gcc_jit_type *array_type =
+    gcc_jit_context_new_array_type (ctxt, NULL, void_ptr_type, 3);
+
+  gcc_jit_param *param_idx =
+    gcc_jit_context_new_param (ctxt, NULL, int_type, "idx");
+  gcc_jit_function *func =
+    gcc_jit_context_new_function (ctxt, NULL,
+				  GCC_JIT_FUNCTION_EXPORTED,
+				  int_type,
+				  "test_indirect_jump",
+				  1, &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