The Linaro precommit bot flagged an aarch64 regression in
libstdc++-dg/conformance.exp: 29_atomics/atomic/wait_notify/127757.cc.
Looking at the artifact log, this looks like an execution
timeout/flake under runner load; the patch touches only gcc/jit/ and
introduces ABI 39 entry points.

On Fri, Nov 6, 2026 at 11:13 PM Vincent Li <[email protected]> wrote:
>
> This patch adds `gcc_jit_block_get_address` and 
> `gcc_jit_block_end_with_indirect_jump`
> under ABI version LIBGCCJIT_ABI_39. This exposes GNU C labels-as-values 
> (`&&label`)
> and indirect jumps (`goto *expr;`) in libgccjit, enabling JIT-compiled 
> interpreter
> dispatch loops and state machines to implement direct-threaded code tables.
>
> Tested on x86_64-pc-linux-gnu. All 30 iterations of 
> jit.dg/test-indirect-jump.c
> passed across -O0 to -O3. check_GNU_style.py reports 0 errors.
>
> gcc/jit/ChangeLog:
>
>         * docs/topics/compatibility.rst (LIBGCCJIT_ABI_39): Document.
>         * docs/topics/functions.rst (gcc_jit_block_get_address): Document.
>         (gcc_jit_block_end_with_indirect_jump): Document.
>         * jit-playback.cc (playback::block::get_address): New method.
>         (playback::block::add_indirect_jump): New method.
>         * jit-playback.h (playback::block::get_address): New method.
>         (playback::block::add_indirect_jump): New method.
>         * jit-recording.cc (recording::block::get_address): New method.
>         (recording::block::end_with_indirect_jump): New method.
>         (recording::get_block_address::replay_into): New method.
>         (recording::get_block_address::make_debug_string): New method.
>         (recording::get_block_address::write_reproducer): New method.
>         (recording::indirect_jump::replay_into): New method.
>         (recording::indirect_jump::get_successor_blocks): New method.
>         (recording::indirect_jump::make_debug_string): New method.
>         (recording::indirect_jump::write_reproducer): New method.
>         * jit-recording.h (class get_block_address): New class.
>         (class indirect_jump): New class.
>         (recording::block::get_address): New method.
>         (recording::block::end_with_indirect_jump): New method.
>         * libgccjit.cc (gcc_jit_block_get_address): New entrypoint.
>         (gcc_jit_block_end_with_indirect_jump): New entrypoint.
>         * libgccjit.exports: Add gcc_jit_block_get_address and
>         gcc_jit_block_end_with_indirect_jump.
>         * libgccjit.h (LIBGCCJIT_HAVE_gcc_jit_block_get_address): New macro.
>         (LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump): New macro.
>         (gcc_jit_block_get_address): New declaration.
>         (gcc_jit_block_end_with_indirect_jump): New declaration.
>         * libgccjit.map (LIBGCCJIT_ABI_39): Add gcc_jit_block_get_address and
>         gcc_jit_block_end_with_indirect_jump.
>
> gcc/testsuite/ChangeLog:
>
>         * jit.dg/all-non-failing-tests.h: Include test-indirect-jump.c.
>         * jit.dg/test-error-block-address-global-init.c: New test.
>         * jit.dg/test-error-indirect-jump.c: New test.
>         * jit.dg/test-indirect-jump.c: New test.
>
> Signed-off-by: Vincent Li <[email protected]>
> ---
> v4 -> v5
>
> Removed duplicate initializer flag check in 
> gcc_jit_global_set_initializer_rvalue
> and redundant visit_children call in verify_valid_within_stmt
>
>  gcc/jit/docs/topics/compatibility.rst         |   8 +
>  gcc/jit/docs/topics/functions.rst             |  40 +++
>  gcc/jit/jit-playback.cc                       |  43 +++
>  gcc/jit/jit-playback.h                        |   7 +
>  gcc/jit/jit-recording.cc                      | 306 +++++++++++++++---
>  gcc/jit/jit-recording.h                       |  62 +++-
>  gcc/jit/libgccjit.cc                          |  71 ++++
>  gcc/jit/libgccjit.exports                     |   4 +
>  gcc/jit/libgccjit.h                           |  45 ++-
>  gcc/jit/libgccjit.map                         |   6 +
>  gcc/testsuite/jit.dg/all-non-failing-tests.h  |  10 +
>  .../test-error-block-address-global-init.c    |  79 +++++
>  .../jit.dg/test-error-indirect-jump.c         | 112 +++++++
>  gcc/testsuite/jit.dg/test-indirect-jump.c     | 109 +++++++
>  14 files changed, 859 insertions(+), 43 deletions(-)
>  create mode 100644 
> gcc/testsuite/jit.dg/test-error-block-address-global-init.c
>  create mode 100644 gcc/testsuite/jit.dg/test-error-indirect-jump.c
>  create mode 100644 gcc/testsuite/jit.dg/test-indirect-jump.c
>
> diff --git a/gcc/jit/docs/topics/compatibility.rst 
> b/gcc/jit/docs/topics/compatibility.rst
> index e4a231e79..ca1a428f3 100644
> --- a/gcc/jit/docs/topics/compatibility.rst
> +++ b/gcc/jit/docs/topics/compatibility.rst
> @@ -489,3 +489,11 @@ information:
>  ``LIBGCCJIT_ABI_38`` covers the addition of
>
>   * :func:`gcc_jit_type_is_floating_point`
> +
> +   .. _LIBGCCJIT_ABI_39:
> +
> +``LIBGCCJIT_ABI_39``
> +-----------------------
> +``LIBGCCJIT_ABI_39`` covers the addition of API entrypoints
> + * :func:`gcc_jit_block_get_address`
> + * :func:`gcc_jit_block_end_with_indirect_jump`
> diff --git a/gcc/jit/docs/topics/functions.rst 
> b/gcc/jit/docs/topics/functions.rst
> index 66d4b6b2f..67818881d 100644
> --- a/gcc/jit/docs/topics/functions.rst
> +++ b/gcc/jit/docs/topics/functions.rst
> @@ -466,6 +466,46 @@ Statements
>
>        goto target;
>
> +.. function:: gcc_jit_rvalue *\
> +              gcc_jit_block_get_address (gcc_jit_block *block,\
> +                                         gcc_jit_location *loc)
> +
> +   Get the address of a block as a ``void *`` rvalue, equivalent to GNU C's
> +   ``&&label`` extension.
> +
> +   ``block`` must be non-NULL.
> +
> +   This API entrypoint was added in :ref:`LIBGCCJIT_ABI_39`; you can test
> +   for its presence using
> +
> +   .. code-block:: c
> +
> +      #ifdef LIBGCCJIT_HAVE_gcc_jit_block_get_address
> +
> +.. function:: void\
> +             gcc_jit_block_end_with_indirect_jump (\
> +             gcc_jit_block *block,\
> +             gcc_jit_location *loc,\
> +             gcc_jit_rvalue *target_address,\
> +             int num_destinations,\
> +             gcc_jit_block **destinations)
> +
> +   Terminate a basic block by adding an indirect jump to ``target_address``,
> +   analogous to GNU C's ``goto *target_address;``.
> +
> +   Here, ``target_address`` must be a pointer rvalue, and ``destinations``
> +   must be an array of ``num_destinations`` candidate target blocks within
> +   the same function.  Listing the candidate destination blocks is required
> +   so that ``libgccjit`` can validate block reachability when checking the
> +   function.
> +
> +   This API entrypoint was added in ``LIBGCCJIT_ABI_39``; you can test for 
> its
> +   presence using:
> +
> +   .. code-block:: c
> +
> +      #ifdef LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump
> +
>  .. function:: void\
>                gcc_jit_block_end_with_return (gcc_jit_block *block,\
>                                               gcc_jit_location *loc,\
> diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc
> index 56c9413f8..c4c1ec8fd 100644
> --- a/gcc/jit/jit-playback.cc
> +++ b/gcc/jit/jit-playback.cc
> @@ -2547,6 +2547,49 @@ c_finish_goto_label (location_t loc, tree label)
>
>  }
>
> +/* Take the address of a block as a void * rvalue (&&block).  */
> +
> +playback::rvalue *
> +playback::block::
> +get_address (location *loc)
> +{
> +  tree label = as_label_decl ();
> +  TREE_USED (label) = 1;
> +  /* Also set during gimplification by gimplify_addr_expr, but marked
> +     explicitly here when constructing the ADDR_EXPR.  */
> +  FORCED_LABEL (label) = 1;
> +
> +  tree addr = build1 (ADDR_EXPR, ptr_type_node, label);
> +  if (loc)
> +    set_tree_location (addr, loc);
> +
> +  return new rvalue (m_func->m_ctxt, addr);
> +}
> +
> +/* Add an indirect jump statement (goto *target_address;).  */
> +
> +void
> +playback::block::add_indirect_jump (location *loc,
> +                                   rvalue *target_address,
> +                                   auto_vec <block *> *destinations)
> +{
> +  unsigned i;
> +  block *dest;
> +  FOR_EACH_VEC_ELT (*destinations, i, dest)
> +    {
> +      tree label = dest->as_label_decl ();
> +      TREE_USED (label) = 1;
> +      FORCED_LABEL (label) = 1;
> +    }
> +
> +  tree target = target_address->as_tree ();
> +  target = fold_convert (ptr_type_node, target);
> +  tree stmt = build1 (GOTO_EXPR, void_type_node, target);
> +  if (loc)
> +    set_tree_location (stmt, loc);
> +  add_stmt (stmt);
> +}
> +
>  /* Add a return statement to the function's statement list.  */
>
>  void
> diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h
> index ad3e41f3d..d32ed4d49 100644
> --- a/gcc/jit/jit-playback.h
> +++ b/gcc/jit/jit-playback.h
> @@ -692,6 +692,13 @@ public:
>    add_jump (location *loc,
>             block *target);
>
> +  rvalue *get_address (location *loc);
> +
> +  void
> +  add_indirect_jump (location *loc,
> +                    rvalue *target_address,
> +                    auto_vec <block *> *destinations);
> +
>    void
>    add_return (location *loc,
>               rvalue *rvalue);
> diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc
> index e28e5f67c..b6c88fd62 100644
> --- a/gcc/jit/jit-recording.cc
> +++ b/gcc/jit/jit-recording.cc
> @@ -4103,25 +4103,36 @@ class rvalue_usage_validator : public 
> recording::rvalue_visitor
>   public:
>    rvalue_usage_validator (const char *api_funcname,
>                           recording::context *ctxt,
> -                         recording::statement *stmt);
> -
> +                         recording::statement *stmt,
> +                         recording::lvalue *global = NULL);
>    void
>    visit (recording::rvalue *rvalue) final override;
>
> +  bool
> +  has_errors () const
> +  {
> +    return m_has_errors;
> +  }
> +
>   private:
>    const char *m_api_funcname;
>    recording::context *m_ctxt;
>    recording::statement *m_stmt;
> +  recording::lvalue *m_global;
> +  bool m_has_errors;
>  };
>
>  /* The trivial constructor for rvalue_usage_validator.  */
>
>  rvalue_usage_validator::rvalue_usage_validator (const char *api_funcname,
>                                                 recording::context *ctxt,
> -                                               recording::statement *stmt)
> +                                               recording::statement *stmt,
> +                                               recording::lvalue *global)
>    : m_api_funcname (api_funcname),
>      m_ctxt (ctxt),
> -    m_stmt (stmt)
> +    m_stmt (stmt),
> +    m_global (global),
> +    m_has_errors (false)
>  {
>  }
>
> @@ -4130,43 +4141,88 @@ rvalue_usage_validator::rvalue_usage_validator (const 
> char *api_funcname,
>  void
>  rvalue_usage_validator::visit (recording::rvalue *rvalue)
>  {
> -  gcc_assert (m_stmt->get_block ());
> -  recording::function *stmt_scope = m_stmt->get_block ()->get_function ();
> -
> -  /* Most rvalues don't have a scope (only locals and params).  */
> -  if (rvalue->get_scope ())
> +  if (!m_stmt)
>      {
> -      if (rvalue->get_scope () != stmt_scope)
> -       m_ctxt->add_error
> -         (rvalue->get_loc (),
> -          "%s:"
> -          " rvalue %s (type: %s)"
> -          " has scope limited to function %s"
> -          " but was used within function %s"
> -          " (in statement: %s)",
> -          m_api_funcname,
> -          rvalue->get_debug_string (),
> -          rvalue->get_type ()->get_debug_string (),
> -          rvalue->get_scope ()->get_debug_string (),
> -          stmt_scope->get_debug_string (),
> -          m_stmt->get_debug_string ());
> +      gcc_assert (m_global);
> +      if (rvalue->get_scope ())
> +       {
> +         m_ctxt->add_error
> +           (rvalue->get_loc (),
> +            "%s:"
> +            " rvalue %s (type: %s)"
> +            " has scope limited to function %s"
> +            " but was used in initializer for global %s",
> +            m_api_funcname,
> +            rvalue->get_debug_string (),
> +            rvalue->get_type ()->get_debug_string (),
> +            rvalue->get_scope ()->get_debug_string (),
> +            m_global->get_debug_string ());
> +         m_has_errors = true;
> +       }
> +      else if (rvalue->dyn_cast_param ())
> +       {
> +         m_ctxt->add_error
> +           (rvalue->get_loc (),
> +            "%s:"
> +            " param %s (type: %s)"
> +            " was used in initializer for global %s"
> +            " but is not associated with any function",
> +            m_api_funcname,
> +            rvalue->get_debug_string (),
> +            rvalue->get_type ()->get_debug_string (),
> +            m_global->get_debug_string ());
> +         m_has_errors = true;
> +       }
>      }
>    else
>      {
> -      if (rvalue->dyn_cast_param ())
> -       m_ctxt->add_error
> -         (rvalue->get_loc (),
> -          "%s:"
> -          " param %s (type: %s)"
> -          " was used within function %s"
> -          " (in statement: %s)"
> -          " but is not associated with any function",
> -          m_api_funcname,
> -          rvalue->get_debug_string (),
> -          rvalue->get_type ()->get_debug_string (),
> -          stmt_scope->get_debug_string (),
> -          m_stmt->get_debug_string ());
> +      gcc_assert (m_stmt->get_block ());
> +      recording::function *stmt_scope = m_stmt->get_block ()->get_function 
> ();
> +
> +      /* Most rvalues don't have a scope (only locals, params, and
> +        block addresses).  */
> +      if (rvalue->get_scope ())
> +       {
> +         if (rvalue->get_scope () != stmt_scope)
> +           {
> +             m_ctxt->add_error
> +               (rvalue->get_loc (),
> +                "%s:"
> +                " rvalue %s (type: %s)"
> +                " has scope limited to function %s"
> +                " but was used within function %s"
> +                " (in statement: %s)",
> +                m_api_funcname,
> +                rvalue->get_debug_string (),
> +                rvalue->get_type ()->get_debug_string (),
> +                rvalue->get_scope ()->get_debug_string (),
> +                stmt_scope->get_debug_string (),
> +                m_stmt->get_debug_string ());
> +             m_has_errors = true;
> +           }
> +       }
> +      else
> +       {
> +         if (rvalue->dyn_cast_param ())
> +           {
> +             m_ctxt->add_error
> +               (rvalue->get_loc (),
> +                "%s:"
> +                " param %s (type: %s)"
> +                " was used within function %s"
> +                " (in statement: %s)"
> +                " but is not associated with any function",
> +                m_api_funcname,
> +                rvalue->get_debug_string (),
> +                rvalue->get_type ()->get_debug_string (),
> +                stmt_scope->get_debug_string (),
> +                m_stmt->get_debug_string ());
> +             m_has_errors = true;
> +           }
> +       }
>      }
> +
> +  rvalue->visit_children (this);
>  }
>
>  /* Verify that it's valid to use this rvalue (and all expressions
> @@ -4185,10 +4241,22 @@ recording::rvalue::verify_valid_within_stmt (const 
> char *api_funcname, statement
>
>    /* Verify that it's OK to use this rvalue within s.  */
>    v.visit (this);
> +}
> +
> +/* Verify that it's valid to use this rvalue (and all expressions
> +   in the tree below it) as the initializer for GLOBAL.  */
>
> -  /* Traverse the expression tree below "this", verifying all rvalues
> -     within it.  */
> -  visit_children (&v);
> +bool
> +recording::rvalue::verify_valid_within_global_init (const char *api_funcname,
> +                                                   lvalue *global)
> +{
> +  rvalue_usage_validator v (api_funcname,
> +                           global->get_context (),
> +                           NULL,
> +                           global);
> +
> +  v.visit (this);
> +  return !v.has_errors ();
>  }
>
>  /* Set the scope of this rvalue to be the given function.  This can only
> @@ -5072,6 +5140,26 @@ recording::block::end_with_jump (recording::location 
> *loc,
>    return result;
>  }
>
> +/* Create a recording::end_with_indirect_jump instance and add
> +   it to the block's context's list of mementos, and to the
> +   block's list of statements.
> +
> +   Implements the heart of gcc_jit_block_end_with_indirect_jump.  */
> +
> +recording::statement *
> +recording::block::end_with_indirect_jump (location *loc,
> +                                         rvalue *target_address,
> +                                         int num_destinations,
> +                                         block **destinations)
> +{
> +  statement *result = new indirect_jump (this, loc, target_address,
> +                                        num_destinations, destinations);
> +  m_ctxt->record (result);
> +  m_statements.safe_push (result);
> +  m_has_been_terminated = true;
> +  return result;
> +}
> +
>  /* Create a recording::end_with_return instance and add it to
>     the block's context's list of mementos, and to the block's
>     list of statements.
> @@ -5197,6 +5285,20 @@ recording::block::get_loc () const
>      return NULL;
>  }
>
> +/* Create a recording::get_address instance and add it to
> +   the block's context's list of mementos, and to the block's
> +   list of statements.
> +
> +   Implements the heart of gcc_jit_block_get_address.  */
> +
> +recording::rvalue *
> +recording::block::get_address (location *loc)
> +{
> +  recording::rvalue *result = new get_block_address (m_ctxt, loc, this);
> +  m_ctxt->record (result);
> +  return result;
> +}
> +
>  /* Get the first statement within a block, if any.  */
>
>  recording::statement *
> @@ -6099,7 +6201,8 @@ void
>  recording::ctor::visit_children (rvalue_visitor *v)
>  {
>    for (unsigned int i = 0; i < m_values.length (); i++)
> -    v->visit (m_values[i]);
> +    if (m_values[i])
> +      v->visit (m_values[i]);
>  }
>
>  recording::string *
> @@ -7332,6 +7435,45 @@ recording::get_address_of_lvalue::write_reproducer 
> (reproducer &r)
>            r.get_identifier (m_loc));
>  }
>
> +/* The implementation of class gcc::jit::recording::get_block_address.  */
> +
> +/* Implementation of pure virtual hook recording::memento::replay_into
> +   for recording::get_block_address.  */
> +
> +void
> +recording::get_block_address::replay_into (replayer *r)
> +{
> +  set_playback_obj (
> +    m_block->playback_block ()->
> +      get_address (playback_location (r, m_loc)));
> +}
> +
> +/* Implementation of recording::memento::make_debug_string for
> +   getting the address of a block.  */
> +
> +recording::string *
> +recording::get_block_address::make_debug_string ()
> +{
> +  return string::from_printf (m_ctxt,
> +                             "&&%s",
> +                             m_block->get_debug_string ());
> +}
> +
> +/* Implementation of recording::memento::write_reproducer for
> +   get_block_address.  */
> +
> +void
> +recording::get_block_address::write_reproducer (reproducer &r)
> +{
> +  const char *id = r.make_identifier (this, "address_of");
> +  r.write ("  gcc_jit_rvalue *%s =\n"
> +          "    gcc_jit_block_get_address (%s,\n"
> +          "                               %s);\n",
> +          id,
> +          r.get_identifier (m_block),
> +          r.get_identifier (m_loc));
> +}
> +
>  /* The implementation of class gcc::jit::recording::function_pointer.  */
>
>  /* Implementation of pure virtual hook recording::memento::replay_into
> @@ -7765,6 +7907,90 @@ recording::jump::write_reproducer (reproducer &r)
>            r.get_identifier (m_target));
>  }
>
> +/* The implementation of class gcc::jit::recording::indirect_jump.  */
> +
> +/* gcc::jit::recording::indirect_jump's constructor.  */
> +
> +recording::indirect_jump::indirect_jump (block *b,
> +                                        location *loc,
> +                                        rvalue *target_address,
> +                                        int num_destinations,
> +                                        block **destinations)
> +: statement (b, loc),
> +  m_target_address (target_address)
> +{
> +  m_destinations.reserve_exact (num_destinations);
> +  for (int i = 0; i < num_destinations; i++)
> +    m_destinations.quick_push (destinations[i]);
> +}
> +
> +/* Implementation of pure virtual hook recording::memento::replay_into
> +   for recording::indirect_jump.  */
> +
> +void
> +recording::indirect_jump::replay_into (replayer *r)
> +{
> +  auto_vec <playback::block *> pb_dests;
> +  pb_dests.reserve_exact (m_destinations.length ());
> +  for (unsigned i = 0; i < m_destinations.length (); i++)
> +    pb_dests.quick_push (m_destinations[i]->playback_block ());
> +
> +  playback_block (get_block ())
> +    ->add_indirect_jump (playback_location (r),
> +                        m_target_address->playback_rvalue (),
> +                        &pb_dests);
> +}
> +
> +/* Override the poisoned default implementation of
> +   gcc::jit::recording::statement::get_successor_blocks.  */
> +
> +vec <recording::block *>
> +recording::indirect_jump::get_successor_blocks () const
> +{
> +  vec <block *> result;
> +  result.create (m_destinations.length ());
> +  for (unsigned i = 0; i < m_destinations.length (); i++)
> +    result.quick_push (m_destinations[i]);
> +  return result;
> +}
> +
> +/* Implementation of recording::memento::make_debug_string for
> +   an indirect jump statement.  */
> +
> +recording::string *
> +recording::indirect_jump::make_debug_string ()
> +{
> +  return string::from_printf (m_ctxt,
> +                             "goto *%s;",
> +                             m_target_address->get_debug_string_parens 
> (PRECEDENCE_UNARY));
> +}
> +
> +/* Implementation of recording::memento::write_reproducer for
> +   indirect_jump statements.  */
> +
> +void
> +recording::indirect_jump::write_reproducer (reproducer &r)
> +{
> +  r.make_identifier (this, "indirect_jump");
> +  const char *dests_id = r.make_tmp_identifier ("destinations_for", this);
> +  r.write ("  gcc_jit_block *%s[%i] = {\n",
> +          dests_id,
> +          m_destinations.length ());
> +  for (unsigned i = 0; i < m_destinations.length (); i++)
> +    r.write ("    %s,\n", r.get_identifier (m_destinations[i]));
> +  r.write ("  };\n");
> +  r.write ("  gcc_jit_block_end_with_indirect_jump (%s,\n"
> +          "                                        %s,\n"
> +          "                                        %s,\n"
> +          "                                        %i,\n"
> +          "                                        %s);\n",
> +          r.get_identifier (get_block ()),
> +          r.get_identifier (get_loc ()),
> +          r.get_identifier_as_rvalue (m_target_address),
> +          m_destinations.length (),
> +          dests_id);
> +}
> +
>  /* The implementation of class gcc::jit::recording::return_.  */
>
>  /* Implementation of pure virtual hook recording::memento::replay_into
> diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h
> index 2a5f23a05..cbcbdf216 100644
> --- a/gcc/jit/jit-recording.h
> +++ b/gcc/jit/jit-recording.h
> @@ -966,7 +966,7 @@ public:
>    type *unqualified () final override { return m_other_type; }
>
>    void replay_into (replayer *) final override;
> -  memento_of_get_aligned *dyn_cast_aligned_type () final override
> +  memento_of_get_aligned *dyn_cast_aligned_type () final override
>    {
>      return this;
>    }
> @@ -1413,6 +1413,9 @@ public:
>    void
>    verify_valid_within_stmt (const char *api_funcname, statement *s);
>
> +  bool verify_valid_within_global_init (const char *api_funcname,
> +                                       lvalue *global);
> +
>    virtual void visit_children (rvalue_visitor *v) = 0;
>
>    void set_scope (function *scope);
> @@ -1682,6 +1685,13 @@ public:
>    end_with_jump (location *loc,
>                  block *target);
>
> +  rvalue * get_address (location *loc);
> +
> +  statement * end_with_indirect_jump (location *loc,
> +                                    rvalue *target_address,
> +                                    int num_destinations,
> +                                    block **destinations);
> +
>    statement *
>    end_with_return (location *loc,
>                    rvalue *rvalue);
> @@ -2427,6 +2437,34 @@ private:
>    lvalue *m_lvalue;
>  };
>
> +class get_block_address : public rvalue
> +{
> +public:
> +  get_block_address (context *ctxt,
> +                location *loc,
> +                block *b)
> +  : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_VOID_PTR)),
> +    m_block (b)
> +  {
> +    set_scope (b->get_function ());
> +  }
> +
> +  void replay_into (replayer *r) final override;
> +
> +  void visit_children (rvalue_visitor *) final override {}
> +
> +private:
> +  string * make_debug_string () final override;
> +  void write_reproducer (reproducer &r) final override;
> +  enum precedence get_precedence () const final override
> +  {
> +    return PRECEDENCE_UNARY;
> +  }
> +
> +private:
> +  block *m_block;
> +};
> +
>  class function_pointer : public rvalue
>  {
>  public:
> @@ -2650,6 +2688,28 @@ private:
>    block *m_target;
>  };
>
> +class indirect_jump : public statement
> +{
> +public:
> +  indirect_jump (block *b,
> +                location *loc,
> +                rvalue *target_address,
> +                int num_destinations,
> +                block **destinations);
> +
> +  void replay_into (replayer *r) final override;
> +
> +  vec <block *> get_successor_blocks () const final override;
> +
> +private:
> +  string * make_debug_string () final override;
> +  void write_reproducer (reproducer &r) final override;
> +
> +private:
> +  rvalue *m_target_address;
> +  auto_vec <block *> m_destinations;
> +};
> +
>  class return_ : public statement
>  {
>  public:
> diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc
> index 5a874fc48..b38f8961e 100644
> --- a/gcc/jit/libgccjit.cc
> +++ b/gcc/jit/libgccjit.cc
> @@ -1871,6 +1871,9 @@ gcc_jit_global_set_initializer_rvalue (gcc_jit_lvalue 
> *global,
>                                "global variable already initialized: %s",
>                                global->get_debug_string ());
>
> +  if (!init_rvalue->verify_valid_within_global_init (__func__, global))
> +    return NULL;
> +
>    /* The global need to know during playback that it will be
>       initialized.  */
>    gbl->set_flags (gcc::jit::GLOBAL_VAR_FLAGS_WILL_BE_RVAL_INIT);
> @@ -2874,6 +2877,23 @@ gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue,
>    return (gcc_jit_rvalue *)lvalue->get_address (loc);
>  }
>
> +/* Public entrypoint.  See description in libgccjit.h.
> +
> +   After error-checking, the real work is done by the
> +   gcc::jit::recording::block::get_address method in
> +   jit-recording.cc.  */
> +
> +gcc_jit_rvalue *
> +gcc_jit_block_get_address (gcc_jit_block *block,
> +                          gcc_jit_location *loc)
> +{
> +  RETURN_NULL_IF_FAIL (block, NULL, loc, "NULL block");
> +  JIT_LOG_FUNC (block->get_context ()->get_logger ());
> +  /* LOC can be NULL.  */
> +
> +  return (gcc_jit_rvalue *)block->get_address (loc);
> +}
> +
>  /* Public entrypoint.  See description in libgccjit.h.
>
>     After error-checking, the real work is done by the
> @@ -3258,6 +3278,57 @@ gcc_jit_block_end_with_jump (gcc_jit_block *block,
>    block->end_with_jump (loc, target);
>  }
>
> +/* Public entrypoint.  See description in libgccjit.h.
> +
> +   After error-checking, the real work is done by the
> +   gcc::jit::recording::block::end_with_indirect_jump method in
> +   jit-recording.cc.  */
> +
> +void
> +gcc_jit_block_end_with_indirect_jump (gcc_jit_block *block,
> +                                     gcc_jit_location *loc,
> +                                     gcc_jit_rvalue *target_address,
> +                                     int num_destinations,
> +                                     gcc_jit_block **destinations)
> +{
> +  RETURN_IF_NOT_VALID_BLOCK (block, loc);
> +  gcc::jit::recording::context *ctxt = block->get_context ();
> +  JIT_LOG_FUNC (ctxt->get_logger ());
> +  /* LOC can be NULL.  */
> +  RETURN_IF_FAIL (target_address, ctxt, loc, "NULL target_address");
> +  RETURN_IF_FAIL_PRINTF1 (
> +    target_address->get_type ()->is_pointer (),
> +    ctxt, loc,
> +    "target_address: %s is not of a pointer type",
> +    target_address->get_debug_string ());
> +  RETURN_IF_FAIL (num_destinations >= 0, ctxt, loc, "num_destinations < 0");
> +  if (num_destinations > 0)
> +    RETURN_IF_FAIL (destinations, ctxt, loc, "NULL destinations");
> +
> +  for (int i = 0; i < num_destinations; i++)
> +    {
> +      RETURN_IF_FAIL_PRINTF1 (destinations[i], ctxt, loc,
> +                             "NULL destination block at index %d", i);
> +      RETURN_IF_FAIL_PRINTF4 (
> +       block->get_function () == destinations[i]->get_function (),
> +       ctxt, loc,
> +       "destination block %d (%s) is not in the same function"
> +       " (function %s) as source block %s",
> +       i,
> +       destinations[i]->get_debug_string (),
> +       destinations[i]->get_function ()->get_debug_string (),
> +       block->get_debug_string ());
> +    }
> +
> +  gcc::jit::recording::statement *stmt =
> +    block->end_with_indirect_jump (loc, target_address,
> +                                  num_destinations,
> +                                  (gcc::jit::recording::block 
> **)destinations);
> +
> +  /* target_address must be valid to use within STMT.  */
> +  target_address->verify_valid_within_stmt (__func__, stmt);
> +}
> +
>  /* Public entrypoint.  See description in libgccjit.h.
>
>     After error-checking, the real work is done by the
> diff --git a/gcc/jit/libgccjit.exports b/gcc/jit/libgccjit.exports
> index fae095192..751918c45 100644
> --- a/gcc/jit/libgccjit.exports
> +++ b/gcc/jit/libgccjit.exports
> @@ -267,3 +267,7 @@ _gcc_jit_context_new_array_type_u64
>
>  # LIBGCCJIT_ABI_38
>  _gcc_jit_type_is_floating_point
> +
> +# LIBGCCJIT_ABI_39
> +_gcc_jit_block_get_address
> +_gcc_jit_block_end_with_indirect_jump
> diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h
> index 2247c99de..272085986 100644
> --- a/gcc/jit/libgccjit.h
> +++ b/gcc/jit/libgccjit.h
> @@ -1455,16 +1455,31 @@ extern gcc_jit_rvalue *
>  gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue,
>                             gcc_jit_location *loc);
>
> +#define LIBGCCJIT_HAVE_gcc_jit_block_get_address
> +
> +/* Taking the address of a block; analogous to:
> +     &&block
> +   in C.
> +
> +   This API entrypoint was added in LIBGCCJIT_ABI_39; you can test for its
> +   presence using
> +      #ifdef LIBGCCJIT_HAVE_gcc_jit_block_get_address
> +*/
> +extern gcc_jit_rvalue *
> +gcc_jit_block_get_address (gcc_jit_block *block,
> +                          gcc_jit_location *loc);
> +
>  #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model
>
>  /* Set the thread-local storage model of a global variable
>
>     This API entrypoint was added in LIBGCCJIT_ABI_17; you can test for its
>     presence using
> -     #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model  */
> +     #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model
> +*/
>  extern void
>  gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue *lvalue,
> -                           enum gcc_jit_tls_model model);
> +                             enum gcc_jit_tls_model model);
>
>  #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section
>
> @@ -1592,6 +1607,32 @@ gcc_jit_block_end_with_jump (gcc_jit_block *block,
>                              gcc_jit_location *loc,
>                              gcc_jit_block *target);
>
> +#define LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump
> +
> +/* Terminate a block by adding an indirect jump to target_address.
> +
> +   All possible indirect jump targets must be constrained to a fixed array.
> +
> +   The candidate destination blocks must be listed in DESTINATIONS
> +
> +   (of length NUM_DESTINATIONS) so that libgccjit can validate block
> +
> +   reachability within the function.
> +
> +   This is roughly equivalent to this C code:
> +
> +      goto *target_address;
> +
> +   This API entrypoint was added in LIBGCCJIT_ABI_39; you can test for its
> +   presence using
> +      #ifdef LIBGCCJIT_HAVE_gcc_jit_block_end_with_indirect_jump.  */
> +extern void
> +gcc_jit_block_end_with_indirect_jump (gcc_jit_block *block,
> +                                     gcc_jit_location *loc,
> +                                     gcc_jit_rvalue *target_address,
> +                                     int num_destinations,
> +                                     gcc_jit_block **destinations);
> +
>  /* Terminate a block by adding evaluation of an rvalue, returning the value.
>
>     This is roughly equivalent to this C code:
> diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map
> index 78b6be9ff..9412700a2 100644
> --- a/gcc/jit/libgccjit.map
> +++ b/gcc/jit/libgccjit.map
> @@ -349,3 +349,9 @@ LIBGCCJIT_ABI_38 {
>    global:
>      gcc_jit_type_is_floating_point;
>  } LIBGCCJIT_ABI_37;
> +
> +LIBGCCJIT_ABI_39 {
> +  global:
> +    gcc_jit_block_get_address;
> +    gcc_jit_block_end_with_indirect_jump;
> +} LIBGCCJIT_ABI_38;
> diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h 
> b/gcc/testsuite/jit.dg/all-non-failing-tests.h
> index e8f8463e8..f8202635e 100644
> --- a/gcc/testsuite/jit.dg/all-non-failing-tests.h
> +++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h
> @@ -269,6 +269,13 @@
>  #undef create_code
>  #undef verify_code
>
> +/* test-indirect-jump.c */
> +#define create_code create_code_indirect_jump
> +#define verify_code verify_code_indirect_jump
> +#include "test-indirect-jump.c"
> +#undef create_code
> +#undef verify_code
> +
>  /* test-link-section-assembler.c: This can't be in the testcases array as it
>     doesn't have a verify_code implementation.  */
>
> @@ -688,6 +695,9 @@ const struct testcase testcases[] = {
>    {"vector_perm",
>     create_code_vector_perm,
>     verify_code_vector_perm},
> +  {"indirect_jump",
> +   create_code_indirect_jump,
> +   verify_code_indirect_jump},
>  };
>
>  const int num_testcases = (sizeof (testcases) / sizeof (testcases[0]));
> diff --git a/gcc/testsuite/jit.dg/test-error-block-address-global-init.c 
> b/gcc/testsuite/jit.dg/test-error-block-address-global-init.c
> new file mode 100644
> index 000000000..1df8988ff
> --- /dev/null
> +++ b/gcc/testsuite/jit.dg/test-error-block-address-global-init.c
> @@ -0,0 +1,79 @@
> +#include <stdlib.h>
> +#include <stdio.h>
> +
> +#include "libgccjit.h"
> +#include "harness.h"
> +
> +void
> +create_code (gcc_jit_context *ctxt, void *user_data)
> +{
> +  gcc_jit_type *void_type =
> +    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
> +  gcc_jit_type *void_ptr_type =
> +    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR);
> +
> +  gcc_jit_function *fn =
> +    gcc_jit_context_new_function (ctxt, NULL,
> +                                 GCC_JIT_FUNCTION_EXPORTED,
> +                                 void_type,
> +                                 "my_fn",
> +                                 0, NULL,
> +                                 0);
> +  gcc_jit_block *block =
> +    gcc_jit_function_new_block (fn, "target_block");
> +
> +  gcc_jit_rvalue *block_addr =
> +    gcc_jit_block_get_address (block, NULL);
> +
> +  /* 1. Direct global initializer (should fail validation).  */
> +  gcc_jit_lvalue *global_ptr =
> +    gcc_jit_context_new_global (ctxt, NULL,
> +                               GCC_JIT_GLOBAL_EXPORTED,
> +                               void_ptr_type,
> +                               "global_ptr");
> +  CHECK_VALUE (
> +    gcc_jit_global_set_initializer_rvalue (global_ptr, block_addr),
> +    NULL);
> +
> +  /* 2. Nested inside an array constructor (should fail validation).  */
> +  gcc_jit_type *array_type =
> +    gcc_jit_context_new_array_type (ctxt, NULL, void_ptr_type, 1);
> +  gcc_jit_lvalue *global_table =
> +    gcc_jit_context_new_global (ctxt, NULL,
> +                               GCC_JIT_GLOBAL_EXPORTED,
> +                               array_type,
> +                               "global_table");
> +  gcc_jit_rvalue *ctor =
> +    gcc_jit_context_new_array_constructor (ctxt, NULL,
> +                                          array_type,
> +                                          1, &block_addr);
> +  CHECK_VALUE (
> +    gcc_jit_global_set_initializer_rvalue (global_table, ctor),
> +    NULL);
> +
> +  /* Consume ctor (and transitively block_addr) within my_fn so the
> +     generated reproducer reads the variables and avoids
> +     -Werror=unused-but-set-variable.  */
> +  gcc_jit_block_add_eval (block, NULL, ctor);
> +  gcc_jit_block_end_with_void_return (block, NULL);
> +}
> +
> +void
> +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
> +{
> +  CHECK_VALUE (result, NULL);
> +
> +  CHECK_STRING_VALUE (
> +    gcc_jit_context_get_first_error (ctxt),
> +    "gcc_jit_global_set_initializer_rvalue:"
> +    " rvalue &&target_block (type: void *)"
> +    " has scope limited to function my_fn"
> +    " but was used in initializer for global global_ptr");
> +
> +  CHECK_STRING_VALUE (
> +    gcc_jit_context_get_last_error (ctxt),
> +    "gcc_jit_global_set_initializer_rvalue:"
> +    " rvalue &&target_block (type: void *)"
> +    " has scope limited to function my_fn"
> +    " but was used in initializer for global global_table");
> +}
> diff --git a/gcc/testsuite/jit.dg/test-error-indirect-jump.c 
> b/gcc/testsuite/jit.dg/test-error-indirect-jump.c
> new file mode 100644
> index 000000000..8f40a3738
> --- /dev/null
> +++ b/gcc/testsuite/jit.dg/test-error-indirect-jump.c
> @@ -0,0 +1,112 @@
> +#include <stdlib.h>
> +#include <stdio.h>
> +
> +#include "libgccjit.h"
> +#include "harness.h"
> +
> +void
> +create_code (gcc_jit_context *ctxt, void *user_data)
> +{
> +  /* Let's try to trigger every validation error on
> +     gcc_jit_block_get_address and gcc_jit_block_end_with_indirect_jump.  */
> +  gcc_jit_type *void_type =
> +    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
> +  gcc_jit_type *int_type =
> +    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
> +
> +  gcc_jit_function *fn1 =
> +    gcc_jit_context_new_function (ctxt, NULL,
> +                                 GCC_JIT_FUNCTION_EXPORTED,
> +                                 void_type,
> +                                 "fn1",
> +                                 0, NULL,
> +                                 0);
> +  gcc_jit_block *b_fn1 =
> +    gcc_jit_function_new_block (fn1, "b_fn1");
> +
> +  gcc_jit_function *fn2 =
> +    gcc_jit_context_new_function (ctxt, NULL,
> +                                 GCC_JIT_FUNCTION_EXPORTED,
> +                                 void_type,
> +                                 "fn2",
> +                                 0, NULL,
> +                                 0);
> +  gcc_jit_block *b_fn2 =
> +    gcc_jit_function_new_block (fn2, "b_fn2");
> +
> +  /* 1. Non-pointer target_address.  */
> +  gcc_jit_rvalue * non_ptr =
> +    gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 42);
> +  gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, non_ptr, 0, NULL);
> +  CHECK_STRING_VALUE (
> +    gcc_jit_context_get_last_error (ctxt),
> +    "gcc_jit_block_end_with_indirect_jump:"
> +    " target_address: (int)42 is not of a pointer type");
> +
> +  /* 2. Negative num_destinations.  */
> +  gcc_jit_rvalue *addr_fn1 = gcc_jit_block_get_address (b_fn1, NULL);
> +  gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, -1, NULL);
> +  CHECK_STRING_VALUE (
> +    gcc_jit_context_get_last_error (ctxt),
> +    "gcc_jit_block_end_with_indirect_jump: num_destinations < 0");
> +
> +  /* 3. NULL destinations array when num_destinations > 0.  */
> +  gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1, NULL);
> +  CHECK_STRING_VALUE (
> +    gcc_jit_context_get_last_error (ctxt),
> +    "gcc_jit_block_end_with_indirect_jump: NULL destinations");
> +
> +  /* 4. NULL element in destinations array.  */
> +  gcc_jit_block *null_dests[1] = { NULL };
> +  gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1, 
> null_dests);
> +  CHECK_STRING_VALUE (
> +    gcc_jit_context_get_last_error (ctxt),
> +    "gcc_jit_block_end_with_indirect_jump:"
> +    " NULL destination block at index 0");
> +
> +  /* 5. Destination block in wrong function.  */
> +  gcc_jit_block *wrong_fn_dests[1] = { b_fn2 };
> +  gcc_jit_block_end_with_indirect_jump (b_fn1, NULL, addr_fn1, 1,
> +                                       wrong_fn_dests);
> +  CHECK_STRING_VALUE (
> +    gcc_jit_context_get_last_error (ctxt),
> +    "gcc_jit_block_end_with_indirect_jump:"
> +    " destination block 0 (b_fn2) is not in the same function"
> +    " (function fn2) as source block b_fn1");
> +
> +  /* Terminate b_fn1 cleanly so function validation doesn't overwrite
> +     last_error with an "unterminated block" error during compile.  */
> +  gcc_jit_block_end_with_void_return (b_fn1, NULL);
> +
> +  /* 6. Cross-function block address (addr_fn1 used inside fn2).  */
> +  gcc_jit_block *fn2_dests[1] = { b_fn2 };
> +  gcc_jit_block_end_with_indirect_jump (b_fn2, NULL, addr_fn1, 1,
> +                                       fn2_dests);
> +
> +  CHECK_STRING_VALUE (
> +    gcc_jit_context_get_last_error (ctxt),
> +    "gcc_jit_block_end_with_indirect_jump:"
> +    " rvalue &&b_fn1 (type: void *) has scope limited to function fn1"
> +    " but was used within function fn2"
> +    " (in statement: goto *&&b_fn1;)");
> +}
> +
> +void
> +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
> +{
> +  CHECK_VALUE (result, NULL);
> +
> +  CHECK_STRING_VALUE (
> +    gcc_jit_context_get_first_error (ctxt),
> +    "gcc_jit_block_end_with_indirect_jump:"
> +    " target_address: (int)42 is not of a pointer type");
> +
> +  /* Verify that using a block address from fn1 inside fn2 was caught
> +     by verify_valid_within_stmt.  */
> +  CHECK_STRING_VALUE (
> +    gcc_jit_context_get_last_error (ctxt),
> +    "gcc_jit_block_end_with_indirect_jump:"
> +    " rvalue &&b_fn1 (type: void *) has scope limited to function fn1"
> +    " but was used within function fn2"
> +    " (in statement: goto *&&b_fn1;)");
> +}
> diff --git a/gcc/testsuite/jit.dg/test-indirect-jump.c 
> b/gcc/testsuite/jit.dg/test-indirect-jump.c
> new file mode 100644
> index 000000000..f464a6edb
> --- /dev/null
> +++ b/gcc/testsuite/jit.dg/test-indirect-jump.c
> @@ -0,0 +1,109 @@
> +#include <stdlib.h>
> +#include <stdio.h>
> +
> +#include "libgccjit.h"
> +#include "harness.h"
> +
> +void
> +create_code (gcc_jit_context *ctxt, void *user_data)
> +{
> +  /* Let's try to inject the equivalent of:
> +     int
> +     test_indirect_jump (int idx)
> +     {
> +       void *targets[3];
> +       targets[0] = &&b_zero;
> +       targets[1] = &&b_one;
> +       targets[2] = &&b_two;
> +       goto *targets[idx];
> +
> +     b_zero:
> +       return 10;
> +     b_one:
> +       return 20;
> +     b_two:
> +       return 30;
> +     }
> +  */
> +  gcc_jit_type *int_type =
> +    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
> +  gcc_jit_type *void_ptr_type =
> +    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR);
> +  gcc_jit_type *array_type =
> +    gcc_jit_context_new_array_type (ctxt, NULL, void_ptr_type, 3);
> +
> +  gcc_jit_param *param_idx =
> +    gcc_jit_context_new_param (ctxt, NULL, int_type, "idx");
> +  gcc_jit_function *func =
> +    gcc_jit_context_new_function (ctxt, NULL,
> +                                 GCC_JIT_FUNCTION_EXPORTED,
> +                                 int_type,
> +                                 "test_indirect_jump",
> +                                 1, &param_idx,
> +                                 0);
> +
> +  gcc_jit_block *b_entry = gcc_jit_function_new_block (func, "entry");
> +  gcc_jit_block *b_zero = gcc_jit_function_new_block (func, "b_zero");
> +  gcc_jit_block *b_one = gcc_jit_function_new_block (func, "b_one");
> +  gcc_jit_block *b_two = gcc_jit_function_new_block (func, "b_two");
> +
> +  gcc_jit_lvalue *targets =
> +    gcc_jit_function_new_local (func, NULL, array_type, "targets");
> +
> +  gcc_jit_block *blocks[3] = { b_zero, b_one, b_two };
> +  for (int i = 0; i < 3; i++)
> +    {
> +      gcc_jit_rvalue *idx_val =
> +       gcc_jit_context_new_rvalue_from_int (ctxt, int_type, i);
> +      gcc_jit_lvalue *elem =
> +       gcc_jit_context_new_array_access (ctxt, NULL,
> +                                         gcc_jit_lvalue_as_rvalue (targets),
> +                                         idx_val);
> +      gcc_jit_rvalue *blk_addr =
> +       gcc_jit_block_get_address (blocks[i], NULL);
> +      gcc_jit_block_add_assignment (b_entry, NULL, elem, blk_addr);
> +    }
> +
> +  /* void *target_addr = targets[idx]; */
> +  gcc_jit_lvalue *selected_elem =
> +    gcc_jit_context_new_array_access (ctxt, NULL,
> +                                     gcc_jit_lvalue_as_rvalue (targets),
> +                                     gcc_jit_param_as_rvalue (param_idx));
> +
> +  /* goto *targets[idx]; */
> +  gcc_jit_block_end_with_indirect_jump (
> +    b_entry, NULL,
> +    gcc_jit_lvalue_as_rvalue (selected_elem),
> +    3, blocks);
> +
> +  /* b_zero: return 10; */
> +  gcc_jit_block_end_with_return (
> +    b_zero, NULL,
> +    gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 10));
> +
> +  /* b_one: return 20; */
> +  gcc_jit_block_end_with_return (
> +    b_one, NULL,
> +    gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 20));
> +
> +  /* b_two: return 30; */
> +  gcc_jit_block_end_with_return (
> +    b_two, NULL,
> +    gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 30));
> +}
> +
> +void
> +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
> +
> +{
> +  typedef int (*fn_type) (int);
> +  CHECK_NON_NULL (result);
> +
> +  fn_type test_indirect_jump =
> +    (fn_type)gcc_jit_result_get_code (result, "test_indirect_jump");
> +  CHECK_NON_NULL (test_indirect_jump);
> +
> +  CHECK_VALUE (test_indirect_jump (0), 10);
> +  CHECK_VALUE (test_indirect_jump (1), 20);
> +  CHECK_VALUE (test_indirect_jump (2), 30);
> +}
> --
> 2.56.0
>

Reply via email to