* LIBGCCJIT_ABI_0::
* LIBGCCJIT_ABI_1::
* LIBGCCJIT_ABI_2::
+* LIBGCCJIT_ABI_3::
C++ bindings for libgccjit
* LIBGCCJIT_ABI_0::
* LIBGCCJIT_ABI_1::
* LIBGCCJIT_ABI_2::
+* LIBGCCJIT_ABI_3::
@end menu
+- gcc_jit_rvalue
+- gcc_jit_lvalue
+- gcc_jit_param
+ +- gcc_jit_case
@end example
@noindent
be the entrypoint.
Each basic block that you create within a function must be
-terminated, either with a conditional, a jump, or a return.
+terminated, either with a conditional, a jump, a return, or a
+switch.
It's legal to have multiple basic blocks that return within
one function.
@noindent
@end deffn
+@geindex gcc_jit_block_end_with_switch (C function)
+@anchor{topics/functions gcc_jit_block_end_with_switch}@anchor{d4}
+@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
+a multiway branch.
+
+This is roughly equivalent to this C code:
+
+@example
+switch (expr)
+ @{
+ default:
+ goto default_block;
+
+ case C0.min_value ... C0.max_value:
+ goto C0.dest_block;
+
+ case C1.min_value ... C1.max_value:
+ goto C1.dest_block;
+
+ ...etc...
+
+ case C[N - 1].min_value ... C[N - 1].max_value:
+ goto C[N - 1].dest_block;
+@}
+@end example
+
+@noindent
+
+@code{block}, @code{expr}, @code{default_block} and @code{cases} must all be
+non-NULL.
+
+@code{expr} must be of the same integer type as all of the @code{min_value}
+and @code{max_value} within the cases.
+
+@code{num_cases} must be >= 0.
+
+The ranges of the cases must not overlap (or have duplicate
+values).
+
+The API entrypoints relating to switch statements and cases:
+
+@quotation
+
+
+@itemize *
+
+@item
+@pxref{d4,,gcc_jit_block_end_with_switch()}
+
+@item
+@pxref{d5,,gcc_jit_case_as_object()}
+
+@item
+@pxref{d6,,gcc_jit_context_new_case()}
+@end itemize
+@end quotation
+
+were added in @pxref{d7,,LIBGCCJIT_ABI_3}; you can test for their presence
+using
+
+@example
+#ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
+@end example
+
+@noindent
+
+@geindex gcc_jit_case (C type)
+@anchor{topics/functions gcc_jit_case}@anchor{d8}
+@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 @pxref{8,,gcc_jit_context} using
+@pxref{d6,,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 gcc_jit_context_new_case}@anchor{d6}
+@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.
+@cite{min_value} and @cite{max_value} must be constants of an integer type,
+which must match that of the expression of the switch statement.
+
+@cite{dest_block} must be within the same function as the switch
+statement.
+@end deffn
+
+@geindex gcc_jit_case_as_object (C function)
+@anchor{topics/functions gcc_jit_case_as_object}@anchor{d5}
+@deffn {C Function} gcc_jit_object * gcc_jit_case_as_object (gcc_jit_case@w{ }*case_)
+
+Upcast from a case to an object.
+@end deffn
+
+Here's an example of creating a switch statement:
+
+@quotation
+
+@example
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+@{
+ /* Let's try to inject the equivalent of:
+ int
+ test_switch (int x)
+ @{
+ switch (x)
+ @{
+ case 0 ... 5:
+ return 3;
+
+ case 25 ... 27:
+ return 4;
+
+ case -42 ... -17:
+ return 83;
+
+ case 40:
+ return 8;
+
+ default:
+ return 10;
+ @}
+ @}
+ */
+ gcc_jit_type *t_int =
+ gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+ gcc_jit_type *return_type = t_int;
+ gcc_jit_param *x =
+ gcc_jit_context_new_param (ctxt, NULL, t_int, "x");
+ gcc_jit_param *params[1] = @{x@};
+ gcc_jit_function *func =
+ gcc_jit_context_new_function (ctxt, NULL,
+ GCC_JIT_FUNCTION_EXPORTED,
+ return_type,
+ "test_switch",
+ 1, params, 0);
+
+ gcc_jit_block *b_initial =
+ gcc_jit_function_new_block (func, "initial");
+
+ gcc_jit_block *b_default =
+ gcc_jit_function_new_block (func, "default");
+ gcc_jit_block *b_case_0_5 =
+ gcc_jit_function_new_block (func, "case_0_5");
+ gcc_jit_block *b_case_25_27 =
+ gcc_jit_function_new_block (func, "case_25_27");
+ gcc_jit_block *b_case_m42_m17 =
+ gcc_jit_function_new_block (func, "case_m42_m17");
+ gcc_jit_block *b_case_40 =
+ gcc_jit_function_new_block (func, "case_40");
+
+ gcc_jit_case *cases[4] = @{
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 0),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 5),
+ b_case_0_5),
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 25),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 27),
+ b_case_25_27),
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, -42),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, -17),
+ b_case_m42_m17),
+ gcc_jit_context_new_case (
+ ctxt,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 40),
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 40),
+ b_case_40)
+ @};
+ gcc_jit_block_end_with_switch (
+ b_initial, NULL,
+ gcc_jit_param_as_rvalue (x),
+ b_default,
+ 4, cases);
+
+ gcc_jit_block_end_with_return (
+ b_case_0_5, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 3));
+ gcc_jit_block_end_with_return (
+ b_case_25_27, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 4));
+ gcc_jit_block_end_with_return (
+ b_case_m42_m17, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 83));
+ gcc_jit_block_end_with_return (
+ b_case_40, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 8));
+ gcc_jit_block_end_with_return (
+ b_default, NULL,
+ gcc_jit_context_new_rvalue_from_int (ctxt, t_int, 10));
+@}
+
+
+@end example
+
+@noindent
+@end quotation
+@end deffn
+
@c Copyright (C) 2014-2015 Free Software Foundation, Inc.
@c Originally contributed by David Malcolm <dmalcolm@redhat.com>
@c
@c <http://www.gnu.org/licenses/>.
@node Source Locations,Compiling a context,Creating and using functions,Topic Reference
-@anchor{topics/locations source-locations}@anchor{d4}@anchor{topics/locations doc}@anchor{d5}
+@anchor{topics/locations source-locations}@anchor{d9}@anchor{topics/locations doc}@anchor{da}
@section Source Locations
@end menu
@node Faking it,,,Source Locations
-@anchor{topics/locations faking-it}@anchor{d6}
+@anchor{topics/locations faking-it}@anchor{db}
@subsection Faking it
@c <http://www.gnu.org/licenses/>.
@node Compiling a context,ABI and API compatibility,Source Locations,Topic Reference
-@anchor{topics/compilation compiling-a-context}@anchor{d7}@anchor{topics/compilation doc}@anchor{d8}
+@anchor{topics/compilation compiling-a-context}@anchor{dc}@anchor{topics/compilation doc}@anchor{dd}
@section Compiling a context
@end menu
@node In-memory compilation,Ahead-of-time compilation,,Compiling a context
-@anchor{topics/compilation in-memory-compilation}@anchor{d9}
+@anchor{topics/compilation in-memory-compilation}@anchor{de}
@subsection In-memory compilation
@end deffn
@node Ahead-of-time compilation,,In-memory compilation,Compiling a context
-@anchor{topics/compilation ahead-of-time-compilation}@anchor{da}
+@anchor{topics/compilation ahead-of-time-compilation}@anchor{df}
@subsection Ahead-of-time compilation
@end cartouche
@geindex gcc_jit_output_kind (C type)
-@anchor{topics/compilation gcc_jit_output_kind}@anchor{db}
+@anchor{topics/compilation gcc_jit_output_kind}@anchor{e0}
@deffn {C Type} enum gcc_jit_output_kind
@end deffn
@item
-@pxref{dc,,GCC_JIT_OUTPUT_KIND_ASSEMBLER}
+@pxref{e1,,GCC_JIT_OUTPUT_KIND_ASSEMBLER}
@tab
@item
-@pxref{dd,,GCC_JIT_OUTPUT_KIND_OBJECT_FILE}
+@pxref{e2,,GCC_JIT_OUTPUT_KIND_OBJECT_FILE}
@tab
@item
-@pxref{de,,GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY}
+@pxref{e3,,GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY}
@tab
@item
-@pxref{df,,GCC_JIT_OUTPUT_KIND_EXECUTABLE}
+@pxref{e4,,GCC_JIT_OUTPUT_KIND_EXECUTABLE}
@tab
@geindex GCC_JIT_OUTPUT_KIND_ASSEMBLER (C macro)
-@anchor{topics/compilation GCC_JIT_OUTPUT_KIND_ASSEMBLER}@anchor{dc}
+@anchor{topics/compilation GCC_JIT_OUTPUT_KIND_ASSEMBLER}@anchor{e1}
@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 GCC_JIT_OUTPUT_KIND_OBJECT_FILE}@anchor{dd}
+@anchor{topics/compilation GCC_JIT_OUTPUT_KIND_OBJECT_FILE}@anchor{e2}
@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 GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY}@anchor{de}
+@anchor{topics/compilation GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY}@anchor{e3}
@deffn {C Macro} GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY
Compile the context to a dynamic library.
@end deffn
@geindex GCC_JIT_OUTPUT_KIND_EXECUTABLE (C macro)
-@anchor{topics/compilation GCC_JIT_OUTPUT_KIND_EXECUTABLE}@anchor{df}
+@anchor{topics/compilation GCC_JIT_OUTPUT_KIND_EXECUTABLE}@anchor{e4}
@deffn {C Macro} GCC_JIT_OUTPUT_KIND_EXECUTABLE
Compile the context to an executable.
@c <http://www.gnu.org/licenses/>.
@node ABI and API compatibility,,Compiling a context,Topic Reference
-@anchor{topics/compatibility abi-and-api-compatibility}@anchor{e0}@anchor{topics/compatibility doc}@anchor{e1}
+@anchor{topics/compatibility abi-and-api-compatibility}@anchor{e5}@anchor{topics/compatibility doc}@anchor{e6}
@section ABI and API compatibility
0x00824161 0x00 04 LIBGCCJIT_ABI_1
0x00824160 0x00 03 LIBGCCJIT_ABI_0
required from libc.so.6:
- 0x09691a75 0x00 02 GLIBC_2.2.5
@end example
@noindent
* LIBGCCJIT_ABI_0::
* LIBGCCJIT_ABI_1::
* LIBGCCJIT_ABI_2::
+* LIBGCCJIT_ABI_3::
@end menu
@node ABI symbol tags,,,ABI and API compatibility
-@anchor{topics/compatibility abi-symbol-tags}@anchor{e2}
+@anchor{topics/compatibility abi-symbol-tags}@anchor{e7}
@subsection ABI symbol tags
* LIBGCCJIT_ABI_0::
* LIBGCCJIT_ABI_1::
* LIBGCCJIT_ABI_2::
+* LIBGCCJIT_ABI_3::
@end menu
@node LIBGCCJIT_ABI_0,LIBGCCJIT_ABI_1,,ABI symbol tags
-@anchor{topics/compatibility libgccjit-abi-0}@anchor{e3}@anchor{topics/compatibility id1}@anchor{e4}
+@anchor{topics/compatibility libgccjit-abi-0}@anchor{e8}@anchor{topics/compatibility id1}@anchor{e9}
@subsubsection @code{LIBGCCJIT_ABI_0}
(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 libgccjit-abi-1}@anchor{71}@anchor{topics/compatibility id2}@anchor{e5}
+@anchor{topics/compatibility libgccjit-abi-1}@anchor{71}@anchor{topics/compatibility id2}@anchor{ea}
@subsubsection @code{LIBGCCJIT_ABI_1}
@code{LIBGCCJIT_ABI_1} covers the addition of
@pxref{70,,gcc_jit_context_add_command_line_option()}
-@node LIBGCCJIT_ABI_2,,LIBGCCJIT_ABI_1,ABI symbol tags
-@anchor{topics/compatibility libgccjit-abi-2}@anchor{6c}@anchor{topics/compatibility id3}@anchor{e6}
+@node LIBGCCJIT_ABI_2,LIBGCCJIT_ABI_3,LIBGCCJIT_ABI_1,ABI symbol tags
+@anchor{topics/compatibility libgccjit-abi-2}@anchor{6c}@anchor{topics/compatibility id3}@anchor{eb}
@subsubsection @code{LIBGCCJIT_ABI_2}
@code{LIBGCCJIT_ABI_2} covers the addition of
@pxref{6b,,gcc_jit_context_set_bool_allow_unreachable_blocks()}
+@node LIBGCCJIT_ABI_3,,LIBGCCJIT_ABI_2,ABI symbol tags
+@anchor{topics/compatibility libgccjit-abi-3}@anchor{d7}@anchor{topics/compatibility id4}@anchor{ec}
+@subsubsection @code{LIBGCCJIT_ABI_3}
+
+
+@code{LIBGCCJIT_ABI_3} covers the addition of switch statements via API
+entrypoints:
+
+@quotation
+
+
+@itemize *
+
+@item
+@pxref{d4,,gcc_jit_block_end_with_switch()}
+
+@item
+@pxref{d5,,gcc_jit_case_as_object()}
+
+@item
+@pxref{d6,,gcc_jit_context_new_case()}
+@end itemize
+@end quotation
+
@c Copyright (C) 2014-2015 Free Software Foundation, Inc.
@c Originally contributed by David Malcolm <dmalcolm@redhat.com>
@c
@c <http://www.gnu.org/licenses/>.
@node C++ bindings for libgccjit,Internals,Topic Reference,Top
-@anchor{cp/index c-bindings-for-libgccjit}@anchor{e7}@anchor{cp/index doc}@anchor{e8}
+@anchor{cp/index c-bindings-for-libgccjit}@anchor{ed}@anchor{cp/index doc}@anchor{ee}
@chapter C++ bindings for libgccjit
@node Tutorial<2>,Topic Reference<2>,,C++ bindings for libgccjit
-@anchor{cp/intro/index doc}@anchor{e9}@anchor{cp/intro/index tutorial}@anchor{ea}
+@anchor{cp/intro/index doc}@anchor{ef}@anchor{cp/intro/index tutorial}@anchor{f0}
@section Tutorial
@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{eb}@anchor{cp/intro/tutorial01 tutorial-part-1-hello-world}@anchor{ec}
+@anchor{cp/intro/tutorial01 doc}@anchor{f1}@anchor{cp/intro/tutorial01 tutorial-part-1-hello-world}@anchor{f2}
@subsection Tutorial part 1: "Hello world"
@c <http://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{ed}@anchor{cp/intro/tutorial02 tutorial-part-2-creating-a-trivial-machine-code-function}@anchor{ee}
+@anchor{cp/intro/tutorial02 doc}@anchor{f3}@anchor{cp/intro/tutorial02 tutorial-part-2-creating-a-trivial-machine-code-function}@anchor{f4}
@subsection Tutorial part 2: Creating a trivial machine code function
@code{gccjit::context}, which is a thin C++ wrapper around the C API's
@pxref{8,,gcc_jit_context *}.
-Create one using @pxref{ef,,gccjit;;context;;acquire()}:
+Create one using @pxref{f5,,gccjit;;context;;acquire()}:
@example
gccjit::context ctxt;
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 @code{gccjit::type}, using
-@pxref{f0,,gccjit;;context;;get_type()}:
+@pxref{f6,,gccjit;;context;;get_type()}:
@example
gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);
Memory management is easy: all such "contextual" objects are automatically
cleaned up for you when the context is released, using
-@pxref{f1,,gccjit;;context;;release()}:
+@pxref{f7,,gccjit;;context;;release()}:
@example
ctxt.release ();
One thing you can do with a @code{gccjit::object} is
to ask it for a human-readable description as a @code{std::string}, using
-@pxref{f2,,gccjit;;object;;get_debug_string()}:
+@pxref{f8,,gccjit;;object;;get_debug_string()}:
@example
printf ("obj: %s\n", obj.get_debug_string ().c_str ());
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 @pxref{f3,,gccjit;;context;;new_param()}:
+using @pxref{f9,,gccjit;;context;;new_param()}:
@example
gccjit::param param_i = ctxt.new_param (int_type, "i");
Our basic block is relatively simple: it immediately terminates by
returning the value of an expression.
-We can build the expression using @pxref{f4,,gccjit;;context;;new_binary_op()}:
+We can build the expression using @pxref{fa,,gccjit;;context;;new_binary_op()}:
@example
gccjit::rvalue expr =
A @code{gccjit::rvalue} is another example of a
@code{gccjit::object} subclass. As before, we can print it with
-@pxref{f2,,gccjit;;object;;get_debug_string()}.
+@pxref{f8,,gccjit;;object;;get_debug_string()}.
@example
printf ("expr: %s\n", expr.get_debug_string ().c_str ());
@noindent
OK, we've populated the context. We can now compile it using
-@pxref{f5,,gccjit;;context;;compile()}:
+@pxref{fb,,gccjit;;context;;compile()}:
@example
gcc_jit_result *result;
@end menu
@node Options<3>,Full example<3>,,Tutorial part 2 Creating a trivial machine code function<2>
-@anchor{cp/intro/tutorial02 options}@anchor{f6}
+@anchor{cp/intro/tutorial02 options}@anchor{fc}
@subsubsection Options
To get more information on what's going on, you can set debugging flags
-on the context using @pxref{f7,,gccjit;;context;;set_bool_option()}.
+on the context using @pxref{fd,,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
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
-@pxref{f8,,gccjit;;context;;set_int_option()} with
+@pxref{fe,,gccjit;;context;;set_int_option()} with
@pxref{1f,,GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL}:
@example
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{f9}
+@anchor{cp/intro/tutorial02 full-example}@anchor{ff}
@subsubsection Full example
@c <http://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 tutorial-part-3-loops-and-variables}@anchor{fa}@anchor{cp/intro/tutorial03 doc}@anchor{fb}
+@anchor{cp/intro/tutorial03 tutorial-part-3-loops-and-variables}@anchor{100}@anchor{cp/intro/tutorial03 doc}@anchor{101}
@subsection Tutorial part 3: Loops and variables
@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{fc}
+@anchor{cp/intro/tutorial03 expressions-lvalues-and-rvalues}@anchor{102}
@subsubsection Expressions: lvalues and rvalues
Our new example has a new kind of expression: we have two local
variables. We create them by calling
-@pxref{fd,,gccjit;;function;;new_local()}, supplying a type and a name:
+@pxref{103,,gccjit;;function;;new_local()}, supplying a type and a name:
@example
/* Build locals: */
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{fe}
+@anchor{cp/intro/tutorial03 control-flow}@anchor{104}
@subsubsection Control flow
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
-@pxref{ff,,gccjit;;block;;add_assignment()} to add
-an assignment statement, and using @pxref{100,,gccjit;;context;;zero()} to get
+@pxref{105,,gccjit;;block;;add_assignment()} to add
+an assignment statement, and using @pxref{106,,gccjit;;context;;zero()} to get
the constant value @cite{0} for the relevant type for the right-hand side of
the assignment:
one of two destination blocks depending on a boolean
@code{gccjit::rvalue}, in this case the comparison of @cite{i} and @cite{n}.
-We could build the comparison using @pxref{101,,gccjit;;context;;new_comparison()}:
+We could build the comparison using @pxref{107,,gccjit;;context;;new_comparison()}:
@example
gccjit::rvalue guard =
@noindent
and can then use this to add @cite{b_loop_cond}'s sole statement, via
-@pxref{102,,gccjit;;block;;end_with_conditional()}:
+@pxref{108,,gccjit;;block;;end_with_conditional()}:
@example
b_loop_cond.end_with_conditional (guard,
The C statement @cite{sum += i * i;} is an assignment operation, where an
lvalue is modified "in-place". We use
-@pxref{103,,gccjit;;block;;add_assignment_op()} to handle these operations:
+@pxref{109,,gccjit;;block;;add_assignment_op()} to handle these operations:
@example
/* sum += i * i */
@cartouche
@quotation Note
For numeric constants other than 0 or 1, we could use
-@pxref{104,,gccjit;;context;;new_rvalue()}, which has overloads
+@pxref{10a,,gccjit;;context;;new_rvalue()}, which has overloads
for both @code{int} and @code{double}.
@end quotation
@end cartouche
@noindent
@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{105}
+@anchor{cp/intro/tutorial03 visualizing-the-control-flow-graph}@anchor{10b}
@subsubsection Visualizing the control flow graph
You can see the control flow graph of a function using
-@pxref{106,,gccjit;;function;;dump_to_dot()}:
+@pxref{10c,,gccjit;;function;;dump_to_dot()}:
@example
func.dump_to_dot ("/tmp/sum-of-squares.dot");
@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{107}
+@anchor{cp/intro/tutorial03 full-example}@anchor{10d}
@subsubsection Full example
@c <http://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 tutorial-part-4-adding-jit-compilation-to-a-toy-interpreter}@anchor{108}@anchor{cp/intro/tutorial04 doc}@anchor{109}
+@anchor{cp/intro/tutorial04 tutorial-part-4-adding-jit-compilation-to-a-toy-interpreter}@anchor{10e}@anchor{cp/intro/tutorial04 doc}@anchor{10f}
@subsection Tutorial part 4: Adding JIT-compilation to a toy interpreter
@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{10a}
+@anchor{cp/intro/tutorial04 our-toy-interpreter}@anchor{110}
@subsubsection Our toy interpreter
@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{10b}
+@anchor{cp/intro/tutorial04 compiling-to-machine-code}@anchor{111}
@subsubsection Compiling to machine code
@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{10c}
+@anchor{cp/intro/tutorial04 setting-things-up}@anchor{112}
@subsubsection Setting things up
@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{10d}
+@anchor{cp/intro/tutorial04 populating-the-function}@anchor{113}
@subsubsection Populating the function
uninitialized.
To track this kind of thing down, we can use
-@pxref{10e,,gccjit;;block;;add_comment()} to add descriptive comments
+@pxref{114,,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}:
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{10f}
+@anchor{cp/intro/tutorial04 verifying-the-control-flow-graph}@anchor{115}
@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 @pxref{106,,gccjit;;function;;dump_to_dot()}:
+using @pxref{10c,,gccjit;;function;;dump_to_dot()}:
@example
fn.dump_to_dot ("/tmp/factorial.dot");
@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{110}
+@anchor{cp/intro/tutorial04 compiling-the-context}@anchor{116}
@subsubsection Compiling the context
@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{111}
+@anchor{cp/intro/tutorial04 single-stepping-through-the-generated-code}@anchor{117}
@subsubsection Single-stepping through the generated code
@item
Set up source code locations for our statements, so that we can
meaningfully step through the code. We did this above by
-calling @pxref{112,,gccjit;;context;;new_location()} and using the
+calling @pxref{118,,gccjit;;context;;new_location()} and using the
results.
@item
Enable the generation of debugging information, by setting
@pxref{42,,GCC_JIT_BOOL_OPTION_DEBUGINFO} on the
@code{gccjit::context} via
-@pxref{f7,,gccjit;;context;;set_bool_option()}:
+@pxref{fd,,gccjit;;context;;set_bool_option()}:
@example
ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DEBUGINFO, 1);
@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{113}
+@anchor{cp/intro/tutorial04 examining-the-generated-code}@anchor{119}
@subsubsection Examining the generated code
How good is the optimized code?
We can turn up optimizations, by calling
-@pxref{f8,,gccjit;;context;;set_int_option()} with
+@pxref{fe,,gccjit;;context;;set_int_option()} with
@pxref{1f,,GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL}:
@example
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{114}
+@anchor{cp/intro/tutorial04 putting-it-all-together}@anchor{11a}
@subsubsection Putting it all together
@noindent
@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{115}
+@anchor{cp/intro/tutorial04 behind-the-curtain-how-does-our-code-get-optimized}@anchor{11b}
@subsubsection Behind the curtain: How does our code get optimized?
@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{116}
+@anchor{cp/intro/tutorial04 optimizing-away-stack-manipulation}@anchor{11c}
@subsubsection Optimizing away stack manipulation
@noindent
@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{117}
+@anchor{cp/intro/tutorial04 elimination-of-tail-recursion}@anchor{11d}
@subsubsection Elimination of tail recursion
@c <http://www.gnu.org/licenses/>.
@node Topic Reference<2>,,Tutorial<2>,C++ bindings for libgccjit
-@anchor{cp/topics/index doc}@anchor{118}@anchor{cp/topics/index topic-reference}@anchor{119}
+@anchor{cp/topics/index doc}@anchor{11e}@anchor{cp/topics/index topic-reference}@anchor{11f}
@section Topic Reference
@node Compilation contexts<2>,Objects<2>,,Topic Reference<2>
-@anchor{cp/topics/contexts compilation-contexts}@anchor{11a}@anchor{cp/topics/contexts doc}@anchor{11b}
+@anchor{cp/topics/contexts compilation-contexts}@anchor{120}@anchor{cp/topics/contexts doc}@anchor{121}
@subsection Compilation contexts
@geindex gccjit;;context (C++ class)
-@anchor{cp/topics/contexts gccjit context}@anchor{11c}
+@anchor{cp/topics/contexts gccjit context}@anchor{122}
@deffn {C++ Class} gccjit::context
@end deffn
-The top-level of the C++ API is the @pxref{11c,,gccjit;;context} type.
+The top-level of the C++ API is the @pxref{122,,gccjit;;context} type.
-A @pxref{11c,,gccjit;;context} instance encapsulates the state of a
+A @pxref{122,,gccjit;;context} instance encapsulates the state of a
compilation.
You can set up options on it, and add types, functions and code.
-Invoking @pxref{f5,,gccjit;;context;;compile()} on it gives you a
+Invoking @pxref{fb,,gccjit;;context;;compile()} on it gives you a
@pxref{16,,gcc_jit_result *}.
It is a thin wrapper around the C API's @pxref{8,,gcc_jit_context *}.
@end menu
@node Lifetime-management<2>,Thread-safety<2>,,Compilation contexts<2>
-@anchor{cp/topics/contexts lifetime-management}@anchor{11d}
+@anchor{cp/topics/contexts lifetime-management}@anchor{123}
@subsubsection Lifetime-management
cleanup of such objects is done for you when the context is released.
@geindex gccjit;;context;;acquire (C++ function)
-@anchor{cp/topics/contexts gccjit context acquire}@anchor{ef}
+@anchor{cp/topics/contexts gccjit context acquire}@anchor{f5}
@deffn {C++ Function} gccjit::context gccjit::context::acquire ()
-This function acquires a new @pxref{11c,,gccjit;;context} instance,
+This function acquires a new @pxref{122,,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 gccjit context release}@anchor{f1}
+@anchor{cp/topics/contexts gccjit context release}@anchor{f7}
@deffn {C++ Function} void gccjit::context::release ()
This function releases all resources associated with the given context.
@end deffn
@geindex gccjit;;context;;new_child_context (C++ function)
-@anchor{cp/topics/contexts gccjit context new_child_context}@anchor{11e}
+@anchor{cp/topics/contexts gccjit context new_child_context}@anchor{124}
@deffn {C++ Function} gccjit::context gccjit::context::new_child_context ()
Given an existing JIT context, create a child context.
@end deffn
@node Thread-safety<2>,Error-handling<3>,Lifetime-management<2>,Compilation contexts<2>
-@anchor{cp/topics/contexts thread-safety}@anchor{11f}
+@anchor{cp/topics/contexts thread-safety}@anchor{125}
@subsubsection Thread-safety
-Instances of @pxref{11c,,gccjit;;context} created via
-@pxref{ef,,gccjit;;context;;acquire()} are independent from each other:
+Instances of @pxref{122,,gccjit;;context} created via
+@pxref{f5,,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 @pxref{11e,,gccjit;;context;;new_child_context()} are
+Contexts created via @pxref{124,,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,
around entire such context partitions.
@node Error-handling<3>,Debugging<2>,Thread-safety<2>,Compilation contexts<2>
-@anchor{cp/topics/contexts error-handling}@anchor{120}
+@anchor{cp/topics/contexts error-handling}@anchor{126}
@subsubsection Error-handling
API gracefully handles a NULL being passed in for any argument.
Errors are printed on stderr and can be queried using
-@pxref{121,,gccjit;;context;;get_first_error()}.
+@pxref{127,,gccjit;;context;;get_first_error()}.
@geindex gccjit;;context;;get_first_error (C++ function)
-@anchor{cp/topics/contexts gccjit context get_first_error__gccjit contextP}@anchor{121}
+@anchor{cp/topics/contexts gccjit context get_first_error__gccjit contextP}@anchor{127}
@deffn {C++ Function} const char* gccjit::context::get_first_error (gccjit::context* ctxt)
Returns the first error message that occurred on the context.
@end deffn
@node Debugging<2>,Options<4>,Error-handling<3>,Compilation contexts<2>
-@anchor{cp/topics/contexts debugging}@anchor{122}
+@anchor{cp/topics/contexts debugging}@anchor{128}
@subsubsection Debugging
@geindex gccjit;;context;;dump_to_file (C++ function)
-@anchor{cp/topics/contexts gccjit context dump_to_file__ssCR i}@anchor{123}
+@anchor{cp/topics/contexts gccjit context dump_to_file__ssCR i}@anchor{129}
@deffn {C++ Function} void gccjit::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 @pxref{124,,gccjit;;location}
+If "update_locations" is true, then also set up @pxref{12a,,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
@end deffn
@geindex gccjit;;context;;dump_reproducer_to_file (C++ function)
-@anchor{cp/topics/contexts gccjit context dump_reproducer_to_file__gcc_jit_contextP cCP}@anchor{125}
+@anchor{cp/topics/contexts gccjit context dump_reproducer_to_file__gcc_jit_contextP cCP}@anchor{12b}
@deffn {C++ Function} void gccjit::context::dump_reproducer_to_file (gcc_jit_context* ctxt, const char* path)
This is a thin wrapper around the C API
@end deffn
@node Options<4>,,Debugging<2>,Compilation contexts<2>
-@anchor{cp/topics/contexts options}@anchor{126}
+@anchor{cp/topics/contexts options}@anchor{12c}
@subsubsection Options
@end menu
@node String Options<2>,Boolean options<2>,,Options<4>
-@anchor{cp/topics/contexts string-options}@anchor{127}
+@anchor{cp/topics/contexts string-options}@anchor{12d}
@subsubsection String Options
@geindex gccjit;;context;;set_str_option (C++ function)
-@anchor{cp/topics/contexts gccjit context set_str_option__enum cCP}@anchor{128}
+@anchor{cp/topics/contexts gccjit context set_str_option__enum cCP}@anchor{12e}
@deffn {C++ Function} void gccjit::context::set_str_option (enum gcc_jit_str_option, const char* value)
Set a string option of the context.
@end deffn
@node Boolean options<2>,Integer options<2>,String Options<2>,Options<4>
-@anchor{cp/topics/contexts boolean-options}@anchor{129}
+@anchor{cp/topics/contexts boolean-options}@anchor{12f}
@subsubsection Boolean options
@geindex gccjit;;context;;set_bool_option (C++ function)
-@anchor{cp/topics/contexts gccjit context set_bool_option__enum i}@anchor{f7}
+@anchor{cp/topics/contexts gccjit context set_bool_option__enum i}@anchor{fd}
@deffn {C++ Function} void gccjit::context::set_bool_option (enum gcc_jit_bool_option, int value)
Set a boolean option of the context.
@end deffn
@geindex gccjit;;context;;set_bool_allow_unreachable_blocks (C++ function)
-@anchor{cp/topics/contexts gccjit context set_bool_allow_unreachable_blocks__i}@anchor{12a}
+@anchor{cp/topics/contexts gccjit context set_bool_allow_unreachable_blocks__i}@anchor{130}
@deffn {C++ Function} void gccjit::context::set_bool_allow_unreachable_blocks (int bool_value)
By default, libgccjit will issue an error about unreachable blocks
@end deffn
@node Integer options<2>,Additional command-line options<2>,Boolean options<2>,Options<4>
-@anchor{cp/topics/contexts integer-options}@anchor{12b}
+@anchor{cp/topics/contexts integer-options}@anchor{131}
@subsubsection Integer options
@geindex gccjit;;context;;set_int_option (C++ function)
-@anchor{cp/topics/contexts gccjit context set_int_option__enum i}@anchor{f8}
+@anchor{cp/topics/contexts gccjit context set_int_option__enum i}@anchor{fe}
@deffn {C++ Function} void gccjit::context::set_int_option (enum gcc_jit_int_option, int value)
Set an integer option of the context.
@end deffn
@node Additional command-line options<2>,,Integer options<2>,Options<4>
-@anchor{cp/topics/contexts additional-command-line-options}@anchor{12c}
+@anchor{cp/topics/contexts additional-command-line-options}@anchor{132}
@subsubsection Additional command-line options
@geindex gccjit;;context;;add_command_line_option (C++ function)
-@anchor{cp/topics/contexts gccjit context add_command_line_option__cCP}@anchor{12d}
+@anchor{cp/topics/contexts gccjit context add_command_line_option__cCP}@anchor{133}
@deffn {C++ Function} void gccjit::context::add_command_line_option (const char* optname)
Add an arbitrary gcc command-line option to the context for use
@c <http://www.gnu.org/licenses/>.
@node Objects<2>,Types<2>,Compilation contexts<2>,Topic Reference<2>
-@anchor{cp/topics/objects objects}@anchor{12e}@anchor{cp/topics/objects doc}@anchor{12f}
+@anchor{cp/topics/objects objects}@anchor{134}@anchor{cp/topics/objects doc}@anchor{135}
@subsection Objects
@geindex gccjit;;object (C++ class)
-@anchor{cp/topics/objects gccjit object}@anchor{130}
+@anchor{cp/topics/objects gccjit object}@anchor{136}
@deffn {C++ Class} gccjit::object
@end deffn
Almost every entity in the API (with the exception of
-@pxref{11c,,gccjit;;context} and @pxref{16,,gcc_jit_result *}) is a
-"contextual" object, a @pxref{130,,gccjit;;object}.
+@pxref{122,,gccjit;;context} and @pxref{16,,gcc_jit_result *}) is a
+"contextual" object, a @pxref{136,,gccjit;;object}.
A JIT object:
@itemize *
@item
-is associated with a @pxref{11c,,gccjit;;context}.
+is associated with a @pxref{122,,gccjit;;context}.
@item
is automatically cleaned up for you when its context is released so
+- rvalue
+- lvalue
+- param
+ +- case_
@end example
@noindent
-The @pxref{130,,gccjit;;object} base class has the following operations:
+The @pxref{136,,gccjit;;object} base class has the following operations:
@geindex gccjit;;object;;get_context (C++ function)
-@anchor{cp/topics/objects gccjit object get_contextC}@anchor{131}
+@anchor{cp/topics/objects gccjit object get_contextC}@anchor{137}
@deffn {C++ Function} gccjit::context gccjit::object::get_context () const
Which context is the obj within?
@end deffn
@geindex gccjit;;object;;get_debug_string (C++ function)
-@anchor{cp/topics/objects gccjit object get_debug_stringC}@anchor{f2}
+@anchor{cp/topics/objects gccjit object get_debug_stringC}@anchor{f8}
@deffn {C++ Function} std::string gccjit::object::get_debug_string () const
Generate a human-readable description for the given object.
@c <http://www.gnu.org/licenses/>.
@node Types<2>,Expressions<2>,Objects<2>,Topic Reference<2>
-@anchor{cp/topics/types doc}@anchor{132}@anchor{cp/topics/types types}@anchor{133}
+@anchor{cp/topics/types doc}@anchor{138}@anchor{cp/topics/types types}@anchor{139}
@subsection Types
@geindex gccjit;;type (C++ class)
-@anchor{cp/topics/types gccjit type}@anchor{134}
+@anchor{cp/topics/types gccjit type}@anchor{13a}
@deffn {C++ Class} gccjit::type
gccjit::type represents a type within the library. It is a subclass
-of @pxref{130,,gccjit;;object}.
+of @pxref{136,,gccjit;;object}.
@end deffn
Types can be created in several ways:
@item
fundamental types can be accessed using
-@pxref{f0,,gccjit;;context;;get_type()}:
+@pxref{f6,,gccjit;;context;;get_type()}:
@example
gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);
@item
derived types can be accessed by using functions such as
-@pxref{135,,gccjit;;type;;get_pointer()} and @pxref{136,,gccjit;;type;;get_const()}:
+@pxref{13b,,gccjit;;type;;get_pointer()} and @pxref{13c,,gccjit;;type;;get_const()}:
@example
gccjit::type const_int_star = int_type.get_const ().get_pointer ();
@end menu
@node Standard types<2>,Pointers const and volatile<2>,,Types<2>
-@anchor{cp/topics/types standard-types}@anchor{137}
+@anchor{cp/topics/types standard-types}@anchor{13d}
@subsubsection Standard types
@geindex gccjit;;context;;get_type (C++ function)
-@anchor{cp/topics/types gccjit context get_type__enum}@anchor{f0}
+@anchor{cp/topics/types gccjit context get_type__enum}@anchor{f6}
@deffn {C++ Function} gccjit::type gccjit::context::get_type (enum gcc_jit_types)
Access a specific type. This is a thin wrapper around
@end deffn
@geindex gccjit;;context;;get_int_type (C++ function)
-@anchor{cp/topics/types gccjit context get_int_type__s i}@anchor{138}
+@anchor{cp/topics/types gccjit context get_int_type__s i}@anchor{13e}
@deffn {C++ Function} gccjit::type gccjit::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 gccjit context get_int_type T}@anchor{139}
+@anchor{cp/topics/types gccjit context get_int_type T}@anchor{13f}
@deffn {C++ Function} gccjit::type gccjit::context::get_int_type<T> ()
Access the given integer type. For example, you could map the
@end deffn
@node Pointers const and volatile<2>,Structures and unions<2>,Standard types<2>,Types<2>
-@anchor{cp/topics/types pointers-const-and-volatile}@anchor{13a}
+@anchor{cp/topics/types pointers-const-and-volatile}@anchor{140}
@subsubsection Pointers, @cite{const}, and @cite{volatile}
@geindex gccjit;;type;;get_pointer (C++ function)
-@anchor{cp/topics/types gccjit type get_pointer}@anchor{135}
+@anchor{cp/topics/types gccjit type get_pointer}@anchor{13b}
@deffn {C++ Function} gccjit::type gccjit::type::get_pointer ()
Given type "T", get type "T*".
@c FIXME: get_const doesn't seem to exist
@geindex gccjit;;type;;get_const (C++ function)
-@anchor{cp/topics/types gccjit type get_const}@anchor{136}
+@anchor{cp/topics/types gccjit type get_const}@anchor{13c}
@deffn {C++ Function} gccjit::type gccjit::type::get_const ()
Given type "T", get type "const T".
@end deffn
@geindex gccjit;;type;;get_volatile (C++ function)
-@anchor{cp/topics/types gccjit type get_volatile}@anchor{13b}
+@anchor{cp/topics/types gccjit type get_volatile}@anchor{141}
@deffn {C++ Function} gccjit::type gccjit::type::get_volatile ()
Given type "T", get type "volatile T".
@end deffn
@geindex gccjit;;context;;new_array_type (C++ function)
-@anchor{cp/topics/types gccjit context new_array_type__gccjit type i gccjit location}@anchor{13c}
+@anchor{cp/topics/types gccjit context new_array_type__gccjit type i gccjit location}@anchor{142}
@deffn {C++ Function} gccjit::type gccjit::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).
@end deffn
@node Structures and unions<2>,,Pointers const and volatile<2>,Types<2>
-@anchor{cp/topics/types structures-and-unions}@anchor{13d}
+@anchor{cp/topics/types structures-and-unions}@anchor{143}
@subsubsection Structures and unions
@geindex gccjit;;struct_ (C++ class)
-@anchor{cp/topics/types gccjit struct_}@anchor{13e}
+@anchor{cp/topics/types gccjit struct_}@anchor{144}
@deffn {C++ Class} gccjit::struct_
@end deffn
A compound type analagous to a C @cite{struct}.
-@pxref{13e,,gccjit;;struct_} is a subclass of @pxref{134,,gccjit;;type} (and thus
-of @pxref{130,,gccjit;;object} in turn).
+@pxref{144,,gccjit;;struct_} is a subclass of @pxref{13a,,gccjit;;type} (and thus
+of @pxref{136,,gccjit;;object} in turn).
@geindex gccjit;;field (C++ class)
-@anchor{cp/topics/types gccjit field}@anchor{13f}
+@anchor{cp/topics/types gccjit field}@anchor{145}
@deffn {C++ Class} gccjit::field
@end deffn
-A field within a @pxref{13e,,gccjit;;struct_}.
+A field within a @pxref{144,,gccjit;;struct_}.
-@pxref{13f,,gccjit;;field} is a subclass of @pxref{130,,gccjit;;object}.
+@pxref{145,,gccjit;;field} is a subclass of @pxref{136,,gccjit;;object}.
-You can model C @cite{struct} types by creating @pxref{13e,,gccjit;;struct_} and
-@pxref{13f,,gccjit;;field} instances, in either order:
+You can model C @cite{struct} types by creating @pxref{144,,gccjit;;struct_} and
+@pxref{145,,gccjit;;field} instances, in either order:
@itemize *
@c FIXME: the above API doesn't seem to exist yet
@geindex gccjit;;context;;new_field (C++ function)
-@anchor{cp/topics/types gccjit context new_field__gccjit type cCP gccjit location}@anchor{140}
+@anchor{cp/topics/types gccjit context new_field__gccjit type cCP gccjit location}@anchor{146}
@deffn {C++ Function} gccjit::field gccjit::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 gccjit context new_struct_type__ssCR std vector field R gccjit location}@anchor{141}
+@anchor{cp/topics/types gccjit context new_struct_type__ssCR std vector field R gccjit location}@anchor{147}
@deffn {C++ Function} gccjit::struct_ gccjit::context::new_struct_type (const std::string& name, std::vector<field>& fields, gccjit::location loc)
@quotation
@end deffn
@geindex gccjit;;context;;new_opaque_struct (C++ function)
-@anchor{cp/topics/types gccjit context new_opaque_struct__ssCR gccjit location}@anchor{142}
+@anchor{cp/topics/types gccjit context new_opaque_struct__ssCR gccjit location}@anchor{148}
@deffn {C++ Function} gccjit::struct_ gccjit::context::new_opaque_struct (const std::string& name, gccjit::location loc)
Construct a new struct type, with the given name, but without
@c <http://www.gnu.org/licenses/>.
@node Expressions<2>,Creating and using functions<2>,Types<2>,Topic Reference<2>
-@anchor{cp/topics/expressions expressions}@anchor{143}@anchor{cp/topics/expressions doc}@anchor{144}
+@anchor{cp/topics/expressions expressions}@anchor{149}@anchor{cp/topics/expressions doc}@anchor{14a}
@subsection Expressions
@node Rvalues<2>,Lvalues<2>,,Expressions<2>
-@anchor{cp/topics/expressions rvalues}@anchor{145}
+@anchor{cp/topics/expressions rvalues}@anchor{14b}
@subsubsection Rvalues
@geindex gccjit;;rvalue (C++ class)
-@anchor{cp/topics/expressions gccjit rvalue}@anchor{146}
+@anchor{cp/topics/expressions gccjit rvalue}@anchor{14c}
@deffn {C++ Class} gccjit::rvalue
@end deffn
-A @pxref{146,,gccjit;;rvalue} is an expression that can be computed. It is a
-subclass of @pxref{130,,gccjit;;object}, and is a thin wrapper around
+A @pxref{14c,,gccjit;;rvalue} is an expression that can be computed. It is a
+subclass of @pxref{136,,gccjit;;object}, and is a thin wrapper around
@pxref{13,,gcc_jit_rvalue *} from the C API.
It can be simple, e.g.:
that types match up correctly (otherwise the context will emit an error).
@geindex gccjit;;rvalue;;get_type (C++ function)
-@anchor{cp/topics/expressions gccjit rvalue get_type}@anchor{147}
+@anchor{cp/topics/expressions gccjit rvalue get_type}@anchor{14d}
@deffn {C++ Function} gccjit::type gccjit::rvalue::get_type ()
Get the type of this rvalue.
@end menu
@node Simple expressions<2>,Unary Operations<2>,,Rvalues<2>
-@anchor{cp/topics/expressions simple-expressions}@anchor{148}
+@anchor{cp/topics/expressions simple-expressions}@anchor{14e}
@subsubsection Simple expressions
@geindex gccjit;;context;;new_rvalue (C++ function)
-@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type iC}@anchor{104}
+@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type iC}@anchor{10a}
@deffn {C++ Function} gccjit::rvalue gccjit::context::new_rvalue (gccjit::type numeric_type, int value) const
Given a numeric type (integer or floating point), build an rvalue for
@end deffn
@geindex gccjit;;context;;new_rvalue (C++ function)
-@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type lC}@anchor{149}
+@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type lC}@anchor{14f}
@deffn {C++ Function} gccjit::rvalue gccjit::context::new_rvalue (gccjit::type numeric_type, long value) const
Given a numeric type (integer or floating point), build an rvalue for
@end deffn
@geindex gccjit;;context;;zero (C++ function)
-@anchor{cp/topics/expressions gccjit context zero__gccjit typeC}@anchor{100}
+@anchor{cp/topics/expressions gccjit context zero__gccjit typeC}@anchor{106}
@deffn {C++ Function} gccjit::rvalue gccjit::context::zero (gccjit::type numeric_type) const
Given a numeric type (integer or floating point), get the rvalue for
@end deffn
@geindex gccjit;;context;;one (C++ function)
-@anchor{cp/topics/expressions gccjit context one__gccjit typeC}@anchor{14a}
+@anchor{cp/topics/expressions gccjit context one__gccjit typeC}@anchor{150}
@deffn {C++ Function} gccjit::rvalue gccjit::context::one (gccjit::type numeric_type) const
Given a numeric type (integer or floating point), get the rvalue for
@end deffn
@geindex gccjit;;context;;new_rvalue (C++ function)
-@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type doubleC}@anchor{14b}
+@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type doubleC}@anchor{151}
@deffn {C++ Function} gccjit::rvalue gccjit::context::new_rvalue (gccjit::type numeric_type, double value) const
Given a numeric type (integer or floating point), build an rvalue for
@end deffn
@geindex gccjit;;context;;new_rvalue (C++ function)
-@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type voidPC}@anchor{14c}
+@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type voidPC}@anchor{152}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_rvalue__ssCRC}@anchor{14d}
+@anchor{cp/topics/expressions gccjit context new_rvalue__ssCRC}@anchor{153}
@deffn {C++ Function} gccjit::rvalue gccjit::context::new_rvalue (const std::string& value) const
Generate an rvalue of type @code{GCC_JIT_TYPE_CONST_CHAR_PTR} for
@end deffn
@node Unary Operations<2>,Binary Operations<2>,Simple expressions<2>,Rvalues<2>
-@anchor{cp/topics/expressions unary-operations}@anchor{14e}
+@anchor{cp/topics/expressions unary-operations}@anchor{154}
@subsubsection Unary Operations
@geindex gccjit;;context;;new_unary_op (C++ function)
-@anchor{cp/topics/expressions gccjit context new_unary_op__enum gccjit type gccjit rvalue gccjit location}@anchor{14f}
+@anchor{cp/topics/expressions gccjit context new_unary_op__enum gccjit type gccjit rvalue gccjit location}@anchor{155}
@deffn {C++ Function} gccjit::rvalue gccjit::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.
operation:
@geindex gccjit;;context;;new_minus (C++ function)
-@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit location}@anchor{150}
+@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit location}@anchor{156}
@deffn {C++ Function} gccjit::rvalue gccjit::context::new_minus (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc)
Negate an arithmetic value; for example:
@end deffn
@geindex new_bitwise_negate (C++ function)
-@anchor{cp/topics/expressions new_bitwise_negate__gccjit type gccjit rvalue gccjit location}@anchor{151}
+@anchor{cp/topics/expressions new_bitwise_negate__gccjit type gccjit rvalue gccjit location}@anchor{157}
@deffn {C++ Function} gccjit::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:
@end deffn
@geindex new_logical_negate (C++ function)
-@anchor{cp/topics/expressions new_logical_negate__gccjit type gccjit rvalue gccjit location}@anchor{152}
+@anchor{cp/topics/expressions new_logical_negate__gccjit type gccjit rvalue gccjit location}@anchor{158}
@deffn {C++ Function} gccjit::rvalue new_logical_negate (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc)
Logical negation of an arithmetic or pointer value; for example:
The most concise way to spell them is with overloaded operators:
@geindex operator- (C++ function)
-@anchor{cp/topics/expressions sub-operator__gccjit rvalue}@anchor{153}
+@anchor{cp/topics/expressions sub-operator__gccjit rvalue}@anchor{159}
@deffn {C++ Function} gccjit::rvalue operator- (gccjit::rvalue a)
@example
@end deffn
@geindex operator~ (C++ function)
-@anchor{cp/topics/expressions inv-operator__gccjit rvalue}@anchor{154}
+@anchor{cp/topics/expressions inv-operator__gccjit rvalue}@anchor{15a}
@deffn {C++ Function} gccjit::rvalue operator~ (gccjit::rvalue a)
@example
@end deffn
@geindex operator! (C++ function)
-@anchor{cp/topics/expressions not-operator__gccjit rvalue}@anchor{155}
+@anchor{cp/topics/expressions not-operator__gccjit rvalue}@anchor{15b}
@deffn {C++ Function} gccjit::rvalue operator! (gccjit::rvalue a)
@example
@end deffn
@node Binary Operations<2>,Comparisons<2>,Unary Operations<2>,Rvalues<2>
-@anchor{cp/topics/expressions binary-operations}@anchor{156}
+@anchor{cp/topics/expressions binary-operations}@anchor{15c}
@subsubsection Binary Operations
@geindex gccjit;;context;;new_binary_op (C++ function)
-@anchor{cp/topics/expressions gccjit context new_binary_op__enum gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{f4}
+@anchor{cp/topics/expressions gccjit context new_binary_op__enum gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{fa}
@deffn {C++ Function} gccjit::rvalue gccjit::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.
operation:
@geindex gccjit;;context;;new_plus (C++ function)
-@anchor{cp/topics/expressions gccjit context new_plus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{157}
+@anchor{cp/topics/expressions gccjit context new_plus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{15d}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_minus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{158}
+@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{15e}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_mult__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{159}
+@anchor{cp/topics/expressions gccjit context new_mult__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{15f}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_divide__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{15a}
+@anchor{cp/topics/expressions gccjit context new_divide__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{160}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_modulo__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{15b}
+@anchor{cp/topics/expressions gccjit context new_modulo__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{161}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_bitwise_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{15c}
+@anchor{cp/topics/expressions gccjit context new_bitwise_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{162}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_bitwise_xor__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{15d}
+@anchor{cp/topics/expressions gccjit context new_bitwise_xor__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{163}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_bitwise_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{15e}
+@anchor{cp/topics/expressions gccjit context new_bitwise_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{164}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_logical_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{15f}
+@anchor{cp/topics/expressions gccjit context new_logical_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{165}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_logical_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{160}
+@anchor{cp/topics/expressions gccjit context new_logical_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{166}
@deffn {C++ Function} gccjit::rvalue gccjit::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 add-operator__gccjit rvalue gccjit rvalue}@anchor{161}
+@anchor{cp/topics/expressions add-operator__gccjit rvalue gccjit rvalue}@anchor{167}
@deffn {C++ Function} gccjit::rvalue operator+ (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator- (C++ function)
-@anchor{cp/topics/expressions sub-operator__gccjit rvalue gccjit rvalue}@anchor{162}
+@anchor{cp/topics/expressions sub-operator__gccjit rvalue gccjit rvalue}@anchor{168}
@deffn {C++ Function} gccjit::rvalue operator- (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator* (C++ function)
-@anchor{cp/topics/expressions mul-operator__gccjit rvalue gccjit rvalue}@anchor{163}
+@anchor{cp/topics/expressions mul-operator__gccjit rvalue gccjit rvalue}@anchor{169}
@deffn {C++ Function} gccjit::rvalue operator* (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator/ (C++ function)
-@anchor{cp/topics/expressions div-operator__gccjit rvalue gccjit rvalue}@anchor{164}
+@anchor{cp/topics/expressions div-operator__gccjit rvalue gccjit rvalue}@anchor{16a}
@deffn {C++ Function} gccjit::rvalue operator/ (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator% (C++ function)
-@anchor{cp/topics/expressions mod-operator__gccjit rvalue gccjit rvalue}@anchor{165}
+@anchor{cp/topics/expressions mod-operator__gccjit rvalue gccjit rvalue}@anchor{16b}
@deffn {C++ Function} gccjit::rvalue operator% (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator& (C++ function)
-@anchor{cp/topics/expressions and-operator__gccjit rvalue gccjit rvalue}@anchor{166}
+@anchor{cp/topics/expressions and-operator__gccjit rvalue gccjit rvalue}@anchor{16c}
@deffn {C++ Function} gccjit::rvalue operator& (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator^ (C++ function)
-@anchor{cp/topics/expressions xor-operator__gccjit rvalue gccjit rvalue}@anchor{167}
+@anchor{cp/topics/expressions xor-operator__gccjit rvalue gccjit rvalue}@anchor{16d}
@deffn {C++ Function} gccjit::rvalue operator^ (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator| (C++ function)
-@anchor{cp/topics/expressions or-operator__gccjit rvalue gccjit rvalue}@anchor{168}
+@anchor{cp/topics/expressions or-operator__gccjit rvalue gccjit rvalue}@anchor{16e}
@deffn {C++ Function} gccjit::rvalue operator| (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator&& (C++ function)
-@anchor{cp/topics/expressions sand-operator__gccjit rvalue gccjit rvalue}@anchor{169}
+@anchor{cp/topics/expressions sand-operator__gccjit rvalue gccjit rvalue}@anchor{16f}
@deffn {C++ Function} gccjit::rvalue operator&& (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator|| (C++ function)
-@anchor{cp/topics/expressions sor-operator__gccjit rvalue gccjit rvalue}@anchor{16a}
+@anchor{cp/topics/expressions sor-operator__gccjit rvalue gccjit rvalue}@anchor{170}
@deffn {C++ Function} gccjit::rvalue operator|| (gccjit::rvalue a, gccjit::rvalue b)
@example
@end quotation
@node Comparisons<2>,Function calls<2>,Binary Operations<2>,Rvalues<2>
-@anchor{cp/topics/expressions comparisons}@anchor{16b}
+@anchor{cp/topics/expressions comparisons}@anchor{171}
@subsubsection Comparisons
@geindex gccjit;;context;;new_comparison (C++ function)
-@anchor{cp/topics/expressions gccjit context new_comparison__enum gccjit rvalue gccjit rvalue gccjit location}@anchor{101}
+@anchor{cp/topics/expressions gccjit context new_comparison__enum gccjit rvalue gccjit rvalue gccjit location}@anchor{107}
@deffn {C++ Function} gccjit::rvalue gccjit::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.
operation:
@geindex gccjit;;context;;new_eq (C++ function)
-@anchor{cp/topics/expressions gccjit context new_eq__gccjit rvalue gccjit rvalue gccjit location}@anchor{16c}
+@anchor{cp/topics/expressions gccjit context new_eq__gccjit rvalue gccjit rvalue gccjit location}@anchor{172}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_ne__gccjit rvalue gccjit rvalue gccjit location}@anchor{16d}
+@anchor{cp/topics/expressions gccjit context new_ne__gccjit rvalue gccjit rvalue gccjit location}@anchor{173}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_lt__gccjit rvalue gccjit rvalue gccjit location}@anchor{16e}
+@anchor{cp/topics/expressions gccjit context new_lt__gccjit rvalue gccjit rvalue gccjit location}@anchor{174}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_le__gccjit rvalue gccjit rvalue gccjit location}@anchor{16f}
+@anchor{cp/topics/expressions gccjit context new_le__gccjit rvalue gccjit rvalue gccjit location}@anchor{175}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_gt__gccjit rvalue gccjit rvalue gccjit location}@anchor{170}
+@anchor{cp/topics/expressions gccjit context new_gt__gccjit rvalue gccjit rvalue gccjit location}@anchor{176}
@deffn {C++ Function} gccjit::rvalue gccjit::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 gccjit context new_ge__gccjit rvalue gccjit rvalue gccjit location}@anchor{171}
+@anchor{cp/topics/expressions gccjit context new_ge__gccjit rvalue gccjit rvalue gccjit location}@anchor{177}
@deffn {C++ Function} gccjit::rvalue gccjit::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 eq-operator__gccjit rvalue gccjit rvalue}@anchor{172}
+@anchor{cp/topics/expressions eq-operator__gccjit rvalue gccjit rvalue}@anchor{178}
@deffn {C++ Function} gccjit::rvalue operator== (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator!= (C++ function)
-@anchor{cp/topics/expressions neq-operator__gccjit rvalue gccjit rvalue}@anchor{173}
+@anchor{cp/topics/expressions neq-operator__gccjit rvalue gccjit rvalue}@anchor{179}
@deffn {C++ Function} gccjit::rvalue operator!= (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator< (C++ function)
-@anchor{cp/topics/expressions lt-operator__gccjit rvalue gccjit rvalue}@anchor{174}
+@anchor{cp/topics/expressions lt-operator__gccjit rvalue gccjit rvalue}@anchor{17a}
@deffn {C++ Function} gccjit::rvalue operator< (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator<= (C++ function)
-@anchor{cp/topics/expressions lte-operator__gccjit rvalue gccjit rvalue}@anchor{175}
+@anchor{cp/topics/expressions lte-operator__gccjit rvalue gccjit rvalue}@anchor{17b}
@deffn {C++ Function} gccjit::rvalue operator<= (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator> (C++ function)
-@anchor{cp/topics/expressions gt-operator__gccjit rvalue gccjit rvalue}@anchor{176}
+@anchor{cp/topics/expressions gt-operator__gccjit rvalue gccjit rvalue}@anchor{17c}
@deffn {C++ Function} gccjit::rvalue operator> (gccjit::rvalue a, gccjit::rvalue b)
@example
@end deffn
@geindex operator>= (C++ function)
-@anchor{cp/topics/expressions gte-operator__gccjit rvalue gccjit rvalue}@anchor{177}
+@anchor{cp/topics/expressions gte-operator__gccjit rvalue gccjit rvalue}@anchor{17d}
@deffn {C++ Function} gccjit::rvalue operator>= (gccjit::rvalue a, gccjit::rvalue b)
@example
@c TODO: beyond this point
@node Function calls<2>,Type-coercion<2>,Comparisons<2>,Rvalues<2>
-@anchor{cp/topics/expressions function-calls}@anchor{178}
+@anchor{cp/topics/expressions function-calls}@anchor{17e}
@subsubsection Function calls
@geindex gcc_jit_context_new_call (C++ function)
-@anchor{cp/topics/expressions gcc_jit_context_new_call__gcc_jit_contextP gcc_jit_locationP gcc_jit_functionP i gcc_jit_rvaluePP}@anchor{179}
+@anchor{cp/topics/expressions gcc_jit_context_new_call__gcc_jit_contextP gcc_jit_locationP gcc_jit_functionP i gcc_jit_rvaluePP}@anchor{17f}
@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
@cartouche
@quotation Note
@code{gccjit::context::new_call()} merely builds a
-@pxref{146,,gccjit;;rvalue} i.e. an expression that can be evaluated,
+@pxref{14c,,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
-@pxref{17a,,gccjit;;block;;add_eval()}:
+@pxref{180,,gccjit;;block;;add_eval()}:
@example
/* Add "(void)printf (arg0, arg1);". */
@end deffn
@node Type-coercion<2>,,Function calls<2>,Rvalues<2>
-@anchor{cp/topics/expressions type-coercion}@anchor{17b}
+@anchor{cp/topics/expressions type-coercion}@anchor{181}
@subsubsection Type-coercion
@geindex gccjit;;context;;new_cast (C++ function)
-@anchor{cp/topics/expressions gccjit context new_cast__gccjit rvalue gccjit type gccjit location}@anchor{17c}
+@anchor{cp/topics/expressions gccjit context new_cast__gccjit rvalue gccjit type gccjit location}@anchor{182}
@deffn {C++ Function} gccjit::rvalue gccjit::context::new_cast (gccjit::rvalue rvalue, gccjit::type type, gccjit::location loc)
Given an rvalue of T, construct another rvalue of another type.
@end deffn
@node Lvalues<2>,Working with pointers structs and unions<2>,Rvalues<2>,Expressions<2>
-@anchor{cp/topics/expressions lvalues}@anchor{17d}
+@anchor{cp/topics/expressions lvalues}@anchor{183}
@subsubsection Lvalues
@geindex gccjit;;lvalue (C++ class)
-@anchor{cp/topics/expressions gccjit lvalue}@anchor{17e}
+@anchor{cp/topics/expressions gccjit lvalue}@anchor{184}
@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
-@pxref{146,,gccjit;;rvalue}, where the rvalue is computed by reading from the
+@pxref{14c,,gccjit;;rvalue}, where the rvalue is computed by reading from the
storage area.
It iss a thin wrapper around @pxref{24,,gcc_jit_lvalue *} from the C API.
@geindex gccjit;;lvalue;;get_address (C++ function)
-@anchor{cp/topics/expressions gccjit lvalue get_address__gccjit location}@anchor{17f}
+@anchor{cp/topics/expressions gccjit lvalue get_address__gccjit location}@anchor{185}
@deffn {C++ Function} gccjit::rvalue gccjit::lvalue::get_address (gccjit::location loc)
Take the address of an lvalue; analogous to:
@end menu
@node Global variables<2>,,,Lvalues<2>
-@anchor{cp/topics/expressions global-variables}@anchor{180}
+@anchor{cp/topics/expressions global-variables}@anchor{186}
@subsubsection Global variables
@geindex gccjit;;context;;new_global (C++ function)
-@anchor{cp/topics/expressions gccjit context new_global__enum gccjit type cCP gccjit location}@anchor{181}
+@anchor{cp/topics/expressions gccjit context new_global__enum gccjit type cCP gccjit location}@anchor{187}
@deffn {C++ Function} gccjit::lvalue gccjit::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.
@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{182}
+@anchor{cp/topics/expressions working-with-pointers-structs-and-unions}@anchor{188}
@subsubsection Working with pointers, structs and unions
@geindex gccjit;;rvalue;;dereference (C++ function)
-@anchor{cp/topics/expressions gccjit rvalue dereference__gccjit location}@anchor{183}
+@anchor{cp/topics/expressions gccjit rvalue dereference__gccjit location}@anchor{189}
@deffn {C++ Function} gccjit::lvalue gccjit::rvalue::dereference (gccjit::location loc)
Given an rvalue of pointer type @code{T *}, dereferencing the pointer,
an overloaded operator:
@geindex gccjit;;rvalue;;operator* (C++ function)
-@anchor{cp/topics/expressions gccjit rvalue mul-operator}@anchor{184}
+@anchor{cp/topics/expressions gccjit rvalue mul-operator}@anchor{18a}
@deffn {C++ Function} gccjit::lvalue gccjit::rvalue::operator* ()
@example
Field access is provided separately for both lvalues and rvalues:
@geindex gccjit;;lvalue;;access_field (C++ function)
-@anchor{cp/topics/expressions gccjit lvalue access_field__gccjit field gccjit location}@anchor{185}
+@anchor{cp/topics/expressions gccjit lvalue access_field__gccjit field gccjit location}@anchor{18b}
@deffn {C++ Function} gccjit::lvalue gccjit::lvalue::access_field (gccjit::field field, gccjit::location loc)
Given an lvalue of struct or union type, access the given field,
@end deffn
@geindex gccjit;;rvalue;;access_field (C++ function)
-@anchor{cp/topics/expressions gccjit rvalue access_field__gccjit field gccjit location}@anchor{186}
+@anchor{cp/topics/expressions gccjit rvalue access_field__gccjit field gccjit location}@anchor{18c}
@deffn {C++ Function} gccjit::rvalue gccjit::rvalue::access_field (gccjit::field field, gccjit::location loc)
Given an rvalue of struct or union type, access the given field
@end deffn
@geindex gccjit;;rvalue;;dereference_field (C++ function)
-@anchor{cp/topics/expressions gccjit rvalue dereference_field__gccjit field gccjit location}@anchor{187}
+@anchor{cp/topics/expressions gccjit rvalue dereference_field__gccjit field gccjit location}@anchor{18d}
@deffn {C++ Function} gccjit::lvalue gccjit::rvalue::dereference_field (gccjit::field field, gccjit::location loc)
Given an rvalue of pointer type @code{T *} where T is of struct or union
@end deffn
@geindex gccjit;;context;;new_array_access (C++ function)
-@anchor{cp/topics/expressions gccjit context new_array_access__gccjit rvalue gccjit rvalue gccjit location}@anchor{188}
+@anchor{cp/topics/expressions gccjit context new_array_access__gccjit rvalue gccjit rvalue gccjit location}@anchor{18e}
@deffn {C++ Function} gccjit::lvalue gccjit::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
Parameter "loc" is optional.
@end deffn
-For array accesses where you don't need to specify a @pxref{124,,gccjit;;location},
+For array accesses where you don't need to specify a @pxref{12a,,gccjit;;location},
two overloaded operators are available:
@quotation
@c <http://www.gnu.org/licenses/>.
@node Creating and using functions<2>,Source Locations<2>,Expressions<2>,Topic Reference<2>
-@anchor{cp/topics/functions doc}@anchor{189}@anchor{cp/topics/functions creating-and-using-functions}@anchor{18a}
+@anchor{cp/topics/functions doc}@anchor{18f}@anchor{cp/topics/functions creating-and-using-functions}@anchor{190}
@subsection Creating and using functions
@end menu
@node Params<2>,Functions<2>,,Creating and using functions<2>
-@anchor{cp/topics/functions params}@anchor{18b}
+@anchor{cp/topics/functions params}@anchor{191}
@subsubsection Params
@geindex gccjit;;param (C++ class)
-@anchor{cp/topics/functions gccjit param}@anchor{18c}
+@anchor{cp/topics/functions gccjit param}@anchor{192}
@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 gccjit context new_param__gccjit type cCP gccjit location}@anchor{f3}
+@anchor{cp/topics/functions gccjit context new_param__gccjit type cCP gccjit location}@anchor{f9}
@deffn {C++ Function} gccjit::param gccjit::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
-@pxref{18c,,gccjit;;param} is a subclass of @pxref{17e,,gccjit;;lvalue} (and thus
-of @pxref{146,,gccjit;;rvalue} and @pxref{130,,gccjit;;object}). It is a thin
+@pxref{192,,gccjit;;param} is a subclass of @pxref{184,,gccjit;;lvalue} (and thus
+of @pxref{14c,,gccjit;;rvalue} and @pxref{136,,gccjit;;object}). It is a thin
wrapper around the C API's @pxref{25,,gcc_jit_param *}.
@node Functions<2>,Blocks<2>,Params<2>,Creating and using functions<2>
-@anchor{cp/topics/functions functions}@anchor{18d}
+@anchor{cp/topics/functions functions}@anchor{193}
@subsubsection Functions
@geindex gccjit;;function (C++ class)
-@anchor{cp/topics/functions gccjit function}@anchor{18e}
+@anchor{cp/topics/functions gccjit function}@anchor{194}
@deffn {C++ Class} gccjit::function
A @cite{gccjit::function} represents a function - either one that we're
@end deffn
@geindex gccjit;;context;;new_function (C++ function)
-@anchor{cp/topics/functions gccjit context new_function__enum gccjit type cCP std vector param R i gccjit location}@anchor{18f}
+@anchor{cp/topics/functions gccjit context new_function__enum gccjit type cCP std vector param R i gccjit location}@anchor{195}
@deffn {C++ Function} gccjit::function gccjit::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.
@end deffn
@geindex gccjit;;context;;get_builtin_function (C++ function)
-@anchor{cp/topics/functions gccjit context get_builtin_function__cCP}@anchor{190}
+@anchor{cp/topics/functions gccjit context get_builtin_function__cCP}@anchor{196}
@deffn {C++ Function} gccjit::function gccjit::context::get_builtin_function (const char* name)
This is a wrapper around the C API's
@end deffn
@geindex gccjit;;function;;get_param (C++ function)
-@anchor{cp/topics/functions gccjit function get_param__iC}@anchor{191}
+@anchor{cp/topics/functions gccjit function get_param__iC}@anchor{197}
@deffn {C++ Function} gccjit::param gccjit::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 gccjit function dump_to_dot__cCP}@anchor{106}
+@anchor{cp/topics/functions gccjit function dump_to_dot__cCP}@anchor{10c}
@deffn {C++ Function} void gccjit::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 gccjit function new_local__gccjit type cCP gccjit location}@anchor{fd}
+@anchor{cp/topics/functions gccjit function new_local__gccjit type cCP gccjit location}@anchor{103}
@deffn {C++ Function} gccjit::lvalue gccjit::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
@end deffn
@node Blocks<2>,Statements<2>,Functions<2>,Creating and using functions<2>
-@anchor{cp/topics/functions blocks}@anchor{192}
+@anchor{cp/topics/functions blocks}@anchor{198}
@subsubsection Blocks
@geindex gccjit;;block (C++ class)
-@anchor{cp/topics/functions gccjit block}@anchor{193}
+@anchor{cp/topics/functions gccjit block}@anchor{199}
@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.
-@pxref{193,,gccjit;;block} is a subclass of @pxref{130,,gccjit;;object}.
+@pxref{199,,gccjit;;block} is a subclass of @pxref{136,,gccjit;;object}.
The first basic block that you create within a function will
be the entrypoint.
Each basic block that you create within a function must be
-terminated, either with a conditional, a jump, or a return.
+terminated, either with a conditional, a jump, a return, or
+a switch.
It's legal to have multiple basic blocks that return within
one function.
@end deffn
@geindex gccjit;;function;;new_block (C++ function)
-@anchor{cp/topics/functions gccjit function new_block__cCP}@anchor{194}
+@anchor{cp/topics/functions gccjit function new_block__cCP}@anchor{19a}
@deffn {C++ Function} gccjit::block gccjit::function::new_block (const char* name)
Create a basic block of the given name. The name may be NULL, but
@end deffn
@node Statements<2>,,Blocks<2>,Creating and using functions<2>
-@anchor{cp/topics/functions statements}@anchor{195}
+@anchor{cp/topics/functions statements}@anchor{19b}
@subsubsection Statements
@geindex gccjit;;block;;add_eval (C++ function)
-@anchor{cp/topics/functions gccjit block add_eval__gccjit rvalue gccjit location}@anchor{17a}
+@anchor{cp/topics/functions gccjit block add_eval__gccjit rvalue gccjit location}@anchor{180}
@deffn {C++ Function} void gccjit::block::add_eval (gccjit::rvalue rvalue, gccjit::location loc)
Add evaluation of an rvalue, discarding the result
@end deffn
@geindex gccjit;;block;;add_assignment (C++ function)
-@anchor{cp/topics/functions gccjit block add_assignment__gccjit lvalue gccjit rvalue gccjit location}@anchor{ff}
+@anchor{cp/topics/functions gccjit block add_assignment__gccjit lvalue gccjit rvalue gccjit location}@anchor{105}
@deffn {C++ Function} void gccjit::block::add_assignment (gccjit::lvalue lvalue, gccjit::rvalue rvalue, gccjit::location loc)
Add evaluation of an rvalue, assigning the result to the given
@end deffn
@geindex gccjit;;block;;add_assignment_op (C++ function)
-@anchor{cp/topics/functions gccjit block add_assignment_op__gccjit lvalue enum gccjit rvalue gccjit location}@anchor{103}
+@anchor{cp/topics/functions gccjit block add_assignment_op__gccjit lvalue enum gccjit rvalue gccjit location}@anchor{109}
@deffn {C++ Function} void gccjit::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
@end deffn
@geindex gccjit;;block;;add_comment (C++ function)
-@anchor{cp/topics/functions gccjit block add_comment__cCP gccjit location}@anchor{10e}
+@anchor{cp/topics/functions gccjit block add_comment__cCP gccjit location}@anchor{114}
@deffn {C++ Function} void gccjit::block::add_comment (const char* text, gccjit::location loc)
Add a no-op textual comment to the internal representation of the
@end deffn
@geindex gccjit;;block;;end_with_conditional (C++ function)
-@anchor{cp/topics/functions gccjit block end_with_conditional__gccjit rvalue gccjit block gccjit block gccjit location}@anchor{102}
+@anchor{cp/topics/functions gccjit block end_with_conditional__gccjit rvalue gccjit block gccjit block gccjit location}@anchor{108}
@deffn {C++ Function} void gccjit::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
@end deffn
@geindex gccjit;;block;;end_with_jump (C++ function)
-@anchor{cp/topics/functions gccjit block end_with_jump__gccjit block gccjit location}@anchor{196}
+@anchor{cp/topics/functions gccjit block end_with_jump__gccjit block gccjit location}@anchor{19c}
@deffn {C++ Function} void gccjit::block::end_with_jump (gccjit::block target, gccjit::location loc)
Terminate a block by adding a jump to the given target block.
@end deffn
@geindex gccjit;;block;;end_with_return (C++ function)
-@anchor{cp/topics/functions gccjit block end_with_return__gccjit rvalue gccjit location}@anchor{197}
+@anchor{cp/topics/functions gccjit block end_with_return__gccjit rvalue gccjit location}@anchor{19d}
@deffn {C++ Function} void gccjit::block::end_with_return (gccjit::rvalue rvalue, gccjit::location loc)
Terminate a block.
@noindent
@end deffn
+@geindex gccjit;;block;;end_with_switch (C++ function)
+@anchor{cp/topics/functions gccjit block end_with_switch__gccjit rvalue gccjit block std vector gccjit case_ gccjit location}@anchor{19e}
+@deffn {C++ Function} void gccjit::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.
+
+This is roughly equivalent to this C code:
+
+@example
+switch (expr)
+ @{
+ default:
+ goto default_block;
+
+ case C0.min_value ... C0.max_value:
+ goto C0.dest_block;
+
+ case C1.min_value ... C1.max_value:
+ goto C1.dest_block;
+
+ ...etc...
+
+ case C[N - 1].min_value ... C[N - 1].max_value:
+ goto C[N - 1].dest_block;
+@}
+@end example
+
+@noindent
+
+@code{expr} must be of the same integer type as all of the @code{min_value}
+and @code{max_value} within the cases.
+
+The ranges of the cases must not overlap (or have duplicate
+values).
+
+The API entrypoints relating to switch statements and cases:
+
+@quotation
+
+
+@itemize *
+
+@item
+@pxref{19e,,gccjit;;block;;end_with_switch()}
+
+@item
+@pxref{19f,,gccjit;;context;;new_case()}
+@end itemize
+@end quotation
+
+were added in @pxref{d7,,LIBGCCJIT_ABI_3}; you can test for their presence
+using
+
+@example
+#ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
+@end example
+
+@noindent
+
+@geindex gccjit;;block;;end_with_switch;;gccjit;;case_ (C++ class)
+@anchor{cp/topics/functions gccjit block end_with_switch gccjit case_}@anchor{1a0}
+@deffn {C++ Class} gccjit::case_
+@end deffn
+
+A @cite{gccjit::case_} represents a case within a switch statement, and
+is created within a particular @pxref{122,,gccjit;;context} using
+@pxref{19f,,gccjit;;context;;new_case()}. It is a subclass of
+@pxref{136,,gccjit;;object}.
+
+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 gccjit;;block;;end_with_switch;;gccjit;;context;;new_case (C++ function)
+@anchor{cp/topics/functions gccjit block end_with_switch gccjit context new_case__gccjit rvalue gccjit rvalue gccjit block}@anchor{19f}
+@deffn {C++ Function} gccjit::case_* gccjit::context::new_case (gccjit::rvalue min_value, gccjit::rvalue max_value, gccjit::block dest_block)
+
+Create a new gccjit::case for use in a switch statement.
+@cite{min_value} and @cite{max_value} must be constants of an integer type,
+which must match that of the expression of the switch statement.
+
+@cite{dest_block} must be within the same function as the switch
+statement.
+@end deffn
+
+Here's an example of creating a switch statement:
+
+@quotation
+
+@example
+
+void
+create_code (gcc_jit_context *c_ctxt, void *user_data)
+@{
+ /* Let's try to inject the equivalent of:
+ int
+ test_switch (int x)
+ @{
+ switch (x)
+ @{
+ case 0 ... 5:
+ return 3;
+
+ case 25 ... 27:
+ return 4;
+
+ case -42 ... -17:
+ return 83;
+
+ case 40:
+ return 8;
+
+ default:
+ return 10;
+ @}
+ @}
+ */
+ gccjit::context ctxt (c_ctxt);
+ gccjit::type t_int = ctxt.get_type (GCC_JIT_TYPE_INT);
+ gccjit::type return_type = t_int;
+ gccjit::param x = ctxt.new_param (t_int, "x");
+ std::vector <gccjit::param> params;
+ params.push_back (x);
+ gccjit::function func = ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
+ return_type,
+ "test_switch",
+ params, 0);
+
+ gccjit::block b_initial = func.new_block ("initial");
+
+ gccjit::block b_default = func.new_block ("default");
+ gccjit::block b_case_0_5 = func.new_block ("case_0_5");
+ gccjit::block b_case_25_27 = func.new_block ("case_25_27");
+ gccjit::block b_case_m42_m17 = func.new_block ("case_m42_m17");
+ gccjit::block b_case_40 = func.new_block ("case_40");
+
+ std::vector <gccjit::case_> cases;
+ cases.push_back (ctxt.new_case (ctxt.new_rvalue (t_int, 0),
+ ctxt.new_rvalue (t_int, 5),
+ b_case_0_5));
+ cases.push_back (ctxt.new_case (ctxt.new_rvalue (t_int, 25),
+ ctxt.new_rvalue (t_int, 27),
+ b_case_25_27));
+ cases.push_back (ctxt.new_case (ctxt.new_rvalue (t_int, -42),
+ ctxt.new_rvalue (t_int, -17),
+ b_case_m42_m17));
+ cases.push_back (ctxt.new_case (ctxt.new_rvalue (t_int, 40),
+ ctxt.new_rvalue (t_int, 40),
+ b_case_40));
+ b_initial.end_with_switch (x,
+ b_default,
+ cases);
+
+ b_case_0_5.end_with_return (ctxt.new_rvalue (t_int, 3));
+ b_case_25_27.end_with_return (ctxt.new_rvalue (t_int, 4));
+ b_case_m42_m17.end_with_return (ctxt.new_rvalue (t_int, 83));
+ b_case_40.end_with_return (ctxt.new_rvalue (t_int, 8));
+ b_default.end_with_return (ctxt.new_rvalue (t_int, 10));
+@}
+
+
+@end example
+
+@noindent
+@end quotation
+@end deffn
+
@c Copyright (C) 2014-2015 Free Software Foundation, Inc.
@c Originally contributed by David Malcolm <dmalcolm@redhat.com>
@c
@c <http://www.gnu.org/licenses/>.
@node Source Locations<2>,Compiling a context<2>,Creating and using functions<2>,Topic Reference<2>
-@anchor{cp/topics/locations source-locations}@anchor{198}@anchor{cp/topics/locations doc}@anchor{199}
+@anchor{cp/topics/locations source-locations}@anchor{1a1}@anchor{cp/topics/locations doc}@anchor{1a2}
@subsection Source Locations
@geindex gccjit;;location (C++ class)
-@anchor{cp/topics/locations gccjit location}@anchor{124}
+@anchor{cp/topics/locations gccjit location}@anchor{12a}
@deffn {C++ Class} gccjit::location
A @cite{gccjit::location} encapsulates a source code location, so that
@cite{gccjit::location} instances are optional: you can always omit them
from any C++ API entrypoint accepting one.
-You can construct them using @pxref{112,,gccjit;;context;;new_location()}.
+You can construct them using @pxref{118,,gccjit;;context;;new_location()}.
You need to enable @pxref{42,,GCC_JIT_BOOL_OPTION_DEBUGINFO} on the
-@pxref{11c,,gccjit;;context} for these locations to actually be usable by
+@pxref{122,,gccjit;;context} for these locations to actually be usable by
the debugger:
@example
@end deffn
@geindex gccjit;;context;;new_location (C++ function)
-@anchor{cp/topics/locations gccjit context new_location__cCP i i}@anchor{112}
+@anchor{cp/topics/locations gccjit context new_location__cCP i i}@anchor{118}
@deffn {C++ Function} gccjit::location gccjit::context::new_location (const char* filename, int line, int column)
Create a @cite{gccjit::location} instance representing the given source
@end menu
@node Faking it<2>,,,Source Locations<2>
-@anchor{cp/topics/locations faking-it}@anchor{19a}
+@anchor{cp/topics/locations faking-it}@anchor{1a3}
@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 @pxref{123,,gccjit;;context;;dump_to_file()}:
+your context using @pxref{129,,gccjit;;context;;dump_to_file()}:
@example
ctxt.dump_to_file ("/tmp/something.c",
@c <http://www.gnu.org/licenses/>.
@node Compiling a context<2>,,Source Locations<2>,Topic Reference<2>
-@anchor{cp/topics/compilation compiling-a-context}@anchor{19b}@anchor{cp/topics/compilation doc}@anchor{19c}
+@anchor{cp/topics/compilation compiling-a-context}@anchor{1a4}@anchor{cp/topics/compilation doc}@anchor{1a5}
@subsection Compiling a context
-Once populated, a @pxref{11c,,gccjit;;context} can be compiled to
-machine code, either in-memory via @pxref{f5,,gccjit;;context;;compile()} or
-to disk via @pxref{19d,,gccjit;;context;;compile_to_file()}.
+Once populated, a @pxref{122,,gccjit;;context} can be compiled to
+machine code, either in-memory via @pxref{fb,,gccjit;;context;;compile()} or
+to disk via @pxref{1a6,,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
@end menu
@node In-memory compilation<2>,Ahead-of-time compilation<2>,,Compiling a context<2>
-@anchor{cp/topics/compilation in-memory-compilation}@anchor{19e}
+@anchor{cp/topics/compilation in-memory-compilation}@anchor{1a7}
@subsubsection In-memory compilation
@geindex gccjit;;context;;compile (C++ function)
-@anchor{cp/topics/compilation gccjit context compile}@anchor{f5}
+@anchor{cp/topics/compilation gccjit context compile}@anchor{fb}
@deffn {C++ Function} gcc_jit_result* gccjit::context::compile ()
This calls into GCC and builds the code, returning a
@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{19f}
+@anchor{cp/topics/compilation ahead-of-time-compilation}@anchor{1a8}
@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 @pxref{19d,,gccjit;;context;;compile_to_file()} method.
+compilers, via the @pxref{1a6,,gccjit;;context;;compile_to_file()} method.
@geindex gccjit;;context;;compile_to_file (C++ function)
-@anchor{cp/topics/compilation gccjit context compile_to_file__enum cCP}@anchor{19d}
+@anchor{cp/topics/compilation gccjit context compile_to_file__enum cCP}@anchor{1a6}
@deffn {C++ Function} void gccjit::context::compile_to_file (enum gcc_jit_output_kind, const char* output_path)
-Compile the @pxref{11c,,gccjit;;context} to a file of the given
+Compile the @pxref{122,,gccjit;;context} to a file of the given
kind.
This is a thin wrapper around the
@c <http://www.gnu.org/licenses/>.
@node Internals,Indices and tables,C++ bindings for libgccjit,Top
-@anchor{internals/index internals}@anchor{1a0}@anchor{internals/index doc}@anchor{1a1}
+@anchor{internals/index internals}@anchor{1a9}@anchor{internals/index doc}@anchor{1aa}
@chapter Internals
@end menu
@node Working on the JIT library,Running the test suite,,Internals
-@anchor{internals/index working-on-the-jit-library}@anchor{1a2}
+@anchor{internals/index working-on-the-jit-library}@anchor{1ab}
@section Working on the JIT library
Here's what those configuration options mean:
@geindex command line option; --enable-host-shared
-@anchor{internals/index cmdoption--enable-host-shared}@anchor{1a3}
+@anchor{internals/index cmdoption--enable-host-shared}@anchor{1ac}
@deffn {Option} --enable-host-shared
Configuring with this option means that the compiler is built as
@end deffn
@geindex command line option; --enable-languages=jit@comma{}c++
-@anchor{internals/index cmdoption--enable-languages}@anchor{1a4}
+@anchor{internals/index cmdoption--enable-languages}@anchor{1ad}
@deffn {Option} --enable-languages=jit,c++
This specifies which frontends to build. The JIT library looks like
@end deffn
@geindex command line option; --disable-bootstrap
-@anchor{internals/index cmdoption--disable-bootstrap}@anchor{1a5}
+@anchor{internals/index cmdoption--disable-bootstrap}@anchor{1ae}
@deffn {Option} --disable-bootstrap
For hacking on the "jit" subdirectory, performing a full
@end deffn
@geindex command line option; --enable-checking=release
-@anchor{internals/index cmdoption--enable-checking}@anchor{1a6}
+@anchor{internals/index cmdoption--enable-checking}@anchor{1af}
@deffn {Option} --enable-checking=release
The compile can perform extensive self-checking as it runs, useful when
@end deffn
@node Running the test suite,Environment variables,Working on the JIT library,Internals
-@anchor{internals/index running-the-test-suite}@anchor{1a7}
+@anchor{internals/index running-the-test-suite}@anchor{1b0}
@section Running the test suite
@end menu
@node Running under valgrind,,,Running the test suite
-@anchor{internals/index running-under-valgrind}@anchor{1a8}
+@anchor{internals/index running-under-valgrind}@anchor{1b1}
@subsection Running under valgrind
various known false positives.
@node Environment variables,Packaging notes,Running the test suite,Internals
-@anchor{internals/index environment-variables}@anchor{1a9}
+@anchor{internals/index environment-variables}@anchor{1b2}
@section Environment variables
environment variables need to be set up:
@geindex environment variable; LD_LIBRARY_PATH
-@anchor{internals/index envvar-LD_LIBRARY_PATH}@anchor{1aa}
+@anchor{internals/index envvar-LD_LIBRARY_PATH}@anchor{1b3}
@deffn {Environment Variable} LD_LIBRARY_PATH
@quotation
@end deffn
@geindex environment variable; PATH
-@anchor{internals/index envvar-PATH}@anchor{1ab}
+@anchor{internals/index envvar-PATH}@anchor{1b4}
@deffn {Environment Variable} PATH
The library uses a driver executable for converting from .s assembler
@end deffn
@geindex environment variable; LIBRARY_PATH
-@anchor{internals/index envvar-LIBRARY_PATH}@anchor{1ac}
+@anchor{internals/index envvar-LIBRARY_PATH}@anchor{1b5}
@deffn {Environment Variable} LIBRARY_PATH
The driver executable invokes the linker, and the latter needs to locate
@noindent
@node Packaging notes,Overview of code structure,Environment variables,Internals
-@anchor{internals/index packaging-notes}@anchor{1ad}
+@anchor{internals/index packaging-notes}@anchor{1b6}
@section Packaging notes
-The configure-time option @pxref{1a3,,--enable-host-shared} is needed when
+The configure-time option @pxref{1ac,,--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:
@itemize *
@item
-once without @pxref{1a3,,--enable-host-shared} for most languages, and
+once without @pxref{1ac,,--enable-host-shared} for most languages, and
@item
-once with @pxref{1a3,,--enable-host-shared} for the jit
+once with @pxref{1ac,,--enable-host-shared} for the jit
@end itemize
@end quotation
@noindent
@node Overview of code structure,Design notes,Packaging notes,Internals
-@anchor{internals/index overview-of-code-structure}@anchor{1ae}
+@anchor{internals/index overview-of-code-structure}@anchor{1b7}
@section Overview of code structure
class global;
class param;
class statement;
+ class case_;
@end example
class source_file;
class source_line;
class location;
+ class case_;
@end example
@noindent
@node Design notes,,Overview of code structure,Internals
-@anchor{internals/index design-notes}@anchor{1af}
+@anchor{internals/index design-notes}@anchor{1b8}
@section Design notes
@code{recording::context::validate ()} in jit-recording.c.
@node Indices and tables,Index,Internals,Top
-@anchor{index indices-and-tables}@anchor{1b0}
+@anchor{index indices-and-tables}@anchor{1b9}
@unnumbered Indices and tables
projects / gcc.git / commitdiff