jit: further doc fixes

Further jit doc fixes, which fix links to
gcc_jit_function_type_get_param_type and gcc_jit_struct_get_field.

gcc/jit/ChangeLog:
	* docs/topics/expressions.rst: Fix formatting.
	* docs/topics/types.rst: Likewise.
	* docs/_build/texinfo/libgccjit.texi: Regenerate

Signed-off-by: David Malcolm <dmalcolm@redhat.com>

3 files changed, 1320 insertions, 702 deletions

diff --git a/gcc/jit/docs/_build/texinfo/libgccjit.texi b/gcc/jit/docs/_build/texinfo/libgccjit.texi
index 603de63..c1ca5aa 100644
--- a/gcc/jit/docs/_build/texinfo/libgccjit.texi
+++ b/gcc/jit/docs/_build/texinfo/libgccjit.texi
@@ -21,7 +21,7 @@
 
 @copying
 @quotation
-libgccjit 11.0.0 (experimental 20210114), Jan 14, 2021
+libgccjit 12.0.1 (experimental 20220331), Mar 31, 2022
 
 David Malcolm
 
@@ -193,6 +193,7 @@ Types
 * Vector types:: 
 * Structures and unions:: 
 * Function pointer types:: 
+* Reflection API:: 
 
 Expressions
 
@@ -203,6 +204,7 @@ Expressions
 Rvalues
 
 * Simple expressions:: 
+* Constructor expressions:: 
 * Vector expressions:: 
 * Unary Operations:: 
 * Binary Operations:: 
@@ -254,6 +256,10 @@ ABI symbol tags
 * LIBGCCJIT_ABI_13:: 
 * LIBGCCJIT_ABI_14:: 
 * LIBGCCJIT_ABI_15:: 
+* LIBGCCJIT_ABI_16:: 
+* LIBGCCJIT_ABI_17:: 
+* LIBGCCJIT_ABI_18:: 
+* LIBGCCJIT_ABI_19:: 
 
 Performance
 
@@ -463,7 +469,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
-<https://www.gnu.org/licenses/>.  */
+<http://www.gnu.org/licenses/>.  */
 
 #include <libgccjit.h>
 
@@ -1001,7 +1007,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
-<https://www.gnu.org/licenses/>.  */
+<http://www.gnu.org/licenses/>.  */
 
 #include <libgccjit.h>
 
@@ -1560,7 +1566,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
-<https://www.gnu.org/licenses/>.  */
+<http://www.gnu.org/licenses/>.  */
 
 #include <libgccjit.h>
 
@@ -2445,7 +2451,7 @@ be consolidated into larger blocks when the optimizer runs.
 @example
   for (pc = 0; pc < fn->fn_num_ops; pc++)
     @{
-      char buf[16];
+      char buf[100];
       sprintf (buf, "instr%i", pc);
       state.op_blocks[pc] = gcc_jit_function_new_block (state.fn, buf);
     @}
@@ -5108,6 +5114,11 @@ For example:
 @example
 gcc_jit_context_add_driver_option (ctxt, "-lm");
 gcc_jit_context_add_driver_option (ctxt, "-fuse-linker-plugin");
+
+gcc_jit_context_add_driver_option (ctxt, "obj.o");
+
+gcc_jit_context_add_driver_option (ctxt, "-L.");
+gcc_jit_context_add_driver_option (ctxt, "-lwhatever");
 @end example
 
 Note that only some options are likely to be meaningful; there is no
@@ -5302,6 +5313,7 @@ by creating structures (see below).
 * Vector types:: 
 * Structures and unions:: 
 * Function pointer types:: 
+* Reflection API:: 
 
 @end menu
 
@@ -5636,7 +5648,7 @@ A compound type analagous to a C @cite{struct}.
 
 A field within a @ref{89,,gcc_jit_struct}.
 
-You can model C @cite{struct} types by creating @ref{89,,gcc_jit_struct *} and
+You can model C @cite{struct} types by creating @ref{89,,gcc_jit_struct} and
 @ref{8a,,gcc_jit_field} instances, in either order:
 
 
@@ -5860,7 +5872,7 @@ create_code (gcc_jit_context *ctxt, void *user_data)
 @end example
 @end deffn
 
-@node Function pointer types,,Structures and unions,Types
+@node Function pointer types,Reflection API,Structures and unions,Types
 @anchor{topics/types function-pointer-types}@anchor{94}
 @subsection Function pointer types
 
@@ -5868,6 +5880,186 @@ create_code (gcc_jit_context *ctxt, void *user_data)
 Function pointer types can be created using
 @ref{95,,gcc_jit_context_new_function_ptr_type()}.
 
+@node Reflection API,,Function pointer types,Types
+@anchor{topics/types reflection-api}@anchor{96}
+@subsection Reflection API
+
+
+@geindex gcc_jit_type_dyncast_array (C function)
+@anchor{topics/types c gcc_jit_type_dyncast_array}@anchor{97}
+@deffn {C Function} gcc_jit_type *          gcc_jit_type_dyncast_array (gcc_jit_type@w{ }*type)
+
+Get the element type of an array type or NULL if it’s not an array.
+@end deffn
+
+@geindex gcc_jit_type_is_bool (C function)
+@anchor{topics/types c gcc_jit_type_is_bool}@anchor{98}
+@deffn {C Function} int          gcc_jit_type_is_bool (gcc_jit_type@w{ }*type)
+
+Return non-zero if the type is a bool.
+@end deffn
+
+@geindex gcc_jit_type_dyncast_function_ptr_type (C function)
+@anchor{topics/types c gcc_jit_type_dyncast_function_ptr_type}@anchor{99}
+@deffn {C Function} gcc_jit_function_type *          gcc_jit_type_dyncast_function_ptr_type (gcc_jit_type@w{ }*type)
+
+Return the function type if it is one or NULL.
+@end deffn
+
+@geindex gcc_jit_function_type_get_return_type (C function)
+@anchor{topics/types c gcc_jit_function_type_get_return_type}@anchor{9a}
+@deffn {C Function} gcc_jit_type *          gcc_jit_function_type_get_return_type (gcc_jit_function_type@w{ }*function_type)
+
+Given a function type, return its return type.
+@end deffn
+
+@geindex gcc_jit_function_type_get_param_count (C function)
+@anchor{topics/types c gcc_jit_function_type_get_param_count}@anchor{9b}
+@deffn {C Function} size_t          gcc_jit_function_type_get_param_count (gcc_jit_function_type@w{ }*function_type)
+
+Given a function type, return its number of parameters.
+@end deffn
+
+@geindex gcc_jit_function_type_get_param_type (C function)
+@anchor{topics/types c gcc_jit_function_type_get_param_type}@anchor{9c}
+@deffn {C Function} gcc_jit_type *          gcc_jit_function_type_get_param_type (gcc_jit_function_type@w{ }*function_type, size_t@w{ }index)
+
+Given a function type, return the type of the specified parameter.
+@end deffn
+
+@geindex gcc_jit_type_is_integral (C function)
+@anchor{topics/types c gcc_jit_type_is_integral}@anchor{9d}
+@deffn {C Function} int          gcc_jit_type_is_integral (gcc_jit_type@w{ }*type)
+
+Return non-zero if the type is an integral.
+@end deffn
+
+@geindex gcc_jit_type_is_pointer (C function)
+@anchor{topics/types c gcc_jit_type_is_pointer}@anchor{9e}
+@deffn {C Function} gcc_jit_type *          gcc_jit_type_is_pointer (gcc_jit_type@w{ }*type)
+
+Return the type pointed by the pointer type or NULL if it’s not a pointer.
+@end deffn
+
+@geindex gcc_jit_type_dyncast_vector (C function)
+@anchor{topics/types c gcc_jit_type_dyncast_vector}@anchor{9f}
+@deffn {C Function} gcc_jit_vector_type *          gcc_jit_type_dyncast_vector (gcc_jit_type@w{ }*type)
+
+Given a type, return a dynamic cast to a vector type or NULL.
+@end deffn
+
+@geindex gcc_jit_type_is_struct (C function)
+@anchor{topics/types c gcc_jit_type_is_struct}@anchor{a0}
+@deffn {C Function} gcc_jit_struct *          gcc_jit_type_is_struct (gcc_jit_type@w{ }*type)
+
+Given a type, return a dynamic cast to a struct type or NULL.
+@end deffn
+
+@geindex gcc_jit_vector_type_get_num_units (C function)
+@anchor{topics/types c gcc_jit_vector_type_get_num_units}@anchor{a1}
+@deffn {C Function} size_t          gcc_jit_vector_type_get_num_units (gcc_jit_vector_type@w{ }*vector_type)
+
+Given a vector type, return the number of units it contains.
+@end deffn
+
+@geindex gcc_jit_vector_type_get_element_type (C function)
+@anchor{topics/types c gcc_jit_vector_type_get_element_type}@anchor{a2}
+@deffn {C Function} gcc_jit_type *          gcc_jit_vector_type_get_element_type (gcc_jit_vector_type *@w{ }vector_type)
+
+Given a vector type, return the type of its elements.
+@end deffn
+
+@geindex gcc_jit_type_unqualified (C function)
+@anchor{topics/types c gcc_jit_type_unqualified}@anchor{a3}
+@deffn {C Function} gcc_jit_type *          gcc_jit_type_unqualified (gcc_jit_type@w{ }*type)
+
+Given a type, return the unqualified type, removing “const”, “volatile” and
+alignment qualifiers.
+@end deffn
+
+@geindex gcc_jit_struct_get_field (C function)
+@anchor{topics/types c gcc_jit_struct_get_field}@anchor{a4}
+@deffn {C Function} gcc_jit_field *          gcc_jit_struct_get_field (gcc_jit_struct@w{ }*struct_type, size_t@w{ }index)
+
+Get a struct field by index.
+@end deffn
+
+@geindex gcc_jit_struct_get_field_count (C function)
+@anchor{topics/types c gcc_jit_struct_get_field_count}@anchor{a5}
+@deffn {C Function} size_t            gcc_jit_struct_get_field_count (gcc_jit_struct@w{ }*struct_type)
+
+@quotation
+
+Get the number of fields in the struct.
+@end quotation
+
+The API entrypoints related to the reflection API:
+
+@quotation
+
+
+@itemize *
+
+@item 
+@ref{9a,,gcc_jit_function_type_get_return_type()}
+
+@item 
+@ref{9b,,gcc_jit_function_type_get_param_count()}
+
+@item 
+@ref{9c,,gcc_jit_function_type_get_param_type()}
+
+@item 
+@ref{a3,,gcc_jit_type_unqualified()}
+
+@item 
+@ref{97,,gcc_jit_type_dyncast_array()}
+
+@item 
+@ref{98,,gcc_jit_type_is_bool()}
+
+@item 
+@ref{99,,gcc_jit_type_dyncast_function_ptr_type()}
+
+@item 
+@ref{9d,,gcc_jit_type_is_integral()}
+
+@item 
+@ref{9e,,gcc_jit_type_is_pointer()}
+
+@item 
+@ref{9f,,gcc_jit_type_dyncast_vector()}
+
+@item 
+@ref{a2,,gcc_jit_vector_type_get_element_type()}
+
+@item 
+@ref{a1,,gcc_jit_vector_type_get_num_units()}
+
+@item 
+@ref{a4,,gcc_jit_struct_get_field()}
+
+@item 
+@ref{a0,,gcc_jit_type_is_struct()}
+
+@item 
+@ref{a5,,gcc_jit_struct_get_field_count()}
+@end itemize
+@end quotation
+
+were added in @ref{a6,,LIBGCCJIT_ABI_16}; you can test for their presence
+using
+
+@example
+#ifdef LIBGCCJIT_HAVE_REFLECTION
+@end example
+
+@geindex gcc_jit_case (C type)
+@anchor{topics/types c gcc_jit_case}@anchor{a7}
+@deffn {C Type} gcc_jit_case
+@end deffn
+@end deffn
+
 @c Copyright (C) 2014-2022 Free Software Foundation, Inc.
 @c Originally contributed by David Malcolm <dmalcolm@redhat.com>
 @c 
@@ -5886,7 +6078,7 @@ Function pointer types can be created using
 @c <https://www.gnu.org/licenses/>.
 
 @node Expressions,Creating and using functions,Types,Topic Reference
-@anchor{topics/expressions doc}@anchor{96}@anchor{topics/expressions expressions}@anchor{97}
+@anchor{topics/expressions doc}@anchor{a8}@anchor{topics/expressions expressions}@anchor{a9}
 @section Expressions
 
 
@@ -5898,7 +6090,7 @@ Function pointer types can be created using
 @end menu
 
 @node Rvalues,Lvalues,,Expressions
-@anchor{topics/expressions rvalues}@anchor{98}
+@anchor{topics/expressions rvalues}@anchor{aa}
 @subsection Rvalues
 
 
@@ -5907,7 +6099,7 @@ Function pointer types can be created using
 @deffn {C Type} gcc_jit_rvalue
 @end deffn
 
-A @ref{13,,gcc_jit_rvalue *} is an expression that can be computed.
+A @ref{13,,gcc_jit_rvalue} is an expression that can be computed.
 
 It can be simple, e.g.:
 
@@ -5952,7 +6144,7 @@ Every rvalue has an associated type, and the API will check to ensure
 that types match up correctly (otherwise the context will emit an error).
 
 @geindex gcc_jit_rvalue_get_type (C function)
-@anchor{topics/expressions c gcc_jit_rvalue_get_type}@anchor{99}
+@anchor{topics/expressions c gcc_jit_rvalue_get_type}@anchor{ab}
 @deffn {C Function} gcc_jit_type *gcc_jit_rvalue_get_type (gcc_jit_rvalue@w{ }*rvalue)
 
 Get the type of this rvalue.
@@ -5967,6 +6159,7 @@ Upcast the given rvalue to be an object.
 
 @menu
 * Simple expressions:: 
+* Constructor expressions:: 
 * Vector expressions:: 
 * Unary Operations:: 
 * Binary Operations:: 
@@ -5977,8 +6170,8 @@ Upcast the given rvalue to be an object.
 
 @end menu
 
-@node Simple expressions,Vector expressions,,Rvalues
-@anchor{topics/expressions simple-expressions}@anchor{9a}
+@node Simple expressions,Constructor expressions,,Rvalues
+@anchor{topics/expressions simple-expressions}@anchor{ac}
 @subsubsection Simple expressions
 
 
@@ -5991,7 +6184,7 @@ the given constant @code{int} value.
 @end deffn
 
 @geindex gcc_jit_context_new_rvalue_from_long (C function)
-@anchor{topics/expressions c gcc_jit_context_new_rvalue_from_long}@anchor{9b}
+@anchor{topics/expressions c gcc_jit_context_new_rvalue_from_long}@anchor{ad}
 @deffn {C Function} gcc_jit_rvalue *           gcc_jit_context_new_rvalue_from_long (gcc_jit_context@w{ }*ctxt, gcc_jit_type@w{ }*numeric_type, long@w{ }value)
 
 Given a numeric type (integer or floating point), build an rvalue for
@@ -6031,14 +6224,14 @@ the given constant @code{double} value.
 @end deffn
 
 @geindex gcc_jit_context_new_rvalue_from_ptr (C function)
-@anchor{topics/expressions c gcc_jit_context_new_rvalue_from_ptr}@anchor{9c}
+@anchor{topics/expressions c gcc_jit_context_new_rvalue_from_ptr}@anchor{ae}
 @deffn {C Function} gcc_jit_rvalue *           gcc_jit_context_new_rvalue_from_ptr (gcc_jit_context@w{ }*ctxt, gcc_jit_type@w{ }*pointer_type, void@w{ }*value)
 
 Given a pointer type, build an rvalue for the given address.
 @end deffn
 
 @geindex gcc_jit_context_null (C function)
-@anchor{topics/expressions c gcc_jit_context_null}@anchor{9d}
+@anchor{topics/expressions c gcc_jit_context_null}@anchor{af}
 @deffn {C Function} gcc_jit_rvalue *gcc_jit_context_null (gcc_jit_context@w{ }*ctxt, gcc_jit_type@w{ }*pointer_type)
 
 Given a pointer type, build an rvalue for @code{NULL}.  Essentially this
@@ -6050,7 +6243,7 @@ gcc_jit_context_new_rvalue_from_ptr (ctxt, pointer_type, NULL)
 @end deffn
 
 @geindex gcc_jit_context_new_string_literal (C function)
-@anchor{topics/expressions c gcc_jit_context_new_string_literal}@anchor{9e}
+@anchor{topics/expressions c gcc_jit_context_new_string_literal}@anchor{b0}
 @deffn {C Function} gcc_jit_rvalue *           gcc_jit_context_new_string_literal (gcc_jit_context@w{ }*ctxt, const char@w{ }*value)
 
 Generate an rvalue for the given NIL-terminated string, of type
@@ -6061,8 +6254,150 @@ underlying string, so it is valid to pass in a pointer to an on-stack
 buffer.
 @end deffn
 
-@node Vector expressions,Unary Operations,Simple expressions,Rvalues
-@anchor{topics/expressions vector-expressions}@anchor{9f}
+@node Constructor expressions,Vector expressions,Simple expressions,Rvalues
+@anchor{topics/expressions constructor-expressions}@anchor{b1}
+@subsubsection Constructor expressions
+
+
+@quotation
+
+The following functions make constructors for array, struct and union
+types.
+
+The constructor rvalue can be used for assignment to locals.
+It can be used to initialize global variables with
+@ref{b2,,gcc_jit_global_set_initializer_rvalue()}. It can also be used as a
+temporary value for function calls and return values, but its address
+can’t be taken.
+
+Note that arrays in libgccjit do not collapse to pointers like in
+C. I.e. if an array constructor is used as e.g. a return value, the whole
+array would be returned by value - array constructors can be assigned to
+array variables.
+
+The constructor can contain nested constructors.
+
+Note that a string literal rvalue can’t be used to construct a char array;
+the latter needs one rvalue for each char.
+
+These entrypoints were added in @ref{b3,,LIBGCCJIT_ABI_19}; you can test for
+their presence using:
+
+@example
+#ifdef LIBGCCJIT_HAVE_CTORS
+@end example
+@end quotation
+
+@geindex gcc_jit_context_new_array_constructor (C function)
+@anchor{topics/expressions c gcc_jit_context_new_array_constructor}@anchor{b4}
+@deffn {C Function} gcc_jit_rvalue *           gcc_jit_context_new_array_constructor (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*type, size_t@w{ }num_values, gcc_jit_rvalue@w{ }**values)
+
+Create a constructor for an array as an rvalue.
+
+Returns NULL on error. @code{values} are copied and
+do not have to outlive the context.
+
+@code{type} specifies what the constructor will build and has to be
+an array.
+
+@code{num_values} specifies the number of elements in @code{values} and
+it can’t have more elements than the array type.
+
+Each value in @code{values} sets the corresponding value in the array.
+If the array type itself has more elements than @code{values}, the
+left-over elements will be zeroed.
+
+Each value in @code{values} need to be the same unqualified type as the
+array type’s element type.
+
+If @code{num_values} is 0, the @code{values} parameter will be
+ignored and zero initialization will be used.
+
+This entrypoint was added in @ref{b3,,LIBGCCJIT_ABI_19}; you can test for its
+presence using:
+
+@example
+#ifdef LIBGCCJIT_HAVE_CTORS
+@end example
+@end deffn
+
+@geindex gcc_jit_context_new_struct_constructor (C function)
+@anchor{topics/expressions c gcc_jit_context_new_struct_constructor}@anchor{b5}
+@deffn {C Function} gcc_jit_rvalue *           gcc_jit_context_new_struct_constructor (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*type, size_t@w{ }num_values, gcc_jit_field@w{ }**fields, gcc_jit_rvalue@w{ }**values)
+
+Create a constructor for a struct as an rvalue.
+
+Returns NULL on error. The two parameter arrays are copied and
+do not have to outlive the context.
+
+@code{type} specifies what the constructor will build and has to be
+a struct.
+
+@code{num_values} specifies the number of elements in @code{values}.
+
+@code{fields} need to have the same length as @code{values}, or be NULL.
+
+If @code{fields} is null, the values are applied in definition order.
+
+Otherwise, each field in @code{fields} specifies which field in the struct to
+set to the corresponding value in @code{values}. @code{fields} and @code{values}
+are paired by index.
+
+The fields in @code{fields} have to be in definition order, but there
+can be gaps. Any field in the struct that is not specified in
+@code{fields} will be zeroed.
+
+The fields in @code{fields} need to be the same objects that were used
+to create the struct.
+
+Each value has to have have the same unqualified type as the field
+it is applied to.
+
+A NULL value element  in @code{values} is a shorthand for zero initialization
+of the corresponding field.
+
+If @code{num_values} is 0, the array parameters will be
+ignored and zero initialization will be used.
+
+This entrypoint was added in @ref{b3,,LIBGCCJIT_ABI_19}; you can test for its
+presence using:
+
+@example
+#ifdef LIBGCCJIT_HAVE_CTORS
+@end example
+@end deffn
+
+@geindex gcc_jit_context_new_union_constructor (C function)
+@anchor{topics/expressions c gcc_jit_context_new_union_constructor}@anchor{b6}
+@deffn {C Function} gcc_jit_rvalue *           gcc_jit_context_new_union_constructor (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*type, gcc_jit_field@w{ }*field, gcc_jit_rvalue@w{ }*value)
+
+Create a constructor for a union as an rvalue.
+
+Returns NULL on error.
+
+@code{type} specifies what the constructor will build and has to be
+an union.
+
+@code{field} specifies which field to set. If it is NULL, the first
+field in the union will be set.`@w{`}field`@w{`} need to be the same object
+that were used to create the union.
+
+@code{value} specifies what value to set the corresponding field to.
+If @code{value} is NULL, zero initialization will be used.
+
+Each value has to have have the same unqualified type as the field
+it is applied to.
+
+This entrypoint was added in @ref{b3,,LIBGCCJIT_ABI_19}; you can test for its
+presence using:
+
+@example
+#ifdef LIBGCCJIT_HAVE_CTORS
+@end example
+@end deffn
+
+@node Vector expressions,Unary Operations,Constructor expressions,Rvalues
+@anchor{topics/expressions vector-expressions}@anchor{b7}
 @subsubsection Vector expressions
 
 
@@ -6077,7 +6412,7 @@ Build a vector rvalue from an array of elements.
 
 “num_elements” should match that of the vector type.
 
-This entrypoint was added in @ref{a0,,LIBGCCJIT_ABI_10}; you can test for
+This entrypoint was added in @ref{b8,,LIBGCCJIT_ABI_10}; you can test for
 its presence using
 
 @example
@@ -6086,12 +6421,12 @@ its presence using
 @end deffn
 
 @node Unary Operations,Binary Operations,Vector expressions,Rvalues
-@anchor{topics/expressions unary-operations}@anchor{a1}
+@anchor{topics/expressions unary-operations}@anchor{b9}
 @subsubsection Unary Operations
 
 
 @geindex gcc_jit_context_new_unary_op (C function)
-@anchor{topics/expressions c gcc_jit_context_new_unary_op}@anchor{a2}
+@anchor{topics/expressions c gcc_jit_context_new_unary_op}@anchor{ba}
 @deffn {C Function} gcc_jit_rvalue *            gcc_jit_context_new_unary_op (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, enum gcc_jit_unary_op@w{ }op, gcc_jit_type@w{ }*result_type, gcc_jit_rvalue@w{ }*rvalue)
 
 Build a unary operation out of an input rvalue.
@@ -6100,7 +6435,7 @@ The parameter @code{result_type} must be a numeric type.
 @end deffn
 
 @geindex gcc_jit_unary_op (C type)
-@anchor{topics/expressions c gcc_jit_unary_op}@anchor{a3}
+@anchor{topics/expressions c gcc_jit_unary_op}@anchor{bb}
 @deffn {C Type} enum gcc_jit_unary_op
 @end deffn
 
@@ -6118,7 +6453,7 @@ C equivalent
 
 @item
 
-@ref{a4,,GCC_JIT_UNARY_OP_MINUS}
+@ref{bc,,GCC_JIT_UNARY_OP_MINUS}
 
 @tab
 
@@ -6126,7 +6461,7 @@ C equivalent
 
 @item
 
-@ref{a5,,GCC_JIT_UNARY_OP_BITWISE_NEGATE}
+@ref{bd,,GCC_JIT_UNARY_OP_BITWISE_NEGATE}
 
 @tab
 
@@ -6134,7 +6469,7 @@ C equivalent
 
 @item
 
-@ref{a6,,GCC_JIT_UNARY_OP_LOGICAL_NEGATE}
+@ref{be,,GCC_JIT_UNARY_OP_LOGICAL_NEGATE}
 
 @tab
 
@@ -6142,7 +6477,7 @@ C equivalent
 
 @item
 
-@ref{a7,,GCC_JIT_UNARY_OP_ABS}
+@ref{bf,,GCC_JIT_UNARY_OP_ABS}
 
 @tab
 
@@ -6152,7 +6487,7 @@ C equivalent
 
 
 @geindex GCC_JIT_UNARY_OP_MINUS (C macro)
-@anchor{topics/expressions c GCC_JIT_UNARY_OP_MINUS}@anchor{a4}
+@anchor{topics/expressions c GCC_JIT_UNARY_OP_MINUS}@anchor{bc}
 @deffn {C Macro} GCC_JIT_UNARY_OP_MINUS
 
 Negate an arithmetic value; analogous to:
@@ -6165,7 +6500,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_UNARY_OP_BITWISE_NEGATE (C macro)
-@anchor{topics/expressions c GCC_JIT_UNARY_OP_BITWISE_NEGATE}@anchor{a5}
+@anchor{topics/expressions c GCC_JIT_UNARY_OP_BITWISE_NEGATE}@anchor{bd}
 @deffn {C Macro} GCC_JIT_UNARY_OP_BITWISE_NEGATE
 
 Bitwise negation of an integer value (one’s complement); analogous
@@ -6179,7 +6514,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_UNARY_OP_LOGICAL_NEGATE (C macro)
-@anchor{topics/expressions c GCC_JIT_UNARY_OP_LOGICAL_NEGATE}@anchor{a6}
+@anchor{topics/expressions c GCC_JIT_UNARY_OP_LOGICAL_NEGATE}@anchor{be}
 @deffn {C Macro} GCC_JIT_UNARY_OP_LOGICAL_NEGATE
 
 Logical negation of an arithmetic or pointer value; analogous to:
@@ -6192,7 +6527,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_UNARY_OP_ABS (C macro)
-@anchor{topics/expressions c GCC_JIT_UNARY_OP_ABS}@anchor{a7}
+@anchor{topics/expressions c GCC_JIT_UNARY_OP_ABS}@anchor{bf}
 @deffn {C Macro} GCC_JIT_UNARY_OP_ABS
 
 Absolute value of an arithmetic expression; analogous to:
@@ -6205,7 +6540,7 @@ in C.
 @end deffn
 
 @node Binary Operations,Comparisons,Unary Operations,Rvalues
-@anchor{topics/expressions binary-operations}@anchor{a8}
+@anchor{topics/expressions binary-operations}@anchor{c0}
 @subsubsection Binary Operations
 
 
@@ -6219,7 +6554,7 @@ The parameter @code{result_type} must be a numeric type.
 @end deffn
 
 @geindex gcc_jit_binary_op (C type)
-@anchor{topics/expressions c gcc_jit_binary_op}@anchor{a9}
+@anchor{topics/expressions c gcc_jit_binary_op}@anchor{c1}
 @deffn {C Type} enum gcc_jit_binary_op
 @end deffn
 
@@ -6237,7 +6572,7 @@ C equivalent
 
 @item
 
-@ref{aa,,GCC_JIT_BINARY_OP_PLUS}
+@ref{c2,,GCC_JIT_BINARY_OP_PLUS}
 
 @tab
 
@@ -6245,7 +6580,7 @@ C equivalent
 
 @item
 
-@ref{ab,,GCC_JIT_BINARY_OP_MINUS}
+@ref{c3,,GCC_JIT_BINARY_OP_MINUS}
 
 @tab
 
@@ -6253,7 +6588,7 @@ C equivalent
 
 @item
 
-@ref{ac,,GCC_JIT_BINARY_OP_MULT}
+@ref{c4,,GCC_JIT_BINARY_OP_MULT}
 
 @tab
 
@@ -6261,7 +6596,7 @@ C equivalent
 
 @item
 
-@ref{ad,,GCC_JIT_BINARY_OP_DIVIDE}
+@ref{c5,,GCC_JIT_BINARY_OP_DIVIDE}
 
 @tab
 
@@ -6269,7 +6604,7 @@ C equivalent
 
 @item
 
-@ref{ae,,GCC_JIT_BINARY_OP_MODULO}
+@ref{c6,,GCC_JIT_BINARY_OP_MODULO}
 
 @tab
 
@@ -6277,7 +6612,7 @@ C equivalent
 
 @item
 
-@ref{af,,GCC_JIT_BINARY_OP_BITWISE_AND}
+@ref{c7,,GCC_JIT_BINARY_OP_BITWISE_AND}
 
 @tab
 
@@ -6285,7 +6620,7 @@ C equivalent
 
 @item
 
-@ref{b0,,GCC_JIT_BINARY_OP_BITWISE_XOR}
+@ref{c8,,GCC_JIT_BINARY_OP_BITWISE_XOR}
 
 @tab
 
@@ -6293,7 +6628,7 @@ C equivalent
 
 @item
 
-@ref{b1,,GCC_JIT_BINARY_OP_BITWISE_OR}
+@ref{c9,,GCC_JIT_BINARY_OP_BITWISE_OR}
 
 @tab
 
@@ -6301,7 +6636,7 @@ C equivalent
 
 @item
 
-@ref{b2,,GCC_JIT_BINARY_OP_LOGICAL_AND}
+@ref{ca,,GCC_JIT_BINARY_OP_LOGICAL_AND}
 
 @tab
 
@@ -6309,7 +6644,7 @@ C equivalent
 
 @item
 
-@ref{b3,,GCC_JIT_BINARY_OP_LOGICAL_OR}
+@ref{cb,,GCC_JIT_BINARY_OP_LOGICAL_OR}
 
 @tab
 
@@ -6317,7 +6652,7 @@ C equivalent
 
 @item
 
-@ref{b4,,GCC_JIT_BINARY_OP_LSHIFT}
+@ref{cc,,GCC_JIT_BINARY_OP_LSHIFT}
 
 @tab
 
@@ -6325,7 +6660,7 @@ C equivalent
 
 @item
 
-@ref{b5,,GCC_JIT_BINARY_OP_RSHIFT}
+@ref{cd,,GCC_JIT_BINARY_OP_RSHIFT}
 
 @tab
 
@@ -6335,7 +6670,7 @@ C equivalent
 
 
 @geindex GCC_JIT_BINARY_OP_PLUS (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_PLUS}@anchor{aa}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_PLUS}@anchor{c2}
 @deffn {C Macro} GCC_JIT_BINARY_OP_PLUS
 
 Addition of arithmetic values; analogous to:
@@ -6346,11 +6681,11 @@ Addition of arithmetic values; analogous to:
 
 in C.
 
-For pointer addition, use @ref{b6,,gcc_jit_context_new_array_access()}.
+For pointer addition, use @ref{ce,,gcc_jit_context_new_array_access()}.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_MINUS (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_MINUS}@anchor{ab}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_MINUS}@anchor{c3}
 @deffn {C Macro} GCC_JIT_BINARY_OP_MINUS
 
 Subtraction of arithmetic values; analogous to:
@@ -6363,7 +6698,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_MULT (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_MULT}@anchor{ac}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_MULT}@anchor{c4}
 @deffn {C Macro} GCC_JIT_BINARY_OP_MULT
 
 Multiplication of a pair of arithmetic values; analogous to:
@@ -6376,7 +6711,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_DIVIDE (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_DIVIDE}@anchor{ad}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_DIVIDE}@anchor{c5}
 @deffn {C Macro} GCC_JIT_BINARY_OP_DIVIDE
 
 Quotient of division of arithmetic values; analogous to:
@@ -6393,7 +6728,7 @@ a floating-point result type indicates floating-point division.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_MODULO (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_MODULO}@anchor{ae}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_MODULO}@anchor{c6}
 @deffn {C Macro} GCC_JIT_BINARY_OP_MODULO
 
 Remainder of division of arithmetic values; analogous to:
@@ -6406,7 +6741,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_BITWISE_AND (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_AND}@anchor{af}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_AND}@anchor{c7}
 @deffn {C Macro} GCC_JIT_BINARY_OP_BITWISE_AND
 
 Bitwise AND; analogous to:
@@ -6419,7 +6754,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_BITWISE_XOR (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_XOR}@anchor{b0}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_XOR}@anchor{c8}
 @deffn {C Macro} GCC_JIT_BINARY_OP_BITWISE_XOR
 
 Bitwise exclusive OR; analogous to:
@@ -6432,7 +6767,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_BITWISE_OR (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_OR}@anchor{b1}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_OR}@anchor{c9}
 @deffn {C Macro} GCC_JIT_BINARY_OP_BITWISE_OR
 
 Bitwise inclusive OR; analogous to:
@@ -6445,7 +6780,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_LOGICAL_AND (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_AND}@anchor{b2}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_AND}@anchor{ca}
 @deffn {C Macro} GCC_JIT_BINARY_OP_LOGICAL_AND
 
 Logical AND; analogous to:
@@ -6458,7 +6793,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_LOGICAL_OR (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_OR}@anchor{b3}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_OR}@anchor{cb}
 @deffn {C Macro} GCC_JIT_BINARY_OP_LOGICAL_OR
 
 Logical OR; analogous to:
@@ -6471,7 +6806,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_LSHIFT (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_LSHIFT}@anchor{b4}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_LSHIFT}@anchor{cc}
 @deffn {C Macro} GCC_JIT_BINARY_OP_LSHIFT
 
 Left shift; analogous to:
@@ -6484,7 +6819,7 @@ in C.
 @end deffn
 
 @geindex GCC_JIT_BINARY_OP_RSHIFT (C macro)
-@anchor{topics/expressions c GCC_JIT_BINARY_OP_RSHIFT}@anchor{b5}
+@anchor{topics/expressions c GCC_JIT_BINARY_OP_RSHIFT}@anchor{cd}
 @deffn {C Macro} GCC_JIT_BINARY_OP_RSHIFT
 
 Right shift; analogous to:
@@ -6497,7 +6832,7 @@ in C.
 @end deffn
 
 @node Comparisons,Function calls,Binary Operations,Rvalues
-@anchor{topics/expressions comparisons}@anchor{b7}
+@anchor{topics/expressions comparisons}@anchor{cf}
 @subsubsection Comparisons
 
 
@@ -6509,7 +6844,7 @@ Build a boolean rvalue out of the comparison of two other rvalues.
 @end deffn
 
 @geindex gcc_jit_comparison (C type)
-@anchor{topics/expressions c gcc_jit_comparison}@anchor{b8}
+@anchor{topics/expressions c gcc_jit_comparison}@anchor{d0}
 @deffn {C Type} enum gcc_jit_comparison
 @end deffn
 
@@ -6575,12 +6910,12 @@ C equivalent
 
 
 @node Function calls,Function pointers,Comparisons,Rvalues
-@anchor{topics/expressions function-calls}@anchor{b9}
+@anchor{topics/expressions function-calls}@anchor{d1}
 @subsubsection Function calls
 
 
 @geindex gcc_jit_context_new_call (C function)
-@anchor{topics/expressions c gcc_jit_context_new_call}@anchor{ba}
+@anchor{topics/expressions c gcc_jit_context_new_call}@anchor{d2}
 @deffn {C Function} gcc_jit_rvalue *           gcc_jit_context_new_call (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_function@w{ }*func, int@w{ }numargs, gcc_jit_rvalue@w{ }**args)
 
 Given a function and the given table of argument rvalues, construct a
@@ -6588,7 +6923,7 @@ call to the function, with the result as an rvalue.
 
 @cartouche
 @quotation Note 
-@ref{ba,,gcc_jit_context_new_call()} merely builds a
+@ref{d2,,gcc_jit_context_new_call()} merely builds a
 @ref{13,,gcc_jit_rvalue} i.e. an expression that can be evaluated,
 perhaps as part of a more complicated expression.
 The call @emph{won’t} happen unless you add a statement to a function
@@ -6596,7 +6931,7 @@ that evaluates the expression.
 
 For example, if you want to call a function and discard the result
 (or to call a function with @code{void} return type), use
-@ref{bb,,gcc_jit_block_add_eval()}:
+@ref{d3,,gcc_jit_block_add_eval()}:
 
 @example
 /* Add "(void)printf (arg0, arg1);".  */
@@ -6613,7 +6948,7 @@ gcc_jit_block_add_eval (
 @end deffn
 
 @geindex gcc_jit_context_new_call_through_ptr (C function)
-@anchor{topics/expressions c gcc_jit_context_new_call_through_ptr}@anchor{bc}
+@anchor{topics/expressions c gcc_jit_context_new_call_through_ptr}@anchor{d4}
 @deffn {C Function} gcc_jit_rvalue *           gcc_jit_context_new_call_through_ptr (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*fn_ptr, int@w{ }numargs, gcc_jit_rvalue@w{ }**args)
 
 Given an rvalue of function pointer type (e.g. from
@@ -6623,18 +6958,18 @@ result as an rvalue.
 
 @cartouche
 @quotation Note 
-The same caveat as for @ref{ba,,gcc_jit_context_new_call()} applies.
+The same caveat as for @ref{d2,,gcc_jit_context_new_call()} applies.
 @end quotation
 @end cartouche
 @end deffn
 
 @geindex gcc_jit_rvalue_set_bool_require_tail_call (C function)
-@anchor{topics/expressions c gcc_jit_rvalue_set_bool_require_tail_call}@anchor{bd}
+@anchor{topics/expressions c gcc_jit_rvalue_set_bool_require_tail_call}@anchor{d5}
 @deffn {C Function} void           gcc_jit_rvalue_set_bool_require_tail_call (gcc_jit_rvalue@w{ }*call, int@w{ }require_tail_call)
 
-Given an @ref{13,,gcc_jit_rvalue *} for a call created through
-@ref{ba,,gcc_jit_context_new_call()} or
-@ref{bc,,gcc_jit_context_new_call_through_ptr()}, mark/clear the
+Given an @ref{13,,gcc_jit_rvalue} for a call created through
+@ref{d2,,gcc_jit_context_new_call()} or
+@ref{d4,,gcc_jit_context_new_call_through_ptr()}, mark/clear the
 call as needing tail-call optimization.  The optimizer will
 attempt to optimize the call into a jump instruction; if it is
 unable to do do, an error will be emitted.
@@ -6646,7 +6981,7 @@ languages), in which every function “returns” by calling a
 guaranteed to be implemented as a jump, otherwise the program
 could consume an arbitrary amount of stack space as it executed.
 
-This entrypoint was added in @ref{be,,LIBGCCJIT_ABI_6}; you can test for
+This entrypoint was added in @ref{d6,,LIBGCCJIT_ABI_6}; you can test for
 its presence using
 
 @example
@@ -6655,7 +6990,7 @@ its presence using
 @end deffn
 
 @node Function pointers,Type-coercion,Function calls,Rvalues
-@anchor{topics/expressions function-pointers}@anchor{bf}
+@anchor{topics/expressions function-pointers}@anchor{d7}
 @subsubsection Function pointers
 
 
@@ -6668,23 +7003,23 @@ Function pointers can be obtained:
 
 @item 
 from a @ref{29,,gcc_jit_function} using
-@ref{c0,,gcc_jit_function_get_address()}, or
+@ref{d8,,gcc_jit_function_get_address()}, or
 
 @item 
 from an existing function using
-@ref{9c,,gcc_jit_context_new_rvalue_from_ptr()},
+@ref{ae,,gcc_jit_context_new_rvalue_from_ptr()},
 using a function pointer type obtained using
 @ref{95,,gcc_jit_context_new_function_ptr_type()}.
 @end itemize
 @end quotation
 
 @node Type-coercion,,Function pointers,Rvalues
-@anchor{topics/expressions type-coercion}@anchor{c1}
+@anchor{topics/expressions type-coercion}@anchor{d9}
 @subsubsection Type-coercion
 
 
 @geindex gcc_jit_context_new_cast (C function)
-@anchor{topics/expressions c gcc_jit_context_new_cast}@anchor{c2}
+@anchor{topics/expressions c gcc_jit_context_new_cast}@anchor{da}
 @deffn {C Function} gcc_jit_rvalue *           gcc_jit_context_new_cast (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*rvalue, gcc_jit_type@w{ }*type)
 
 Given an rvalue of T, construct another rvalue of another type.
@@ -6709,7 +7044,7 @@ P*  <-> Q*, for pointer types P and Q
 @end deffn
 
 @node Lvalues,Working with pointers structs and unions,Rvalues,Expressions
-@anchor{topics/expressions lvalues}@anchor{c3}
+@anchor{topics/expressions lvalues}@anchor{db}
 @subsection Lvalues
 
 
@@ -6723,21 +7058,21 @@ a storage area (such as a variable).  It is also usable as an rvalue,
 where the rvalue is computed by reading from the storage area.
 
 @geindex gcc_jit_lvalue_as_object (C function)
-@anchor{topics/expressions c gcc_jit_lvalue_as_object}@anchor{c4}
+@anchor{topics/expressions c gcc_jit_lvalue_as_object}@anchor{dc}
 @deffn {C Function} gcc_jit_object *           gcc_jit_lvalue_as_object (gcc_jit_lvalue@w{ }*lvalue)
 
 Upcast an lvalue to be an object.
 @end deffn
 
 @geindex gcc_jit_lvalue_as_rvalue (C function)
-@anchor{topics/expressions c gcc_jit_lvalue_as_rvalue}@anchor{c5}
+@anchor{topics/expressions c gcc_jit_lvalue_as_rvalue}@anchor{dd}
 @deffn {C Function} gcc_jit_rvalue *           gcc_jit_lvalue_as_rvalue (gcc_jit_lvalue@w{ }*lvalue)
 
 Upcast an lvalue to be an rvalue.
 @end deffn
 
 @geindex gcc_jit_lvalue_get_address (C function)
-@anchor{topics/expressions c gcc_jit_lvalue_get_address}@anchor{c6}
+@anchor{topics/expressions c gcc_jit_lvalue_get_address}@anchor{de}
 @deffn {C Function} gcc_jit_rvalue *           gcc_jit_lvalue_get_address (gcc_jit_lvalue@w{ }*lvalue, gcc_jit_location@w{ }*loc)
 
 Take the address of an lvalue; analogous to:
@@ -6749,18 +7084,96 @@ Take the address of an lvalue; analogous to:
 in C.
 @end deffn
 
+@geindex gcc_jit_lvalue_set_tls_model (C function)
+@anchor{topics/expressions c gcc_jit_lvalue_set_tls_model}@anchor{df}
+@deffn {C Function} void           gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue@w{ }*lvalue, enum gcc_jit_tls_model@w{ }model)
+
+Make a variable a thread-local variable.
+
+The “model” parameter determines the thread-local storage model of the “lvalue”:
+
+@geindex gcc_jit_tls_model (C type)
+@anchor{topics/expressions c gcc_jit_tls_model}@anchor{e0}
+@deffn {C Type} enum gcc_jit_tls_model
+@end deffn
+
+@geindex GCC_JIT_TLS_MODEL_NONE (C macro)
+@anchor{topics/expressions c GCC_JIT_TLS_MODEL_NONE}@anchor{e1}
+@deffn {C Macro} GCC_JIT_TLS_MODEL_NONE
+
+Don’t set the TLS model.
+@end deffn
+
+@geindex GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC (C macro)
+@anchor{topics/expressions c GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC}@anchor{e2}
+@deffn {C Macro} GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC
+@end deffn
+
+@geindex GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC (C macro)
+@anchor{topics/expressions c GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC}@anchor{e3}
+@deffn {C Macro} GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC
+@end deffn
+
+@geindex GCC_JIT_TLS_MODEL_INITIAL_EXEC (C macro)
+@anchor{topics/expressions c GCC_JIT_TLS_MODEL_INITIAL_EXEC}@anchor{e4}
+@deffn {C Macro} GCC_JIT_TLS_MODEL_INITIAL_EXEC
+@end deffn
+
+@geindex GCC_JIT_TLS_MODEL_LOCAL_EXEC (C macro)
+@anchor{topics/expressions c GCC_JIT_TLS_MODEL_LOCAL_EXEC}@anchor{e5}
+@deffn {C Macro} GCC_JIT_TLS_MODEL_LOCAL_EXEC
+@end deffn
+
+This is analogous to:
+
+@example
+_Thread_local int foo __attribute__ ((tls_model("MODEL")));
+@end example
+
+in C.
+
+This entrypoint was added in @ref{e6,,LIBGCCJIT_ABI_17}; you can test for
+its presence using
+
+@example
+#ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model
+@end example
+@end deffn
+
+@geindex gcc_jit_lvalue_set_link_section (C function)
+@anchor{topics/expressions c gcc_jit_lvalue_set_link_section}@anchor{e7}
+@deffn {C Function} void           gcc_jit_lvalue_set_link_section (gcc_jit_lvalue@w{ }*lvalue, const char@w{ }*section_name)
+
+Set the link section of a variable.
+The parameter @code{section_name} must be non-NULL and must contain the
+leading dot. Analogous to:
+
+@example
+int variable __attribute__((section(".section")));
+@end example
+
+in C.
+
+This entrypoint was added in @ref{e8,,LIBGCCJIT_ABI_18}; you can test for
+its presence using
+
+@example
+#ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section
+@end example
+@end deffn
+
 @menu
 * Global variables:: 
 
 @end menu
 
 @node Global variables,,,Lvalues
-@anchor{topics/expressions global-variables}@anchor{c7}
+@anchor{topics/expressions global-variables}@anchor{e9}
 @subsubsection Global variables
 
 
 @geindex gcc_jit_context_new_global (C function)
-@anchor{topics/expressions c gcc_jit_context_new_global}@anchor{c8}
+@anchor{topics/expressions c gcc_jit_context_new_global}@anchor{ea}
 @deffn {C Function} gcc_jit_lvalue *           gcc_jit_context_new_global (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, enum gcc_jit_global_kind@w{ }kind, gcc_jit_type@w{ }*type, const char@w{ }*name)
 
 Add a new global variable of the given type and name to the context.
@@ -6775,22 +7188,22 @@ The “kind” parameter determines the visibility of the “global” outside
 of the @ref{16,,gcc_jit_result}:
 
 @geindex gcc_jit_global_kind (C type)
-@anchor{topics/expressions c gcc_jit_global_kind}@anchor{c9}
+@anchor{topics/expressions c gcc_jit_global_kind}@anchor{eb}
 @deffn {C Type} enum gcc_jit_global_kind
 @end deffn
 
 @geindex GCC_JIT_GLOBAL_EXPORTED (C macro)
-@anchor{topics/expressions c GCC_JIT_GLOBAL_EXPORTED}@anchor{ca}
+@anchor{topics/expressions c GCC_JIT_GLOBAL_EXPORTED}@anchor{ec}
 @deffn {C Macro} GCC_JIT_GLOBAL_EXPORTED
 
 Global is defined by the client code and is visible
 by name outside of this JIT context via
-@ref{cb,,gcc_jit_result_get_global()} (and this value is required for
+@ref{ed,,gcc_jit_result_get_global()} (and this value is required for
 the global to be accessible via that entrypoint).
 @end deffn
 
 @geindex GCC_JIT_GLOBAL_INTERNAL (C macro)
-@anchor{topics/expressions c GCC_JIT_GLOBAL_INTERNAL}@anchor{cc}
+@anchor{topics/expressions c GCC_JIT_GLOBAL_INTERNAL}@anchor{ee}
 @deffn {C Macro} GCC_JIT_GLOBAL_INTERNAL
 
 Global is defined by the client code, but is invisible
@@ -6800,7 +7213,7 @@ context and within child contexts.
 @end deffn
 
 @geindex GCC_JIT_GLOBAL_IMPORTED (C macro)
-@anchor{topics/expressions c GCC_JIT_GLOBAL_IMPORTED}@anchor{cd}
+@anchor{topics/expressions c GCC_JIT_GLOBAL_IMPORTED}@anchor{ef}
 @deffn {C Macro} GCC_JIT_GLOBAL_IMPORTED
 
 Global is not defined by the client code; we’re merely
@@ -6810,7 +7223,7 @@ header file.
 @end deffn
 
 @geindex gcc_jit_global_set_initializer (C function)
-@anchor{topics/expressions c gcc_jit_global_set_initializer}@anchor{ce}
+@anchor{topics/expressions c gcc_jit_global_set_initializer}@anchor{f0}
 @deffn {C Function} gcc_jit_lvalue *           gcc_jit_global_set_initializer (gcc_jit_lvalue@w{ }*global, const void@w{ }*blob, size_t@w{ }num_bytes)
 
 Set an initializer for @code{global} using the memory content pointed
@@ -6822,7 +7235,7 @@ pointed by @code{blob} for @code{num_bytes} bytes, so it is valid to pass
 in a pointer to an on-stack buffer.  The content will be stored in
 the compilation unit and used as initialization value of the array.
 
-This entrypoint was added in @ref{cf,,LIBGCCJIT_ABI_14}; you can test for
+This entrypoint was added in @ref{f1,,LIBGCCJIT_ABI_14}; you can test for
 its presence using
 
 @example
@@ -6830,13 +7243,47 @@ its presence using
 @end example
 @end deffn
 
+@geindex gcc_jit_global_set_initializer_rvalue (C function)
+@anchor{topics/expressions c gcc_jit_global_set_initializer_rvalue}@anchor{b2}
+@deffn {C Function} gcc_jit_lvalue *           gcc_jit_global_set_initializer_rvalue (gcc_jit_lvalue@w{ }*global, gcc_jit_rvalue@w{ }*init_value)
+
+Set the initial value of a global with an rvalue.
+
+The rvalue needs to be a constant expression, e.g. no function calls.
+
+The global can’t have the @code{kind} @ref{ef,,GCC_JIT_GLOBAL_IMPORTED}.
+
+As a non-comprehensive example it is OK to do the equivalent of:
+
+@example
+int foo = 3 * 2; /* rvalue from gcc_jit_context_new_binary_op.  */
+int arr[] = @{1,2,3,4@}; /* rvalue from gcc_jit_context_new_constructor.  */
+int *bar = &arr[2] + 1; /* rvalue from nested "get address" of "array access".  */
+const int baz = 3; /* rvalue from gcc_jit_context_rvalue_from_int.  */
+int boz = baz; /* rvalue from gcc_jit_lvalue_as_rvalue.  */
+@end example
+
+Use together with @ref{b5,,gcc_jit_context_new_struct_constructor()},
+@ref{b6,,gcc_jit_context_new_union_constructor()}, @ref{b4,,gcc_jit_context_new_array_constructor()}
+to initialize structs, unions and arrays.
+
+On success, returns the @code{global} parameter unchanged. Otherwise, @code{NULL}.
+
+This entrypoint was added in @ref{b3,,LIBGCCJIT_ABI_19}; you can test for its
+presence using:
+
+@example
+#ifdef LIBGCCJIT_HAVE_CTORS
+@end example
+@end deffn
+
 @node Working with pointers structs and unions,,Lvalues,Expressions
-@anchor{topics/expressions working-with-pointers-structs-and-unions}@anchor{d0}
+@anchor{topics/expressions working-with-pointers-structs-and-unions}@anchor{f2}
 @subsection Working with pointers, structs and unions
 
 
 @geindex gcc_jit_rvalue_dereference (C function)
-@anchor{topics/expressions c gcc_jit_rvalue_dereference}@anchor{d1}
+@anchor{topics/expressions c gcc_jit_rvalue_dereference}@anchor{f3}
 @deffn {C Function} gcc_jit_lvalue *           gcc_jit_rvalue_dereference (gcc_jit_rvalue@w{ }*rvalue, gcc_jit_location@w{ }*loc)
 
 Given an rvalue of pointer type @code{T *}, dereferencing the pointer,
@@ -6852,7 +7299,7 @@ in C.
 Field access is provided separately for both lvalues and rvalues.
 
 @geindex gcc_jit_lvalue_access_field (C function)
-@anchor{topics/expressions c gcc_jit_lvalue_access_field}@anchor{d2}
+@anchor{topics/expressions c gcc_jit_lvalue_access_field}@anchor{f4}
 @deffn {C Function} gcc_jit_lvalue *           gcc_jit_lvalue_access_field (gcc_jit_lvalue@w{ }*struct_, gcc_jit_location@w{ }*loc, gcc_jit_field@w{ }*field)
 
 Given an lvalue of struct or union type, access the given field,
@@ -6866,7 +7313,7 @@ in C.
 @end deffn
 
 @geindex gcc_jit_rvalue_access_field (C function)
-@anchor{topics/expressions c gcc_jit_rvalue_access_field}@anchor{d3}
+@anchor{topics/expressions c gcc_jit_rvalue_access_field}@anchor{f5}
 @deffn {C Function} gcc_jit_rvalue *           gcc_jit_rvalue_access_field (gcc_jit_rvalue@w{ }*struct_, gcc_jit_location@w{ }*loc, gcc_jit_field@w{ }*field)
 
 Given an rvalue of struct or union type, access the given field
@@ -6880,7 +7327,7 @@ in C.
 @end deffn
 
 @geindex gcc_jit_rvalue_dereference_field (C function)
-@anchor{topics/expressions c gcc_jit_rvalue_dereference_field}@anchor{d4}
+@anchor{topics/expressions c gcc_jit_rvalue_dereference_field}@anchor{f6}
 @deffn {C Function} gcc_jit_lvalue *           gcc_jit_rvalue_dereference_field (gcc_jit_rvalue@w{ }*ptr, gcc_jit_location@w{ }*loc, gcc_jit_field@w{ }*field)
 
 Given an rvalue of pointer type @code{T *} where T is of struct or union
@@ -6894,7 +7341,7 @@ in C, itself equivalent to @code{(*EXPR).FIELD}.
 @end deffn
 
 @geindex gcc_jit_context_new_array_access (C function)
-@anchor{topics/expressions c gcc_jit_context_new_array_access}@anchor{b6}
+@anchor{topics/expressions c gcc_jit_context_new_array_access}@anchor{ce}
 @deffn {C Function} gcc_jit_lvalue *           gcc_jit_context_new_array_access (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*ptr, gcc_jit_rvalue@w{ }*index)
 
 Given an rvalue of pointer type @code{T *}, get at the element @cite{T} at
@@ -6927,7 +7374,7 @@ in C (or, indeed, to @code{PTR + INDEX}).
 @c <https://www.gnu.org/licenses/>.
 
 @node Creating and using functions,Function pointers<2>,Expressions,Topic Reference
-@anchor{topics/functions doc}@anchor{d5}@anchor{topics/functions creating-and-using-functions}@anchor{d6}
+@anchor{topics/functions doc}@anchor{f7}@anchor{topics/functions creating-and-using-functions}@anchor{f8}
 @section Creating and using functions
 
 
@@ -6940,7 +7387,7 @@ in C (or, indeed, to @code{PTR + INDEX}).
 @end menu
 
 @node Params,Functions,,Creating and using functions
-@anchor{topics/functions params}@anchor{d7}
+@anchor{topics/functions params}@anchor{f9}
 @subsection Params
 
 
@@ -6969,28 +7416,28 @@ Parameters are lvalues, and thus are also rvalues (and objects), so the
 following upcasts are available:
 
 @geindex gcc_jit_param_as_lvalue (C function)
-@anchor{topics/functions c gcc_jit_param_as_lvalue}@anchor{d8}
+@anchor{topics/functions c gcc_jit_param_as_lvalue}@anchor{fa}
 @deffn {C Function} gcc_jit_lvalue *            gcc_jit_param_as_lvalue (gcc_jit_param@w{ }*param)
 
 Upcasting from param to lvalue.
 @end deffn
 
 @geindex gcc_jit_param_as_rvalue (C function)
-@anchor{topics/functions c gcc_jit_param_as_rvalue}@anchor{d9}
+@anchor{topics/functions c gcc_jit_param_as_rvalue}@anchor{fb}
 @deffn {C Function} gcc_jit_rvalue *            gcc_jit_param_as_rvalue (gcc_jit_param@w{ }*param)
 
 Upcasting from param to rvalue.
 @end deffn
 
 @geindex gcc_jit_param_as_object (C function)
-@anchor{topics/functions c gcc_jit_param_as_object}@anchor{da}
+@anchor{topics/functions c gcc_jit_param_as_object}@anchor{fc}
 @deffn {C Function} gcc_jit_object *            gcc_jit_param_as_object (gcc_jit_param@w{ }*param)
 
 Upcasting from param to object.
 @end deffn
 
 @node Functions,Blocks,Params,Creating and using functions
-@anchor{topics/functions functions}@anchor{db}
+@anchor{topics/functions functions}@anchor{fd}
 @subsection Functions
 
 
@@ -7009,7 +7456,7 @@ creating ourselves, or one that we’re referencing.
 Create a gcc_jit_function with the given name and parameters.
 
 @geindex gcc_jit_function_kind (C type)
-@anchor{topics/functions c gcc_jit_function_kind}@anchor{dc}
+@anchor{topics/functions c gcc_jit_function_kind}@anchor{fe}
 @deffn {C Type} enum gcc_jit_function_kind
 @end deffn
 
@@ -7019,7 +7466,7 @@ values:
 @quotation
 
 @geindex GCC_JIT_FUNCTION_EXPORTED (C macro)
-@anchor{topics/functions c GCC_JIT_FUNCTION_EXPORTED}@anchor{dd}
+@anchor{topics/functions c GCC_JIT_FUNCTION_EXPORTED}@anchor{ff}
 @deffn {C Macro} GCC_JIT_FUNCTION_EXPORTED
 
 Function is defined by the client code and visible
@@ -7031,7 +7478,7 @@ for this function from a @ref{16,,gcc_jit_result} via
 @end deffn
 
 @geindex GCC_JIT_FUNCTION_INTERNAL (C macro)
-@anchor{topics/functions c GCC_JIT_FUNCTION_INTERNAL}@anchor{de}
+@anchor{topics/functions c GCC_JIT_FUNCTION_INTERNAL}@anchor{100}
 @deffn {C Macro} GCC_JIT_FUNCTION_INTERNAL
 
 Function is defined by the client code, but is invisible
@@ -7039,7 +7486,7 @@ outside of the JIT.  Analogous to a “static” function.
 @end deffn
 
 @geindex GCC_JIT_FUNCTION_IMPORTED (C macro)
-@anchor{topics/functions c GCC_JIT_FUNCTION_IMPORTED}@anchor{df}
+@anchor{topics/functions c GCC_JIT_FUNCTION_IMPORTED}@anchor{101}
 @deffn {C Macro} GCC_JIT_FUNCTION_IMPORTED
 
 Function is not defined by the client code; we’re merely
@@ -7048,7 +7495,7 @@ header file.
 @end deffn
 
 @geindex GCC_JIT_FUNCTION_ALWAYS_INLINE (C macro)
-@anchor{topics/functions c GCC_JIT_FUNCTION_ALWAYS_INLINE}@anchor{e0}
+@anchor{topics/functions c GCC_JIT_FUNCTION_ALWAYS_INLINE}@anchor{102}
 @deffn {C Macro} GCC_JIT_FUNCTION_ALWAYS_INLINE
 
 Function is only ever inlined into other functions, and is
@@ -7069,7 +7516,7 @@ buffer.
 @end deffn
 
 @geindex gcc_jit_context_get_builtin_function (C function)
-@anchor{topics/functions c gcc_jit_context_get_builtin_function}@anchor{e1}
+@anchor{topics/functions c gcc_jit_context_get_builtin_function}@anchor{103}
 @deffn {C Function} gcc_jit_function *            gcc_jit_context_get_builtin_function (gcc_jit_context@w{ }*ctxt, const char@w{ }*name)
 
 Get the @ref{29,,gcc_jit_function} for the built-in function with the
@@ -7093,14 +7540,14 @@ the context.
 @end deffn
 
 @geindex gcc_jit_function_as_object (C function)
-@anchor{topics/functions c gcc_jit_function_as_object}@anchor{e2}
+@anchor{topics/functions c gcc_jit_function_as_object}@anchor{104}
 @deffn {C Function} gcc_jit_object *           gcc_jit_function_as_object (gcc_jit_function@w{ }*func)
 
 Upcasting from function to object.
 @end deffn
 
 @geindex gcc_jit_function_get_param (C function)
-@anchor{topics/functions c gcc_jit_function_get_param}@anchor{e3}
+@anchor{topics/functions c gcc_jit_function_get_param}@anchor{105}
 @deffn {C Function} gcc_jit_param *            gcc_jit_function_get_param (gcc_jit_function@w{ }*func, int@w{ }index)
 
 Get the param of the given index (0-based).
@@ -7127,8 +7574,50 @@ underlying string, so it is valid to pass in a pointer to an on-stack
 buffer.
 @end deffn
 
+@geindex gcc_jit_function_get_param_count (C function)
+@anchor{topics/functions c gcc_jit_function_get_param_count}@anchor{106}
+@deffn {C Function} size_t             gcc_jit_function_get_param_count (gcc_jit_function@w{ }*func)
+
+Get the number of parameters of the function.
+@end deffn
+
+@geindex gcc_jit_function_get_return_type (C function)
+@anchor{topics/functions c gcc_jit_function_get_return_type}@anchor{107}
+@deffn {C Function} gcc_jit_type *            gcc_jit_function_get_return_type (gcc_jit_function@w{ }*func)
+
+Get the return type of the function.
+
+The API entrypoints relating to getting info about parameters and return
+types:
+
+@quotation
+
+
+@itemize *
+
+@item 
+@ref{107,,gcc_jit_function_get_return_type()}
+
+@item 
+@ref{106,,gcc_jit_function_get_param_count()}
+@end itemize
+@end quotation
+
+were added in @ref{a6,,LIBGCCJIT_ABI_16}; you can test for their presence
+using
+
+@example
+#ifdef LIBGCCJIT_HAVE_REFLECTION
+@end example
+
+@geindex gcc_jit_case (C type)
+@anchor{topics/functions c gcc_jit_case}@anchor{108}
+@deffn {C Type} gcc_jit_case
+@end deffn
+@end deffn
+
 @node Blocks,Statements,Functions,Creating and using functions
-@anchor{topics/functions blocks}@anchor{e4}
+@anchor{topics/functions blocks}@anchor{109}
 @subsection Blocks
 
 
@@ -7152,7 +7641,7 @@ one function.
 @end deffn
 
 @geindex gcc_jit_function_new_block (C function)
-@anchor{topics/functions c gcc_jit_function_new_block}@anchor{e5}
+@anchor{topics/functions c gcc_jit_function_new_block}@anchor{10a}
 @deffn {C Function} gcc_jit_block *            gcc_jit_function_new_block (gcc_jit_function@w{ }*func, const char@w{ }*name)
 
 Create a basic block of the given name.  The name may be NULL, but
@@ -7172,26 +7661,26 @@ for (pc = 0; pc < fn->fn_num_ops; pc++)
 @end deffn
 
 @geindex gcc_jit_block_as_object (C function)
-@anchor{topics/functions c gcc_jit_block_as_object}@anchor{e6}
+@anchor{topics/functions c gcc_jit_block_as_object}@anchor{10b}
 @deffn {C Function} gcc_jit_object *            gcc_jit_block_as_object (gcc_jit_block@w{ }*block)
 
 Upcast from block to object.
 @end deffn
 
 @geindex gcc_jit_block_get_function (C function)
-@anchor{topics/functions c gcc_jit_block_get_function}@anchor{e7}
+@anchor{topics/functions c gcc_jit_block_get_function}@anchor{10c}
 @deffn {C Function} gcc_jit_function *            gcc_jit_block_get_function (gcc_jit_block@w{ }*block)
 
 Which function is this block within?
 @end deffn
 
 @node Statements,,Blocks,Creating and using functions
-@anchor{topics/functions statements}@anchor{e8}
+@anchor{topics/functions statements}@anchor{10d}
 @subsection Statements
 
 
 @geindex gcc_jit_block_add_eval (C function)
-@anchor{topics/functions c gcc_jit_block_add_eval}@anchor{bb}
+@anchor{topics/functions c gcc_jit_block_add_eval}@anchor{d3}
 @deffn {C Function} void           gcc_jit_block_add_eval (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*rvalue)
 
 Add evaluation of an rvalue, discarding the result
@@ -7288,7 +7777,7 @@ block, boolval, on_true, and on_false must be non-NULL.
 @end deffn
 
 @geindex gcc_jit_block_end_with_jump (C function)
-@anchor{topics/functions c gcc_jit_block_end_with_jump}@anchor{e9}
+@anchor{topics/functions c gcc_jit_block_end_with_jump}@anchor{10e}
 @deffn {C Function} void           gcc_jit_block_end_with_jump (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, gcc_jit_block@w{ }*target)
 
 Terminate a block by adding a jump to the given target block.
@@ -7301,7 +7790,7 @@ goto target;
 @end deffn
 
 @geindex gcc_jit_block_end_with_return (C function)
-@anchor{topics/functions c gcc_jit_block_end_with_return}@anchor{ea}
+@anchor{topics/functions c gcc_jit_block_end_with_return}@anchor{10f}
 @deffn {C Function} void           gcc_jit_block_end_with_return (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*rvalue)
 
 Terminate a block by adding evaluation of an rvalue, returning the value.
@@ -7314,7 +7803,7 @@ return expression;
 @end deffn
 
 @geindex gcc_jit_block_end_with_void_return (C function)
-@anchor{topics/functions c gcc_jit_block_end_with_void_return}@anchor{eb}
+@anchor{topics/functions c gcc_jit_block_end_with_void_return}@anchor{110}
 @deffn {C Function} void           gcc_jit_block_end_with_void_return (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc)
 
 Terminate a block by adding a valueless return, for use within a function
@@ -7328,7 +7817,7 @@ return;
 @end deffn
 
 @geindex gcc_jit_block_end_with_switch (C function)
-@anchor{topics/functions c gcc_jit_block_end_with_switch}@anchor{ec}
+@anchor{topics/functions c gcc_jit_block_end_with_switch}@anchor{111}
 @deffn {C Function} void           gcc_jit_block_end_with_switch (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*expr, gcc_jit_block@w{ }*default_block, int@w{ }num_cases, gcc_jit_case@w{ }**cases)
 
 Terminate a block by adding evalation of an rvalue, then performing
@@ -7374,17 +7863,17 @@ The API entrypoints relating to switch statements and cases:
 @itemize *
 
 @item 
-@ref{ec,,gcc_jit_block_end_with_switch()}
+@ref{111,,gcc_jit_block_end_with_switch()}
 
 @item 
-@ref{ed,,gcc_jit_case_as_object()}
+@ref{112,,gcc_jit_case_as_object()}
 
 @item 
-@ref{ee,,gcc_jit_context_new_case()}
+@ref{113,,gcc_jit_context_new_case()}
 @end itemize
 @end quotation
 
-were added in @ref{ef,,LIBGCCJIT_ABI_3}; you can test for their presence
+were added in @ref{114,,LIBGCCJIT_ABI_3}; you can test for their presence
 using
 
 @example
@@ -7392,20 +7881,20 @@ using
 @end example
 
 @geindex gcc_jit_case (C type)
-@anchor{topics/functions c gcc_jit_case}@anchor{f0}
+
 @deffn {C Type} gcc_jit_case
 @end deffn
 
 A @cite{gcc_jit_case} represents a case within a switch statement, and
 is created within a particular @ref{8,,gcc_jit_context} using
-@ref{ee,,gcc_jit_context_new_case()}.
+@ref{113,,gcc_jit_context_new_case()}.
 
 Each case expresses a multivalued range of integer values.  You
 can express single-valued cases by passing in the same value for
 both @cite{min_value} and @cite{max_value}.
 
 @geindex gcc_jit_context_new_case (C function)
-@anchor{topics/functions c gcc_jit_context_new_case}@anchor{ee}
+@anchor{topics/functions c gcc_jit_context_new_case}@anchor{113}
 @deffn {C Function} gcc_jit_case *           gcc_jit_context_new_case (gcc_jit_context@w{ }*ctxt, gcc_jit_rvalue@w{ }*min_value, gcc_jit_rvalue@w{ }*max_value, gcc_jit_block@w{ }*dest_block)
 
 Create a new gcc_jit_case instance for use in a switch statement.
@@ -7417,7 +7906,7 @@ statement.
 @end deffn
 
 @geindex gcc_jit_case_as_object (C function)
-@anchor{topics/functions c gcc_jit_case_as_object}@anchor{ed}
+@anchor{topics/functions c gcc_jit_case_as_object}@anchor{112}
 @deffn {C Function} gcc_jit_object *           gcc_jit_case_as_object (gcc_jit_case@w{ }*case_)
 
 Upcast from a case to an object.
@@ -7531,7 +8020,7 @@ create_code (gcc_jit_context *ctxt, void *user_data)
 @end quotation
 @end deffn
 
-See also @ref{f1,,gcc_jit_extended_asm} for entrypoints for adding inline
+See also @ref{115,,gcc_jit_extended_asm} for entrypoints for adding inline
 assembler statements to a function.
 
 @c Copyright (C) 2017-2022 Free Software Foundation, Inc.
@@ -7552,26 +8041,26 @@ assembler statements to a function.
 @c <https://www.gnu.org/licenses/>.
 
 @node Function pointers<2>,Source Locations,Creating and using functions,Topic Reference
-@anchor{topics/function-pointers doc}@anchor{f2}@anchor{topics/function-pointers function-pointers}@anchor{f3}
+@anchor{topics/function-pointers doc}@anchor{116}@anchor{topics/function-pointers function-pointers}@anchor{117}
 @section Function pointers
 
 
 You can generate calls that use a function pointer via
-@ref{bc,,gcc_jit_context_new_call_through_ptr()}.
+@ref{d4,,gcc_jit_context_new_call_through_ptr()}.
 
 To do requires a @ref{13,,gcc_jit_rvalue} of the correct function pointer type.
 
 Function pointers for a @ref{29,,gcc_jit_function} can be obtained
-via @ref{c0,,gcc_jit_function_get_address()}.
+via @ref{d8,,gcc_jit_function_get_address()}.
 
 @geindex gcc_jit_function_get_address (C function)
-@anchor{topics/function-pointers c gcc_jit_function_get_address}@anchor{c0}
+@anchor{topics/function-pointers c gcc_jit_function_get_address}@anchor{d8}
 @deffn {C Function} gcc_jit_rvalue *           gcc_jit_function_get_address (gcc_jit_function@w{ }*fn, gcc_jit_location@w{ }*loc)
 
 Get the address of a function as an rvalue, of function pointer
 type.
 
-This entrypoint was added in @ref{f4,,LIBGCCJIT_ABI_9}; you can test
+This entrypoint was added in @ref{118,,LIBGCCJIT_ABI_9}; you can test
 for its presence using
 
 @example
@@ -7581,7 +8070,7 @@ for its presence using
 
 Alternatively, given an existing function, you can obtain a pointer
 to it in @ref{13,,gcc_jit_rvalue} form using
-@ref{9c,,gcc_jit_context_new_rvalue_from_ptr()}, using a function pointer
+@ref{ae,,gcc_jit_context_new_rvalue_from_ptr()}, using a function pointer
 type obtained using @ref{95,,gcc_jit_context_new_function_ptr_type()}.
 
 Here’s an example of creating a function pointer type corresponding to C’s
@@ -7633,7 +8122,7 @@ Each of @cite{param_types} must be non-@cite{void}; @cite{return_type} may be @c
 @c <https://www.gnu.org/licenses/>.
 
 @node Source Locations,Compiling a context,Function pointers<2>,Topic Reference
-@anchor{topics/locations doc}@anchor{f5}@anchor{topics/locations source-locations}@anchor{f6}
+@anchor{topics/locations doc}@anchor{119}@anchor{topics/locations source-locations}@anchor{11a}
 @section Source Locations
 
 
@@ -7681,7 +8170,7 @@ on-stack buffer.
 @end menu
 
 @node Faking it,,,Source Locations
-@anchor{topics/locations faking-it}@anchor{f7}
+@anchor{topics/locations faking-it}@anchor{11b}
 @subsection Faking it
 
 
@@ -7717,7 +8206,7 @@ file, giving you @emph{something} you can step through in the debugger.
 @c <https://www.gnu.org/licenses/>.
 
 @node Compiling a context,ABI and API compatibility,Source Locations,Topic Reference
-@anchor{topics/compilation doc}@anchor{f8}@anchor{topics/compilation compiling-a-context}@anchor{f9}
+@anchor{topics/compilation doc}@anchor{11c}@anchor{topics/compilation compiling-a-context}@anchor{11d}
 @section Compiling a context
 
 
@@ -7736,7 +8225,7 @@ prevent any future compilation of that context.
 @end menu
 
 @node In-memory compilation,Ahead-of-time compilation,,Compiling a context
-@anchor{topics/compilation in-memory-compilation}@anchor{fa}
+@anchor{topics/compilation in-memory-compilation}@anchor{11e}
 @subsection In-memory compilation
 
 
@@ -7771,7 +8260,7 @@ Functions are looked up by name.  For this to succeed, a function
 with a name matching @cite{funcname} must have been created on
 @cite{result}’s context (or a parent context) via a call to
 @ref{11,,gcc_jit_context_new_function()} with @cite{kind}
-@ref{dd,,GCC_JIT_FUNCTION_EXPORTED}:
+@ref{ff,,GCC_JIT_FUNCTION_EXPORTED}:
 
 @example
 gcc_jit_context_new_function (ctxt,
@@ -7799,7 +8288,7 @@ to a segmentation fault.
 @end deffn
 
 @geindex gcc_jit_result_get_global (C function)
-@anchor{topics/compilation c gcc_jit_result_get_global}@anchor{cb}
+@anchor{topics/compilation c gcc_jit_result_get_global}@anchor{ed}
 @deffn {C Function} void *           gcc_jit_result_get_global (gcc_jit_result@w{ }*result, const char@w{ }*name)
 
 Locate a given global within the built machine code.
@@ -7807,8 +8296,8 @@ Locate a given global within the built machine code.
 Globals are looked up by name.  For this to succeed, a global
 with a name matching @cite{name} must have been created on
 @cite{result}’s context (or a parent context) via a call to
-@ref{c8,,gcc_jit_context_new_global()} with @cite{kind}
-@ref{ca,,GCC_JIT_GLOBAL_EXPORTED}.
+@ref{ea,,gcc_jit_context_new_global()} with @cite{kind}
+@ref{ec,,GCC_JIT_GLOBAL_EXPORTED}.
 
 If the global is found, the result will need to be cast to a
 pointer of the correct type before it can be called.
@@ -7852,11 +8341,11 @@ Once we’re done with the code, this unloads the built .so file.
 This cleans up the result; after calling this, it’s no longer
 valid to use the result, or any code or globals that were obtained
 by calling @ref{17,,gcc_jit_result_get_code()} or
-@ref{cb,,gcc_jit_result_get_global()} on it.
+@ref{ed,,gcc_jit_result_get_global()} on it.
 @end deffn
 
 @node Ahead-of-time compilation,,In-memory compilation,Compiling a context
-@anchor{topics/compilation ahead-of-time-compilation}@anchor{fb}
+@anchor{topics/compilation ahead-of-time-compilation}@anchor{11f}
 @subsection Ahead-of-time compilation
 
 
@@ -7865,6 +8354,8 @@ can also be used for implementing more traditional ahead-of-time
 compilers, via the @ref{4a,,gcc_jit_context_compile_to_file()}
 API entrypoint.
 
+For linking in object files, use @ref{74,,gcc_jit_context_add_driver_option()}.
+
 @geindex gcc_jit_context_compile_to_file (C function)
 @anchor{topics/compilation c gcc_jit_context_compile_to_file}@anchor{4a}
 @deffn {C Function} void            gcc_jit_context_compile_to_file (gcc_jit_context@w{ }*ctxt, enum gcc_jit_output_kind@w{ }output_kind, const char@w{ }*output_path)
@@ -7885,7 +8376,7 @@ suffix of the output file when determining what to do.
 @end cartouche
 
 @geindex gcc_jit_output_kind (C type)
-@anchor{topics/compilation c gcc_jit_output_kind}@anchor{fc}
+@anchor{topics/compilation c gcc_jit_output_kind}@anchor{120}
 @deffn {C Type} enum gcc_jit_output_kind
 @end deffn
 
@@ -7903,7 +8394,7 @@ Typical suffix
 
 @item
 
-@ref{fd,,GCC_JIT_OUTPUT_KIND_ASSEMBLER}
+@ref{121,,GCC_JIT_OUTPUT_KIND_ASSEMBLER}
 
 @tab
 
@@ -7911,7 +8402,7 @@ Typical suffix
 
 @item
 
-@ref{fe,,GCC_JIT_OUTPUT_KIND_OBJECT_FILE}
+@ref{122,,GCC_JIT_OUTPUT_KIND_OBJECT_FILE}
 
 @tab
 
@@ -7919,7 +8410,7 @@ Typical suffix
 
 @item
 
-@ref{ff,,GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY}
+@ref{123,,GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY}
 
 @tab
 
@@ -7927,7 +8418,7 @@ Typical suffix
 
 @item
 
-@ref{100,,GCC_JIT_OUTPUT_KIND_EXECUTABLE}
+@ref{124,,GCC_JIT_OUTPUT_KIND_EXECUTABLE}
 
 @tab
 
@@ -7937,37 +8428,31 @@ None, or .exe
 
 
 @geindex GCC_JIT_OUTPUT_KIND_ASSEMBLER (C macro)
-@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_ASSEMBLER}@anchor{fd}
+@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_ASSEMBLER}@anchor{121}
 @deffn {C Macro} GCC_JIT_OUTPUT_KIND_ASSEMBLER
 
 Compile the context to an assembler file.
 @end deffn
 
 @geindex GCC_JIT_OUTPUT_KIND_OBJECT_FILE (C macro)
-@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_OBJECT_FILE}@anchor{fe}
+@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_OBJECT_FILE}@anchor{122}
 @deffn {C Macro} GCC_JIT_OUTPUT_KIND_OBJECT_FILE
 
 Compile the context to an object file.
 @end deffn
 
 @geindex GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY (C macro)
-@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY}@anchor{ff}
+@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY}@anchor{123}
 @deffn {C Macro} GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY
 
 Compile the context to a dynamic library.
-
-There is currently no support for specifying other libraries to link
-against.
 @end deffn
 
 @geindex GCC_JIT_OUTPUT_KIND_EXECUTABLE (C macro)
-@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_EXECUTABLE}@anchor{100}
+@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_EXECUTABLE}@anchor{124}
 @deffn {C Macro} GCC_JIT_OUTPUT_KIND_EXECUTABLE
 
 Compile the context to an executable.
-
-There is currently no support for specifying libraries to link
-against.
 @end deffn
 
 @c Copyright (C) 2015-2022 Free Software Foundation, Inc.
@@ -7988,7 +8473,7 @@ against.
 @c <https://www.gnu.org/licenses/>.
 
 @node ABI and API compatibility,Performance,Compiling a context,Topic Reference
-@anchor{topics/compatibility doc}@anchor{101}@anchor{topics/compatibility abi-and-api-compatibility}@anchor{102}
+@anchor{topics/compatibility doc}@anchor{125}@anchor{topics/compatibility abi-and-api-compatibility}@anchor{126}
 @section ABI and API compatibility
 
 
@@ -8044,21 +8529,21 @@ Version definitions:
 @end menu
 
 @node Programmatically checking version,ABI symbol tags,,ABI and API compatibility
-@anchor{topics/compatibility programmatically-checking-version}@anchor{103}
+@anchor{topics/compatibility programmatically-checking-version}@anchor{127}
 @subsection Programmatically checking version
 
 
 Client code can programmatically check libgccjit version using:
 
 @geindex gcc_jit_version_major (C function)
-@anchor{topics/compatibility c gcc_jit_version_major}@anchor{104}
+@anchor{topics/compatibility c gcc_jit_version_major}@anchor{128}
 @deffn {C Function} int gcc_jit_version_major (void)
 
 Return libgccjit major version.  This is analogous to __GNUC__ in C code.
 @end deffn
 
 @geindex gcc_jit_version_minor (C function)
-@anchor{topics/compatibility c gcc_jit_version_minor}@anchor{105}
+@anchor{topics/compatibility c gcc_jit_version_minor}@anchor{129}
 @deffn {C Function} int gcc_jit_version_minor (void)
 
 Return libgccjit minor version.  This is analogous to
@@ -8066,7 +8551,7 @@ __GNUC_MINOR__ in C code.
 @end deffn
 
 @geindex gcc_jit_version_patchlevel (C function)
-@anchor{topics/compatibility c gcc_jit_version_patchlevel}@anchor{106}
+@anchor{topics/compatibility c gcc_jit_version_patchlevel}@anchor{12a}
 @deffn {C Function} int gcc_jit_version_patchlevel (void)
 
 Return libgccjit patchlevel version.  This is analogous to
@@ -8081,7 +8566,7 @@ These entry points has been added with @code{LIBGCCJIT_ABI_13}
 @end cartouche
 
 @node ABI symbol tags,,Programmatically checking version,ABI and API compatibility
-@anchor{topics/compatibility abi-symbol-tags}@anchor{107}
+@anchor{topics/compatibility abi-symbol-tags}@anchor{12b}
 @subsection ABI symbol tags
 
 
@@ -8106,11 +8591,15 @@ Newer releases use the following tags.
 * LIBGCCJIT_ABI_13:: 
 * LIBGCCJIT_ABI_14:: 
 * LIBGCCJIT_ABI_15:: 
+* LIBGCCJIT_ABI_16:: 
+* LIBGCCJIT_ABI_17:: 
+* LIBGCCJIT_ABI_18:: 
+* LIBGCCJIT_ABI_19:: 
 
 @end menu
 
 @node LIBGCCJIT_ABI_0,LIBGCCJIT_ABI_1,,ABI symbol tags
-@anchor{topics/compatibility id1}@anchor{108}@anchor{topics/compatibility libgccjit-abi-0}@anchor{109}
+@anchor{topics/compatibility id1}@anchor{12c}@anchor{topics/compatibility libgccjit-abi-0}@anchor{12d}
 @subsubsection @code{LIBGCCJIT_ABI_0}
 
 
@@ -8122,7 +8611,7 @@ continue to work, with this being handled transparently by the linker
 (see this post@footnote{https://gcc.gnu.org/ml/gcc-patches/2015-06/msg02126.html})
 
 @node LIBGCCJIT_ABI_1,LIBGCCJIT_ABI_2,LIBGCCJIT_ABI_0,ABI symbol tags
-@anchor{topics/compatibility id2}@anchor{10a}@anchor{topics/compatibility libgccjit-abi-1}@anchor{73}
+@anchor{topics/compatibility id2}@anchor{12e}@anchor{topics/compatibility libgccjit-abi-1}@anchor{73}
 @subsubsection @code{LIBGCCJIT_ABI_1}
 
 
@@ -8130,7 +8619,7 @@ continue to work, with this being handled transparently by the linker
 @ref{72,,gcc_jit_context_add_command_line_option()}
 
 @node LIBGCCJIT_ABI_2,LIBGCCJIT_ABI_3,LIBGCCJIT_ABI_1,ABI symbol tags
-@anchor{topics/compatibility id3}@anchor{10b}@anchor{topics/compatibility libgccjit-abi-2}@anchor{6c}
+@anchor{topics/compatibility id3}@anchor{12f}@anchor{topics/compatibility libgccjit-abi-2}@anchor{6c}
 @subsubsection @code{LIBGCCJIT_ABI_2}
 
 
@@ -8138,7 +8627,7 @@ continue to work, with this being handled transparently by the linker
 @ref{6b,,gcc_jit_context_set_bool_allow_unreachable_blocks()}
 
 @node LIBGCCJIT_ABI_3,LIBGCCJIT_ABI_4,LIBGCCJIT_ABI_2,ABI symbol tags
-@anchor{topics/compatibility id4}@anchor{10c}@anchor{topics/compatibility libgccjit-abi-3}@anchor{ef}
+@anchor{topics/compatibility id4}@anchor{130}@anchor{topics/compatibility libgccjit-abi-3}@anchor{114}
 @subsubsection @code{LIBGCCJIT_ABI_3}
 
 
@@ -8151,18 +8640,18 @@ entrypoints:
 @itemize *
 
 @item 
-@ref{ec,,gcc_jit_block_end_with_switch()}
+@ref{111,,gcc_jit_block_end_with_switch()}
 
 @item 
-@ref{ed,,gcc_jit_case_as_object()}
+@ref{112,,gcc_jit_case_as_object()}
 
 @item 
-@ref{ee,,gcc_jit_context_new_case()}
+@ref{113,,gcc_jit_context_new_case()}
 @end itemize
 @end quotation
 
 @node LIBGCCJIT_ABI_4,LIBGCCJIT_ABI_5,LIBGCCJIT_ABI_3,ABI symbol tags
-@anchor{topics/compatibility id5}@anchor{10d}@anchor{topics/compatibility libgccjit-abi-4}@anchor{10e}
+@anchor{topics/compatibility id5}@anchor{131}@anchor{topics/compatibility libgccjit-abi-4}@anchor{132}
 @subsubsection @code{LIBGCCJIT_ABI_4}
 
 
@@ -8175,30 +8664,30 @@ entrypoints:
 @itemize *
 
 @item 
-@ref{10f,,gcc_jit_context_get_timer()}
+@ref{133,,gcc_jit_context_get_timer()}
 
 @item 
-@ref{110,,gcc_jit_context_set_timer()}
+@ref{134,,gcc_jit_context_set_timer()}
 
 @item 
-@ref{111,,gcc_jit_timer_new()}
+@ref{135,,gcc_jit_timer_new()}
 
 @item 
-@ref{112,,gcc_jit_timer_release()}
+@ref{136,,gcc_jit_timer_release()}
 
 @item 
-@ref{113,,gcc_jit_timer_push()}
+@ref{137,,gcc_jit_timer_push()}
 
 @item 
-@ref{114,,gcc_jit_timer_pop()}
+@ref{138,,gcc_jit_timer_pop()}
 
 @item 
-@ref{115,,gcc_jit_timer_print()}
+@ref{139,,gcc_jit_timer_print()}
 @end itemize
 @end quotation
 
 @node LIBGCCJIT_ABI_5,LIBGCCJIT_ABI_6,LIBGCCJIT_ABI_4,ABI symbol tags
-@anchor{topics/compatibility id6}@anchor{116}@anchor{topics/compatibility libgccjit-abi-5}@anchor{6e}
+@anchor{topics/compatibility id6}@anchor{13a}@anchor{topics/compatibility libgccjit-abi-5}@anchor{6e}
 @subsubsection @code{LIBGCCJIT_ABI_5}
 
 
@@ -8206,15 +8695,15 @@ entrypoints:
 @ref{6d,,gcc_jit_context_set_bool_use_external_driver()}
 
 @node LIBGCCJIT_ABI_6,LIBGCCJIT_ABI_7,LIBGCCJIT_ABI_5,ABI symbol tags
-@anchor{topics/compatibility id7}@anchor{117}@anchor{topics/compatibility libgccjit-abi-6}@anchor{be}
+@anchor{topics/compatibility id7}@anchor{13b}@anchor{topics/compatibility libgccjit-abi-6}@anchor{d6}
 @subsubsection @code{LIBGCCJIT_ABI_6}
 
 
 @code{LIBGCCJIT_ABI_6} covers the addition of
-@ref{bd,,gcc_jit_rvalue_set_bool_require_tail_call()}
+@ref{d5,,gcc_jit_rvalue_set_bool_require_tail_call()}
 
 @node LIBGCCJIT_ABI_7,LIBGCCJIT_ABI_8,LIBGCCJIT_ABI_6,ABI symbol tags
-@anchor{topics/compatibility id8}@anchor{118}@anchor{topics/compatibility libgccjit-abi-7}@anchor{83}
+@anchor{topics/compatibility id8}@anchor{13c}@anchor{topics/compatibility libgccjit-abi-7}@anchor{83}
 @subsubsection @code{LIBGCCJIT_ABI_7}
 
 
@@ -8222,7 +8711,7 @@ entrypoints:
 @ref{82,,gcc_jit_type_get_aligned()}
 
 @node LIBGCCJIT_ABI_8,LIBGCCJIT_ABI_9,LIBGCCJIT_ABI_7,ABI symbol tags
-@anchor{topics/compatibility id9}@anchor{119}@anchor{topics/compatibility libgccjit-abi-8}@anchor{86}
+@anchor{topics/compatibility id9}@anchor{13d}@anchor{topics/compatibility libgccjit-abi-8}@anchor{86}
 @subsubsection @code{LIBGCCJIT_ABI_8}
 
 
@@ -8230,15 +8719,15 @@ entrypoints:
 @ref{85,,gcc_jit_type_get_vector()}
 
 @node LIBGCCJIT_ABI_9,LIBGCCJIT_ABI_10,LIBGCCJIT_ABI_8,ABI symbol tags
-@anchor{topics/compatibility id10}@anchor{11a}@anchor{topics/compatibility libgccjit-abi-9}@anchor{f4}
+@anchor{topics/compatibility id10}@anchor{13e}@anchor{topics/compatibility libgccjit-abi-9}@anchor{118}
 @subsubsection @code{LIBGCCJIT_ABI_9}
 
 
 @code{LIBGCCJIT_ABI_9} covers the addition of
-@ref{c0,,gcc_jit_function_get_address()}
+@ref{d8,,gcc_jit_function_get_address()}
 
 @node LIBGCCJIT_ABI_10,LIBGCCJIT_ABI_11,LIBGCCJIT_ABI_9,ABI symbol tags
-@anchor{topics/compatibility id11}@anchor{11b}@anchor{topics/compatibility libgccjit-abi-10}@anchor{a0}
+@anchor{topics/compatibility id11}@anchor{13f}@anchor{topics/compatibility libgccjit-abi-10}@anchor{b8}
 @subsubsection @code{LIBGCCJIT_ABI_10}
 
 
@@ -8246,7 +8735,7 @@ entrypoints:
 @ref{87,,gcc_jit_context_new_rvalue_from_vector()}
 
 @node LIBGCCJIT_ABI_11,LIBGCCJIT_ABI_12,LIBGCCJIT_ABI_10,ABI symbol tags
-@anchor{topics/compatibility id12}@anchor{11c}@anchor{topics/compatibility libgccjit-abi-11}@anchor{75}
+@anchor{topics/compatibility id12}@anchor{140}@anchor{topics/compatibility libgccjit-abi-11}@anchor{75}
 @subsubsection @code{LIBGCCJIT_ABI_11}
 
 
@@ -8254,7 +8743,7 @@ entrypoints:
 @ref{74,,gcc_jit_context_add_driver_option()}
 
 @node LIBGCCJIT_ABI_12,LIBGCCJIT_ABI_13,LIBGCCJIT_ABI_11,ABI symbol tags
-@anchor{topics/compatibility id13}@anchor{11d}@anchor{topics/compatibility libgccjit-abi-12}@anchor{8d}
+@anchor{topics/compatibility id13}@anchor{141}@anchor{topics/compatibility libgccjit-abi-12}@anchor{8d}
 @subsubsection @code{LIBGCCJIT_ABI_12}
 
 
@@ -8262,7 +8751,7 @@ entrypoints:
 @ref{8c,,gcc_jit_context_new_bitfield()}
 
 @node LIBGCCJIT_ABI_13,LIBGCCJIT_ABI_14,LIBGCCJIT_ABI_12,ABI symbol tags
-@anchor{topics/compatibility id14}@anchor{11e}@anchor{topics/compatibility libgccjit-abi-13}@anchor{11f}
+@anchor{topics/compatibility id14}@anchor{142}@anchor{topics/compatibility libgccjit-abi-13}@anchor{143}
 @subsubsection @code{LIBGCCJIT_ABI_13}
 
 
@@ -8275,26 +8764,26 @@ entrypoints:
 @itemize *
 
 @item 
-@ref{104,,gcc_jit_version_major()}
+@ref{128,,gcc_jit_version_major()}
 
 @item 
-@ref{105,,gcc_jit_version_minor()}
+@ref{129,,gcc_jit_version_minor()}
 
 @item 
-@ref{106,,gcc_jit_version_patchlevel()}
+@ref{12a,,gcc_jit_version_patchlevel()}
 @end itemize
 @end quotation
 
 @node LIBGCCJIT_ABI_14,LIBGCCJIT_ABI_15,LIBGCCJIT_ABI_13,ABI symbol tags
-@anchor{topics/compatibility id15}@anchor{120}@anchor{topics/compatibility libgccjit-abi-14}@anchor{cf}
+@anchor{topics/compatibility id15}@anchor{144}@anchor{topics/compatibility libgccjit-abi-14}@anchor{f1}
 @subsubsection @code{LIBGCCJIT_ABI_14}
 
 
 @code{LIBGCCJIT_ABI_14} covers the addition of
-@ref{ce,,gcc_jit_global_set_initializer()}
+@ref{f0,,gcc_jit_global_set_initializer()}
 
-@node LIBGCCJIT_ABI_15,,LIBGCCJIT_ABI_14,ABI symbol tags
-@anchor{topics/compatibility id16}@anchor{121}@anchor{topics/compatibility libgccjit-abi-15}@anchor{122}
+@node LIBGCCJIT_ABI_15,LIBGCCJIT_ABI_16,LIBGCCJIT_ABI_14,ABI symbol tags
+@anchor{topics/compatibility id16}@anchor{145}@anchor{topics/compatibility libgccjit-abi-15}@anchor{146}
 @subsubsection @code{LIBGCCJIT_ABI_15}
 
 
@@ -8307,31 +8796,160 @@ embedding assembler instructions:
 @itemize *
 
 @item 
-@ref{123,,gcc_jit_block_add_extended_asm()}
+@ref{147,,gcc_jit_block_add_extended_asm()}
 
 @item 
-@ref{124,,gcc_jit_block_end_with_extended_asm_goto()}
+@ref{148,,gcc_jit_block_end_with_extended_asm_goto()}
 
 @item 
-@ref{125,,gcc_jit_extended_asm_as_object()}
+@ref{149,,gcc_jit_extended_asm_as_object()}
 
 @item 
-@ref{126,,gcc_jit_extended_asm_set_volatile_flag()}
+@ref{14a,,gcc_jit_extended_asm_set_volatile_flag()}
 
 @item 
-@ref{127,,gcc_jit_extended_asm_set_inline_flag()}
+@ref{14b,,gcc_jit_extended_asm_set_inline_flag()}
+
+@item 
+@ref{14c,,gcc_jit_extended_asm_add_output_operand()}
+
+@item 
+@ref{14d,,gcc_jit_extended_asm_add_input_operand()}
+
+@item 
+@ref{14e,,gcc_jit_extended_asm_add_clobber()}
+
+@item 
+@ref{14f,,gcc_jit_context_add_top_level_asm()}
+@end itemize
+@end quotation
+
+@node LIBGCCJIT_ABI_16,LIBGCCJIT_ABI_17,LIBGCCJIT_ABI_15,ABI symbol tags
+@anchor{topics/compatibility id17}@anchor{150}@anchor{topics/compatibility libgccjit-abi-16}@anchor{a6}
+@subsubsection @code{LIBGCCJIT_ABI_16}
+
+
+@code{LIBGCCJIT_ABI_16} covers the addition of reflection functions via API
+entrypoints:
+
+@quotation
+
+
+@itemize *
+
+@item 
+@ref{107,,gcc_jit_function_get_return_type()}
+
+@item 
+@ref{106,,gcc_jit_function_get_param_count()}
+
+@item 
+@ref{97,,gcc_jit_type_dyncast_array()}
+
+@item 
+@ref{98,,gcc_jit_type_is_bool()}
+
+@item 
+@ref{9d,,gcc_jit_type_is_integral()}
+
+@item 
+@ref{9e,,gcc_jit_type_is_pointer()}
+
+@item 
+@ref{a0,,gcc_jit_type_is_struct()}
+
+@item 
+@ref{9f,,gcc_jit_type_dyncast_vector()}
+
+@item 
+@ref{a3,,gcc_jit_type_unqualified()}
+
+@item 
+@ref{99,,gcc_jit_type_dyncast_function_ptr_type()}
+
+@item 
+@ref{9a,,gcc_jit_function_type_get_return_type()}
+
+@item 
+@ref{9b,,gcc_jit_function_type_get_param_count()}
+
+@item 
+@ref{9c,,gcc_jit_function_type_get_param_type()}
+
+@item 
+@ref{a1,,gcc_jit_vector_type_get_num_units()}
+
+@item 
+@ref{a2,,gcc_jit_vector_type_get_element_type()}
+
+@item 
+@ref{a4,,gcc_jit_struct_get_field()}
+
+@item 
+@ref{a5,,gcc_jit_struct_get_field_count()}
+@end itemize
+@end quotation
+
+@node LIBGCCJIT_ABI_17,LIBGCCJIT_ABI_18,LIBGCCJIT_ABI_16,ABI symbol tags
+@anchor{topics/compatibility id18}@anchor{151}@anchor{topics/compatibility libgccjit-abi-17}@anchor{e6}
+@subsubsection @code{LIBGCCJIT_ABI_17}
+
+
+@code{LIBGCCJIT_ABI_17} covers the addition of an API entrypoint to set the
+thread-local storage model of a variable:
+
+@quotation
+
+
+@itemize *
+
+@item 
+@ref{df,,gcc_jit_lvalue_set_tls_model()}
+@end itemize
+@end quotation
+
+@node LIBGCCJIT_ABI_18,LIBGCCJIT_ABI_19,LIBGCCJIT_ABI_17,ABI symbol tags
+@anchor{topics/compatibility id19}@anchor{152}@anchor{topics/compatibility libgccjit-abi-18}@anchor{e8}
+@subsubsection @code{LIBGCCJIT_ABI_18}
+
+
+@code{LIBGCCJIT_ABI_18} covers the addition of an API entrypoint to set the link
+section of a variable:
+
+@quotation
+
+
+@itemize *
+
+@item 
+@ref{e7,,gcc_jit_lvalue_set_link_section()}
+@end itemize
+@end quotation
+
+@node LIBGCCJIT_ABI_19,,LIBGCCJIT_ABI_18,ABI symbol tags
+@anchor{topics/compatibility id20}@anchor{153}@anchor{topics/compatibility libgccjit-abi-19}@anchor{b3}
+@subsubsection @code{LIBGCCJIT_ABI_19}
+
+
+@code{LIBGCCJIT_ABI_19} covers the addition of API entrypoints to set the initial value
+of a global with an rvalue and to use constructors:
+
+@quotation
+
+
+@itemize *
 
 @item 
-@ref{128,,gcc_jit_extended_asm_add_output_operand()}
+@ref{b4,,gcc_jit_context_new_array_constructor()}
 
 @item 
-@ref{129,,gcc_jit_extended_asm_add_input_operand()}
+@ref{b5,,gcc_jit_context_new_struct_constructor()}
 
 @item 
-@ref{12a,,gcc_jit_extended_asm_add_clobber()}
+@ref{b6,,gcc_jit_context_new_union_constructor()}
 
 @item 
-@ref{12b,,gcc_jit_context_add_top_level_asm()}
+@ref{b2,,gcc_jit_global_set_initializer_rvalue()}
 @end itemize
 @end quotation
 
@@ -8353,7 +8971,7 @@ embedding assembler instructions:
 @c <https://www.gnu.org/licenses/>.
 
 @node Performance,Using Assembly Language with libgccjit,ABI and API compatibility,Topic Reference
-@anchor{topics/performance doc}@anchor{12c}@anchor{topics/performance performance}@anchor{12d}
+@anchor{topics/performance doc}@anchor{154}@anchor{topics/performance performance}@anchor{155}
 @section Performance
 
 
@@ -8363,14 +8981,14 @@ embedding assembler instructions:
 @end menu
 
 @node The timing API,,,Performance
-@anchor{topics/performance the-timing-api}@anchor{12e}
+@anchor{topics/performance the-timing-api}@anchor{156}
 @subsection The timing API
 
 
 As of GCC 6, libgccjit exposes a timing API, for printing reports on
 how long was spent in different parts of code.
 
-You can create a @ref{12f,,gcc_jit_timer} instance, which will
+You can create a @ref{157,,gcc_jit_timer} instance, which will
 measure time spent since its creation.  The timer maintains a stack
 of “timer items”: as control flow moves through your code, you can push
 and pop named items relating to your code onto the stack, and the timer
@@ -8468,7 +9086,7 @@ Client items:
 The exact format is intended to be human-readable, and is subject to change.
 
 @geindex LIBGCCJIT_HAVE_TIMING_API (C macro)
-@anchor{topics/performance c LIBGCCJIT_HAVE_TIMING_API}@anchor{130}
+@anchor{topics/performance c LIBGCCJIT_HAVE_TIMING_API}@anchor{158}
 @deffn {C Macro} LIBGCCJIT_HAVE_TIMING_API
 
 The timer API was added to libgccjit in GCC 6.
@@ -8485,21 +9103,21 @@ gcc_jit_context_set_timer (ctxt, t);
 @end deffn
 
 @geindex gcc_jit_timer (C type)
-@anchor{topics/performance c gcc_jit_timer}@anchor{12f}
+@anchor{topics/performance c gcc_jit_timer}@anchor{157}
 @deffn {C Type} gcc_jit_timer
 @end deffn
 
 @geindex gcc_jit_timer_new (C function)
-@anchor{topics/performance c gcc_jit_timer_new}@anchor{111}
+@anchor{topics/performance c gcc_jit_timer_new}@anchor{135}
 @deffn {C Function} gcc_jit_timer * gcc_jit_timer_new (void)
 
-Create a @ref{12f,,gcc_jit_timer} instance, and start timing:
+Create a @ref{157,,gcc_jit_timer} instance, and start timing:
 
 @example
 gcc_jit_timer *t = gcc_jit_timer_new ();
 @end example
 
-This API entrypoint was added in @ref{10e,,LIBGCCJIT_ABI_4}; you can test
+This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test
 for its presence using
 
 @example
@@ -8508,10 +9126,10 @@ for its presence using
 @end deffn
 
 @geindex gcc_jit_timer_release (C function)
-@anchor{topics/performance c gcc_jit_timer_release}@anchor{112}
+@anchor{topics/performance c gcc_jit_timer_release}@anchor{136}
 @deffn {C Function} void gcc_jit_timer_release (gcc_jit_timer@w{ }*timer)
 
-Release a @ref{12f,,gcc_jit_timer} instance:
+Release a @ref{157,,gcc_jit_timer} instance:
 
 @example
 gcc_jit_timer_release (t);
@@ -8519,7 +9137,7 @@ gcc_jit_timer_release (t);
 
 This should be called exactly once on a timer.
 
-This API entrypoint was added in @ref{10e,,LIBGCCJIT_ABI_4}; you can test
+This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test
 for its presence using
 
 @example
@@ -8528,10 +9146,10 @@ for its presence using
 @end deffn
 
 @geindex gcc_jit_context_set_timer (C function)
-@anchor{topics/performance c gcc_jit_context_set_timer}@anchor{110}
+@anchor{topics/performance c gcc_jit_context_set_timer}@anchor{134}
 @deffn {C Function} void gcc_jit_context_set_timer (gcc_jit_context@w{ }*ctxt, gcc_jit_timer@w{ }*timer)
 
-Associate a @ref{12f,,gcc_jit_timer} instance with a context:
+Associate a @ref{157,,gcc_jit_timer} instance with a context:
 
 @example
 gcc_jit_context_set_timer (ctxt, t);
@@ -8544,7 +9162,7 @@ Timers have no locking, so if you have a multithreaded program, you
 must provide your own locks if more than one thread could be working
 with the same timer via timer-associated contexts.
 
-This API entrypoint was added in @ref{10e,,LIBGCCJIT_ABI_4}; you can test
+This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test
 for its presence using
 
 @example
@@ -8553,12 +9171,12 @@ for its presence using
 @end deffn
 
 @geindex gcc_jit_context_get_timer (C function)
-@anchor{topics/performance c gcc_jit_context_get_timer}@anchor{10f}
+@anchor{topics/performance c gcc_jit_context_get_timer}@anchor{133}
 @deffn {C Function} gcc_jit_timer *gcc_jit_context_get_timer (gcc_jit_context@w{ }*ctxt)
 
 Get the timer associated with a context (if any).
 
-This API entrypoint was added in @ref{10e,,LIBGCCJIT_ABI_4}; you can test
+This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test
 for its presence using
 
 @example
@@ -8567,7 +9185,7 @@ for its presence using
 @end deffn
 
 @geindex gcc_jit_timer_push (C function)
-@anchor{topics/performance c gcc_jit_timer_push}@anchor{113}
+@anchor{topics/performance c gcc_jit_timer_push}@anchor{137}
 @deffn {C Function} void gcc_jit_timer_push (gcc_jit_timer@w{ }*timer, const char@w{ }*item_name)
 
 Push the given item onto the timer’s stack:
@@ -8578,7 +9196,7 @@ run_the_code (ctxt, result);
 gcc_jit_timer_pop (t, "running code");
 @end example
 
-This API entrypoint was added in @ref{10e,,LIBGCCJIT_ABI_4}; you can test
+This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test
 for its presence using
 
 @example
@@ -8587,7 +9205,7 @@ for its presence using
 @end deffn
 
 @geindex gcc_jit_timer_pop (C function)
-@anchor{topics/performance c gcc_jit_timer_pop}@anchor{114}
+@anchor{topics/performance c gcc_jit_timer_pop}@anchor{138}
 @deffn {C Function} void gcc_jit_timer_pop (gcc_jit_timer@w{ }*timer, const char@w{ }*item_name)
 
 Pop the top item from the timer’s stack.
@@ -8595,7 +9213,7 @@ Pop the top item from the timer’s stack.
 If “item_name” is provided, it must match that of the top item.
 Alternatively, @code{NULL} can be passed in, to suppress checking.
 
-This API entrypoint was added in @ref{10e,,LIBGCCJIT_ABI_4}; you can test
+This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test
 for its presence using
 
 @example
@@ -8604,13 +9222,13 @@ for its presence using
 @end deffn
 
 @geindex gcc_jit_timer_print (C function)
-@anchor{topics/performance c gcc_jit_timer_print}@anchor{115}
+@anchor{topics/performance c gcc_jit_timer_print}@anchor{139}
 @deffn {C Function} void gcc_jit_timer_print (gcc_jit_timer@w{ }*timer, FILE@w{ }*f_out)
 
 Print timing information to the given stream about activity since
 the timer was started.
 
-This API entrypoint was added in @ref{10e,,LIBGCCJIT_ABI_4}; you can test
+This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test
 for its presence using
 
 @example
@@ -8636,7 +9254,7 @@ for its presence using
 @c <https://www.gnu.org/licenses/>.
 
 @node Using Assembly Language with libgccjit,,Performance,Topic Reference
-@anchor{topics/asm doc}@anchor{131}@anchor{topics/asm using-assembly-language-with-libgccjit}@anchor{132}
+@anchor{topics/asm doc}@anchor{159}@anchor{topics/asm using-assembly-language-with-libgccjit}@anchor{15a}
 @section Using Assembly Language with libgccjit
 
 
@@ -8646,7 +9264,7 @@ following assumes a familiarity with that functionality.  See
 How to Use Inline Assembly Language in C Code@footnote{https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-with-C.html}
 in GCC’s documentation, the “Extended Asm” section in particular.
 
-These entrypoints were added in @ref{122,,LIBGCCJIT_ABI_15}; you can test
+These entrypoints were added in @ref{146,,LIBGCCJIT_ABI_15}; you can test
 for their presence using
 
 @quotation
@@ -8663,12 +9281,12 @@ for their presence using
 @end menu
 
 @node Adding assembler instructions within a function,Adding top-level assembler statements,,Using Assembly Language with libgccjit
-@anchor{topics/asm adding-assembler-instructions-within-a-function}@anchor{133}
+@anchor{topics/asm adding-assembler-instructions-within-a-function}@anchor{15b}
 @subsection Adding assembler instructions within a function
 
 
 @geindex gcc_jit_extended_asm (C type)
-@anchor{topics/asm c gcc_jit_extended_asm}@anchor{f1}
+@anchor{topics/asm c gcc_jit_extended_asm}@anchor{115}
 @deffn {C Type} gcc_jit_extended_asm
 
 A @cite{gcc_jit_extended_asm} represents an extended @code{asm} statement: a
@@ -8677,21 +9295,21 @@ to outputs.
 
 To avoid having an API entrypoint with a very large number of
 parameters, an extended @code{asm} statement is made in stages:
-an initial call to create the @ref{f1,,gcc_jit_extended_asm},
+an initial call to create the @ref{115,,gcc_jit_extended_asm},
 followed by calls to add operands and set other properties of the
 statement.
 
-There are two API entrypoints for creating a @ref{f1,,gcc_jit_extended_asm}:
+There are two API entrypoints for creating a @ref{115,,gcc_jit_extended_asm}:
 
 
 @itemize *
 
 @item 
-@ref{123,,gcc_jit_block_add_extended_asm()} for an @code{asm} statement with
+@ref{147,,gcc_jit_block_add_extended_asm()} for an @code{asm} statement with
 no control flow, and
 
 @item 
-@ref{124,,gcc_jit_block_end_with_extended_asm_goto()} for an @code{asm goto}.
+@ref{148,,gcc_jit_block_end_with_extended_asm_goto()} for an @code{asm goto}.
 @end itemize
 
 For example, to create the equivalent of:
@@ -8722,8 +9340,8 @@ extended @code{asm} statement (e.g. the @code{%0} and @code{%1}
 above), the equivalent to the C syntax is followed i.e. all
 output operands, then all input operands, regardless of
 what order the calls to
-@ref{128,,gcc_jit_extended_asm_add_output_operand()} and
-@ref{129,,gcc_jit_extended_asm_add_input_operand()} were made in.
+@ref{14c,,gcc_jit_extended_asm_add_output_operand()} and
+@ref{14d,,gcc_jit_extended_asm_add_input_operand()} were made in.
 @end quotation
 @end cartouche
 
@@ -8751,10 +9369,10 @@ the following API calls could be used:
 @end deffn
 
 @geindex gcc_jit_block_add_extended_asm (C function)
-@anchor{topics/asm c gcc_jit_block_add_extended_asm}@anchor{123}
+@anchor{topics/asm c gcc_jit_block_add_extended_asm}@anchor{147}
 @deffn {C Function} gcc_jit_extended_asm *           gcc_jit_block_add_extended_asm (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, const char@w{ }*asm_template)
 
-Create a @ref{f1,,gcc_jit_extended_asm} for an extended @code{asm} statement
+Create a @ref{115,,gcc_jit_extended_asm} for an extended @code{asm} statement
 with no control flow (i.e. without the @code{goto} qualifier).
 
 The parameter @code{asm_template} corresponds to the @cite{AssemblerTemplate}
@@ -8764,10 +9382,10 @@ an on-stack buffer.
 @end deffn
 
 @geindex gcc_jit_block_end_with_extended_asm_goto (C function)
-@anchor{topics/asm c gcc_jit_block_end_with_extended_asm_goto}@anchor{124}
+@anchor{topics/asm c gcc_jit_block_end_with_extended_asm_goto}@anchor{148}
 @deffn {C Function} gcc_jit_extended_asm *           gcc_jit_block_end_with_extended_asm_goto (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, const char@w{ }*asm_template, int@w{ }num_goto_blocks, gcc_jit_block@w{ }**goto_blocks, gcc_jit_block@w{ }*fallthrough_block)
 
-Create a @ref{f1,,gcc_jit_extended_asm} for an extended @code{asm} statement
+Create a @ref{115,,gcc_jit_extended_asm} for an extended @code{asm} statement
 that may perform jumps, and use it to terminate the given block.
 This is equivalent to the @code{goto} qualifier in C’s extended @code{asm}
 syntax.
@@ -8830,10 +9448,10 @@ would have happened in the C case.
 @end deffn
 
 @geindex gcc_jit_extended_asm_set_volatile_flag (C function)
-@anchor{topics/asm c gcc_jit_extended_asm_set_volatile_flag}@anchor{126}
+@anchor{topics/asm c gcc_jit_extended_asm_set_volatile_flag}@anchor{14a}
 @deffn {C Function} void           gcc_jit_extended_asm_set_volatile_flag (gcc_jit_extended_asm@w{ }*ext_asm, int@w{ }flag)
 
-Set whether the @ref{f1,,gcc_jit_extended_asm} has side-effects, equivalent to the
+Set whether the @ref{115,,gcc_jit_extended_asm} has side-effects, equivalent to the
 volatile@footnote{https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#Volatile}
 qualifier in C’s extended asm syntax.
 
@@ -8862,11 +9480,11 @@ the following API calls could be used:
   gcc_jit_extended_asm_add_clobber (ext_asm, "rdx");
 @end example
 
-where the @ref{f1,,gcc_jit_extended_asm} is flagged as volatile.
+where the @ref{115,,gcc_jit_extended_asm} is flagged as volatile.
 @end deffn
 
 @geindex gcc_jit_extended_asm_set_inline_flag (C function)
-@anchor{topics/asm c gcc_jit_extended_asm_set_inline_flag}@anchor{127}
+@anchor{topics/asm c gcc_jit_extended_asm_set_inline_flag}@anchor{14b}
 @deffn {C Function} void           gcc_jit_extended_asm_set_inline_flag (gcc_jit_extended_asm@w{ }*ext_asm, int@w{ }flag)
 
 Set the equivalent of the
@@ -8875,7 +9493,7 @@ qualifier in C’s extended @code{asm} syntax.
 @end deffn
 
 @geindex gcc_jit_extended_asm_add_output_operand (C function)
-@anchor{topics/asm c gcc_jit_extended_asm_add_output_operand}@anchor{128}
+@anchor{topics/asm c gcc_jit_extended_asm_add_output_operand}@anchor{14c}
 @deffn {C Function} void           gcc_jit_extended_asm_add_output_operand (gcc_jit_extended_asm@w{ }*ext_asm, const char@w{ }*asm_symbolic_name, const char@w{ }*constraint, gcc_jit_lvalue@w{ }*dest)
 
 Add an output operand to the extended @code{asm} statement.  See the
@@ -8909,7 +9527,7 @@ section of GCC’s “Extended Asm” documentation.
 @end deffn
 
 @geindex gcc_jit_extended_asm_add_input_operand (C function)
-@anchor{topics/asm c gcc_jit_extended_asm_add_input_operand}@anchor{129}
+@anchor{topics/asm c gcc_jit_extended_asm_add_input_operand}@anchor{14d}
 @deffn {C Function} void           gcc_jit_extended_asm_add_input_operand (gcc_jit_extended_asm@w{ }*ext_asm, const char@w{ }*asm_symbolic_name, const char@w{ }*constraint, gcc_jit_rvalue@w{ }*src)
 
 Add an input operand to the extended @code{asm} statement.  See the
@@ -8940,7 +9558,7 @@ gcc_jit_extended_asm_add_input_operand (ext_asm, "aMask", "r",
 @end deffn
 
 @geindex gcc_jit_extended_asm_add_clobber (C function)
-@anchor{topics/asm c gcc_jit_extended_asm_add_clobber}@anchor{12a}
+@anchor{topics/asm c gcc_jit_extended_asm_add_clobber}@anchor{14e}
 @deffn {C Function} void           gcc_jit_extended_asm_add_clobber (gcc_jit_extended_asm@w{ }*ext_asm, const char@w{ }*victim)
 
 Add @cite{victim} to the list of registers clobbered by the extended @code{asm}
@@ -8960,18 +9578,18 @@ gcc_jit_extended_asm_add_clobber (ext_asm, "memory");
 @end example
 @end deffn
 
-A @ref{f1,,gcc_jit_extended_asm} is a @ref{e,,gcc_jit_object} “owned” by
+A @ref{115,,gcc_jit_extended_asm} is a @ref{e,,gcc_jit_object} “owned” by
 the block’s context.  The following upcast is available:
 
 @geindex gcc_jit_extended_asm_as_object (C function)
-@anchor{topics/asm c gcc_jit_extended_asm_as_object}@anchor{125}
+@anchor{topics/asm c gcc_jit_extended_asm_as_object}@anchor{149}
 @deffn {C Function} gcc_jit_object *           gcc_jit_extended_asm_as_object (gcc_jit_extended_asm@w{ }*ext_asm)
 
 Upcast from extended @code{asm} to object.
 @end deffn
 
 @node Adding top-level assembler statements,,Adding assembler instructions within a function,Using Assembly Language with libgccjit
-@anchor{topics/asm adding-top-level-assembler-statements}@anchor{134}
+@anchor{topics/asm adding-top-level-assembler-statements}@anchor{15c}
 @subsection Adding top-level assembler statements
 
 
@@ -8980,7 +9598,7 @@ there is support for creating “top-level” assembler statements, outside
 of any function.
 
 @geindex gcc_jit_context_add_top_level_asm (C function)
-@anchor{topics/asm c gcc_jit_context_add_top_level_asm}@anchor{12b}
+@anchor{topics/asm c gcc_jit_context_add_top_level_asm}@anchor{14f}
 @deffn {C Function} void            gcc_jit_context_add_top_level_asm (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, const char@w{ }*asm_stmts)
 
 Create a set of top-level asm statements, analogous to those created
@@ -9033,7 +9651,7 @@ the following API calls could be used:
 @c <https://www.gnu.org/licenses/>.
 
 @node C++ bindings for libgccjit,Internals,Topic Reference,Top
-@anchor{cp/index doc}@anchor{135}@anchor{cp/index c-bindings-for-libgccjit}@anchor{136}
+@anchor{cp/index doc}@anchor{15d}@anchor{cp/index c-bindings-for-libgccjit}@anchor{15e}
 @chapter C++ bindings for libgccjit
 
 
@@ -9073,7 +9691,7 @@ Contents:
 @end menu
 
 @node Tutorial<2>,Topic Reference<2>,,C++ bindings for libgccjit
-@anchor{cp/intro/index doc}@anchor{137}@anchor{cp/intro/index tutorial}@anchor{138}
+@anchor{cp/intro/index doc}@anchor{15f}@anchor{cp/intro/index tutorial}@anchor{160}
 @section Tutorial
 
 
@@ -9103,7 +9721,7 @@ Contents:
 @end menu
 
 @node Tutorial part 1 “Hello world”<2>,Tutorial part 2 Creating a trivial machine code function<2>,,Tutorial<2>
-@anchor{cp/intro/tutorial01 doc}@anchor{139}@anchor{cp/intro/tutorial01 tutorial-part-1-hello-world}@anchor{13a}
+@anchor{cp/intro/tutorial01 doc}@anchor{161}@anchor{cp/intro/tutorial01 tutorial-part-1-hello-world}@anchor{162}
 @subsection Tutorial part 1: “Hello world”
 
 
@@ -9136,7 +9754,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
-<https://www.gnu.org/licenses/>.  */
+<http://www.gnu.org/licenses/>.  */
 
 #include <libgccjit++.h>
 
@@ -9266,7 +9884,7 @@ hello world
 @c <https://www.gnu.org/licenses/>.
 
 @node Tutorial part 2 Creating a trivial machine code function<2>,Tutorial part 3 Loops and variables<2>,Tutorial part 1 “Hello world”<2>,Tutorial<2>
-@anchor{cp/intro/tutorial02 doc}@anchor{13b}@anchor{cp/intro/tutorial02 tutorial-part-2-creating-a-trivial-machine-code-function}@anchor{13c}
+@anchor{cp/intro/tutorial02 doc}@anchor{163}@anchor{cp/intro/tutorial02 tutorial-part-2-creating-a-trivial-machine-code-function}@anchor{164}
 @subsection Tutorial part 2: Creating a trivial machine code function
 
 
@@ -9288,10 +9906,10 @@ First we need to include the relevant header:
 @end example
 
 All state associated with compilation is associated with a
-@ref{13d,,gccjit;;context}, which is a thin C++ wrapper around the C API’s
+@ref{165,,gccjit;;context}, which is a thin C++ wrapper around the C API’s
 @ref{8,,gcc_jit_context *}.
 
-Create one using @ref{13e,,gccjit;;context;;acquire()}:
+Create one using @ref{166,,gccjit;;context;;acquire()}:
 
 @example
 gccjit::context ctxt;
@@ -9301,19 +9919,19 @@ ctxt = gccjit::context::acquire ();
 The JIT library has a system of types.  It is statically-typed: every
 expression is of a specific type, fixed at compile-time.  In our example,
 all of the expressions are of the C @cite{int} type, so let’s obtain this from
-the context, as a @ref{13f,,gccjit;;type}, using
-@ref{140,,gccjit;;context;;get_type()}:
+the context, as a @ref{167,,gccjit;;type}, using
+@ref{168,,gccjit;;context;;get_type()}:
 
 @example
 gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);
 @end example
 
-@ref{13f,,gccjit;;type} is an example of a “contextual” object: every
-entity in the API is associated with a @ref{13d,,gccjit;;context}.
+@ref{167,,gccjit;;type} is an example of a “contextual” object: every
+entity in the API is associated with a @ref{165,,gccjit;;context}.
 
 Memory management is easy: all such “contextual” objects are automatically
 cleaned up for you when the context is released, using
-@ref{141,,gccjit;;context;;release()}:
+@ref{169,,gccjit;;context;;release()}:
 
 @example
 ctxt.release ();
@@ -9340,9 +9958,9 @@ The C++ class hierarchy within the @code{gccjit} namespace looks like this:
            +- param
 @end example
 
-One thing you can do with a @ref{142,,gccjit;;object} is
+One thing you can do with a @ref{16a,,gccjit;;object} is
 to ask it for a human-readable description as a @code{std::string}, using
-@ref{143,,gccjit;;object;;get_debug_string()}:
+@ref{16b,,gccjit;;object;;get_debug_string()}:
 
 @example
 printf ("obj: %s\n", obj.get_debug_string ().c_str ());
@@ -9358,7 +9976,7 @@ This is invaluable when debugging.
 
 Let’s create the function.  To do so, we first need to construct
 its single parameter, specifying its type and giving it a name,
-using @ref{144,,gccjit;;context;;new_param()}:
+using @ref{16c,,gccjit;;context;;new_param()}:
 
 @example
 gccjit::param param_i = ctxt.new_param (int_type, "i");
@@ -9399,7 +10017,7 @@ gccjit::block block = func.new_block ();
 Our basic block is relatively simple: it immediately terminates by
 returning the value of an expression.
 
-We can build the expression using @ref{145,,gccjit;;context;;new_binary_op()}:
+We can build the expression using @ref{16d,,gccjit;;context;;new_binary_op()}:
 
 @example
 gccjit::rvalue expr =
@@ -9408,9 +10026,9 @@ gccjit::rvalue expr =
     param_i, param_i);
 @end example
 
-A @ref{146,,gccjit;;rvalue} is another example of a
-@ref{142,,gccjit;;object} subclass.  As before, we can print it with
-@ref{143,,gccjit;;object;;get_debug_string()}.
+A @ref{16e,,gccjit;;rvalue} is another example of a
+@ref{16a,,gccjit;;object} subclass.  As before, we can print it with
+@ref{16b,,gccjit;;object;;get_debug_string()}.
 
 @example
 printf ("expr: %s\n", expr.get_debug_string ().c_str ());
@@ -9422,7 +10040,7 @@ giving this output:
 expr: i * i
 @end example
 
-Note that @ref{146,,gccjit;;rvalue} provides numerous overloaded operators
+Note that @ref{16e,,gccjit;;rvalue} provides numerous overloaded operators
 which can be used to dramatically reduce the amount of typing needed.
 We can build the above binary operation more directly with this one-liner:
 
@@ -9439,7 +10057,7 @@ block.end_with_return (expr);
 @end example
 
 OK, we’ve populated the context.  We can now compile it using
-@ref{147,,gccjit;;context;;compile()}:
+@ref{16f,,gccjit;;context;;compile()}:
 
 @example
 gcc_jit_result *result;
@@ -9481,12 +10099,12 @@ result: 25
 @end menu
 
 @node Options<3>,Full example<3>,,Tutorial part 2 Creating a trivial machine code function<2>
-@anchor{cp/intro/tutorial02 options}@anchor{148}
+@anchor{cp/intro/tutorial02 options}@anchor{170}
 @subsubsection Options
 
 
 To get more information on what’s going on, you can set debugging flags
-on the context using @ref{149,,gccjit;;context;;set_bool_option()}.
+on the context using @ref{171,,gccjit;;context;;set_bool_option()}.
 
 @c (I'm deliberately not mentioning
 @c :c:macro:`GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE` here since I think
@@ -9550,7 +10168,7 @@ square:
 
 By default, no optimizations are performed, the equivalent of GCC’s
 @cite{-O0} option.  We can turn things up to e.g. @cite{-O3} by calling
-@ref{14a,,gccjit;;context;;set_int_option()} with
+@ref{172,,gccjit;;context;;set_int_option()} with
 @ref{1f,,GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL}:
 
 @example
@@ -9580,7 +10198,7 @@ square:
 Naturally this has only a small effect on such a trivial function.
 
 @node Full example<3>,,Options<3>,Tutorial part 2 Creating a trivial machine code function<2>
-@anchor{cp/intro/tutorial02 full-example}@anchor{14b}
+@anchor{cp/intro/tutorial02 full-example}@anchor{173}
 @subsubsection Full example
 
 
@@ -9606,7 +10224,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
-<https://www.gnu.org/licenses/>.  */
+<http://www.gnu.org/licenses/>.  */
 
 #include <libgccjit++.h>
 
@@ -9718,7 +10336,7 @@ result: 25
 @c <https://www.gnu.org/licenses/>.
 
 @node Tutorial part 3 Loops and variables<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>,Tutorial part 2 Creating a trivial machine code function<2>,Tutorial<2>
-@anchor{cp/intro/tutorial03 doc}@anchor{14c}@anchor{cp/intro/tutorial03 tutorial-part-3-loops-and-variables}@anchor{14d}
+@anchor{cp/intro/tutorial03 doc}@anchor{174}@anchor{cp/intro/tutorial03 tutorial-part-3-loops-and-variables}@anchor{175}
 @subsection Tutorial part 3: Loops and variables
 
 
@@ -9774,7 +10392,7 @@ Here’s what the final control flow graph will look like:
 @end quotation
 
 As before, we include the libgccjit++ header and make a
-@ref{13d,,gccjit;;context}.
+@ref{165,,gccjit;;context}.
 
 @example
 #include <libgccjit++.h>
@@ -9828,18 +10446,18 @@ gccjit::function func =
 @end menu
 
 @node Expressions lvalues and rvalues<2>,Control flow<2>,,Tutorial part 3 Loops and variables<2>
-@anchor{cp/intro/tutorial03 expressions-lvalues-and-rvalues}@anchor{14e}
+@anchor{cp/intro/tutorial03 expressions-lvalues-and-rvalues}@anchor{176}
 @subsubsection Expressions: lvalues and rvalues
 
 
-The base class of expression is the @ref{146,,gccjit;;rvalue},
+The base class of expression is the @ref{16e,,gccjit;;rvalue},
 representing an expression that can be on the @emph{right}-hand side of
 an assignment: a value that can be computed somehow, and assigned
 @emph{to} a storage area (such as a variable).  It has a specific
-@ref{13f,,gccjit;;type}.
+@ref{167,,gccjit;;type}.
 
-Anothe important class is @ref{14f,,gccjit;;lvalue}.
-A @ref{14f,,gccjit;;lvalue}. is something that can of the @emph{left}-hand
+Anothe important class is @ref{177,,gccjit;;lvalue}.
+A @ref{177,,gccjit;;lvalue}. is something that can of the @emph{left}-hand
 side of an assignment: a storage area (such as a variable).
 
 In other words, every assignment can be thought of as:
@@ -9848,8 +10466,8 @@ In other words, every assignment can be thought of as:
 LVALUE = RVALUE;
 @end example
 
-Note that @ref{14f,,gccjit;;lvalue} is a subclass of
-@ref{146,,gccjit;;rvalue}, where in an assignment of the form:
+Note that @ref{177,,gccjit;;lvalue} is a subclass of
+@ref{16e,,gccjit;;rvalue}, where in an assignment of the form:
 
 @example
 LVALUE_A = LVALUE_B;
@@ -9879,7 +10497,7 @@ gccjit::rvalue expr =
 gccjit::rvalue expr = param_i * param_i;
 @end example
 
-which is a @ref{146,,gccjit;;rvalue}, and
+which is a @ref{16e,,gccjit;;rvalue}, and
 @end quotation
 
 
@@ -9887,15 +10505,15 @@ which is a @ref{146,,gccjit;;rvalue}, and
 
 @item 
 the various function parameters: @cite{param_i} and @cite{param_n}, instances of
-@ref{150,,gccjit;;param}, which is a subclass of @ref{14f,,gccjit;;lvalue}
-(and, in turn, of @ref{146,,gccjit;;rvalue}):
+@ref{178,,gccjit;;param}, which is a subclass of @ref{177,,gccjit;;lvalue}
+(and, in turn, of @ref{16e,,gccjit;;rvalue}):
 we can both read from and write to function parameters within the
 body of a function.
 @end enumerate
 
 Our new example has a new kind of expression: we have two local
 variables.  We create them by calling
-@ref{151,,gccjit;;function;;new_local()}, supplying a type and a name:
+@ref{179,,gccjit;;function;;new_local()}, supplying a type and a name:
 
 @example
 /* Build locals:  */
@@ -9903,7 +10521,7 @@ gccjit::lvalue i = func.new_local (the_type, "i");
 gccjit::lvalue sum = func.new_local (the_type, "sum");
 @end example
 
-These are instances of @ref{14f,,gccjit;;lvalue} - they can be read from
+These are instances of @ref{177,,gccjit;;lvalue} - they can be read from
 and written to.
 
 Note that there is no precanned way to create @emph{and} initialize a variable
@@ -9917,7 +10535,7 @@ Instead, having added the local to the function, we have to separately add
 an assignment of @cite{0} to @cite{local_i} at the beginning of the function.
 
 @node Control flow<2>,Visualizing the control flow graph<2>,Expressions lvalues and rvalues<2>,Tutorial part 3 Loops and variables<2>
-@anchor{cp/intro/tutorial03 control-flow}@anchor{152}
+@anchor{cp/intro/tutorial03 control-flow}@anchor{17a}
 @subsubsection Control flow
 
 
@@ -9940,8 +10558,8 @@ the body of the loop
 after the loop terminates (@cite{return sum})
 @end enumerate
 
-so we create these as @ref{153,,gccjit;;block} instances within the
-@ref{154,,gccjit;;function}:
+so we create these as @ref{17b,,gccjit;;block} instances within the
+@ref{17c,,gccjit;;function}:
 
 @example
 gccjit::block b_initial = func.new_block ("initial");
@@ -9954,8 +10572,8 @@ We now populate each block with statements.
 
 The entry block @cite{b_initial} consists of initializations followed by a jump
 to the conditional.  We assign @cite{0} to @cite{i} and to @cite{sum}, using
-@ref{155,,gccjit;;block;;add_assignment()} to add
-an assignment statement, and using @ref{156,,gccjit;;context;;zero()} to get
+@ref{17d,,gccjit;;block;;add_assignment()} to add
+an assignment statement, and using @ref{17e,,gccjit;;context;;zero()} to get
 the constant value @cite{0} for the relevant type for the right-hand side of
 the assignment:
 
@@ -9976,9 +10594,9 @@ b_initial.end_with_jump (b_loop_cond);
 The conditional block is equivalent to the line @cite{while (i < n)} from our
 C example. It contains a single statement: a conditional, which jumps to
 one of two destination blocks depending on a boolean
-@ref{146,,gccjit;;rvalue}, in this case the comparison of @cite{i} and @cite{n}.
+@ref{16e,,gccjit;;rvalue}, in this case the comparison of @cite{i} and @cite{n}.
 
-We could build the comparison using @ref{157,,gccjit;;context;;new_comparison()}:
+We could build the comparison using @ref{17f,,gccjit;;context;;new_comparison()}:
 
 @example
 gccjit::rvalue guard =
@@ -9987,7 +10605,7 @@ gccjit::rvalue guard =
 @end example
 
 and can then use this to add @cite{b_loop_cond}’s sole statement, via
-@ref{158,,gccjit;;block;;end_with_conditional()}:
+@ref{180,,gccjit;;block;;end_with_conditional()}:
 
 @example
 b_loop_cond.end_with_conditional (guard,
@@ -9995,7 +10613,7 @@ b_loop_cond.end_with_conditional (guard,
                                   b_loop_body); // on_false
 @end example
 
-However @ref{146,,gccjit;;rvalue} has overloaded operators for this, so we
+However @ref{16e,,gccjit;;rvalue} has overloaded operators for this, so we
 express the conditional as
 
 @example
@@ -10015,7 +10633,7 @@ Next, we populate the body of the loop.
 
 The C statement @cite{sum += i * i;} is an assignment operation, where an
 lvalue is modified “in-place”.  We use
-@ref{159,,gccjit;;block;;add_assignment_op()} to handle these operations:
+@ref{181,,gccjit;;block;;add_assignment_op()} to handle these operations:
 
 @example
 /* sum += i * i */
@@ -10039,7 +10657,7 @@ b_loop_body.add_assignment_op (i,
 @cartouche
 @quotation Note 
 For numeric constants other than 0 or 1, we could use
-@ref{15a,,gccjit;;context;;new_rvalue()}, which has overloads
+@ref{182,,gccjit;;context;;new_rvalue()}, which has overloads
 for both @code{int} and @code{double}.
 @end quotation
 @end cartouche
@@ -10105,12 +10723,12 @@ result: 285
 @end example
 
 @node Visualizing the control flow graph<2>,Full example<4>,Control flow<2>,Tutorial part 3 Loops and variables<2>
-@anchor{cp/intro/tutorial03 visualizing-the-control-flow-graph}@anchor{15b}
+@anchor{cp/intro/tutorial03 visualizing-the-control-flow-graph}@anchor{183}
 @subsubsection Visualizing the control flow graph
 
 
 You can see the control flow graph of a function using
-@ref{15c,,gccjit;;function;;dump_to_dot()}:
+@ref{184,,gccjit;;function;;dump_to_dot()}:
 
 @example
 func.dump_to_dot ("/tmp/sum-of-squares.dot");
@@ -10140,7 +10758,7 @@ install it with @cite{yum install python-xdot}):
 @end quotation
 
 @node Full example<4>,,Visualizing the control flow graph<2>,Tutorial part 3 Loops and variables<2>
-@anchor{cp/intro/tutorial03 full-example}@anchor{15d}
+@anchor{cp/intro/tutorial03 full-example}@anchor{185}
 @subsubsection Full example
 
 
@@ -10164,7 +10782,7 @@ General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
-<https://www.gnu.org/licenses/>.  */
+<http://www.gnu.org/licenses/>.  */
 
 #include <libgccjit++.h>
 
@@ -10318,7 +10936,7 @@ loop_test returned: 285
 @c <https://www.gnu.org/licenses/>.
 
 @node Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>,,Tutorial part 3 Loops and variables<2>,Tutorial<2>
-@anchor{cp/intro/tutorial04 doc}@anchor{15e}@anchor{cp/intro/tutorial04 tutorial-part-4-adding-jit-compilation-to-a-toy-interpreter}@anchor{15f}
+@anchor{cp/intro/tutorial04 doc}@anchor{186}@anchor{cp/intro/tutorial04 tutorial-part-4-adding-jit-compilation-to-a-toy-interpreter}@anchor{187}
 @subsection Tutorial part 4: Adding JIT-compilation to a toy interpreter
 
 
@@ -10340,7 +10958,7 @@ to it.
 @end menu
 
 @node Our toy interpreter<2>,Compiling to machine code<2>,,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>
-@anchor{cp/intro/tutorial04 our-toy-interpreter}@anchor{160}
+@anchor{cp/intro/tutorial04 our-toy-interpreter}@anchor{188}
 @subsubsection Our toy interpreter
 
 
@@ -10742,7 +11360,7 @@ toyvm_function::interpret (int arg, FILE *trace)
 @end quotation
 
 @node Compiling to machine code<2>,Setting things up<2>,Our toy interpreter<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>
-@anchor{cp/intro/tutorial04 compiling-to-machine-code}@anchor{161}
+@anchor{cp/intro/tutorial04 compiling-to-machine-code}@anchor{189}
 @subsubsection Compiling to machine code
 
 
@@ -10812,7 +11430,7 @@ This means our compiler has the following state:
 @end quotation
 
 @node Setting things up<2>,Populating the function<2>,Compiling to machine code<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>
-@anchor{cp/intro/tutorial04 setting-things-up}@anchor{162}
+@anchor{cp/intro/tutorial04 setting-things-up}@anchor{18a}
 @subsubsection Setting things up
 
 
@@ -10902,7 +11520,7 @@ compilation_state::add_pop (gccjit::block block,
 @end quotation
 
 We will support single-stepping through the generated code in the
-debugger, so we need to create @ref{163,,gccjit;;location} instances, one
+debugger, so we need to create @ref{18b,,gccjit;;location} instances, one
 per operation in the source code.  These will reference the lines of
 e.g. @code{factorial.toy}.
 
@@ -10962,7 +11580,7 @@ We create the locals within the function.
 @end quotation
 
 @node Populating the function<2>,Verifying the control flow graph<2>,Setting things up<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>
-@anchor{cp/intro/tutorial04 populating-the-function}@anchor{164}
+@anchor{cp/intro/tutorial04 populating-the-function}@anchor{18c}
 @subsubsection Populating the function
 
 
@@ -10986,7 +11604,7 @@ be consolidated into larger blocks when the optimizer runs.
 @example
   for (int pc = 0; pc < toyvmfn.fn_num_ops; pc++)
     @{
-      char buf[16];
+      char buf[100];
       sprintf (buf, "instr%i", pc);
       op_blocks[pc] = fn.new_block (buf);
     @}
@@ -11075,7 +11693,7 @@ stack into @code{y} instead erroneously assigned it to @code{x}, leaving @code{y
 uninitialized.
 
 To track this kind of thing down, we can use
-@ref{165,,gccjit;;block;;add_comment()} to add descriptive comments
+@ref{18d,,gccjit;;block;;add_comment()} to add descriptive comments
 to the internal representation.  This is invaluable when looking through
 the generated IR for, say @code{factorial}:
 
@@ -11215,14 +11833,14 @@ to the next block.
 This is analogous to simply incrementing the program counter.
 
 @node Verifying the control flow graph<2>,Compiling the context<2>,Populating the function<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>
-@anchor{cp/intro/tutorial04 verifying-the-control-flow-graph}@anchor{166}
+@anchor{cp/intro/tutorial04 verifying-the-control-flow-graph}@anchor{18e}
 @subsubsection Verifying the control flow graph
 
 
 Having finished looping over the blocks, the context is complete.
 
 As before, we can verify that the control flow and statements are sane by
-using @ref{15c,,gccjit;;function;;dump_to_dot()}:
+using @ref{184,,gccjit;;function;;dump_to_dot()}:
 
 @example
 fn.dump_to_dot ("/tmp/factorial.dot");
@@ -11244,7 +11862,7 @@ errors in our compiler.
 @end quotation
 
 @node Compiling the context<2>,Single-stepping through the generated code<2>,Verifying the control flow graph<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>
-@anchor{cp/intro/tutorial04 compiling-the-context}@anchor{167}
+@anchor{cp/intro/tutorial04 compiling-the-context}@anchor{18f}
 @subsubsection Compiling the context
 
 
@@ -11295,7 +11913,7 @@ private:
 @end quotation
 
 @node Single-stepping through the generated code<2>,Examining the generated code<2>,Compiling the context<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>
-@anchor{cp/intro/tutorial04 single-stepping-through-the-generated-code}@anchor{168}
+@anchor{cp/intro/tutorial04 single-stepping-through-the-generated-code}@anchor{190}
 @subsubsection Single-stepping through the generated code
 
 
@@ -11309,14 +11927,14 @@ It’s possible to debug the generated code.  To do this we need to both:
 @item 
 Set up source code locations for our statements, so that we can
 meaningfully step through the code.  We did this above by
-calling @ref{169,,gccjit;;context;;new_location()} and using the
+calling @ref{191,,gccjit;;context;;new_location()} and using the
 results.
 
 @item 
 Enable the generation of debugging information, by setting
 @ref{42,,GCC_JIT_BOOL_OPTION_DEBUGINFO} on the
-@ref{13d,,gccjit;;context} via
-@ref{149,,gccjit;;context;;set_bool_option()}:
+@ref{165,,gccjit;;context} via
+@ref{171,,gccjit;;context;;set_bool_option()}:
 
 @example
 ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DEBUGINFO, 1);
@@ -11380,14 +11998,14 @@ optimization level in a regular compiler.
 @end cartouche
 
 @node Examining the generated code<2>,Putting it all together<2>,Single-stepping through the generated code<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>
-@anchor{cp/intro/tutorial04 examining-the-generated-code}@anchor{16a}
+@anchor{cp/intro/tutorial04 examining-the-generated-code}@anchor{192}
 @subsubsection Examining the generated code
 
 
 How good is the optimized code?
 
 We can turn up optimizations, by calling
-@ref{14a,,gccjit;;context;;set_int_option()} with
+@ref{172,,gccjit;;context;;set_int_option()} with
 @ref{1f,,GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL}:
 
 @example
@@ -11555,7 +12173,7 @@ Note that the stack pushing and popping have been eliminated, as has the
 recursive call (in favor of an iteration).
 
 @node Putting it all together<2>,Behind the curtain How does our code get optimized?<2>,Examining the generated code<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>
-@anchor{cp/intro/tutorial04 putting-it-all-together}@anchor{16b}
+@anchor{cp/intro/tutorial04 putting-it-all-together}@anchor{193}
 @subsubsection Putting it all together
 
 
@@ -11586,7 +12204,7 @@ compiler result: 55
 @end example
 
 @node Behind the curtain How does our code get optimized?<2>,,Putting it all together<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>
-@anchor{cp/intro/tutorial04 behind-the-curtain-how-does-our-code-get-optimized}@anchor{16c}
+@anchor{cp/intro/tutorial04 behind-the-curtain-how-does-our-code-get-optimized}@anchor{194}
 @subsubsection Behind the curtain: How does our code get optimized?
 
 
@@ -11764,7 +12382,7 @@ instr9:
 @}
 @end example
 
-Note in the above how all the @ref{153,,gccjit;;block} instances we
+Note in the above how all the @ref{17b,,gccjit;;block} instances we
 created have been consolidated into just 3 blocks in GCC’s internal
 representation: @code{initial}, @code{instr4} and @code{instr9}.
 
@@ -11775,7 +12393,7 @@ representation: @code{initial}, @code{instr4} and @code{instr9}.
 @end menu
 
 @node Optimizing away stack manipulation<2>,Elimination of tail recursion<2>,,Behind the curtain How does our code get optimized?<2>
-@anchor{cp/intro/tutorial04 optimizing-away-stack-manipulation}@anchor{16d}
+@anchor{cp/intro/tutorial04 optimizing-away-stack-manipulation}@anchor{195}
 @subsubsection Optimizing away stack manipulation
 
 
@@ -12039,7 +12657,7 @@ instr9:
 @end example
 
 @node Elimination of tail recursion<2>,,Optimizing away stack manipulation<2>,Behind the curtain How does our code get optimized?<2>
-@anchor{cp/intro/tutorial04 elimination-of-tail-recursion}@anchor{16e}
+@anchor{cp/intro/tutorial04 elimination-of-tail-recursion}@anchor{196}
 @subsubsection Elimination of tail recursion
 
 
@@ -12122,7 +12740,7 @@ instr9:
 @c <https://www.gnu.org/licenses/>.
 
 @node Topic Reference<2>,,Tutorial<2>,C++ bindings for libgccjit
-@anchor{cp/topics/index doc}@anchor{16f}@anchor{cp/topics/index topic-reference}@anchor{170}
+@anchor{cp/topics/index doc}@anchor{197}@anchor{cp/topics/index topic-reference}@anchor{198}
 @section Topic Reference
 
 
@@ -12156,22 +12774,22 @@ instr9:
 @end menu
 
 @node Compilation contexts<2>,Objects<2>,,Topic Reference<2>
-@anchor{cp/topics/contexts doc}@anchor{171}@anchor{cp/topics/contexts compilation-contexts}@anchor{172}
+@anchor{cp/topics/contexts doc}@anchor{199}@anchor{cp/topics/contexts compilation-contexts}@anchor{19a}
 @subsection Compilation contexts
 
 
 @geindex gccjit;;context (C++ class)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7contextE}@anchor{13d}@anchor{cp/topics/contexts _CPPv3N6gccjit7contextE}@anchor{173}@anchor{cp/topics/contexts _CPPv2N6gccjit7contextE}@anchor{174}@anchor{cp/topics/contexts gccjit context}@anchor{175}
+@anchor{cp/topics/contexts _CPPv4N6gccjit7contextE}@anchor{165}@anchor{cp/topics/contexts _CPPv3N6gccjit7contextE}@anchor{19b}@anchor{cp/topics/contexts _CPPv2N6gccjit7contextE}@anchor{19c}@anchor{cp/topics/contexts gccjit context}@anchor{19d}
 @deffn {C++ Class} gccjit::context
 @end deffn
 
-The top-level of the C++ API is the @ref{13d,,gccjit;;context} type.
+The top-level of the C++ API is the @ref{165,,gccjit;;context} type.
 
-A @ref{13d,,gccjit;;context} instance encapsulates the state of a
+A @ref{165,,gccjit;;context} instance encapsulates the state of a
 compilation.
 
 You can set up options on it, and add types, functions and code.
-Invoking @ref{147,,gccjit;;context;;compile()} on it gives you a
+Invoking @ref{16f,,gccjit;;context;;compile()} on it gives you a
 @ref{16,,gcc_jit_result *}.
 
 It is a thin wrapper around the C API’s @ref{8,,gcc_jit_context *}.
@@ -12186,7 +12804,7 @@ It is a thin wrapper around the C API’s @ref{8,,gcc_jit_context *}.
 @end menu
 
 @node Lifetime-management<2>,Thread-safety<2>,,Compilation contexts<2>
-@anchor{cp/topics/contexts lifetime-management}@anchor{176}
+@anchor{cp/topics/contexts lifetime-management}@anchor{19e}
 @subsubsection Lifetime-management
 
 
@@ -12195,17 +12813,17 @@ have their lifetime bounded by the context they are created within, and
 cleanup of such objects is done for you when the context is released.
 
 @geindex gccjit;;context;;acquire (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context7acquireEv}@anchor{13e}@anchor{cp/topics/contexts _CPPv3N6gccjit7context7acquireEv}@anchor{177}@anchor{cp/topics/contexts _CPPv2N6gccjit7context7acquireEv}@anchor{178}@anchor{cp/topics/contexts gccjit context acquire}@anchor{179}
-@deffn {C++ Function} gccjit::@ref{13d,,context} gccjit::@ref{13d,,context}::acquire ()
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context7acquireEv}@anchor{166}@anchor{cp/topics/contexts _CPPv3N6gccjit7context7acquireEv}@anchor{19f}@anchor{cp/topics/contexts _CPPv2N6gccjit7context7acquireEv}@anchor{1a0}@anchor{cp/topics/contexts gccjit context acquire}@anchor{1a1}
+@deffn {C++ Function} gccjit::@ref{165,,context} gccjit::@ref{165,,context}::acquire ()
 
-This function acquires a new @ref{13d,,gccjit;;context} instance,
+This function acquires a new @ref{165,,gccjit;;context} instance,
 which is independent of any others that may be present within this
 process.
 @end deffn
 
 @geindex gccjit;;context;;release (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context7releaseEv}@anchor{141}@anchor{cp/topics/contexts _CPPv3N6gccjit7context7releaseEv}@anchor{17a}@anchor{cp/topics/contexts _CPPv2N6gccjit7context7releaseEv}@anchor{17b}@anchor{cp/topics/contexts gccjit context release}@anchor{17c}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::release ()
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context7releaseEv}@anchor{169}@anchor{cp/topics/contexts _CPPv3N6gccjit7context7releaseEv}@anchor{1a2}@anchor{cp/topics/contexts _CPPv2N6gccjit7context7releaseEv}@anchor{1a3}@anchor{cp/topics/contexts gccjit context release}@anchor{1a4}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::release ()
 
 This function releases all resources associated with the given context.
 Both the context itself and all of its @code{gccjit::object *}
@@ -12221,8 +12839,8 @@ ctxt.release ();
 @end deffn
 
 @geindex gccjit;;context;;new_child_context (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context17new_child_contextEv}@anchor{17d}@anchor{cp/topics/contexts _CPPv3N6gccjit7context17new_child_contextEv}@anchor{17e}@anchor{cp/topics/contexts _CPPv2N6gccjit7context17new_child_contextEv}@anchor{17f}@anchor{cp/topics/contexts gccjit context new_child_context}@anchor{180}
-@deffn {C++ Function} gccjit::@ref{13d,,context} gccjit::@ref{13d,,context}::new_child_context ()
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context17new_child_contextEv}@anchor{1a5}@anchor{cp/topics/contexts _CPPv3N6gccjit7context17new_child_contextEv}@anchor{1a6}@anchor{cp/topics/contexts _CPPv2N6gccjit7context17new_child_contextEv}@anchor{1a7}@anchor{cp/topics/contexts gccjit context new_child_context}@anchor{1a8}
+@deffn {C++ Function} gccjit::@ref{165,,context} gccjit::@ref{165,,context}::new_child_context ()
 
 Given an existing JIT context, create a child context.
 
@@ -12253,16 +12871,16 @@ there will likely be a performance hit for such nesting.
 @end deffn
 
 @node Thread-safety<2>,Error-handling<3>,Lifetime-management<2>,Compilation contexts<2>
-@anchor{cp/topics/contexts thread-safety}@anchor{181}
+@anchor{cp/topics/contexts thread-safety}@anchor{1a9}
 @subsubsection Thread-safety
 
 
-Instances of @ref{13d,,gccjit;;context} created via
-@ref{13e,,gccjit;;context;;acquire()} are independent from each other:
+Instances of @ref{165,,gccjit;;context} created via
+@ref{166,,gccjit;;context;;acquire()} are independent from each other:
 only one thread may use a given context at once, but multiple threads
 could each have their own contexts without needing locks.
 
-Contexts created via @ref{17d,,gccjit;;context;;new_child_context()} are
+Contexts created via @ref{1a5,,gccjit;;context;;new_child_context()} are
 related to their parent context.  They can be partitioned by their
 ultimate ancestor into independent “family trees”.   Only one thread
 within a process may use a given “family tree” of such contexts at once,
@@ -12270,7 +12888,7 @@ and if you’re using multiple threads you should provide your own locking
 around entire such context partitions.
 
 @node Error-handling<3>,Debugging<2>,Thread-safety<2>,Compilation contexts<2>
-@anchor{cp/topics/contexts error-handling}@anchor{182}
+@anchor{cp/topics/contexts error-handling}@anchor{1aa}
 @subsubsection Error-handling
 
 
@@ -12283,11 +12901,11 @@ NULL.  You don’t have to check everywhere for NULL results, since the
 API gracefully handles a NULL being passed in for any argument.
 
 Errors are printed on stderr and can be queried using
-@ref{183,,gccjit;;context;;get_first_error()}.
+@ref{1ab,,gccjit;;context;;get_first_error()}.
 
 @geindex gccjit;;context;;get_first_error (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{183}@anchor{cp/topics/contexts _CPPv3N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{184}@anchor{cp/topics/contexts _CPPv2N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{185}@anchor{cp/topics/contexts gccjit context get_first_error__gccjit contextP}@anchor{186}
-@deffn {C++ Function} const char *gccjit::@ref{13d,,context}::get_first_error (gccjit::context *ctxt)
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{1ab}@anchor{cp/topics/contexts _CPPv3N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{1ac}@anchor{cp/topics/contexts _CPPv2N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{1ad}@anchor{cp/topics/contexts gccjit context get_first_error__gccjit contextP}@anchor{1ae}
+@deffn {C++ Function} const char *gccjit::@ref{165,,context}::get_first_error (gccjit::context *ctxt)
 
 Returns the first error message that occurred on the context.
 
@@ -12298,18 +12916,18 @@ If no errors occurred, this will be NULL.
 @end deffn
 
 @node Debugging<2>,Options<4>,Error-handling<3>,Compilation contexts<2>
-@anchor{cp/topics/contexts debugging}@anchor{187}
+@anchor{cp/topics/contexts debugging}@anchor{1af}
 @subsubsection Debugging
 
 
 @geindex gccjit;;context;;dump_to_file (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{188}@anchor{cp/topics/contexts _CPPv3N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{189}@anchor{cp/topics/contexts _CPPv2N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{18a}@anchor{cp/topics/contexts gccjit context dump_to_file__ssCR i}@anchor{18b}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::dump_to_file (const std::string &path, int update_locations)
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{1b0}@anchor{cp/topics/contexts _CPPv3N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{1b1}@anchor{cp/topics/contexts _CPPv2N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{1b2}@anchor{cp/topics/contexts gccjit context dump_to_file__ssCR i}@anchor{1b3}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::dump_to_file (const std::string &path, int update_locations)
 
 To help with debugging: dump a C-like representation to the given path,
 describing what’s been set up on the context.
 
-If “update_locations” is true, then also set up @ref{163,,gccjit;;location}
+If “update_locations” is true, then also set up @ref{18b,,gccjit;;location}
 information throughout the context, pointing at the dump file as if it
 were a source file.  This may be of use in conjunction with
 @code{GCCJIT::BOOL_OPTION_DEBUGINFO} to allow stepping through the
@@ -12317,8 +12935,8 @@ code in a debugger.
 @end deffn
 
 @geindex gccjit;;context;;dump_reproducer_to_file (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{18c}@anchor{cp/topics/contexts _CPPv3N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{18d}@anchor{cp/topics/contexts _CPPv2N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{18e}@anchor{cp/topics/contexts gccjit context dump_reproducer_to_file__gcc_jit_contextP cCP}@anchor{18f}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::dump_reproducer_to_file (gcc_jit_context *ctxt, const char *path)
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{1b4}@anchor{cp/topics/contexts _CPPv3N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{1b5}@anchor{cp/topics/contexts _CPPv2N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{1b6}@anchor{cp/topics/contexts gccjit context dump_reproducer_to_file__gcc_jit_contextP cCP}@anchor{1b7}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::dump_reproducer_to_file (gcc_jit_context *ctxt, const char *path)
 
 This is a thin wrapper around the C API
 @ref{5d,,gcc_jit_context_dump_reproducer_to_file()}, and hence works the
@@ -12329,7 +12947,7 @@ for seeing what the C++ bindings are doing at the C level.
 @end deffn
 
 @node Options<4>,,Debugging<2>,Compilation contexts<2>
-@anchor{cp/topics/contexts options}@anchor{190}
+@anchor{cp/topics/contexts options}@anchor{1b8}
 @subsubsection Options
 
 
@@ -12342,13 +12960,13 @@ for seeing what the C++ bindings are doing at the C level.
 @end menu
 
 @node String Options<2>,Boolean options<2>,,Options<4>
-@anchor{cp/topics/contexts string-options}@anchor{191}
+@anchor{cp/topics/contexts string-options}@anchor{1b9}
 @subsubsection String Options
 
 
 @geindex gccjit;;context;;set_str_option (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{192}@anchor{cp/topics/contexts _CPPv3N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{193}@anchor{cp/topics/contexts _CPPv2N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{194}@anchor{cp/topics/contexts gccjit context set_str_option__gcc_jit_str_option cCP}@anchor{195}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::set_str_option (enum gcc_jit_str_option, const char *value)
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{1ba}@anchor{cp/topics/contexts _CPPv3N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{1bb}@anchor{cp/topics/contexts _CPPv2N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{1bc}@anchor{cp/topics/contexts gccjit context set_str_option__gcc_jit_str_option cCP}@anchor{1bd}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::set_str_option (enum gcc_jit_str_option, const char *value)
 
 Set a string option of the context.
 
@@ -12358,13 +12976,13 @@ meaning.
 @end deffn
 
 @node Boolean options<2>,Integer options<2>,String Options<2>,Options<4>
-@anchor{cp/topics/contexts boolean-options}@anchor{196}
+@anchor{cp/topics/contexts boolean-options}@anchor{1be}
 @subsubsection Boolean options
 
 
 @geindex gccjit;;context;;set_bool_option (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{149}@anchor{cp/topics/contexts _CPPv3N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{197}@anchor{cp/topics/contexts _CPPv2N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{198}@anchor{cp/topics/contexts gccjit context set_bool_option__gcc_jit_bool_option i}@anchor{199}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::set_bool_option (enum gcc_jit_bool_option, int value)
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{171}@anchor{cp/topics/contexts _CPPv3N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{1bf}@anchor{cp/topics/contexts _CPPv2N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{1c0}@anchor{cp/topics/contexts gccjit context set_bool_option__gcc_jit_bool_option i}@anchor{1c1}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::set_bool_option (enum gcc_jit_bool_option, int value)
 
 Set a boolean option of the context.
 
@@ -12374,8 +12992,8 @@ meaning.
 @end deffn
 
 @geindex gccjit;;context;;set_bool_allow_unreachable_blocks (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{19a}@anchor{cp/topics/contexts _CPPv3N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{19b}@anchor{cp/topics/contexts _CPPv2N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{19c}@anchor{cp/topics/contexts gccjit context set_bool_allow_unreachable_blocks__i}@anchor{19d}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::set_bool_allow_unreachable_blocks (int bool_value)
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{1c2}@anchor{cp/topics/contexts _CPPv3N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{1c3}@anchor{cp/topics/contexts _CPPv2N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{1c4}@anchor{cp/topics/contexts gccjit context set_bool_allow_unreachable_blocks__i}@anchor{1c5}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::set_bool_allow_unreachable_blocks (int bool_value)
 
 By default, libgccjit will issue an error about unreachable blocks
 within a function.
@@ -12393,8 +13011,8 @@ its presence using
 @end deffn
 
 @geindex gccjit;;context;;set_bool_use_external_driver (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context28set_bool_use_external_driverEi}@anchor{19e}@anchor{cp/topics/contexts _CPPv3N6gccjit7context28set_bool_use_external_driverEi}@anchor{19f}@anchor{cp/topics/contexts _CPPv2N6gccjit7context28set_bool_use_external_driverEi}@anchor{1a0}@anchor{cp/topics/contexts gccjit context set_bool_use_external_driver__i}@anchor{1a1}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::set_bool_use_external_driver (int bool_value)
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context28set_bool_use_external_driverEi}@anchor{1c6}@anchor{cp/topics/contexts _CPPv3N6gccjit7context28set_bool_use_external_driverEi}@anchor{1c7}@anchor{cp/topics/contexts _CPPv2N6gccjit7context28set_bool_use_external_driverEi}@anchor{1c8}@anchor{cp/topics/contexts gccjit context set_bool_use_external_driver__i}@anchor{1c9}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::set_bool_use_external_driver (int bool_value)
 
 libgccjit internally generates assembler, and uses “driver” code
 for converting it to other formats (e.g. shared libraries).
@@ -12415,13 +13033,13 @@ its presence using
 @end deffn
 
 @node Integer options<2>,Additional command-line options<2>,Boolean options<2>,Options<4>
-@anchor{cp/topics/contexts integer-options}@anchor{1a2}
+@anchor{cp/topics/contexts integer-options}@anchor{1ca}
 @subsubsection Integer options
 
 
 @geindex gccjit;;context;;set_int_option (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{14a}@anchor{cp/topics/contexts _CPPv3N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{1a3}@anchor{cp/topics/contexts _CPPv2N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{1a4}@anchor{cp/topics/contexts gccjit context set_int_option__gcc_jit_int_option i}@anchor{1a5}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::set_int_option (enum gcc_jit_int_option, int value)
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{172}@anchor{cp/topics/contexts _CPPv3N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{1cb}@anchor{cp/topics/contexts _CPPv2N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{1cc}@anchor{cp/topics/contexts gccjit context set_int_option__gcc_jit_int_option i}@anchor{1cd}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::set_int_option (enum gcc_jit_int_option, int value)
 
 Set an integer option of the context.
 
@@ -12431,13 +13049,13 @@ meaning.
 @end deffn
 
 @node Additional command-line options<2>,,Integer options<2>,Options<4>
-@anchor{cp/topics/contexts additional-command-line-options}@anchor{1a6}
+@anchor{cp/topics/contexts additional-command-line-options}@anchor{1ce}
 @subsubsection Additional command-line options
 
 
 @geindex gccjit;;context;;add_command_line_option (C++ function)
-@anchor{cp/topics/contexts _CPPv4N6gccjit7context23add_command_line_optionEPKc}@anchor{1a7}@anchor{cp/topics/contexts _CPPv3N6gccjit7context23add_command_line_optionEPKc}@anchor{1a8}@anchor{cp/topics/contexts _CPPv2N6gccjit7context23add_command_line_optionEPKc}@anchor{1a9}@anchor{cp/topics/contexts gccjit context add_command_line_option__cCP}@anchor{1aa}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::add_command_line_option (const char *optname)
+@anchor{cp/topics/contexts _CPPv4N6gccjit7context23add_command_line_optionEPKc}@anchor{1cf}@anchor{cp/topics/contexts _CPPv3N6gccjit7context23add_command_line_optionEPKc}@anchor{1d0}@anchor{cp/topics/contexts _CPPv2N6gccjit7context23add_command_line_optionEPKc}@anchor{1d1}@anchor{cp/topics/contexts gccjit context add_command_line_option__cCP}@anchor{1d2}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::add_command_line_option (const char *optname)
 
 Add an arbitrary gcc command-line option to the context for use
 when compiling.
@@ -12471,18 +13089,18 @@ its presence using
 @c <https://www.gnu.org/licenses/>.
 
 @node Objects<2>,Types<2>,Compilation contexts<2>,Topic Reference<2>
-@anchor{cp/topics/objects doc}@anchor{1ab}@anchor{cp/topics/objects objects}@anchor{1ac}
+@anchor{cp/topics/objects doc}@anchor{1d3}@anchor{cp/topics/objects objects}@anchor{1d4}
 @subsection Objects
 
 
 @geindex gccjit;;object (C++ class)
-@anchor{cp/topics/objects _CPPv4N6gccjit6objectE}@anchor{142}@anchor{cp/topics/objects _CPPv3N6gccjit6objectE}@anchor{1ad}@anchor{cp/topics/objects _CPPv2N6gccjit6objectE}@anchor{1ae}@anchor{cp/topics/objects gccjit object}@anchor{1af}
+@anchor{cp/topics/objects _CPPv4N6gccjit6objectE}@anchor{16a}@anchor{cp/topics/objects _CPPv3N6gccjit6objectE}@anchor{1d5}@anchor{cp/topics/objects _CPPv2N6gccjit6objectE}@anchor{1d6}@anchor{cp/topics/objects gccjit object}@anchor{1d7}
 @deffn {C++ Class} gccjit::object
 @end deffn
 
 Almost every entity in the API (with the exception of
-@ref{13d,,gccjit;;context} and @ref{16,,gcc_jit_result *}) is a
-“contextual” object, a @ref{142,,gccjit;;object}.
+@ref{165,,gccjit;;context} and @ref{16,,gcc_jit_result *}) is a
+“contextual” object, a @ref{16a,,gccjit;;object}.
 
 A JIT object:
 
@@ -12492,7 +13110,7 @@ A JIT object:
 @itemize *
 
 @item 
-is associated with a @ref{13d,,gccjit;;context}.
+is associated with a @ref{165,,gccjit;;context}.
 
 @item 
 is automatically cleaned up for you when its context is released so
@@ -12517,18 +13135,18 @@ The C++ class hierarchy within the @code{gccjit} namespace looks like this:
     +- case_
 @end example
 
-The @ref{142,,gccjit;;object} base class has the following operations:
+The @ref{16a,,gccjit;;object} base class has the following operations:
 
 @geindex gccjit;;object;;get_context (C++ function)
-@anchor{cp/topics/objects _CPPv4NK6gccjit6object11get_contextEv}@anchor{1b0}@anchor{cp/topics/objects _CPPv3NK6gccjit6object11get_contextEv}@anchor{1b1}@anchor{cp/topics/objects _CPPv2NK6gccjit6object11get_contextEv}@anchor{1b2}@anchor{cp/topics/objects gccjit object get_contextC}@anchor{1b3}
-@deffn {C++ Function} gccjit::@ref{13d,,context} gccjit::@ref{142,,object}::get_context () const
+@anchor{cp/topics/objects _CPPv4NK6gccjit6object11get_contextEv}@anchor{1d8}@anchor{cp/topics/objects _CPPv3NK6gccjit6object11get_contextEv}@anchor{1d9}@anchor{cp/topics/objects _CPPv2NK6gccjit6object11get_contextEv}@anchor{1da}@anchor{cp/topics/objects gccjit object get_contextC}@anchor{1db}
+@deffn {C++ Function} gccjit::@ref{165,,context} gccjit::@ref{16a,,object}::get_context () const
 
 Which context is the obj within?
 @end deffn
 
 @geindex gccjit;;object;;get_debug_string (C++ function)
-@anchor{cp/topics/objects _CPPv4NK6gccjit6object16get_debug_stringEv}@anchor{143}@anchor{cp/topics/objects _CPPv3NK6gccjit6object16get_debug_stringEv}@anchor{1b4}@anchor{cp/topics/objects _CPPv2NK6gccjit6object16get_debug_stringEv}@anchor{1b5}@anchor{cp/topics/objects gccjit object get_debug_stringC}@anchor{1b6}
-@deffn {C++ Function} std::string gccjit::@ref{142,,object}::get_debug_string () const
+@anchor{cp/topics/objects _CPPv4NK6gccjit6object16get_debug_stringEv}@anchor{16b}@anchor{cp/topics/objects _CPPv3NK6gccjit6object16get_debug_stringEv}@anchor{1dc}@anchor{cp/topics/objects _CPPv2NK6gccjit6object16get_debug_stringEv}@anchor{1dd}@anchor{cp/topics/objects gccjit object get_debug_stringC}@anchor{1de}
+@deffn {C++ Function} std::string gccjit::@ref{16a,,object}::get_debug_string () const
 
 Generate a human-readable description for the given object.
 
@@ -12563,16 +13181,16 @@ obj: 4.0 * (float)i
 @c <https://www.gnu.org/licenses/>.
 
 @node Types<2>,Expressions<2>,Objects<2>,Topic Reference<2>
-@anchor{cp/topics/types doc}@anchor{1b7}@anchor{cp/topics/types types}@anchor{1b8}
+@anchor{cp/topics/types doc}@anchor{1df}@anchor{cp/topics/types types}@anchor{1e0}
 @subsection Types
 
 
 @geindex gccjit;;type (C++ class)
-@anchor{cp/topics/types _CPPv4N6gccjit4typeE}@anchor{13f}@anchor{cp/topics/types _CPPv3N6gccjit4typeE}@anchor{1b9}@anchor{cp/topics/types _CPPv2N6gccjit4typeE}@anchor{1ba}@anchor{cp/topics/types gccjit type}@anchor{1bb}
+@anchor{cp/topics/types _CPPv4N6gccjit4typeE}@anchor{167}@anchor{cp/topics/types _CPPv3N6gccjit4typeE}@anchor{1e1}@anchor{cp/topics/types _CPPv2N6gccjit4typeE}@anchor{1e2}@anchor{cp/topics/types gccjit type}@anchor{1e3}
 @deffn {C++ Class} gccjit::type
 
 gccjit::type represents a type within the library.  It is a subclass
-of @ref{142,,gccjit;;object}.
+of @ref{16a,,gccjit;;object}.
 @end deffn
 
 Types can be created in several ways:
@@ -12582,7 +13200,7 @@ Types can be created in several ways:
 
 @item 
 fundamental types can be accessed using
-@ref{140,,gccjit;;context;;get_type()}:
+@ref{168,,gccjit;;context;;get_type()}:
 
 @example
 gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);
@@ -12598,7 +13216,7 @@ See @ref{b,,gcc_jit_context_get_type()} for the available types.
 
 @item 
 derived types can be accessed by using functions such as
-@ref{1bc,,gccjit;;type;;get_pointer()} and @ref{1bd,,gccjit;;type;;get_const()}:
+@ref{1e4,,gccjit;;type;;get_pointer()} and @ref{1e5,,gccjit;;type;;get_const()}:
 
 @example
 gccjit::type const_int_star = int_type.get_const ().get_pointer ();
@@ -12618,28 +13236,28 @@ by creating structures (see below).
 @end menu
 
 @node Standard types<2>,Pointers const and volatile<2>,,Types<2>
-@anchor{cp/topics/types standard-types}@anchor{1be}
+@anchor{cp/topics/types standard-types}@anchor{1e6}
 @subsubsection Standard types
 
 
 @geindex gccjit;;context;;get_type (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit7context8get_typeE13gcc_jit_types}@anchor{140}@anchor{cp/topics/types _CPPv3N6gccjit7context8get_typeE13gcc_jit_types}@anchor{1bf}@anchor{cp/topics/types _CPPv2N6gccjit7context8get_typeE13gcc_jit_types}@anchor{1c0}@anchor{cp/topics/types gccjit context get_type__gcc_jit_types}@anchor{1c1}
-@deffn {C++ Function} gccjit::@ref{13f,,type} gccjit::@ref{13d,,context}::get_type (enum gcc_jit_types)
+@anchor{cp/topics/types _CPPv4N6gccjit7context8get_typeE13gcc_jit_types}@anchor{168}@anchor{cp/topics/types _CPPv3N6gccjit7context8get_typeE13gcc_jit_types}@anchor{1e7}@anchor{cp/topics/types _CPPv2N6gccjit7context8get_typeE13gcc_jit_types}@anchor{1e8}@anchor{cp/topics/types gccjit context get_type__gcc_jit_types}@anchor{1e9}
+@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{165,,context}::get_type (enum gcc_jit_types)
 
 Access a specific type.  This is a thin wrapper around
 @ref{b,,gcc_jit_context_get_type()}; the parameter has the same meaning.
 @end deffn
 
 @geindex gccjit;;context;;get_int_type (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit7context12get_int_typeE6size_ti}@anchor{1c2}@anchor{cp/topics/types _CPPv3N6gccjit7context12get_int_typeE6size_ti}@anchor{1c3}@anchor{cp/topics/types _CPPv2N6gccjit7context12get_int_typeE6size_ti}@anchor{1c4}@anchor{cp/topics/types gccjit context get_int_type__s i}@anchor{1c5}
-@deffn {C++ Function} gccjit::@ref{13f,,type} gccjit::@ref{13d,,context}::get_int_type (size_t num_bytes, int is_signed)
+@anchor{cp/topics/types _CPPv4N6gccjit7context12get_int_typeE6size_ti}@anchor{1ea}@anchor{cp/topics/types _CPPv3N6gccjit7context12get_int_typeE6size_ti}@anchor{1eb}@anchor{cp/topics/types _CPPv2N6gccjit7context12get_int_typeE6size_ti}@anchor{1ec}@anchor{cp/topics/types gccjit context get_int_type__s i}@anchor{1ed}
+@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{165,,context}::get_int_type (size_t num_bytes, int is_signed)
 
 Access the integer type of the given size.
 @end deffn
 
 @geindex gccjit;;context;;get_int_type<T> (C++ function)
-@anchor{cp/topics/types _CPPv4IEN6gccjit7context12get_int_typeI1TEEN6gccjit4typeEv}@anchor{1c6}@anchor{cp/topics/types _CPPv3IEN6gccjit7context12get_int_typeI1TEEv}@anchor{1c7}@anchor{cp/topics/types _CPPv2IEN6gccjit7context12get_int_typeI1TEEv}@anchor{1c8}
-@deffn {C++ Function} template<>gccjit::@ref{13f,,type} gccjit::@ref{13d,,context}::get_int_type<T> ()
+@anchor{cp/topics/types _CPPv4IEN6gccjit7context12get_int_typeI1TEEN6gccjit4typeEv}@anchor{1ee}@anchor{cp/topics/types _CPPv3IEN6gccjit7context12get_int_typeI1TEEv}@anchor{1ef}@anchor{cp/topics/types _CPPv2IEN6gccjit7context12get_int_typeI1TEEv}@anchor{1f0}
+@deffn {C++ Function} template<>gccjit::@ref{167,,type} gccjit::@ref{165,,context}::get_int_type<T> ()
 
 Access the given integer type.  For example, you could map the
 @code{unsigned short} type into a gccjit::type via:
@@ -12650,34 +13268,34 @@ gccjit::type t = ctxt.get_int_type <unsigned short> ();
 @end deffn
 
 @node Pointers const and volatile<2>,Vector types<2>,Standard types<2>,Types<2>
-@anchor{cp/topics/types pointers-const-and-volatile}@anchor{1c9}
+@anchor{cp/topics/types pointers-const-and-volatile}@anchor{1f1}
 @subsubsection Pointers, @cite{const}, and @cite{volatile}
 
 
 @geindex gccjit;;type;;get_pointer (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit4type11get_pointerEv}@anchor{1bc}@anchor{cp/topics/types _CPPv3N6gccjit4type11get_pointerEv}@anchor{1ca}@anchor{cp/topics/types _CPPv2N6gccjit4type11get_pointerEv}@anchor{1cb}@anchor{cp/topics/types gccjit type get_pointer}@anchor{1cc}
-@deffn {C++ Function} gccjit::@ref{13f,,type} gccjit::@ref{13f,,type}::get_pointer ()
+@anchor{cp/topics/types _CPPv4N6gccjit4type11get_pointerEv}@anchor{1e4}@anchor{cp/topics/types _CPPv3N6gccjit4type11get_pointerEv}@anchor{1f2}@anchor{cp/topics/types _CPPv2N6gccjit4type11get_pointerEv}@anchor{1f3}@anchor{cp/topics/types gccjit type get_pointer}@anchor{1f4}
+@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{167,,type}::get_pointer ()
 
 Given type “T”, get type “T*”.
 @end deffn
 
 @geindex gccjit;;type;;get_const (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit4type9get_constEv}@anchor{1bd}@anchor{cp/topics/types _CPPv3N6gccjit4type9get_constEv}@anchor{1cd}@anchor{cp/topics/types _CPPv2N6gccjit4type9get_constEv}@anchor{1ce}@anchor{cp/topics/types gccjit type get_const}@anchor{1cf}
-@deffn {C++ Function} gccjit::@ref{13f,,type} gccjit::@ref{13f,,type}::get_const ()
+@anchor{cp/topics/types _CPPv4N6gccjit4type9get_constEv}@anchor{1e5}@anchor{cp/topics/types _CPPv3N6gccjit4type9get_constEv}@anchor{1f5}@anchor{cp/topics/types _CPPv2N6gccjit4type9get_constEv}@anchor{1f6}@anchor{cp/topics/types gccjit type get_const}@anchor{1f7}
+@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{167,,type}::get_const ()
 
 Given type “T”, get type “const T”.
 @end deffn
 
 @geindex gccjit;;type;;get_volatile (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit4type12get_volatileEv}@anchor{1d0}@anchor{cp/topics/types _CPPv3N6gccjit4type12get_volatileEv}@anchor{1d1}@anchor{cp/topics/types _CPPv2N6gccjit4type12get_volatileEv}@anchor{1d2}@anchor{cp/topics/types gccjit type get_volatile}@anchor{1d3}
-@deffn {C++ Function} gccjit::@ref{13f,,type} gccjit::@ref{13f,,type}::get_volatile ()
+@anchor{cp/topics/types _CPPv4N6gccjit4type12get_volatileEv}@anchor{1f8}@anchor{cp/topics/types _CPPv3N6gccjit4type12get_volatileEv}@anchor{1f9}@anchor{cp/topics/types _CPPv2N6gccjit4type12get_volatileEv}@anchor{1fa}@anchor{cp/topics/types gccjit type get_volatile}@anchor{1fb}
+@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{167,,type}::get_volatile ()
 
 Given type “T”, get type “volatile T”.
 @end deffn
 
 @geindex gccjit;;type;;get_aligned (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit4type11get_alignedE6size_t}@anchor{1d4}@anchor{cp/topics/types _CPPv3N6gccjit4type11get_alignedE6size_t}@anchor{1d5}@anchor{cp/topics/types _CPPv2N6gccjit4type11get_alignedE6size_t}@anchor{1d6}@anchor{cp/topics/types gccjit type get_aligned__s}@anchor{1d7}
-@deffn {C++ Function} gccjit::@ref{13f,,type} gccjit::@ref{13f,,type}::get_aligned (size_t alignment_in_bytes)
+@anchor{cp/topics/types _CPPv4N6gccjit4type11get_alignedE6size_t}@anchor{1fc}@anchor{cp/topics/types _CPPv3N6gccjit4type11get_alignedE6size_t}@anchor{1fd}@anchor{cp/topics/types _CPPv2N6gccjit4type11get_alignedE6size_t}@anchor{1fe}@anchor{cp/topics/types gccjit type get_aligned__s}@anchor{1ff}
+@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{167,,type}::get_aligned (size_t alignment_in_bytes)
 
 Given type “T”, get type:
 
@@ -12689,21 +13307,21 @@ The alignment must be a power of two.
 @end deffn
 
 @geindex gccjit;;context;;new_array_type (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{1d8}@anchor{cp/topics/types _CPPv3N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{1d9}@anchor{cp/topics/types _CPPv2N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{1da}@anchor{cp/topics/types gccjit context new_array_type__gccjit type i gccjit location}@anchor{1db}
-@deffn {C++ Function} gccjit::@ref{13f,,type} gccjit::@ref{13d,,context}::new_array_type (gccjit::type element_type, int num_elements, gccjit::location loc)
+@anchor{cp/topics/types _CPPv4N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{200}@anchor{cp/topics/types _CPPv3N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{201}@anchor{cp/topics/types _CPPv2N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{202}@anchor{cp/topics/types gccjit context new_array_type__gccjit type i gccjit location}@anchor{203}
+@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{165,,context}::new_array_type (gccjit::type element_type, int num_elements, gccjit::location loc)
 
 Given type “T”, get type “T[N]” (for a constant N).
 Param “loc” is optional.
 @end deffn
 
 @node Vector types<2>,Structures and unions<2>,Pointers const and volatile<2>,Types<2>
-@anchor{cp/topics/types vector-types}@anchor{1dc}
+@anchor{cp/topics/types vector-types}@anchor{204}
 @subsubsection Vector types
 
 
 @geindex gccjit;;type;;get_vector (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit4type10get_vectorE6size_t}@anchor{1dd}@anchor{cp/topics/types _CPPv3N6gccjit4type10get_vectorE6size_t}@anchor{1de}@anchor{cp/topics/types _CPPv2N6gccjit4type10get_vectorE6size_t}@anchor{1df}@anchor{cp/topics/types gccjit type get_vector__s}@anchor{1e0}
-@deffn {C++ Function} gccjit::@ref{13f,,type} gccjit::@ref{13f,,type}::get_vector (size_t num_units)
+@anchor{cp/topics/types _CPPv4N6gccjit4type10get_vectorE6size_t}@anchor{205}@anchor{cp/topics/types _CPPv3N6gccjit4type10get_vectorE6size_t}@anchor{206}@anchor{cp/topics/types _CPPv2N6gccjit4type10get_vectorE6size_t}@anchor{207}@anchor{cp/topics/types gccjit type get_vector__s}@anchor{208}
+@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{167,,type}::get_vector (size_t num_units)
 
 Given type “T”, get type:
 
@@ -12715,31 +13333,31 @@ T must be integral or floating point; num_units must be a power of two.
 @end deffn
 
 @node Structures and unions<2>,,Vector types<2>,Types<2>
-@anchor{cp/topics/types structures-and-unions}@anchor{1e1}
+@anchor{cp/topics/types structures-and-unions}@anchor{209}
 @subsubsection Structures and unions
 
 
 @geindex gccjit;;struct_ (C++ class)
-@anchor{cp/topics/types _CPPv4N6gccjit7struct_E}@anchor{1e2}@anchor{cp/topics/types _CPPv3N6gccjit7struct_E}@anchor{1e3}@anchor{cp/topics/types _CPPv2N6gccjit7struct_E}@anchor{1e4}@anchor{cp/topics/types gccjit struct_}@anchor{1e5}
+@anchor{cp/topics/types _CPPv4N6gccjit7struct_E}@anchor{20a}@anchor{cp/topics/types _CPPv3N6gccjit7struct_E}@anchor{20b}@anchor{cp/topics/types _CPPv2N6gccjit7struct_E}@anchor{20c}@anchor{cp/topics/types gccjit struct_}@anchor{20d}
 @deffn {C++ Class} gccjit::struct_
 @end deffn
 
 A compound type analagous to a C @cite{struct}.
 
-@ref{1e2,,gccjit;;struct_} is a subclass of @ref{13f,,gccjit;;type} (and thus
-of @ref{142,,gccjit;;object} in turn).
+@ref{20a,,gccjit;;struct_} is a subclass of @ref{167,,gccjit;;type} (and thus
+of @ref{16a,,gccjit;;object} in turn).
 
 @geindex gccjit;;field (C++ class)
-@anchor{cp/topics/types _CPPv4N6gccjit5fieldE}@anchor{1e6}@anchor{cp/topics/types _CPPv3N6gccjit5fieldE}@anchor{1e7}@anchor{cp/topics/types _CPPv2N6gccjit5fieldE}@anchor{1e8}@anchor{cp/topics/types gccjit field}@anchor{1e9}
+@anchor{cp/topics/types _CPPv4N6gccjit5fieldE}@anchor{20e}@anchor{cp/topics/types _CPPv3N6gccjit5fieldE}@anchor{20f}@anchor{cp/topics/types _CPPv2N6gccjit5fieldE}@anchor{210}@anchor{cp/topics/types gccjit field}@anchor{211}
 @deffn {C++ Class} gccjit::field
 @end deffn
 
-A field within a @ref{1e2,,gccjit;;struct_}.
+A field within a @ref{20a,,gccjit;;struct_}.
 
-@ref{1e6,,gccjit;;field} is a subclass of @ref{142,,gccjit;;object}.
+@ref{20e,,gccjit;;field} is a subclass of @ref{16a,,gccjit;;object}.
 
-You can model C @cite{struct} types by creating @ref{1e2,,gccjit;;struct_} and
-@ref{1e6,,gccjit;;field} instances, in either order:
+You can model C @cite{struct} types by creating @ref{20a,,gccjit;;struct_} and
+@ref{20e,,gccjit;;field} instances, in either order:
 
 
 @itemize *
@@ -12787,15 +13405,15 @@ node.set_fields (fields);
 @c FIXME: the above API doesn't seem to exist yet
 
 @geindex gccjit;;context;;new_field (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{1ea}@anchor{cp/topics/types _CPPv3N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{1eb}@anchor{cp/topics/types _CPPv2N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{1ec}@anchor{cp/topics/types gccjit context new_field__gccjit type cCP gccjit location}@anchor{1ed}
-@deffn {C++ Function} gccjit::@ref{1e6,,field} gccjit::@ref{13d,,context}::new_field (gccjit::type type, const char *name, gccjit::location loc)
+@anchor{cp/topics/types _CPPv4N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{212}@anchor{cp/topics/types _CPPv3N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{213}@anchor{cp/topics/types _CPPv2N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{214}@anchor{cp/topics/types gccjit context new_field__gccjit type cCP gccjit location}@anchor{215}
+@deffn {C++ Function} gccjit::@ref{20e,,field} gccjit::@ref{165,,context}::new_field (gccjit::type type, const char *name, gccjit::location loc)
 
 Construct a new field, with the given type and name.
 @end deffn
 
 @geindex gccjit;;context;;new_struct_type (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{1ee}@anchor{cp/topics/types _CPPv3N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{1ef}@anchor{cp/topics/types _CPPv2N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{1f0}@anchor{cp/topics/types gccjit context new_struct_type__ssCR std vector field R gccjit location}@anchor{1f1}
-@deffn {C++ Function} gccjit::@ref{1e2,,struct_} gccjit::@ref{13d,,context}::new_struct_type (const std::string &name, std::vector<field> &fields, gccjit::location loc)
+@anchor{cp/topics/types _CPPv4N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{216}@anchor{cp/topics/types _CPPv3N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{217}@anchor{cp/topics/types _CPPv2N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{218}@anchor{cp/topics/types gccjit context new_struct_type__ssCR std vector field R gccjit location}@anchor{219}
+@deffn {C++ Function} gccjit::@ref{20a,,struct_} gccjit::@ref{165,,context}::new_struct_type (const std::string &name, std::vector<field> &fields, gccjit::location loc)
 
 @quotation
 
@@ -12804,8 +13422,8 @@ Construct a new struct type, with the given name and fields.
 @end deffn
 
 @geindex gccjit;;context;;new_opaque_struct (C++ function)
-@anchor{cp/topics/types _CPPv4N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{1f2}@anchor{cp/topics/types _CPPv3N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{1f3}@anchor{cp/topics/types _CPPv2N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{1f4}@anchor{cp/topics/types gccjit context new_opaque_struct__ssCR gccjit location}@anchor{1f5}
-@deffn {C++ Function} gccjit::@ref{1e2,,struct_} gccjit::@ref{13d,,context}::new_opaque_struct (const std::string &name, gccjit::location loc)
+@anchor{cp/topics/types _CPPv4N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{21a}@anchor{cp/topics/types _CPPv3N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{21b}@anchor{cp/topics/types _CPPv2N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{21c}@anchor{cp/topics/types gccjit context new_opaque_struct__ssCR gccjit location}@anchor{21d}
+@deffn {C++ Function} gccjit::@ref{20a,,struct_} gccjit::@ref{165,,context}::new_opaque_struct (const std::string &name, gccjit::location loc)
 
 Construct a new struct type, with the given name, but without
 specifying the fields.   The fields can be omitted (in which case the
@@ -12831,7 +13449,7 @@ size of the struct is not known), or later specified using
 @c <https://www.gnu.org/licenses/>.
 
 @node Expressions<2>,Creating and using functions<2>,Types<2>,Topic Reference<2>
-@anchor{cp/topics/expressions doc}@anchor{1f6}@anchor{cp/topics/expressions expressions}@anchor{1f7}
+@anchor{cp/topics/expressions doc}@anchor{21e}@anchor{cp/topics/expressions expressions}@anchor{21f}
 @subsection Expressions
 
 
@@ -12843,17 +13461,17 @@ size of the struct is not known), or later specified using
 @end menu
 
 @node Rvalues<2>,Lvalues<2>,,Expressions<2>
-@anchor{cp/topics/expressions rvalues}@anchor{1f8}
+@anchor{cp/topics/expressions rvalues}@anchor{220}
 @subsubsection Rvalues
 
 
 @geindex gccjit;;rvalue (C++ class)
-@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalueE}@anchor{146}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalueE}@anchor{1f9}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalueE}@anchor{1fa}@anchor{cp/topics/expressions gccjit rvalue}@anchor{1fb}
+@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalueE}@anchor{16e}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalueE}@anchor{221}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalueE}@anchor{222}@anchor{cp/topics/expressions gccjit rvalue}@anchor{223}
 @deffn {C++ Class} gccjit::rvalue
 @end deffn
 
-A @ref{146,,gccjit;;rvalue} is an expression that can be computed.  It is a
-subclass of @ref{142,,gccjit;;object}, and is a thin wrapper around
+A @ref{16e,,gccjit;;rvalue} is an expression that can be computed.  It is a
+subclass of @ref{16a,,gccjit;;object}, and is a thin wrapper around
 @ref{13,,gcc_jit_rvalue *} from the C API.
 
 It can be simple, e.g.:
@@ -12899,8 +13517,8 @@ Every rvalue has an associated type, and the API will check to ensure
 that types match up correctly (otherwise the context will emit an error).
 
 @geindex gccjit;;rvalue;;get_type (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue8get_typeEv}@anchor{1fc}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue8get_typeEv}@anchor{1fd}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue8get_typeEv}@anchor{1fe}@anchor{cp/topics/expressions gccjit rvalue get_type}@anchor{1ff}
-@deffn {C++ Function} gccjit::@ref{13f,,type} gccjit::@ref{146,,rvalue}::get_type ()
+@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue8get_typeEv}@anchor{224}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue8get_typeEv}@anchor{225}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue8get_typeEv}@anchor{226}@anchor{cp/topics/expressions gccjit rvalue get_type}@anchor{227}
+@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{16e,,rvalue}::get_type ()
 
 Get the type of this rvalue.
 @end deffn
@@ -12918,29 +13536,29 @@ Get the type of this rvalue.
 @end menu
 
 @node Simple expressions<2>,Vector expressions<2>,,Rvalues<2>
-@anchor{cp/topics/expressions simple-expressions}@anchor{200}
+@anchor{cp/topics/expressions simple-expressions}@anchor{228}
 @subsubsection Simple expressions
 
 
 @geindex gccjit;;context;;new_rvalue (C++ function)
-@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{15a}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{201}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{202}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type iC}@anchor{203}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_rvalue (gccjit::type numeric_type, int value) const
+@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{182}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{229}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{22a}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type iC}@anchor{22b}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (gccjit::type numeric_type, int value) const
 
 Given a numeric type (integer or floating point), build an rvalue for
 the given constant @code{int} value.
 @end deffn
 
 @geindex gccjit;;context;;new_rvalue (C++ function)
-@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{204}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{205}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{206}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type lC}@anchor{207}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_rvalue (gccjit::type numeric_type, long value) const
+@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{22c}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{22d}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{22e}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type lC}@anchor{22f}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (gccjit::type numeric_type, long value) const
 
 Given a numeric type (integer or floating point), build an rvalue for
 the given constant @code{long} value.
 @end deffn
 
 @geindex gccjit;;context;;zero (C++ function)
-@anchor{cp/topics/expressions _CPPv4NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{156}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{208}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{209}@anchor{cp/topics/expressions gccjit context zero__gccjit typeC}@anchor{20a}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::zero (gccjit::type numeric_type) const
+@anchor{cp/topics/expressions _CPPv4NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{17e}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{230}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{231}@anchor{cp/topics/expressions gccjit context zero__gccjit typeC}@anchor{232}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::zero (gccjit::type numeric_type) const
 
 Given a numeric type (integer or floating point), get the rvalue for
 zero.  Essentially this is just a shortcut for:
@@ -12951,8 +13569,8 @@ ctxt.new_rvalue (numeric_type, 0)
 @end deffn
 
 @geindex gccjit;;context;;one (C++ function)
-@anchor{cp/topics/expressions _CPPv4NK6gccjit7context3oneEN6gccjit4typeE}@anchor{20b}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context3oneEN6gccjit4typeE}@anchor{20c}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context3oneEN6gccjit4typeE}@anchor{20d}@anchor{cp/topics/expressions gccjit context one__gccjit typeC}@anchor{20e}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::one (gccjit::type numeric_type) const
+@anchor{cp/topics/expressions _CPPv4NK6gccjit7context3oneEN6gccjit4typeE}@anchor{233}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context3oneEN6gccjit4typeE}@anchor{234}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context3oneEN6gccjit4typeE}@anchor{235}@anchor{cp/topics/expressions gccjit context one__gccjit typeC}@anchor{236}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::one (gccjit::type numeric_type) const
 
 Given a numeric type (integer or floating point), get the rvalue for
 one.  Essentially this is just a shortcut for:
@@ -12963,36 +13581,36 @@ ctxt.new_rvalue (numeric_type, 1)
 @end deffn
 
 @geindex gccjit;;context;;new_rvalue (C++ function)
-@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{20f}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{210}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{211}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type doubleC}@anchor{212}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_rvalue (gccjit::type numeric_type, double value) const
+@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{237}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{238}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{239}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type doubleC}@anchor{23a}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (gccjit::type numeric_type, double value) const
 
 Given a numeric type (integer or floating point), build an rvalue for
 the given constant @code{double} value.
 @end deffn
 
 @geindex gccjit;;context;;new_rvalue (C++ function)
-@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{213}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{214}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{215}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type voidPC}@anchor{216}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_rvalue (gccjit::type pointer_type, void *value) const
+@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{23b}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{23c}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{23d}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type voidPC}@anchor{23e}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (gccjit::type pointer_type, void *value) const
 
 Given a pointer type, build an rvalue for the given address.
 @end deffn
 
 @geindex gccjit;;context;;new_rvalue (C++ function)
-@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{217}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{218}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{219}@anchor{cp/topics/expressions gccjit context new_rvalue__ssCRC}@anchor{21a}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_rvalue (const std::string &value) const
+@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{23f}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{240}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{241}@anchor{cp/topics/expressions gccjit context new_rvalue__ssCRC}@anchor{242}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (const std::string &value) const
 
 Generate an rvalue of type @code{GCC_JIT_TYPE_CONST_CHAR_PTR} for
 the given string.  This is akin to a string literal.
 @end deffn
 
 @node Vector expressions<2>,Unary Operations<2>,Simple expressions<2>,Rvalues<2>
-@anchor{cp/topics/expressions vector-expressions}@anchor{21b}
+@anchor{cp/topics/expressions vector-expressions}@anchor{243}
 @subsubsection Vector expressions
 
 
 @geindex gccjit;;context;;new_rvalue (C++ function)
-@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{21c}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{21d}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{21e}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type std vector gccjit rvalue C}@anchor{21f}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_rvalue (gccjit::type vector_type, std::vector<gccjit::rvalue> elements) const
+@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{244}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{245}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{246}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type std vector gccjit rvalue C}@anchor{247}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (gccjit::type vector_type, std::vector<gccjit::rvalue> elements) const
 
 Given a vector type, and a vector of scalar rvalue elements, generate a
 vector rvalue.
@@ -13001,20 +13619,20 @@ The number of elements needs to match that of the vector type.
 @end deffn
 
 @node Unary Operations<2>,Binary Operations<2>,Vector expressions<2>,Rvalues<2>
-@anchor{cp/topics/expressions unary-operations}@anchor{220}
+@anchor{cp/topics/expressions unary-operations}@anchor{248}
 @subsubsection Unary Operations
 
 
 @geindex gccjit;;context;;new_unary_op (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{221}@anchor{cp/topics/expressions _CPPv3N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{222}@anchor{cp/topics/expressions _CPPv2N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{223}@anchor{cp/topics/expressions gccjit context new_unary_op__gcc_jit_unary_op gccjit type gccjit rvalue gccjit location}@anchor{224}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_unary_op (enum gcc_jit_unary_op, gccjit::type result_type, gccjit::rvalue rvalue, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{249}@anchor{cp/topics/expressions _CPPv3N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24b}@anchor{cp/topics/expressions gccjit context new_unary_op__gcc_jit_unary_op gccjit type gccjit rvalue gccjit location}@anchor{24c}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_unary_op (enum gcc_jit_unary_op, gccjit::type result_type, gccjit::rvalue rvalue, gccjit::location loc)
 
 Build a unary operation out of an input rvalue.
 
 Parameter @code{loc} is optional.
 
 This is a thin wrapper around the C API’s
-@ref{a2,,gcc_jit_context_new_unary_op()} and the available unary
+@ref{ba,,gcc_jit_context_new_unary_op()} and the available unary
 operations are documented there.
 @end deffn
 
@@ -13022,8 +13640,8 @@ There are shorter ways to spell the various specific kinds of unary
 operation:
 
 @geindex gccjit;;context;;new_minus (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{225}@anchor{cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{226}@anchor{cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{227}@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit location}@anchor{228}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_minus (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24f}@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit location}@anchor{250}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_minus (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc)
 
 Negate an arithmetic value; for example:
 
@@ -13039,8 +13657,8 @@ builds the equivalent of this C expression:
 @end deffn
 
 @geindex new_bitwise_negate (C++ function)
-@anchor{cp/topics/expressions _CPPv418new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{229}@anchor{cp/topics/expressions _CPPv318new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{22a}@anchor{cp/topics/expressions _CPPv218new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{22b}@anchor{cp/topics/expressions new_bitwise_negate__gccjit type gccjit rvalue gccjit location}@anchor{22c}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} new_bitwise_negate (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv418new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{251}@anchor{cp/topics/expressions _CPPv318new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{252}@anchor{cp/topics/expressions _CPPv218new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{253}@anchor{cp/topics/expressions new_bitwise_negate__gccjit type gccjit rvalue gccjit location}@anchor{254}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} new_bitwise_negate (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc)
 
 Bitwise negation of an integer value (one’s complement); for example:
 
@@ -13056,8 +13674,8 @@ builds the equivalent of this C expression:
 @end deffn
 
 @geindex new_logical_negate (C++ function)
-@anchor{cp/topics/expressions _CPPv418new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{22d}@anchor{cp/topics/expressions _CPPv318new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{22e}@anchor{cp/topics/expressions _CPPv218new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{22f}@anchor{cp/topics/expressions new_logical_negate__gccjit type gccjit rvalue gccjit location}@anchor{230}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} new_logical_negate (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv418new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{255}@anchor{cp/topics/expressions _CPPv318new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{256}@anchor{cp/topics/expressions _CPPv218new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{257}@anchor{cp/topics/expressions new_logical_negate__gccjit type gccjit rvalue gccjit location}@anchor{258}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} new_logical_negate (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc)
 
 Logical negation of an arithmetic or pointer value; for example:
 
@@ -13075,8 +13693,8 @@ builds the equivalent of this C expression:
 The most concise way to spell them is with overloaded operators:
 
 @geindex operator- (C++ function)
-@anchor{cp/topics/expressions _CPPv4miN6gccjit6rvalueE}@anchor{231}@anchor{cp/topics/expressions _CPPv3miN6gccjit6rvalueE}@anchor{232}@anchor{cp/topics/expressions _CPPv2miN6gccjit6rvalueE}@anchor{233}@anchor{cp/topics/expressions sub-operator__gccjit rvalue}@anchor{234}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator@w{-} (gccjit::rvalue a)
+@anchor{cp/topics/expressions _CPPv4miN6gccjit6rvalueE}@anchor{259}@anchor{cp/topics/expressions _CPPv3miN6gccjit6rvalueE}@anchor{25a}@anchor{cp/topics/expressions _CPPv2miN6gccjit6rvalueE}@anchor{25b}@anchor{cp/topics/expressions sub-operator__gccjit rvalue}@anchor{25c}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator@w{-} (gccjit::rvalue a)
 
 @example
 gccjit::rvalue negpi = -pi;
@@ -13084,8 +13702,8 @@ gccjit::rvalue negpi = -pi;
 @end deffn
 
 @geindex operator~ (C++ function)
-@anchor{cp/topics/expressions _CPPv4coN6gccjit6rvalueE}@anchor{235}@anchor{cp/topics/expressions _CPPv3coN6gccjit6rvalueE}@anchor{236}@anchor{cp/topics/expressions _CPPv2coN6gccjit6rvalueE}@anchor{237}@anchor{cp/topics/expressions inv-operator__gccjit rvalue}@anchor{238}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator~ (gccjit::rvalue a)
+@anchor{cp/topics/expressions _CPPv4coN6gccjit6rvalueE}@anchor{25d}@anchor{cp/topics/expressions _CPPv3coN6gccjit6rvalueE}@anchor{25e}@anchor{cp/topics/expressions _CPPv2coN6gccjit6rvalueE}@anchor{25f}@anchor{cp/topics/expressions inv-operator__gccjit rvalue}@anchor{260}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator~ (gccjit::rvalue a)
 
 @example
 gccjit::rvalue mask = ~a;
@@ -13093,8 +13711,8 @@ gccjit::rvalue mask = ~a;
 @end deffn
 
 @geindex operator! (C++ function)
-@anchor{cp/topics/expressions _CPPv4ntN6gccjit6rvalueE}@anchor{239}@anchor{cp/topics/expressions _CPPv3ntN6gccjit6rvalueE}@anchor{23a}@anchor{cp/topics/expressions _CPPv2ntN6gccjit6rvalueE}@anchor{23b}@anchor{cp/topics/expressions not-operator__gccjit rvalue}@anchor{23c}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator! (gccjit::rvalue a)
+@anchor{cp/topics/expressions _CPPv4ntN6gccjit6rvalueE}@anchor{261}@anchor{cp/topics/expressions _CPPv3ntN6gccjit6rvalueE}@anchor{262}@anchor{cp/topics/expressions _CPPv2ntN6gccjit6rvalueE}@anchor{263}@anchor{cp/topics/expressions not-operator__gccjit rvalue}@anchor{264}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator! (gccjit::rvalue a)
 
 @example
 gccjit::rvalue guard = !cond;
@@ -13102,13 +13720,13 @@ gccjit::rvalue guard = !cond;
 @end deffn
 
 @node Binary Operations<2>,Comparisons<2>,Unary Operations<2>,Rvalues<2>
-@anchor{cp/topics/expressions binary-operations}@anchor{23d}
+@anchor{cp/topics/expressions binary-operations}@anchor{265}
 @subsubsection Binary Operations
 
 
 @geindex gccjit;;context;;new_binary_op (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{145}@anchor{cp/topics/expressions _CPPv3N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{23e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{23f}@anchor{cp/topics/expressions gccjit context new_binary_op__gcc_jit_binary_op gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{240}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_binary_op (enum gcc_jit_binary_op, gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{16d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{266}@anchor{cp/topics/expressions _CPPv2N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{267}@anchor{cp/topics/expressions gccjit context new_binary_op__gcc_jit_binary_op gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{268}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_binary_op (enum gcc_jit_binary_op, gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 
 Build a binary operation out of two constituent rvalues.
 
@@ -13123,60 +13741,60 @@ There are shorter ways to spell the various specific kinds of binary
 operation:
 
 @geindex gccjit;;context;;new_plus (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{241}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{242}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{243}@anchor{cp/topics/expressions gccjit context new_plus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{244}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_plus (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{269}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{26a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{26b}@anchor{cp/topics/expressions gccjit context new_plus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{26c}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_plus (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_minus (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{245}@anchor{cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{246}@anchor{cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{247}@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{248}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_minus (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{26d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{26e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{26f}@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{270}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_minus (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_mult (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{249}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24b}@anchor{cp/topics/expressions gccjit context new_mult__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{24c}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_mult (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{271}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{272}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{273}@anchor{cp/topics/expressions gccjit context new_mult__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{274}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_mult (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_divide (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24f}@anchor{cp/topics/expressions gccjit context new_divide__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{250}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_divide (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{275}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{276}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{277}@anchor{cp/topics/expressions gccjit context new_divide__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{278}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_divide (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_modulo (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{251}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{252}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{253}@anchor{cp/topics/expressions gccjit context new_modulo__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{254}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_modulo (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{279}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27b}@anchor{cp/topics/expressions gccjit context new_modulo__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{27c}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_modulo (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_bitwise_and (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{255}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{256}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{257}@anchor{cp/topics/expressions gccjit context new_bitwise_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{258}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_bitwise_and (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27f}@anchor{cp/topics/expressions gccjit context new_bitwise_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{280}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_bitwise_and (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_bitwise_xor (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{259}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{25a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{25b}@anchor{cp/topics/expressions gccjit context new_bitwise_xor__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{25c}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_bitwise_xor (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{281}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{282}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{283}@anchor{cp/topics/expressions gccjit context new_bitwise_xor__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{284}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_bitwise_xor (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_bitwise_or (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{25d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{25e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{25f}@anchor{cp/topics/expressions gccjit context new_bitwise_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{260}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_bitwise_or (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{285}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{286}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{287}@anchor{cp/topics/expressions gccjit context new_bitwise_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{288}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_bitwise_or (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_logical_and (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{261}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{262}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{263}@anchor{cp/topics/expressions gccjit context new_logical_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{264}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_logical_and (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{289}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28b}@anchor{cp/topics/expressions gccjit context new_logical_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{28c}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_logical_and (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_logical_or (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{265}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{266}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{267}@anchor{cp/topics/expressions gccjit context new_logical_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{268}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_logical_or (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28f}@anchor{cp/topics/expressions gccjit context new_logical_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{290}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_logical_or (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 The most concise way to spell them is with overloaded operators:
 
 @geindex operator+ (C++ function)
-@anchor{cp/topics/expressions _CPPv4plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{269}@anchor{cp/topics/expressions _CPPv3plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{26a}@anchor{cp/topics/expressions _CPPv2plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{26b}@anchor{cp/topics/expressions add-operator__gccjit rvalue gccjit rvalue}@anchor{26c}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator+ (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{291}@anchor{cp/topics/expressions _CPPv3plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{292}@anchor{cp/topics/expressions _CPPv2plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{293}@anchor{cp/topics/expressions add-operator__gccjit rvalue gccjit rvalue}@anchor{294}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator+ (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue sum = a + b;
@@ -13184,8 +13802,8 @@ gccjit::rvalue sum = a + b;
 @end deffn
 
 @geindex operator- (C++ function)
-@anchor{cp/topics/expressions _CPPv4miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{26d}@anchor{cp/topics/expressions _CPPv3miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{26e}@anchor{cp/topics/expressions _CPPv2miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{26f}@anchor{cp/topics/expressions sub-operator__gccjit rvalue gccjit rvalue}@anchor{270}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator@w{-} (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{295}@anchor{cp/topics/expressions _CPPv3miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{296}@anchor{cp/topics/expressions _CPPv2miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{297}@anchor{cp/topics/expressions sub-operator__gccjit rvalue gccjit rvalue}@anchor{298}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator@w{-} (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue diff = a - b;
@@ -13193,8 +13811,8 @@ gccjit::rvalue diff = a - b;
 @end deffn
 
 @geindex operator* (C++ function)
-@anchor{cp/topics/expressions _CPPv4mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{271}@anchor{cp/topics/expressions _CPPv3mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{272}@anchor{cp/topics/expressions _CPPv2mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{273}@anchor{cp/topics/expressions mul-operator__gccjit rvalue gccjit rvalue}@anchor{274}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator* (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{299}@anchor{cp/topics/expressions _CPPv3mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{29a}@anchor{cp/topics/expressions _CPPv2mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{29b}@anchor{cp/topics/expressions mul-operator__gccjit rvalue gccjit rvalue}@anchor{29c}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator* (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue prod = a * b;
@@ -13202,8 +13820,8 @@ gccjit::rvalue prod = a * b;
 @end deffn
 
 @geindex operator/ (C++ function)
-@anchor{cp/topics/expressions _CPPv4dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{275}@anchor{cp/topics/expressions _CPPv3dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{276}@anchor{cp/topics/expressions _CPPv2dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{277}@anchor{cp/topics/expressions div-operator__gccjit rvalue gccjit rvalue}@anchor{278}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator/ (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{29d}@anchor{cp/topics/expressions _CPPv3dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{29e}@anchor{cp/topics/expressions _CPPv2dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{29f}@anchor{cp/topics/expressions div-operator__gccjit rvalue gccjit rvalue}@anchor{2a0}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator/ (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue result = a / b;
@@ -13211,8 +13829,8 @@ gccjit::rvalue result = a / b;
 @end deffn
 
 @geindex operator% (C++ function)
-@anchor{cp/topics/expressions _CPPv4rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{279}@anchor{cp/topics/expressions _CPPv3rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{27a}@anchor{cp/topics/expressions _CPPv2rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{27b}@anchor{cp/topics/expressions mod-operator__gccjit rvalue gccjit rvalue}@anchor{27c}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator% (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a1}@anchor{cp/topics/expressions _CPPv3rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a2}@anchor{cp/topics/expressions _CPPv2rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a3}@anchor{cp/topics/expressions mod-operator__gccjit rvalue gccjit rvalue}@anchor{2a4}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator% (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue mod = a % b;
@@ -13220,8 +13838,8 @@ gccjit::rvalue mod = a % b;
 @end deffn
 
 @geindex operator& (C++ function)
-@anchor{cp/topics/expressions _CPPv4anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{27d}@anchor{cp/topics/expressions _CPPv3anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{27e}@anchor{cp/topics/expressions _CPPv2anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{27f}@anchor{cp/topics/expressions and-operator__gccjit rvalue gccjit rvalue}@anchor{280}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator& (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a5}@anchor{cp/topics/expressions _CPPv3anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a6}@anchor{cp/topics/expressions _CPPv2anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a7}@anchor{cp/topics/expressions and-operator__gccjit rvalue gccjit rvalue}@anchor{2a8}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator& (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue x = a & b;
@@ -13229,8 +13847,8 @@ gccjit::rvalue x = a & b;
 @end deffn
 
 @geindex operator^ (C++ function)
-@anchor{cp/topics/expressions _CPPv4eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{281}@anchor{cp/topics/expressions _CPPv3eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{282}@anchor{cp/topics/expressions _CPPv2eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{283}@anchor{cp/topics/expressions xor-operator__gccjit rvalue gccjit rvalue}@anchor{284}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator^ (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a9}@anchor{cp/topics/expressions _CPPv3eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2aa}@anchor{cp/topics/expressions _CPPv2eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ab}@anchor{cp/topics/expressions xor-operator__gccjit rvalue gccjit rvalue}@anchor{2ac}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator^ (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue x = a ^ b;
@@ -13238,8 +13856,8 @@ gccjit::rvalue x = a ^ b;
 @end deffn
 
 @geindex operator| (C++ function)
-@anchor{cp/topics/expressions _CPPv4orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{285}@anchor{cp/topics/expressions _CPPv3orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{286}@anchor{cp/topics/expressions _CPPv2orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{287}@anchor{cp/topics/expressions or-operator__gccjit rvalue gccjit rvalue}@anchor{288}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator| (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ad}@anchor{cp/topics/expressions _CPPv3orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ae}@anchor{cp/topics/expressions _CPPv2orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2af}@anchor{cp/topics/expressions or-operator__gccjit rvalue gccjit rvalue}@anchor{2b0}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator| (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue x = a | b;
@@ -13247,8 +13865,8 @@ gccjit::rvalue x = a | b;
 @end deffn
 
 @geindex operator&& (C++ function)
-@anchor{cp/topics/expressions _CPPv4aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{289}@anchor{cp/topics/expressions _CPPv3aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{28a}@anchor{cp/topics/expressions _CPPv2aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{28b}@anchor{cp/topics/expressions sand-operator__gccjit rvalue gccjit rvalue}@anchor{28c}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator&& (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b1}@anchor{cp/topics/expressions _CPPv3aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b2}@anchor{cp/topics/expressions _CPPv2aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b3}@anchor{cp/topics/expressions sand-operator__gccjit rvalue gccjit rvalue}@anchor{2b4}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator&& (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue cond = a && b;
@@ -13256,8 +13874,8 @@ gccjit::rvalue cond = a && b;
 @end deffn
 
 @geindex operator|| (C++ function)
-@anchor{cp/topics/expressions _CPPv4ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{28d}@anchor{cp/topics/expressions _CPPv3ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{28e}@anchor{cp/topics/expressions _CPPv2ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{28f}@anchor{cp/topics/expressions sor-operator__gccjit rvalue gccjit rvalue}@anchor{290}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator|| (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b5}@anchor{cp/topics/expressions _CPPv3ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b6}@anchor{cp/topics/expressions _CPPv2ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b7}@anchor{cp/topics/expressions sor-operator__gccjit rvalue gccjit rvalue}@anchor{2b8}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator|| (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue cond = a || b;
@@ -13275,13 +13893,13 @@ gccjit::rvalue discriminant = (b * b) - (four * a * c);
 @end quotation
 
 @node Comparisons<2>,Function calls<2>,Binary Operations<2>,Rvalues<2>
-@anchor{cp/topics/expressions comparisons}@anchor{291}
+@anchor{cp/topics/expressions comparisons}@anchor{2b9}
 @subsubsection Comparisons
 
 
 @geindex gccjit;;context;;new_comparison (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{157}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{292}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{293}@anchor{cp/topics/expressions gccjit context new_comparison__gcc_jit_comparison gccjit rvalue gccjit rvalue gccjit location}@anchor{294}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_comparison (enum gcc_jit_comparison, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{17f}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2ba}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2bb}@anchor{cp/topics/expressions gccjit context new_comparison__gcc_jit_comparison gccjit rvalue gccjit rvalue gccjit location}@anchor{2bc}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_comparison (enum gcc_jit_comparison, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 
 Build a boolean rvalue out of the comparison of two other rvalues.
 
@@ -13296,40 +13914,40 @@ There are shorter ways to spell the various specific kinds of binary
 operation:
 
 @geindex gccjit;;context;;new_eq (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{295}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{296}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{297}@anchor{cp/topics/expressions gccjit context new_eq__gccjit rvalue gccjit rvalue gccjit location}@anchor{298}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_eq (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2bd}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2be}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2bf}@anchor{cp/topics/expressions gccjit context new_eq__gccjit rvalue gccjit rvalue gccjit location}@anchor{2c0}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_eq (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_ne (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{299}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{29a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{29b}@anchor{cp/topics/expressions gccjit context new_ne__gccjit rvalue gccjit rvalue gccjit location}@anchor{29c}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_ne (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c1}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c2}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c3}@anchor{cp/topics/expressions gccjit context new_ne__gccjit rvalue gccjit rvalue gccjit location}@anchor{2c4}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_ne (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_lt (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{29d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{29e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{29f}@anchor{cp/topics/expressions gccjit context new_lt__gccjit rvalue gccjit rvalue gccjit location}@anchor{2a0}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_lt (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c5}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c6}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c7}@anchor{cp/topics/expressions gccjit context new_lt__gccjit rvalue gccjit rvalue gccjit location}@anchor{2c8}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_lt (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_le (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2a1}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2a2}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2a3}@anchor{cp/topics/expressions gccjit context new_le__gccjit rvalue gccjit rvalue gccjit location}@anchor{2a4}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_le (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c9}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2ca}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2cb}@anchor{cp/topics/expressions gccjit context new_le__gccjit rvalue gccjit rvalue gccjit location}@anchor{2cc}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_le (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_gt (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2a5}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2a6}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2a7}@anchor{cp/topics/expressions gccjit context new_gt__gccjit rvalue gccjit rvalue gccjit location}@anchor{2a8}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_gt (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2cd}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2ce}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2cf}@anchor{cp/topics/expressions gccjit context new_gt__gccjit rvalue gccjit rvalue gccjit location}@anchor{2d0}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_gt (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 @geindex gccjit;;context;;new_ge (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2a9}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2aa}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2ab}@anchor{cp/topics/expressions gccjit context new_ge__gccjit rvalue gccjit rvalue gccjit location}@anchor{2ac}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_ge (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d1}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d2}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d3}@anchor{cp/topics/expressions gccjit context new_ge__gccjit rvalue gccjit rvalue gccjit location}@anchor{2d4}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_ge (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)
 @end deffn
 
 The most concise way to spell them is with overloaded operators:
 
 @geindex operator== (C++ function)
-@anchor{cp/topics/expressions _CPPv4eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ad}@anchor{cp/topics/expressions _CPPv3eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ae}@anchor{cp/topics/expressions _CPPv2eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2af}@anchor{cp/topics/expressions eq-operator__gccjit rvalue gccjit rvalue}@anchor{2b0}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator== (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2d5}@anchor{cp/topics/expressions _CPPv3eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2d6}@anchor{cp/topics/expressions _CPPv2eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2d7}@anchor{cp/topics/expressions eq-operator__gccjit rvalue gccjit rvalue}@anchor{2d8}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator== (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue cond = (a == ctxt.zero (t_int));
@@ -13337,8 +13955,8 @@ gccjit::rvalue cond = (a == ctxt.zero (t_int));
 @end deffn
 
 @geindex operator!= (C++ function)
-@anchor{cp/topics/expressions _CPPv4neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b1}@anchor{cp/topics/expressions _CPPv3neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b2}@anchor{cp/topics/expressions _CPPv2neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b3}@anchor{cp/topics/expressions neq-operator__gccjit rvalue gccjit rvalue}@anchor{2b4}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator!= (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2d9}@anchor{cp/topics/expressions _CPPv3neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2da}@anchor{cp/topics/expressions _CPPv2neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2db}@anchor{cp/topics/expressions neq-operator__gccjit rvalue gccjit rvalue}@anchor{2dc}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator!= (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue cond = (i != j);
@@ -13346,8 +13964,8 @@ gccjit::rvalue cond = (i != j);
 @end deffn
 
 @geindex operator< (C++ function)
-@anchor{cp/topics/expressions _CPPv4ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b5}@anchor{cp/topics/expressions _CPPv3ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b6}@anchor{cp/topics/expressions _CPPv2ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b7}@anchor{cp/topics/expressions lt-operator__gccjit rvalue gccjit rvalue}@anchor{2b8}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator< (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2dd}@anchor{cp/topics/expressions _CPPv3ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2de}@anchor{cp/topics/expressions _CPPv2ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2df}@anchor{cp/topics/expressions lt-operator__gccjit rvalue gccjit rvalue}@anchor{2e0}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator< (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue cond = i < n;
@@ -13355,8 +13973,8 @@ gccjit::rvalue cond = i < n;
 @end deffn
 
 @geindex operator<= (C++ function)
-@anchor{cp/topics/expressions _CPPv4leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b9}@anchor{cp/topics/expressions _CPPv3leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ba}@anchor{cp/topics/expressions _CPPv2leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2bb}@anchor{cp/topics/expressions lte-operator__gccjit rvalue gccjit rvalue}@anchor{2bc}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator<= (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e1}@anchor{cp/topics/expressions _CPPv3leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e2}@anchor{cp/topics/expressions _CPPv2leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e3}@anchor{cp/topics/expressions lte-operator__gccjit rvalue gccjit rvalue}@anchor{2e4}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator<= (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue cond = i <= n;
@@ -13364,8 +13982,8 @@ gccjit::rvalue cond = i <= n;
 @end deffn
 
 @geindex operator> (C++ function)
-@anchor{cp/topics/expressions _CPPv4gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2bd}@anchor{cp/topics/expressions _CPPv3gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2be}@anchor{cp/topics/expressions _CPPv2gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2bf}@anchor{cp/topics/expressions gt-operator__gccjit rvalue gccjit rvalue}@anchor{2c0}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator> (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e5}@anchor{cp/topics/expressions _CPPv3gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e6}@anchor{cp/topics/expressions _CPPv2gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e7}@anchor{cp/topics/expressions gt-operator__gccjit rvalue gccjit rvalue}@anchor{2e8}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator> (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue cond = (ch > limit);
@@ -13373,8 +13991,8 @@ gccjit::rvalue cond = (ch > limit);
 @end deffn
 
 @geindex operator>= (C++ function)
-@anchor{cp/topics/expressions _CPPv4geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2c1}@anchor{cp/topics/expressions _CPPv3geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2c2}@anchor{cp/topics/expressions _CPPv2geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2c3}@anchor{cp/topics/expressions gte-operator__gccjit rvalue gccjit rvalue}@anchor{2c4}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} operator>= (gccjit::rvalue a, gccjit::rvalue b)
+@anchor{cp/topics/expressions _CPPv4geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e9}@anchor{cp/topics/expressions _CPPv3geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ea}@anchor{cp/topics/expressions _CPPv2geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2eb}@anchor{cp/topics/expressions gte-operator__gccjit rvalue gccjit rvalue}@anchor{2ec}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator>= (gccjit::rvalue a, gccjit::rvalue b)
 
 @example
 gccjit::rvalue cond = (score >= ctxt.new_rvalue (t_int, 100));
@@ -13384,12 +14002,12 @@ gccjit::rvalue cond = (score >= ctxt.new_rvalue (t_int, 100));
 @c TODO: beyond this point
 
 @node Function calls<2>,Function pointers<3>,Comparisons<2>,Rvalues<2>
-@anchor{cp/topics/expressions function-calls}@anchor{2c5}
+@anchor{cp/topics/expressions function-calls}@anchor{2ed}
 @subsubsection Function calls
 
 
 @geindex gcc_jit_context_new_call (C++ function)
-@anchor{cp/topics/expressions _CPPv424gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2c6}@anchor{cp/topics/expressions _CPPv324gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2c7}@anchor{cp/topics/expressions _CPPv224gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2c8}@anchor{cp/topics/expressions gcc_jit_context_new_call__gcc_jit_contextP gcc_jit_locationP gcc_jit_functionP i gcc_jit_rvaluePP}@anchor{2c9}
+@anchor{cp/topics/expressions _CPPv424gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2ee}@anchor{cp/topics/expressions _CPPv324gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2ef}@anchor{cp/topics/expressions _CPPv224gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2f0}@anchor{cp/topics/expressions gcc_jit_context_new_call__gcc_jit_contextP gcc_jit_locationP gcc_jit_functionP i gcc_jit_rvaluePP}@anchor{2f1}
 @deffn {C++ Function} gcc_jit_rvalue *gcc_jit_context_new_call (gcc_jit_context *ctxt, gcc_jit_location *loc, gcc_jit_function *func, int numargs, gcc_jit_rvalue **args)
 
 Given a function and the given table of argument rvalues, construct a
@@ -13398,14 +14016,14 @@ call to the function, with the result as an rvalue.
 @cartouche
 @quotation Note 
 @code{gccjit::context::new_call()} merely builds a
-@ref{146,,gccjit;;rvalue} i.e. an expression that can be evaluated,
+@ref{16e,,gccjit;;rvalue} i.e. an expression that can be evaluated,
 perhaps as part of a more complicated expression.
 The call @emph{won’t} happen unless you add a statement to a function
 that evaluates the expression.
 
 For example, if you want to call a function and discard the result
 (or to call a function with @code{void} return type), use
-@ref{2ca,,gccjit;;block;;add_eval()}:
+@ref{2f2,,gccjit;;block;;add_eval()}:
 
 @example
 /* Add "(void)printf (arg0, arg1);".  */
@@ -13416,26 +14034,26 @@ block.add_eval (ctxt.new_call (printf_func, arg0, arg1));
 @end deffn
 
 @node Function pointers<3>,Type-coercion<2>,Function calls<2>,Rvalues<2>
-@anchor{cp/topics/expressions function-pointers}@anchor{2cb}
+@anchor{cp/topics/expressions function-pointers}@anchor{2f3}
 @subsubsection Function pointers
 
 
 @geindex gccjit;;function;;get_address (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{2cc}@anchor{cp/topics/expressions _CPPv3N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{2cd}@anchor{cp/topics/expressions _CPPv2N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{2ce}@anchor{cp/topics/expressions gccjit function get_address__gccjit location}@anchor{2cf}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{154,,function}::get_address (gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{2f4}@anchor{cp/topics/expressions _CPPv3N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{2f5}@anchor{cp/topics/expressions _CPPv2N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{2f6}@anchor{cp/topics/expressions gccjit function get_address__gccjit location}@anchor{2f7}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{17c,,function}::get_address (gccjit::location loc)
 
 Get the address of a function as an rvalue, of function pointer
 type.
 @end deffn
 
 @node Type-coercion<2>,,Function pointers<3>,Rvalues<2>
-@anchor{cp/topics/expressions type-coercion}@anchor{2d0}
+@anchor{cp/topics/expressions type-coercion}@anchor{2f8}
 @subsubsection Type-coercion
 
 
 @geindex gccjit;;context;;new_cast (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{2d1}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{2d2}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{2d3}@anchor{cp/topics/expressions gccjit context new_cast__gccjit rvalue gccjit type gccjit location}@anchor{2d4}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{13d,,context}::new_cast (gccjit::rvalue rvalue, gccjit::type type, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{2f9}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{2fa}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{2fb}@anchor{cp/topics/expressions gccjit context new_cast__gccjit rvalue gccjit type gccjit location}@anchor{2fc}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_cast (gccjit::rvalue rvalue, gccjit::type type, gccjit::location loc)
 
 Given an rvalue of T, construct another rvalue of another type.
 
@@ -13459,25 +14077,25 @@ P*  <-> Q*, for pointer types P and Q
 @end deffn
 
 @node Lvalues<2>,Working with pointers structs and unions<2>,Rvalues<2>,Expressions<2>
-@anchor{cp/topics/expressions lvalues}@anchor{2d5}
+@anchor{cp/topics/expressions lvalues}@anchor{2fd}
 @subsubsection Lvalues
 
 
 @geindex gccjit;;lvalue (C++ class)
-@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalueE}@anchor{14f}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalueE}@anchor{2d6}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalueE}@anchor{2d7}@anchor{cp/topics/expressions gccjit lvalue}@anchor{2d8}
+@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalueE}@anchor{177}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalueE}@anchor{2fe}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalueE}@anchor{2ff}@anchor{cp/topics/expressions gccjit lvalue}@anchor{300}
 @deffn {C++ Class} gccjit::lvalue
 @end deffn
 
 An lvalue is something that can of the @emph{left}-hand side of an assignment:
 a storage area (such as a variable).  It is a subclass of
-@ref{146,,gccjit;;rvalue}, where the rvalue is computed by reading from the
+@ref{16e,,gccjit;;rvalue}, where the rvalue is computed by reading from the
 storage area.
 
 It iss a thin wrapper around @ref{24,,gcc_jit_lvalue *} from the C API.
 
 @geindex gccjit;;lvalue;;get_address (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{2d9}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{2da}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{2db}@anchor{cp/topics/expressions gccjit lvalue get_address__gccjit location}@anchor{2dc}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{14f,,lvalue}::get_address (gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{301}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{302}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{303}@anchor{cp/topics/expressions gccjit lvalue get_address__gccjit location}@anchor{304}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{177,,lvalue}::get_address (gccjit::location loc)
 
 Take the address of an lvalue; analogous to:
 
@@ -13496,28 +14114,28 @@ Parameter “loc” is optional.
 @end menu
 
 @node Global variables<2>,,,Lvalues<2>
-@anchor{cp/topics/expressions global-variables}@anchor{2dd}
+@anchor{cp/topics/expressions global-variables}@anchor{305}
 @subsubsection Global variables
 
 
 @geindex gccjit;;context;;new_global (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{2de}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{2df}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{2e0}@anchor{cp/topics/expressions gccjit context new_global__gcc_jit_global_kind gccjit type cCP gccjit location}@anchor{2e1}
-@deffn {C++ Function} gccjit::@ref{14f,,lvalue} gccjit::@ref{13d,,context}::new_global (enum gcc_jit_global_kind, gccjit::type type, const char *name, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{306}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{307}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{308}@anchor{cp/topics/expressions gccjit context new_global__gcc_jit_global_kind gccjit type cCP gccjit location}@anchor{309}
+@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{165,,context}::new_global (enum gcc_jit_global_kind, gccjit::type type, const char *name, gccjit::location loc)
 
 Add a new global variable of the given type and name to the context.
 
-This is a thin wrapper around @ref{c8,,gcc_jit_context_new_global()} from
+This is a thin wrapper around @ref{ea,,gcc_jit_context_new_global()} from
 the C API; the “kind” parameter has the same meaning as there.
 @end deffn
 
 @node Working with pointers structs and unions<2>,,Lvalues<2>,Expressions<2>
-@anchor{cp/topics/expressions working-with-pointers-structs-and-unions}@anchor{2e2}
+@anchor{cp/topics/expressions working-with-pointers-structs-and-unions}@anchor{30a}
 @subsubsection Working with pointers, structs and unions
 
 
 @geindex gccjit;;rvalue;;dereference (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{2e3}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{2e4}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{2e5}@anchor{cp/topics/expressions gccjit rvalue dereference__gccjit location}@anchor{2e6}
-@deffn {C++ Function} gccjit::@ref{14f,,lvalue} gccjit::@ref{146,,rvalue}::dereference (gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{30b}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{30c}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{30d}@anchor{cp/topics/expressions gccjit rvalue dereference__gccjit location}@anchor{30e}
+@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{16e,,rvalue}::dereference (gccjit::location loc)
 
 Given an rvalue of pointer type @code{T *}, dereferencing the pointer,
 getting an lvalue of type @code{T}.  Analogous to:
@@ -13535,8 +14153,8 @@ If you don’t need to specify the location, this can also be expressed using
 an overloaded operator:
 
 @geindex gccjit;;rvalue;;operator* (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit6rvaluemlEv}@anchor{2e7}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvaluemlEv}@anchor{2e8}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvaluemlEv}@anchor{2e9}@anchor{cp/topics/expressions gccjit rvalue mul-operator}@anchor{2ea}
-@deffn {C++ Function} gccjit::@ref{14f,,lvalue} gccjit::@ref{146,,rvalue}::operator* ()
+@anchor{cp/topics/expressions _CPPv4N6gccjit6rvaluemlEv}@anchor{30f}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvaluemlEv}@anchor{310}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvaluemlEv}@anchor{311}@anchor{cp/topics/expressions gccjit rvalue mul-operator}@anchor{312}
+@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{16e,,rvalue}::operator* ()
 
 @example
 gccjit::lvalue content = *ptr;
@@ -13546,8 +14164,8 @@ gccjit::lvalue content = *ptr;
 Field access is provided separately for both lvalues and rvalues:
 
 @geindex gccjit;;lvalue;;access_field (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{2eb}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{2ec}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{2ed}@anchor{cp/topics/expressions gccjit lvalue access_field__gccjit field gccjit location}@anchor{2ee}
-@deffn {C++ Function} gccjit::@ref{14f,,lvalue} gccjit::@ref{14f,,lvalue}::access_field (gccjit::field field, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{313}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{314}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{315}@anchor{cp/topics/expressions gccjit lvalue access_field__gccjit field gccjit location}@anchor{316}
+@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{177,,lvalue}::access_field (gccjit::field field, gccjit::location loc)
 
 Given an lvalue of struct or union type, access the given field,
 getting an lvalue of the field’s type.  Analogous to:
@@ -13560,8 +14178,8 @@ in C.
 @end deffn
 
 @geindex gccjit;;rvalue;;access_field (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{2ef}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{2f0}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{2f1}@anchor{cp/topics/expressions gccjit rvalue access_field__gccjit field gccjit location}@anchor{2f2}
-@deffn {C++ Function} gccjit::@ref{146,,rvalue} gccjit::@ref{146,,rvalue}::access_field (gccjit::field field, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{317}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{318}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{319}@anchor{cp/topics/expressions gccjit rvalue access_field__gccjit field gccjit location}@anchor{31a}
+@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{16e,,rvalue}::access_field (gccjit::field field, gccjit::location loc)
 
 Given an rvalue of struct or union type, access the given field
 as an rvalue.  Analogous to:
@@ -13574,8 +14192,8 @@ in C.
 @end deffn
 
 @geindex gccjit;;rvalue;;dereference_field (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{2f3}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{2f4}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{2f5}@anchor{cp/topics/expressions gccjit rvalue dereference_field__gccjit field gccjit location}@anchor{2f6}
-@deffn {C++ Function} gccjit::@ref{14f,,lvalue} gccjit::@ref{146,,rvalue}::dereference_field (gccjit::field field, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{31b}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{31c}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{31d}@anchor{cp/topics/expressions gccjit rvalue dereference_field__gccjit field gccjit location}@anchor{31e}
+@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{16e,,rvalue}::dereference_field (gccjit::field field, gccjit::location loc)
 
 Given an rvalue of pointer type @code{T *} where T is of struct or union
 type, access the given field as an lvalue.  Analogous to:
@@ -13588,8 +14206,8 @@ in C, itself equivalent to @code{(*EXPR).FIELD}.
 @end deffn
 
 @geindex gccjit;;context;;new_array_access (C++ function)
-@anchor{cp/topics/expressions _CPPv4N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2f7}@anchor{cp/topics/expressions _CPPv3N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2f8}@anchor{cp/topics/expressions _CPPv2N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2f9}@anchor{cp/topics/expressions gccjit context new_array_access__gccjit rvalue gccjit rvalue gccjit location}@anchor{2fa}
-@deffn {C++ Function} gccjit::@ref{14f,,lvalue} gccjit::@ref{13d,,context}::new_array_access (gccjit::rvalue ptr, gccjit::rvalue index, gccjit::location loc)
+@anchor{cp/topics/expressions _CPPv4N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{31f}@anchor{cp/topics/expressions _CPPv3N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{320}@anchor{cp/topics/expressions _CPPv2N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{321}@anchor{cp/topics/expressions gccjit context new_array_access__gccjit rvalue gccjit rvalue gccjit location}@anchor{322}
+@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{165,,context}::new_array_access (gccjit::rvalue ptr, gccjit::rvalue index, gccjit::location loc)
 
 Given an rvalue of pointer type @code{T *}, get at the element @cite{T} at
 the given index, using standard C array indexing rules i.e. each
@@ -13605,7 +14223,7 @@ in C (or, indeed, to @code{PTR + INDEX}).
 Parameter “loc” is optional.
 @end deffn
 
-For array accesses where you don’t need to specify a @ref{163,,gccjit;;location},
+For array accesses where you don’t need to specify a @ref{18b,,gccjit;;location},
 two overloaded operators are available:
 
 @quotation
@@ -13641,7 +14259,7 @@ gccjit::lvalue element = array[0];
 @c <https://www.gnu.org/licenses/>.
 
 @node Creating and using functions<2>,Source Locations<2>,Expressions<2>,Topic Reference<2>
-@anchor{cp/topics/functions doc}@anchor{2fb}@anchor{cp/topics/functions creating-and-using-functions}@anchor{2fc}
+@anchor{cp/topics/functions doc}@anchor{323}@anchor{cp/topics/functions creating-and-using-functions}@anchor{324}
 @subsection Creating and using functions
 
 
@@ -13654,36 +14272,36 @@ gccjit::lvalue element = array[0];
 @end menu
 
 @node Params<2>,Functions<2>,,Creating and using functions<2>
-@anchor{cp/topics/functions params}@anchor{2fd}
+@anchor{cp/topics/functions params}@anchor{325}
 @subsubsection Params
 
 
 @geindex gccjit;;param (C++ class)
-@anchor{cp/topics/functions _CPPv4N6gccjit5paramE}@anchor{150}@anchor{cp/topics/functions _CPPv3N6gccjit5paramE}@anchor{2fe}@anchor{cp/topics/functions _CPPv2N6gccjit5paramE}@anchor{2ff}@anchor{cp/topics/functions gccjit param}@anchor{300}
+@anchor{cp/topics/functions _CPPv4N6gccjit5paramE}@anchor{178}@anchor{cp/topics/functions _CPPv3N6gccjit5paramE}@anchor{326}@anchor{cp/topics/functions _CPPv2N6gccjit5paramE}@anchor{327}@anchor{cp/topics/functions gccjit param}@anchor{328}
 @deffn {C++ Class} gccjit::param
 
 A @cite{gccjit::param} represents a parameter to a function.
 @end deffn
 
 @geindex gccjit;;context;;new_param (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{144}@anchor{cp/topics/functions _CPPv3N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{301}@anchor{cp/topics/functions _CPPv2N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{302}@anchor{cp/topics/functions gccjit context new_param__gccjit type cCP gccjit location}@anchor{303}
-@deffn {C++ Function} gccjit::@ref{150,,param} gccjit::@ref{13d,,context}::new_param (gccjit::type type, const char *name, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{16c}@anchor{cp/topics/functions _CPPv3N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{329}@anchor{cp/topics/functions _CPPv2N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{32a}@anchor{cp/topics/functions gccjit context new_param__gccjit type cCP gccjit location}@anchor{32b}
+@deffn {C++ Function} gccjit::@ref{178,,param} gccjit::@ref{165,,context}::new_param (gccjit::type type, const char *name, gccjit::location loc)
 
 In preparation for creating a function, create a new parameter of the
 given type and name.
 @end deffn
 
-@ref{150,,gccjit;;param} is a subclass of @ref{14f,,gccjit;;lvalue} (and thus
-of @ref{146,,gccjit;;rvalue} and @ref{142,,gccjit;;object}).  It is a thin
+@ref{178,,gccjit;;param} is a subclass of @ref{177,,gccjit;;lvalue} (and thus
+of @ref{16e,,gccjit;;rvalue} and @ref{16a,,gccjit;;object}).  It is a thin
 wrapper around the C API’s @ref{25,,gcc_jit_param *}.
 
 @node Functions<2>,Blocks<2>,Params<2>,Creating and using functions<2>
-@anchor{cp/topics/functions functions}@anchor{304}
+@anchor{cp/topics/functions functions}@anchor{32c}
 @subsubsection Functions
 
 
 @geindex gccjit;;function (C++ class)
-@anchor{cp/topics/functions _CPPv4N6gccjit8functionE}@anchor{154}@anchor{cp/topics/functions _CPPv3N6gccjit8functionE}@anchor{305}@anchor{cp/topics/functions _CPPv2N6gccjit8functionE}@anchor{306}@anchor{cp/topics/functions gccjit function}@anchor{307}
+@anchor{cp/topics/functions _CPPv4N6gccjit8functionE}@anchor{17c}@anchor{cp/topics/functions _CPPv3N6gccjit8functionE}@anchor{32d}@anchor{cp/topics/functions _CPPv2N6gccjit8functionE}@anchor{32e}@anchor{cp/topics/functions gccjit function}@anchor{32f}
 @deffn {C++ Class} gccjit::function
 
 A @cite{gccjit::function} represents a function - either one that we’re
@@ -13691,8 +14309,8 @@ creating ourselves, or one that we’re referencing.
 @end deffn
 
 @geindex gccjit;;context;;new_function (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{308}@anchor{cp/topics/functions _CPPv3N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{309}@anchor{cp/topics/functions _CPPv2N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{30a}@anchor{cp/topics/functions gccjit context new_function__gcc_jit_function_kind gccjit type cCP std vector param R i gccjit location}@anchor{30b}
-@deffn {C++ Function} gccjit::@ref{154,,function} gccjit::@ref{13d,,context}::new_function (enum gcc_jit_function_kind, gccjit::type return_type, const char *name, std::vector<param> &params, int is_variadic, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{330}@anchor{cp/topics/functions _CPPv3N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{331}@anchor{cp/topics/functions _CPPv2N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{332}@anchor{cp/topics/functions gccjit context new_function__gcc_jit_function_kind gccjit type cCP std vector param R i gccjit location}@anchor{333}
+@deffn {C++ Function} gccjit::@ref{17c,,function} gccjit::@ref{165,,context}::new_function (enum gcc_jit_function_kind, gccjit::type return_type, const char *name, std::vector<param> &params, int is_variadic, gccjit::location loc)
 
 Create a gcc_jit_function with the given name and parameters.
 
@@ -13702,49 +14320,49 @@ This is a wrapper around the C API’s @ref{11,,gcc_jit_context_new_function()}.
 @end deffn
 
 @geindex gccjit;;context;;get_builtin_function (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit7context20get_builtin_functionEPKc}@anchor{30c}@anchor{cp/topics/functions _CPPv3N6gccjit7context20get_builtin_functionEPKc}@anchor{30d}@anchor{cp/topics/functions _CPPv2N6gccjit7context20get_builtin_functionEPKc}@anchor{30e}@anchor{cp/topics/functions gccjit context get_builtin_function__cCP}@anchor{30f}
-@deffn {C++ Function} gccjit::@ref{154,,function} gccjit::@ref{13d,,context}::get_builtin_function (const char *name)
+@anchor{cp/topics/functions _CPPv4N6gccjit7context20get_builtin_functionEPKc}@anchor{334}@anchor{cp/topics/functions _CPPv3N6gccjit7context20get_builtin_functionEPKc}@anchor{335}@anchor{cp/topics/functions _CPPv2N6gccjit7context20get_builtin_functionEPKc}@anchor{336}@anchor{cp/topics/functions gccjit context get_builtin_function__cCP}@anchor{337}
+@deffn {C++ Function} gccjit::@ref{17c,,function} gccjit::@ref{165,,context}::get_builtin_function (const char *name)
 
 This is a wrapper around the C API’s
-@ref{e1,,gcc_jit_context_get_builtin_function()}.
+@ref{103,,gcc_jit_context_get_builtin_function()}.
 @end deffn
 
 @geindex gccjit;;function;;get_param (C++ function)
-@anchor{cp/topics/functions _CPPv4NK6gccjit8function9get_paramEi}@anchor{310}@anchor{cp/topics/functions _CPPv3NK6gccjit8function9get_paramEi}@anchor{311}@anchor{cp/topics/functions _CPPv2NK6gccjit8function9get_paramEi}@anchor{312}@anchor{cp/topics/functions gccjit function get_param__iC}@anchor{313}
-@deffn {C++ Function} gccjit::@ref{150,,param} gccjit::@ref{154,,function}::get_param (int index) const
+@anchor{cp/topics/functions _CPPv4NK6gccjit8function9get_paramEi}@anchor{338}@anchor{cp/topics/functions _CPPv3NK6gccjit8function9get_paramEi}@anchor{339}@anchor{cp/topics/functions _CPPv2NK6gccjit8function9get_paramEi}@anchor{33a}@anchor{cp/topics/functions gccjit function get_param__iC}@anchor{33b}
+@deffn {C++ Function} gccjit::@ref{178,,param} gccjit::@ref{17c,,function}::get_param (int index) const
 
 Get the param of the given index (0-based).
 @end deffn
 
 @geindex gccjit;;function;;dump_to_dot (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit8function11dump_to_dotEPKc}@anchor{15c}@anchor{cp/topics/functions _CPPv3N6gccjit8function11dump_to_dotEPKc}@anchor{314}@anchor{cp/topics/functions _CPPv2N6gccjit8function11dump_to_dotEPKc}@anchor{315}@anchor{cp/topics/functions gccjit function dump_to_dot__cCP}@anchor{316}
-@deffn {C++ Function} void gccjit::@ref{154,,function}::dump_to_dot (const char *path)
+@anchor{cp/topics/functions _CPPv4N6gccjit8function11dump_to_dotEPKc}@anchor{184}@anchor{cp/topics/functions _CPPv3N6gccjit8function11dump_to_dotEPKc}@anchor{33c}@anchor{cp/topics/functions _CPPv2N6gccjit8function11dump_to_dotEPKc}@anchor{33d}@anchor{cp/topics/functions gccjit function dump_to_dot__cCP}@anchor{33e}
+@deffn {C++ Function} void gccjit::@ref{17c,,function}::dump_to_dot (const char *path)
 
 Emit the function in graphviz format to the given path.
 @end deffn
 
 @geindex gccjit;;function;;new_local (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{151}@anchor{cp/topics/functions _CPPv3N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{317}@anchor{cp/topics/functions _CPPv2N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{318}@anchor{cp/topics/functions gccjit function new_local__gccjit type cCP gccjit location}@anchor{319}
-@deffn {C++ Function} gccjit::@ref{14f,,lvalue} gccjit::@ref{154,,function}::new_local (gccjit::type type, const char *name, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{179}@anchor{cp/topics/functions _CPPv3N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{33f}@anchor{cp/topics/functions _CPPv2N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{340}@anchor{cp/topics/functions gccjit function new_local__gccjit type cCP gccjit location}@anchor{341}
+@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{17c,,function}::new_local (gccjit::type type, const char *name, gccjit::location loc)
 
 Create a new local variable within the function, of the given type and
 name.
 @end deffn
 
 @node Blocks<2>,Statements<2>,Functions<2>,Creating and using functions<2>
-@anchor{cp/topics/functions blocks}@anchor{31a}
+@anchor{cp/topics/functions blocks}@anchor{342}
 @subsubsection Blocks
 
 
 @geindex gccjit;;block (C++ class)
-@anchor{cp/topics/functions _CPPv4N6gccjit5blockE}@anchor{153}@anchor{cp/topics/functions _CPPv3N6gccjit5blockE}@anchor{31b}@anchor{cp/topics/functions _CPPv2N6gccjit5blockE}@anchor{31c}@anchor{cp/topics/functions gccjit block}@anchor{31d}
+@anchor{cp/topics/functions _CPPv4N6gccjit5blockE}@anchor{17b}@anchor{cp/topics/functions _CPPv3N6gccjit5blockE}@anchor{343}@anchor{cp/topics/functions _CPPv2N6gccjit5blockE}@anchor{344}@anchor{cp/topics/functions gccjit block}@anchor{345}
 @deffn {C++ Class} gccjit::block
 
 A @cite{gccjit::block} represents a basic block within a function  i.e. a
 sequence of statements with a single entry point and a single exit
 point.
 
-@ref{153,,gccjit;;block} is a subclass of @ref{142,,gccjit;;object}.
+@ref{17b,,gccjit;;block} is a subclass of @ref{16a,,gccjit;;object}.
 
 The first basic block that you create within a function will
 be the entrypoint.
@@ -13758,8 +14376,8 @@ one function.
 @end deffn
 
 @geindex gccjit;;function;;new_block (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit8function9new_blockEPKc}@anchor{31e}@anchor{cp/topics/functions _CPPv3N6gccjit8function9new_blockEPKc}@anchor{31f}@anchor{cp/topics/functions _CPPv2N6gccjit8function9new_blockEPKc}@anchor{320}@anchor{cp/topics/functions gccjit function new_block__cCP}@anchor{321}
-@deffn {C++ Function} gccjit::@ref{153,,block} gccjit::@ref{154,,function}::new_block (const char *name)
+@anchor{cp/topics/functions _CPPv4N6gccjit8function9new_blockEPKc}@anchor{346}@anchor{cp/topics/functions _CPPv3N6gccjit8function9new_blockEPKc}@anchor{347}@anchor{cp/topics/functions _CPPv2N6gccjit8function9new_blockEPKc}@anchor{348}@anchor{cp/topics/functions gccjit function new_block__cCP}@anchor{349}
+@deffn {C++ Function} gccjit::@ref{17b,,block} gccjit::@ref{17c,,function}::new_block (const char *name)
 
 Create a basic block of the given name.  The name may be NULL, but
 providing meaningful names is often helpful when debugging: it may
@@ -13768,13 +14386,13 @@ messages.
 @end deffn
 
 @node Statements<2>,,Blocks<2>,Creating and using functions<2>
-@anchor{cp/topics/functions statements}@anchor{322}
+@anchor{cp/topics/functions statements}@anchor{34a}
 @subsubsection Statements
 
 
 @geindex gccjit;;block;;add_eval (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2ca}@anchor{cp/topics/functions _CPPv3N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{323}@anchor{cp/topics/functions _CPPv2N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{324}@anchor{cp/topics/functions gccjit block add_eval__gccjit rvalue gccjit location}@anchor{325}
-@deffn {C++ Function} void gccjit::@ref{153,,block}::add_eval (gccjit::rvalue rvalue, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2f2}@anchor{cp/topics/functions _CPPv3N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{34b}@anchor{cp/topics/functions _CPPv2N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{34c}@anchor{cp/topics/functions gccjit block add_eval__gccjit rvalue gccjit location}@anchor{34d}
+@deffn {C++ Function} void gccjit::@ref{17b,,block}::add_eval (gccjit::rvalue rvalue, gccjit::location loc)
 
 Add evaluation of an rvalue, discarding the result
 (e.g. a function call that “returns” void).
@@ -13787,8 +14405,8 @@ This is equivalent to this C code:
 @end deffn
 
 @geindex gccjit;;block;;add_assignment (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{155}@anchor{cp/topics/functions _CPPv3N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{326}@anchor{cp/topics/functions _CPPv2N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{327}@anchor{cp/topics/functions gccjit block add_assignment__gccjit lvalue gccjit rvalue gccjit location}@anchor{328}
-@deffn {C++ Function} void gccjit::@ref{153,,block}::add_assignment (gccjit::lvalue lvalue, gccjit::rvalue rvalue, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{17d}@anchor{cp/topics/functions _CPPv3N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{34e}@anchor{cp/topics/functions _CPPv2N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{34f}@anchor{cp/topics/functions gccjit block add_assignment__gccjit lvalue gccjit rvalue gccjit location}@anchor{350}
+@deffn {C++ Function} void gccjit::@ref{17b,,block}::add_assignment (gccjit::lvalue lvalue, gccjit::rvalue rvalue, gccjit::location loc)
 
 Add evaluation of an rvalue, assigning the result to the given
 lvalue.
@@ -13801,8 +14419,8 @@ lvalue = rvalue;
 @end deffn
 
 @geindex gccjit;;block;;add_assignment_op (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{159}@anchor{cp/topics/functions _CPPv3N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{329}@anchor{cp/topics/functions _CPPv2N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{32a}@anchor{cp/topics/functions gccjit block add_assignment_op__gccjit lvalue gcc_jit_binary_op gccjit rvalue gccjit location}@anchor{32b}
-@deffn {C++ Function} void gccjit::@ref{153,,block}::add_assignment_op (gccjit::lvalue lvalue, enum gcc_jit_binary_op, gccjit::rvalue rvalue, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{181}@anchor{cp/topics/functions _CPPv3N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{351}@anchor{cp/topics/functions _CPPv2N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{352}@anchor{cp/topics/functions gccjit block add_assignment_op__gccjit lvalue gcc_jit_binary_op gccjit rvalue gccjit location}@anchor{353}
+@deffn {C++ Function} void gccjit::@ref{17b,,block}::add_assignment_op (gccjit::lvalue lvalue, enum gcc_jit_binary_op, gccjit::rvalue rvalue, gccjit::location loc)
 
 Add evaluation of an rvalue, using the result to modify an
 lvalue.
@@ -13827,8 +14445,8 @@ loop_body.add_assignment_op (
 @end deffn
 
 @geindex gccjit;;block;;add_comment (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{165}@anchor{cp/topics/functions _CPPv3N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{32c}@anchor{cp/topics/functions _CPPv2N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{32d}@anchor{cp/topics/functions gccjit block add_comment__cCP gccjit location}@anchor{32e}
-@deffn {C++ Function} void gccjit::@ref{153,,block}::add_comment (const char *text, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{18d}@anchor{cp/topics/functions _CPPv3N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{354}@anchor{cp/topics/functions _CPPv2N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{355}@anchor{cp/topics/functions gccjit block add_comment__cCP gccjit location}@anchor{356}
+@deffn {C++ Function} void gccjit::@ref{17b,,block}::add_comment (const char *text, gccjit::location loc)
 
 Add a no-op textual comment to the internal representation of the
 code.  It will be optimized away, but will be visible in the dumps
@@ -13841,8 +14459,8 @@ Parameter “loc” is optional.
 @end deffn
 
 @geindex gccjit;;block;;end_with_conditional (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{158}@anchor{cp/topics/functions _CPPv3N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{32f}@anchor{cp/topics/functions _CPPv2N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{330}@anchor{cp/topics/functions gccjit block end_with_conditional__gccjit rvalue gccjit block gccjit block gccjit location}@anchor{331}
-@deffn {C++ Function} void gccjit::@ref{153,,block}::end_with_conditional (gccjit::rvalue boolval, gccjit::block on_true, gccjit::block on_false, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{180}@anchor{cp/topics/functions _CPPv3N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{357}@anchor{cp/topics/functions _CPPv2N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{358}@anchor{cp/topics/functions gccjit block end_with_conditional__gccjit rvalue gccjit block gccjit block gccjit location}@anchor{359}
+@deffn {C++ Function} void gccjit::@ref{17b,,block}::end_with_conditional (gccjit::rvalue boolval, gccjit::block on_true, gccjit::block on_false, gccjit::location loc)
 
 Terminate a block by adding evaluation of an rvalue, branching on the
 result to the appropriate successor block.
@@ -13860,8 +14478,8 @@ block, boolval, on_true, and on_false must be non-NULL.
 @end deffn
 
 @geindex gccjit;;block;;end_with_jump (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{332}@anchor{cp/topics/functions _CPPv3N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{333}@anchor{cp/topics/functions _CPPv2N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{334}@anchor{cp/topics/functions gccjit block end_with_jump__gccjit block gccjit location}@anchor{335}
-@deffn {C++ Function} void gccjit::@ref{153,,block}::end_with_jump (gccjit::block target, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{35a}@anchor{cp/topics/functions _CPPv3N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{35b}@anchor{cp/topics/functions _CPPv2N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{35c}@anchor{cp/topics/functions gccjit block end_with_jump__gccjit block gccjit location}@anchor{35d}
+@deffn {C++ Function} void gccjit::@ref{17b,,block}::end_with_jump (gccjit::block target, gccjit::location loc)
 
 Terminate a block by adding a jump to the given target block.
 
@@ -13873,8 +14491,8 @@ goto target;
 @end deffn
 
 @geindex gccjit;;block;;end_with_return (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{336}@anchor{cp/topics/functions _CPPv3N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{337}@anchor{cp/topics/functions _CPPv2N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{338}@anchor{cp/topics/functions gccjit block end_with_return__gccjit rvalue gccjit location}@anchor{339}
-@deffn {C++ Function} void gccjit::@ref{153,,block}::end_with_return (gccjit::rvalue rvalue, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{35e}@anchor{cp/topics/functions _CPPv3N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{35f}@anchor{cp/topics/functions _CPPv2N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{360}@anchor{cp/topics/functions gccjit block end_with_return__gccjit rvalue gccjit location}@anchor{361}
+@deffn {C++ Function} void gccjit::@ref{17b,,block}::end_with_return (gccjit::rvalue rvalue, gccjit::location loc)
 
 Terminate a block.
 
@@ -13903,8 +14521,8 @@ return;
 @end deffn
 
 @geindex gccjit;;block;;end_with_switch (C++ function)
-@anchor{cp/topics/functions _CPPv4N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{33a}@anchor{cp/topics/functions _CPPv3N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{33b}@anchor{cp/topics/functions _CPPv2N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{33c}@anchor{cp/topics/functions gccjit block end_with_switch__gccjit rvalue gccjit block std vector gccjit case_ gccjit location}@anchor{33d}
-@deffn {C++ Function} void gccjit::@ref{153,,block}::end_with_switch (gccjit::rvalue expr, gccjit::block default_block, std::vector<gccjit::case_> cases, gccjit::location loc)
+@anchor{cp/topics/functions _CPPv4N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{362}@anchor{cp/topics/functions _CPPv3N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{363}@anchor{cp/topics/functions _CPPv2N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{364}@anchor{cp/topics/functions gccjit block end_with_switch__gccjit rvalue gccjit block std vector gccjit case_ gccjit location}@anchor{365}
+@deffn {C++ Function} void gccjit::@ref{17b,,block}::end_with_switch (gccjit::rvalue expr, gccjit::block default_block, std::vector<gccjit::case_> cases, gccjit::location loc)
 
 Terminate a block by adding evalation of an rvalue, then performing
 a multiway branch.
@@ -13944,14 +14562,14 @@ The API entrypoints relating to switch statements and cases:
 @itemize *
 
 @item 
-@ref{33a,,gccjit;;block;;end_with_switch()}
+@ref{362,,gccjit;;block;;end_with_switch()}
 
 @item 
 @code{gccjit::context::new_case()}
 @end itemize
 @end quotation
 
-were added in @ref{ef,,LIBGCCJIT_ABI_3}; you can test for their presence
+were added in @ref{114,,LIBGCCJIT_ABI_3}; you can test for their presence
 using
 
 @example
@@ -13959,9 +14577,9 @@ using
 @end example
 
 A @cite{gccjit::case_} represents a case within a switch statement, and
-is created within a particular @ref{13d,,gccjit;;context} using
+is created within a particular @ref{165,,gccjit;;context} using
 @code{gccjit::context::new_case()}.  It is a subclass of
-@ref{142,,gccjit;;object}.
+@ref{16a,,gccjit;;object}.
 
 Each case expresses a multivalued range of integer values.  You
 can express single-valued cases by passing in the same value for
@@ -14064,12 +14682,12 @@ create_code (gcc_jit_context *c_ctxt, void *user_data)
 @c <https://www.gnu.org/licenses/>.
 
 @node Source Locations<2>,Compiling a context<2>,Creating and using functions<2>,Topic Reference<2>
-@anchor{cp/topics/locations doc}@anchor{33e}@anchor{cp/topics/locations source-locations}@anchor{33f}
+@anchor{cp/topics/locations doc}@anchor{366}@anchor{cp/topics/locations source-locations}@anchor{367}
 @subsection Source Locations
 
 
 @geindex gccjit;;location (C++ class)
-@anchor{cp/topics/locations _CPPv4N6gccjit8locationE}@anchor{163}@anchor{cp/topics/locations _CPPv3N6gccjit8locationE}@anchor{340}@anchor{cp/topics/locations _CPPv2N6gccjit8locationE}@anchor{341}@anchor{cp/topics/locations gccjit location}@anchor{342}
+@anchor{cp/topics/locations _CPPv4N6gccjit8locationE}@anchor{18b}@anchor{cp/topics/locations _CPPv3N6gccjit8locationE}@anchor{368}@anchor{cp/topics/locations _CPPv2N6gccjit8locationE}@anchor{369}@anchor{cp/topics/locations gccjit location}@anchor{36a}
 @deffn {C++ Class} gccjit::location
 
 A @cite{gccjit::location} encapsulates a source code location, so that
@@ -14080,10 +14698,10 @@ single-step through your language.
 @cite{gccjit::location} instances are optional: you can always omit them
 from any C++ API entrypoint accepting one.
 
-You can construct them using @ref{169,,gccjit;;context;;new_location()}.
+You can construct them using @ref{191,,gccjit;;context;;new_location()}.
 
 You need to enable @ref{42,,GCC_JIT_BOOL_OPTION_DEBUGINFO} on the
-@ref{13d,,gccjit;;context} for these locations to actually be usable by
+@ref{165,,gccjit;;context} for these locations to actually be usable by
 the debugger:
 
 @example
@@ -14092,8 +14710,8 @@ ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DEBUGINFO, 1);
 @end deffn
 
 @geindex gccjit;;context;;new_location (C++ function)
-@anchor{cp/topics/locations _CPPv4N6gccjit7context12new_locationEPKcii}@anchor{169}@anchor{cp/topics/locations _CPPv3N6gccjit7context12new_locationEPKcii}@anchor{343}@anchor{cp/topics/locations _CPPv2N6gccjit7context12new_locationEPKcii}@anchor{344}@anchor{cp/topics/locations gccjit context new_location__cCP i i}@anchor{345}
-@deffn {C++ Function} gccjit::@ref{163,,location} gccjit::@ref{13d,,context}::new_location (const char *filename, int line, int column)
+@anchor{cp/topics/locations _CPPv4N6gccjit7context12new_locationEPKcii}@anchor{191}@anchor{cp/topics/locations _CPPv3N6gccjit7context12new_locationEPKcii}@anchor{36b}@anchor{cp/topics/locations _CPPv2N6gccjit7context12new_locationEPKcii}@anchor{36c}@anchor{cp/topics/locations gccjit context new_location__cCP i i}@anchor{36d}
+@deffn {C++ Function} gccjit::@ref{18b,,location} gccjit::@ref{165,,context}::new_location (const char *filename, int line, int column)
 
 Create a @cite{gccjit::location} instance representing the given source
 location.
@@ -14105,13 +14723,13 @@ location.
 @end menu
 
 @node Faking it<2>,,,Source Locations<2>
-@anchor{cp/topics/locations faking-it}@anchor{346}
+@anchor{cp/topics/locations faking-it}@anchor{36e}
 @subsubsection Faking it
 
 
 If you don’t have source code for your internal representation, but need
 to debug, you can generate a C-like representation of the functions in
-your context using @ref{188,,gccjit;;context;;dump_to_file()}:
+your context using @ref{1b0,,gccjit;;context;;dump_to_file()}:
 
 @example
 ctxt.dump_to_file ("/tmp/something.c",
@@ -14141,13 +14759,13 @@ file, giving you @emph{something} you can step through in the debugger.
 @c <https://www.gnu.org/licenses/>.
 
 @node Compiling a context<2>,Using Assembly Language with libgccjit++,Source Locations<2>,Topic Reference<2>
-@anchor{cp/topics/compilation doc}@anchor{347}@anchor{cp/topics/compilation compiling-a-context}@anchor{348}
+@anchor{cp/topics/compilation doc}@anchor{36f}@anchor{cp/topics/compilation compiling-a-context}@anchor{370}
 @subsection Compiling a context
 
 
-Once populated, a @ref{13d,,gccjit;;context} can be compiled to
-machine code, either in-memory via @ref{147,,gccjit;;context;;compile()} or
-to disk via @ref{349,,gccjit;;context;;compile_to_file()}.
+Once populated, a @ref{165,,gccjit;;context} can be compiled to
+machine code, either in-memory via @ref{16f,,gccjit;;context;;compile()} or
+to disk via @ref{371,,gccjit;;context;;compile_to_file()}.
 
 You can compile a context multiple times (using either form of
 compilation), although any errors that occur on the context will
@@ -14160,13 +14778,13 @@ prevent any future compilation of that context.
 @end menu
 
 @node In-memory compilation<2>,Ahead-of-time compilation<2>,,Compiling a context<2>
-@anchor{cp/topics/compilation in-memory-compilation}@anchor{34a}
+@anchor{cp/topics/compilation in-memory-compilation}@anchor{372}
 @subsubsection In-memory compilation
 
 
 @geindex gccjit;;context;;compile (C++ function)
-@anchor{cp/topics/compilation _CPPv4N6gccjit7context7compileEv}@anchor{147}@anchor{cp/topics/compilation _CPPv3N6gccjit7context7compileEv}@anchor{34b}@anchor{cp/topics/compilation _CPPv2N6gccjit7context7compileEv}@anchor{34c}@anchor{cp/topics/compilation gccjit context compile}@anchor{34d}
-@deffn {C++ Function} gcc_jit_result *gccjit::@ref{13d,,context}::compile ()
+@anchor{cp/topics/compilation _CPPv4N6gccjit7context7compileEv}@anchor{16f}@anchor{cp/topics/compilation _CPPv3N6gccjit7context7compileEv}@anchor{373}@anchor{cp/topics/compilation _CPPv2N6gccjit7context7compileEv}@anchor{374}@anchor{cp/topics/compilation gccjit context compile}@anchor{375}
+@deffn {C++ Function} gcc_jit_result *gccjit::@ref{165,,context}::compile ()
 
 This calls into GCC and builds the code, returning a
 @cite{gcc_jit_result *}.
@@ -14176,19 +14794,19 @@ This is a thin wrapper around the
 @end deffn
 
 @node Ahead-of-time compilation<2>,,In-memory compilation<2>,Compiling a context<2>
-@anchor{cp/topics/compilation ahead-of-time-compilation}@anchor{34e}
+@anchor{cp/topics/compilation ahead-of-time-compilation}@anchor{376}
 @subsubsection Ahead-of-time compilation
 
 
 Although libgccjit is primarily aimed at just-in-time compilation, it
 can also be used for implementing more traditional ahead-of-time
-compilers, via the @ref{349,,gccjit;;context;;compile_to_file()} method.
+compilers, via the @ref{371,,gccjit;;context;;compile_to_file()} method.
 
 @geindex gccjit;;context;;compile_to_file (C++ function)
-@anchor{cp/topics/compilation _CPPv4N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{349}@anchor{cp/topics/compilation _CPPv3N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{34f}@anchor{cp/topics/compilation _CPPv2N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{350}@anchor{cp/topics/compilation gccjit context compile_to_file__gcc_jit_output_kind cCP}@anchor{351}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::compile_to_file (enum gcc_jit_output_kind, const char *output_path)
+@anchor{cp/topics/compilation _CPPv4N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{371}@anchor{cp/topics/compilation _CPPv3N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{377}@anchor{cp/topics/compilation _CPPv2N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{378}@anchor{cp/topics/compilation gccjit context compile_to_file__gcc_jit_output_kind cCP}@anchor{379}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::compile_to_file (enum gcc_jit_output_kind, const char *output_path)
 
-Compile the @ref{13d,,gccjit;;context} to a file of the given
+Compile the @ref{165,,gccjit;;context} to a file of the given
 kind.
 
 This is a thin wrapper around the
@@ -14213,7 +14831,7 @@ This is a thin wrapper around the
 @c <https://www.gnu.org/licenses/>.
 
 @node Using Assembly Language with libgccjit++,,Compiling a context<2>,Topic Reference<2>
-@anchor{cp/topics/asm doc}@anchor{352}@anchor{cp/topics/asm using-assembly-language-with-libgccjit}@anchor{353}
+@anchor{cp/topics/asm doc}@anchor{37a}@anchor{cp/topics/asm using-assembly-language-with-libgccjit}@anchor{37b}
 @subsection Using Assembly Language with libgccjit++
 
 
@@ -14223,7 +14841,7 @@ following assumes a familiarity with that functionality.  See
 How to Use Inline Assembly Language in C Code@footnote{https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-with-C.html}
 in GCC’s documentation, the “Extended Asm” section in particular.
 
-These entrypoints were added in @ref{122,,LIBGCCJIT_ABI_15}; you can test
+These entrypoints were added in @ref{146,,LIBGCCJIT_ABI_15}; you can test
 for their presence using
 
 @quotation
@@ -14240,38 +14858,38 @@ for their presence using
 @end menu
 
 @node Adding assembler instructions within a function<2>,Adding top-level assembler statements<2>,,Using Assembly Language with libgccjit++
-@anchor{cp/topics/asm adding-assembler-instructions-within-a-function}@anchor{354}
+@anchor{cp/topics/asm adding-assembler-instructions-within-a-function}@anchor{37c}
 @subsubsection Adding assembler instructions within a function
 
 
 @geindex gccjit;;extended_asm (C++ class)
-@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asmE}@anchor{355}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asmE}@anchor{356}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asmE}@anchor{357}@anchor{cp/topics/asm gccjit extended_asm}@anchor{358}
+@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asmE}@anchor{37d}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asmE}@anchor{37e}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asmE}@anchor{37f}@anchor{cp/topics/asm gccjit extended_asm}@anchor{380}
 @deffn {C++ Class} gccjit::extended_asm
 
 A @cite{gccjit::extended_asm} represents an extended @code{asm} statement: a
 series of low-level instructions inside a function that convert inputs
 to outputs.
 
-@ref{355,,gccjit;;extended_asm} is a subclass of @ref{142,,gccjit;;object}.
-It is a thin wrapper around the C API’s @ref{f1,,gcc_jit_extended_asm *}.
+@ref{37d,,gccjit;;extended_asm} is a subclass of @ref{16a,,gccjit;;object}.
+It is a thin wrapper around the C API’s @ref{115,,gcc_jit_extended_asm *}.
 
 To avoid having an API entrypoint with a very large number of
 parameters, an extended @code{asm} statement is made in stages:
-an initial call to create the @ref{355,,gccjit;;extended_asm},
+an initial call to create the @ref{37d,,gccjit;;extended_asm},
 followed by calls to add operands and set other properties of the
 statement.
 
-There are two API entrypoints for creating a @ref{355,,gccjit;;extended_asm}:
+There are two API entrypoints for creating a @ref{37d,,gccjit;;extended_asm}:
 
 
 @itemize *
 
 @item 
-@ref{359,,gccjit;;block;;add_extended_asm()} for an @code{asm} statement with
+@ref{381,,gccjit;;block;;add_extended_asm()} for an @code{asm} statement with
 no control flow, and
 
 @item 
-@ref{35a,,gccjit;;block;;end_with_extended_asm_goto()} for an @code{asm goto}.
+@ref{382,,gccjit;;block;;end_with_extended_asm_goto()} for an @code{asm goto}.
 @end itemize
 
 For example, to create the equivalent of:
@@ -14299,8 +14917,8 @@ extended @code{asm} statement (e.g. the @code{%0} and @code{%1}
 above), the equivalent to the C syntax is followed i.e. all
 output operands, then all input operands, regardless of
 what order the calls to
-@ref{35b,,gccjit;;extended_asm;;add_output_operand()} and
-@ref{35c,,gccjit;;extended_asm;;add_input_operand()} were made in.
+@ref{383,,gccjit;;extended_asm;;add_output_operand()} and
+@ref{384,,gccjit;;extended_asm;;add_input_operand()} were made in.
 @end quotation
 @end cartouche
 
@@ -14325,10 +14943,10 @@ the following API calls could be used:
 @end deffn
 
 @geindex gccjit;;block;;add_extended_asm (C++ function)
-@anchor{cp/topics/asm _CPPv4N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{359}@anchor{cp/topics/asm _CPPv3N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{35d}@anchor{cp/topics/asm _CPPv2N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{35e}@anchor{cp/topics/asm gccjit block add_extended_asm__ssCR gccjit location}@anchor{35f}
-@deffn {C++ Function} @ref{355,,extended_asm} gccjit::@ref{153,,block}::add_extended_asm (const std::string &asm_template, gccjit::location loc = location())
+@anchor{cp/topics/asm _CPPv4N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{381}@anchor{cp/topics/asm _CPPv3N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{385}@anchor{cp/topics/asm _CPPv2N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{386}@anchor{cp/topics/asm gccjit block add_extended_asm__ssCR gccjit location}@anchor{387}
+@deffn {C++ Function} @ref{37d,,extended_asm} gccjit::@ref{17b,,block}::add_extended_asm (const std::string &asm_template, gccjit::location loc = location())
 
-Create a @ref{355,,gccjit;;extended_asm} for an extended @code{asm} statement
+Create a @ref{37d,,gccjit;;extended_asm} for an extended @code{asm} statement
 with no control flow (i.e. without the @code{goto} qualifier).
 
 The parameter @code{asm_template} corresponds to the @cite{AssemblerTemplate}
@@ -14338,10 +14956,10 @@ an on-stack buffer.
 @end deffn
 
 @geindex gccjit;;block;;end_with_extended_asm_goto (C++ function)
-@anchor{cp/topics/asm _CPPv4N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{35a}@anchor{cp/topics/asm _CPPv3N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{360}@anchor{cp/topics/asm _CPPv2N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{361}@anchor{cp/topics/asm gccjit block end_with_extended_asm_goto__ssCR std vector block blockP location}@anchor{362}
-@deffn {C++ Function} @ref{355,,extended_asm} gccjit::@ref{153,,block}::end_with_extended_asm_goto (const std::string &asm_template, std::vector<block> goto_blocks, block *fallthrough_block, location loc = location())
+@anchor{cp/topics/asm _CPPv4N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{382}@anchor{cp/topics/asm _CPPv3N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{388}@anchor{cp/topics/asm _CPPv2N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{389}@anchor{cp/topics/asm gccjit block end_with_extended_asm_goto__ssCR std vector block blockP location}@anchor{38a}
+@deffn {C++ Function} @ref{37d,,extended_asm} gccjit::@ref{17b,,block}::end_with_extended_asm_goto (const std::string &asm_template, std::vector<block> goto_blocks, block *fallthrough_block, location loc = location())
 
-Create a @ref{355,,gccjit;;extended_asm} for an extended @code{asm} statement
+Create a @ref{37d,,gccjit;;extended_asm} for an extended @code{asm} statement
 that may perform jumps, and use it to terminate the given block.
 This is equivalent to the @code{goto} qualifier in C’s extended @code{asm}
 syntax.
@@ -14390,7 +15008,7 @@ to fall through to after the statement.
 
 @cartouche
 @quotation Note 
-This is needed since each @ref{153,,gccjit;;block} must have a
+This is needed since each @ref{17b,,gccjit;;block} must have a
 single exit point, as a basic block: you can’t jump from the
 middle of a block.  A “goto” is implicitly added after the
 asm to handle the fallthrough case, which is equivalent to what
@@ -14400,10 +15018,10 @@ would have happened in the C case.
 @end deffn
 
 @geindex gccjit;;extended_asm;;set_volatile_flag (C++ function)
-@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17set_volatile_flagEb}@anchor{363}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17set_volatile_flagEb}@anchor{364}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17set_volatile_flagEb}@anchor{365}@anchor{cp/topics/asm gccjit extended_asm set_volatile_flag__b}@anchor{366}
-@deffn {C++ Function} gccjit::@ref{355,,extended_asm} &gccjit::@ref{355,,extended_asm}::set_volatile_flag (bool flag)
+@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17set_volatile_flagEb}@anchor{38b}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17set_volatile_flagEb}@anchor{38c}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17set_volatile_flagEb}@anchor{38d}@anchor{cp/topics/asm gccjit extended_asm set_volatile_flag__b}@anchor{38e}
+@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::set_volatile_flag (bool flag)
 
-Set whether the @ref{355,,gccjit;;extended_asm} has side-effects, equivalent to the
+Set whether the @ref{37d,,gccjit;;extended_asm} has side-effects, equivalent to the
 volatile@footnote{https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#Volatile}
 qualifier in C’s extended asm syntax.
 
@@ -14431,12 +15049,12 @@ the following API calls could be used:
     .add_clobber ("rdx");
 @end example
 
-where the @ref{355,,gccjit;;extended_asm} is flagged as volatile.
+where the @ref{37d,,gccjit;;extended_asm} is flagged as volatile.
 @end deffn
 
 @geindex gccjit;;extended_asm;;set_inline_flag (C++ function)
-@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm15set_inline_flagEb}@anchor{367}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm15set_inline_flagEb}@anchor{368}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm15set_inline_flagEb}@anchor{369}@anchor{cp/topics/asm gccjit extended_asm set_inline_flag__b}@anchor{36a}
-@deffn {C++ Function} gccjit::@ref{355,,extended_asm} &gccjit::@ref{355,,extended_asm}::set_inline_flag (bool flag)
+@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm15set_inline_flagEb}@anchor{38f}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm15set_inline_flagEb}@anchor{390}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm15set_inline_flagEb}@anchor{391}@anchor{cp/topics/asm gccjit extended_asm set_inline_flag__b}@anchor{392}
+@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::set_inline_flag (bool flag)
 
 Set the equivalent of the
 inline@footnote{https://gcc.gnu.org/onlinedocs/gcc/Size-of-an-asm.html#Size-of-an-asm}
@@ -14444,8 +15062,8 @@ qualifier in C’s extended @code{asm} syntax.
 @end deffn
 
 @geindex gccjit;;extended_asm;;add_output_operand (C++ function)
-@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{35b}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{36b}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{36c}@anchor{cp/topics/asm gccjit extended_asm add_output_operand__ssCR ssCR gccjit lvalue}@anchor{36d}
-@deffn {C++ Function} gccjit::@ref{355,,extended_asm} &gccjit::@ref{355,,extended_asm}::add_output_operand (const std::string &asm_symbolic_name, const std::string &constraint, gccjit::lvalue dest)
+@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{383}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{393}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{394}@anchor{cp/topics/asm gccjit extended_asm add_output_operand__ssCR ssCR gccjit lvalue}@anchor{395}
+@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::add_output_operand (const std::string &asm_symbolic_name, const std::string &constraint, gccjit::lvalue dest)
 
 Add an output operand to the extended @code{asm} statement.  See the
 Output Operands@footnote{https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#OutputOperands}
@@ -14475,8 +15093,8 @@ section of GCC’s “Extended Asm” documentation.
 @end deffn
 
 @geindex gccjit;;extended_asm;;add_output_operand (C++ function)
-@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{36e}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{36f}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{370}@anchor{cp/topics/asm gccjit extended_asm add_output_operand__ssCR gccjit lvalue}@anchor{371}
-@deffn {C++ Function} gccjit::@ref{355,,extended_asm} &gccjit::@ref{355,,extended_asm}::add_output_operand (const std::string &constraint, gccjit::lvalue dest)
+@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{396}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{397}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{398}@anchor{cp/topics/asm gccjit extended_asm add_output_operand__ssCR gccjit lvalue}@anchor{399}
+@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::add_output_operand (const std::string &constraint, gccjit::lvalue dest)
 
 As above, but don’t supply a symbolic name for the operand.
 
@@ -14488,8 +15106,8 @@ ext_asm.add_output_operand ("=r", dst);
 @end deffn
 
 @geindex gccjit;;extended_asm;;add_input_operand (C++ function)
-@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{35c}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{372}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{373}@anchor{cp/topics/asm gccjit extended_asm add_input_operand__ssCR ssCR gccjit rvalue}@anchor{374}
-@deffn {C++ Function} gccjit::@ref{355,,extended_asm} &gccjit::@ref{355,,extended_asm}::add_input_operand (const std::string &asm_symbolic_name, const std::string &constraint, gccjit::rvalue src)
+@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{384}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{39a}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{39b}@anchor{cp/topics/asm gccjit extended_asm add_input_operand__ssCR ssCR gccjit rvalue}@anchor{39c}
+@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::add_input_operand (const std::string &asm_symbolic_name, const std::string &constraint, gccjit::rvalue src)
 
 Add an input operand to the extended @code{asm} statement.  See the
 Input Operands@footnote{https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands}
@@ -14513,8 +15131,8 @@ ext_asm.add_input_operand ("aMask", "r", mask);
 @end deffn
 
 @geindex gccjit;;extended_asm;;add_input_operand (C++ function)
-@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{375}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{376}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{377}@anchor{cp/topics/asm gccjit extended_asm add_input_operand__ssCR gccjit rvalue}@anchor{378}
-@deffn {C++ Function} gccjit::@ref{355,,extended_asm} &gccjit::@ref{355,,extended_asm}::add_input_operand (const std::string &constraint, gccjit::rvalue src)
+@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{39d}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{39e}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{39f}@anchor{cp/topics/asm gccjit extended_asm add_input_operand__ssCR gccjit rvalue}@anchor{3a0}
+@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::add_input_operand (const std::string &constraint, gccjit::rvalue src)
 
 As above, but don’t supply a symbolic name for the operand.
 
@@ -14526,8 +15144,8 @@ ext_asm.add_input_operand ("r", src);
 @end deffn
 
 @geindex gccjit;;extended_asm;;add_clobber (C++ function)
-@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{379}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{37a}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{37b}@anchor{cp/topics/asm gccjit extended_asm add_clobber__ssCR}@anchor{37c}
-@deffn {C++ Function} gccjit::@ref{355,,extended_asm} &gccjit::@ref{355,,extended_asm}::add_clobber (const std::string &victim)
+@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{3a1}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{3a2}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{3a3}@anchor{cp/topics/asm gccjit extended_asm add_clobber__ssCR}@anchor{3a4}
+@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::add_clobber (const std::string &victim)
 
 Add @cite{victim} to the list of registers clobbered by the extended @code{asm}
 statement.  See the
@@ -14545,7 +15163,7 @@ ext_asm.add_clobber ("r0").add_clobber ("cc").add_clobber ("memory");
 @end deffn
 
 @node Adding top-level assembler statements<2>,,Adding assembler instructions within a function<2>,Using Assembly Language with libgccjit++
-@anchor{cp/topics/asm adding-top-level-assembler-statements}@anchor{37d}
+@anchor{cp/topics/asm adding-top-level-assembler-statements}@anchor{3a5}
 @subsubsection Adding top-level assembler statements
 
 
@@ -14554,8 +15172,8 @@ there is support for creating “top-level” assembler statements, outside
 of any function.
 
 @geindex gccjit;;context;;add_top_level_asm (C++ function)
-@anchor{cp/topics/asm _CPPv4N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{37e}@anchor{cp/topics/asm _CPPv3N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{37f}@anchor{cp/topics/asm _CPPv2N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{380}@anchor{cp/topics/asm gccjit context add_top_level_asm__cCP gccjit location}@anchor{381}
-@deffn {C++ Function} void gccjit::@ref{13d,,context}::add_top_level_asm (const char *asm_stmts, gccjit::location loc = location())
+@anchor{cp/topics/asm _CPPv4N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{3a6}@anchor{cp/topics/asm _CPPv3N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{3a7}@anchor{cp/topics/asm _CPPv2N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{3a8}@anchor{cp/topics/asm gccjit context add_top_level_asm__cCP gccjit location}@anchor{3a9}
+@deffn {C++ Function} void gccjit::@ref{165,,context}::add_top_level_asm (const char *asm_stmts, gccjit::location loc = location())
 
 Create a set of top-level asm statements, analogous to those created
 by GCC’s “basic” @code{asm} syntax in C at file scope.
@@ -14606,7 +15224,7 @@ the following API calls could be used:
 @c <https://www.gnu.org/licenses/>.
 
 @node Internals,Indices and tables,C++ bindings for libgccjit,Top
-@anchor{internals/index doc}@anchor{382}@anchor{internals/index internals}@anchor{383}
+@anchor{internals/index doc}@anchor{3aa}@anchor{internals/index internals}@anchor{3ab}
 @chapter Internals
 
 
@@ -14622,7 +15240,7 @@ the following API calls could be used:
 @end menu
 
 @node Working on the JIT library,Running the test suite,,Internals
-@anchor{internals/index working-on-the-jit-library}@anchor{384}
+@anchor{internals/index working-on-the-jit-library}@anchor{3ac}
 @section Working on the JIT library
 
 
@@ -14655,7 +15273,7 @@ gcc/libgccjit.so.0.0.1: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV),
 Here’s what those configuration options mean:
 
 @geindex command line option; --enable-host-shared
-@anchor{internals/index cmdoption-enable-host-shared}@anchor{385}
+@anchor{internals/index cmdoption-enable-host-shared}@anchor{3ad}
 @deffn {Option} @w{-}@w{-}enable@w{-}host@w{-}shared
 
 Configuring with this option means that the compiler is built as
@@ -14664,7 +15282,7 @@ but it necessary for a shared library.
 @end deffn
 
 @geindex command line option; --enable-languages=jit@comma{}c++
-@anchor{internals/index cmdoption-enable-languages}@anchor{386}
+@anchor{internals/index cmdoption-enable-languages}@anchor{3ae}
 @deffn {Option} @w{-}@w{-}enable@w{-}languages=jit,c++
 
 This specifies which frontends to build.  The JIT library looks like
@@ -14681,7 +15299,7 @@ c++: error trying to exec 'cc1plus': execvp: No such file or directory
 @end deffn
 
 @geindex command line option; --disable-bootstrap
-@anchor{internals/index cmdoption-disable-bootstrap}@anchor{387}
+@anchor{internals/index cmdoption-disable-bootstrap}@anchor{3af}
 @deffn {Option} @w{-}@w{-}disable@w{-}bootstrap
 
 For hacking on the “jit” subdirectory, performing a full
@@ -14691,7 +15309,7 @@ the compiler can still bootstrap itself.
 @end deffn
 
 @geindex command line option; --enable-checking=release
-@anchor{internals/index cmdoption-enable-checking}@anchor{388}
+@anchor{internals/index cmdoption-enable-checking}@anchor{3b0}
 @deffn {Option} @w{-}@w{-}enable@w{-}checking=release
 
 The compile can perform extensive self-checking as it runs, useful when
@@ -14702,7 +15320,7 @@ disable this self-checking.
 @end deffn
 
 @node Running the test suite,Environment variables,Working on the JIT library,Internals
-@anchor{internals/index running-the-test-suite}@anchor{389}
+@anchor{internals/index running-the-test-suite}@anchor{3b1}
 @section Running the test suite
 
 
@@ -14760,7 +15378,7 @@ and once a test has been compiled, you can debug it directly:
 @end menu
 
 @node Running under valgrind,,,Running the test suite
-@anchor{internals/index running-under-valgrind}@anchor{38a}
+@anchor{internals/index running-under-valgrind}@anchor{3b2}
 @subsection Running under valgrind
 
 
@@ -14809,7 +15427,7 @@ When running under valgrind, it’s best to have configured gcc with
 various known false positives.
 
 @node Environment variables,Packaging notes,Running the test suite,Internals
-@anchor{internals/index environment-variables}@anchor{38b}
+@anchor{internals/index environment-variables}@anchor{3b3}
 @section Environment variables
 
 
@@ -14817,7 +15435,7 @@ When running client code against a locally-built libgccjit, three
 environment variables need to be set up:
 
 @geindex environment variable; LD_LIBRARY_PATH
-@anchor{internals/index envvar-LD_LIBRARY_PATH}@anchor{38c}
+@anchor{internals/index envvar-LD_LIBRARY_PATH}@anchor{3b4}
 @deffn {Environment Variable} LD_LIBRARY_PATH
 
 @quotation
@@ -14837,7 +15455,7 @@ libgccjit.so.0.0.1: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux),
 @end deffn
 
 @geindex environment variable; PATH
-@anchor{internals/index envvar-PATH}@anchor{38d}
+@anchor{internals/index envvar-PATH}@anchor{3b5}
 @deffn {Environment Variable} PATH
 
 The library uses a driver executable for converting from .s assembler
@@ -14856,7 +15474,7 @@ of development.
 @end deffn
 
 @geindex environment variable; LIBRARY_PATH
-@anchor{internals/index envvar-LIBRARY_PATH}@anchor{38e}
+@anchor{internals/index envvar-LIBRARY_PATH}@anchor{3b6}
 @deffn {Environment Variable} LIBRARY_PATH
 
 The driver executable invokes the linker, and the latter needs to locate
@@ -14888,11 +15506,11 @@ hello world
 @end example
 
 @node Packaging notes,Overview of code structure,Environment variables,Internals
-@anchor{internals/index packaging-notes}@anchor{38f}
+@anchor{internals/index packaging-notes}@anchor{3b7}
 @section Packaging notes
 
 
-The configure-time option @ref{385,,--enable-host-shared} is needed when
+The configure-time option @ref{3ad,,--enable-host-shared} is needed when
 building the jit in order to get position-independent code.  This will
 slow down the regular compiler by a few percent.  Hence when packaging gcc
 with libgccjit, please configure and build twice:
@@ -14903,10 +15521,10 @@ with libgccjit, please configure and build twice:
 @itemize *
 
 @item 
-once without @ref{385,,--enable-host-shared} for most languages, and
+once without @ref{3ad,,--enable-host-shared} for most languages, and
 
 @item 
-once with @ref{385,,--enable-host-shared} for the jit
+once with @ref{3ad,,--enable-host-shared} for the jit
 @end itemize
 @end quotation
 
@@ -14948,7 +15566,7 @@ popd
 @end example
 
 @node Overview of code structure,Design notes,Packaging notes,Internals
-@anchor{internals/index overview-of-code-structure}@anchor{390}
+@anchor{internals/index overview-of-code-structure}@anchor{3b8}
 @section Overview of code structure
 
 
@@ -15417,7 +16035,7 @@ JIT: gcc::jit::logger::~logger()
 @end example
 
 @node Design notes,Submitting patches,Overview of code structure,Internals
-@anchor{internals/index design-notes}@anchor{391}
+@anchor{internals/index design-notes}@anchor{3b9}
 @section Design notes
 
 
@@ -15430,7 +16048,7 @@ close as possible to the error; failing that, a good place is within
 @code{recording::context::validate ()} in jit-recording.cc.
 
 @node Submitting patches,,Design notes,Internals
-@anchor{internals/index submitting-patches}@anchor{392}
+@anchor{internals/index submitting-patches}@anchor{3ba}
 @section Submitting patches
 
 
@@ -15564,7 +16182,7 @@ large and inconsequential (e.g. anchor renumbering), rather like generated
 committing to svn.
 
 @node Indices and tables,Index,Internals,Top
-@anchor{index indices-and-tables}@anchor{393}
+@anchor{index indices-and-tables}@anchor{3bb}
 @unnumbered Indices and tables
 
 
diff --git a/gcc/jit/docs/topics/expressions.rst b/gcc/jit/docs/topics/expressions.rst
index 9267b6d..d51264a 100644
--- a/gcc/jit/docs/topics/expressions.rst
+++ b/gcc/jit/docs/topics/expressions.rst
@@ -24,7 +24,7 @@ Rvalues
 -------
 .. type:: gcc_jit_rvalue
 
-A :c:type:`gcc_jit_rvalue *` is an expression that can be computed.
+A :c:type:`gcc_jit_rvalue` is an expression that can be computed.
 
 It can be simple, e.g.:
 
@@ -602,7 +602,7 @@ Function calls
               gcc_jit_rvalue_set_bool_require_tail_call (gcc_jit_rvalue *call,\
                                                          int require_tail_call)
 
-   Given an :c:type:`gcc_jit_rvalue *` for a call created through
+   Given an :c:type:`gcc_jit_rvalue` for a call created through
    :c:func:`gcc_jit_context_new_call` or
    :c:func:`gcc_jit_context_new_call_through_ptr`, mark/clear the
    call as needing tail-call optimization.  The optimizer will
@@ -721,8 +721,8 @@ where the rvalue is computed by reading from the storage area.
 
       #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model
 
-.. function:: void
-              gcc_jit_lvalue_set_link_section (gcc_jit_lvalue *lvalue,
+.. function:: void\
+              gcc_jit_lvalue_set_link_section (gcc_jit_lvalue *lvalue,\
                                                const char *section_name)
 
    Set the link section of a variable.
diff --git a/gcc/jit/docs/topics/types.rst b/gcc/jit/docs/topics/types.rst
index 9779ad2..c2082c0 100644
--- a/gcc/jit/docs/topics/types.rst
+++ b/gcc/jit/docs/topics/types.rst
@@ -192,7 +192,7 @@ A compound type analagous to a C `struct`.
 
 A field within a :c:type:`gcc_jit_struct`.
 
-You can model C `struct` types by creating :c:type:`gcc_jit_struct *` and
+You can model C `struct` types by creating :c:type:`gcc_jit_struct` and
 :c:type:`gcc_jit_field` instances, in either order:
 
 * by creating the fields, then the structure.  For example, to model:
@@ -375,7 +375,7 @@ Reflection API
      Given a function type, return its number of parameters.
 
 .. function::  gcc_jit_type *\
-               gcc_jit_function_type_get_param_type (gcc_jit_function_type *function_type,
+               gcc_jit_function_type_get_param_type (gcc_jit_function_type *function_type,\
                                                      size_t index)
 
      Given a function type, return the type of the specified parameter.
@@ -417,7 +417,7 @@ Reflection API
      alignment qualifiers.
 
 .. function::  gcc_jit_field *\
-               gcc_jit_struct_get_field (gcc_jit_struct *struct_type,
+               gcc_jit_struct_get_field (gcc_jit_struct *struct_type,\
                                          size_t index)
 
      Get a struct field by index.