This is doc/libgccjit.info, produced by makeinfo version 4.8 from
../../gcc-14.3.0/gcc/jit/docs/_build/texinfo/libgccjit.texi.

Generated by Sphinx 2.2.2.
INFO-DIR-SECTION Miscellaneous
START-INFO-DIR-ENTRY
* libgccjit: (libgccjit.info). GCC-based Just In Time compiler library.
END-INFO-DIR-ENTRY

     libgccjit 12.0.1 (experimental 20220411), Apr 12, 2022

     David Malcolm

     Copyright (C) 2014-2024 Free Software Foundation, Inc.


File: libgccjit.info,  Node: Top,  Next: Tutorial,  Up: (dir)

libgccjit Documentation
***********************

     libgccjit 12.0.1 (experimental 20220411), Apr 12, 2022

     David Malcolm

     Copyright (C) 2014-2024 Free Software Foundation, Inc.

This document describes libgccjit(1), an API for embedding GCC inside
programs and libraries.

There are actually two APIs for the library:

   * a pure C API: `libgccjit.h'

   * a C++ wrapper API: `libgccjit++.h'.  This is a collection of
     “thin” wrapper classes around the C API, to save typing.

Contents:

* Menu:

* Tutorial::
* Topic Reference::
* C++ bindings for libgccjit::
* Internals::
* Indices and tables::
* Index::

 --- The Detailed Node Listing ---

Tutorial

* Tutorial part 1; “Hello world”: Tutorial part 1 “Hello world”.
* Tutorial part 2; Creating a trivial machine code function: Tutorial part 2 Creating a trivial machine code function.
* Tutorial part 3; Loops and variables: Tutorial part 3 Loops and variables.
* Tutorial part 4; Adding JIT-compilation to a toy interpreter: Tutorial part 4 Adding JIT-compilation to a toy interpreter.
* Tutorial part 5; Implementing an Ahead-of-Time compiler: Tutorial part 5 Implementing an Ahead-of-Time compiler.

Tutorial part 2: Creating a trivial machine code function

* Error-handling::
* Options::
* Full example::

Tutorial part 3: Loops and variables

* Expressions; lvalues and rvalues: Expressions lvalues and rvalues.
* Control flow::
* Visualizing the control flow graph::
* Full example: Full example<2>.

Tutorial part 4: Adding JIT-compilation to a toy interpreter

* Our toy interpreter::
* Compiling to machine code::
* Setting things up::
* Populating the function::
* Verifying the control flow graph::
* Compiling the context::
* Single-stepping through the generated code::
* Examining the generated code::
* Putting it all together::
* Behind the curtain; How does our code get optimized?: Behind the curtain How does our code get optimized?.

Behind the curtain: How does our code get optimized?

* Optimizing away stack manipulation::
* Elimination of tail recursion::

Tutorial part 5: Implementing an Ahead-of-Time compiler

* The “brainf” language::
* Converting a brainf script to libgccjit IR::
* Compiling a context to a file::
* Other forms of ahead-of-time-compilation::

Topic Reference

* Compilation contexts::
* Objects::
* Types::
* Expressions::
* Creating and using functions::
* Function pointers: Function pointers<2>.
* Source Locations::
* Compiling a context::
* ABI and API compatibility::
* Performance::
* Using Assembly Language with libgccjit::

Compilation contexts

* Lifetime-management::
* Thread-safety::
* Error-handling: Error-handling<2>.
* Debugging::
* Options: Options<2>.

Options

* String Options::
* Boolean options::
* Integer options::
* Additional command-line options::

Types

* Standard types::
* Pointers, const, and volatile: Pointers const and volatile.
* Vector types::
* Structures and unions::
* Function pointer types::
* Reflection API::

Expressions

* Rvalues::
* Lvalues::
* Working with pointers, structs and unions: Working with pointers structs and unions.

Rvalues

* Simple expressions::
* Constructor expressions::
* Vector expressions::
* Unary Operations::
* Binary Operations::
* Comparisons::
* Function calls::
* Function pointers::
* Type-coercion::

Lvalues

* Global variables::

Creating and using functions

* Params::
* Functions::
* Blocks::
* Statements::

Source Locations

* Faking it::

Compiling a context

* In-memory compilation::
* Ahead-of-time compilation::

ABI and API compatibility

* Programmatically checking version::
* ABI symbol tags::

ABI symbol tags

* LIBGCCJIT_ABI_0::
* LIBGCCJIT_ABI_1::
* LIBGCCJIT_ABI_2::
* LIBGCCJIT_ABI_3::
* LIBGCCJIT_ABI_4::
* LIBGCCJIT_ABI_5::
* LIBGCCJIT_ABI_6::
* LIBGCCJIT_ABI_7::
* LIBGCCJIT_ABI_8::
* LIBGCCJIT_ABI_9::
* LIBGCCJIT_ABI_10::
* LIBGCCJIT_ABI_11::
* LIBGCCJIT_ABI_12::
* LIBGCCJIT_ABI_13::
* LIBGCCJIT_ABI_14::
* LIBGCCJIT_ABI_15::
* LIBGCCJIT_ABI_16::
* LIBGCCJIT_ABI_17::
* LIBGCCJIT_ABI_18::
* LIBGCCJIT_ABI_19::
* LIBGCCJIT_ABI_20::
* LIBGCCJIT_ABI_21::
* LIBGCCJIT_ABI_22::
* LIBGCCJIT_ABI_23::
* LIBGCCJIT_ABI_24::

Performance

* The timing API::

Using Assembly Language with libgccjit

* Adding assembler instructions within a function::
* Adding top-level assembler statements::

C++ bindings for libgccjit

* Tutorial: Tutorial<2>.
* Topic Reference: Topic Reference<2>.

Tutorial

* Tutorial part 1; “Hello world”: Tutorial part 1 “Hello world”<2>.
* Tutorial part 2; Creating a trivial machine code function: Tutorial part 2 Creating a trivial machine code function<2>.
* Tutorial part 3; Loops and variables: Tutorial part 3 Loops and variables<2>.
* Tutorial part 4; Adding JIT-compilation to a toy interpreter: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>.

Tutorial part 2: Creating a trivial machine code function

* Options: Options<3>.
* Full example: Full example<3>.

Tutorial part 3: Loops and variables

* Expressions; lvalues and rvalues: Expressions lvalues and rvalues<2>.
* Control flow: Control flow<2>.
* Visualizing the control flow graph: Visualizing the control flow graph<2>.
* Full example: Full example<4>.

Tutorial part 4: Adding JIT-compilation to a toy interpreter

* Our toy interpreter: Our toy interpreter<2>.
* Compiling to machine code: Compiling to machine code<2>.
* Setting things up: Setting things up<2>.
* Populating the function: Populating the function<2>.
* Verifying the control flow graph: Verifying the control flow graph<2>.
* Compiling the context: Compiling the context<2>.
* Single-stepping through the generated code: Single-stepping through the generated code<2>.
* Examining the generated code: Examining the generated code<2>.
* Putting it all together: Putting it all together<2>.
* Behind the curtain; How does our code get optimized?: Behind the curtain How does our code get optimized?<2>.

Behind the curtain: How does our code get optimized?

* Optimizing away stack manipulation: Optimizing away stack manipulation<2>.
* Elimination of tail recursion: Elimination of tail recursion<2>.

Topic Reference

* Compilation contexts: Compilation contexts<2>.
* Objects: Objects<2>.
* Types: Types<2>.
* Expressions: Expressions<2>.
* Creating and using functions: Creating and using functions<2>.
* Source Locations: Source Locations<2>.
* Compiling a context: Compiling a context<2>.
* Using Assembly Language with libgccjit++::

Compilation contexts

* Lifetime-management: Lifetime-management<2>.
* Thread-safety: Thread-safety<2>.
* Error-handling: Error-handling<3>.
* Debugging: Debugging<2>.
* Options: Options<4>.

Options

* String Options: String Options<2>.
* Boolean options: Boolean options<2>.
* Integer options: Integer options<2>.
* Additional command-line options: Additional command-line options<2>.

Types

* Standard types: Standard types<2>.
* Pointers, const, and volatile: Pointers const and volatile<2>.
* Vector types: Vector types<2>.
* Structures and unions: Structures and unions<2>.

Expressions

* Rvalues: Rvalues<2>.
* Lvalues: Lvalues<2>.
* Working with pointers, structs and unions: Working with pointers structs and unions<2>.

Rvalues

* Simple expressions: Simple expressions<2>.
* Vector expressions: Vector expressions<2>.
* Unary Operations: Unary Operations<2>.
* Binary Operations: Binary Operations<2>.
* Comparisons: Comparisons<2>.
* Function calls: Function calls<2>.
* Function pointers: Function pointers<3>.
* Type-coercion: Type-coercion<2>.

Lvalues

* Global variables: Global variables<2>.

Creating and using functions

* Params: Params<2>.
* Functions: Functions<2>.
* Blocks: Blocks<2>.
* Statements: Statements<2>.

Source Locations

* Faking it: Faking it<2>.

Compiling a context

* In-memory compilation: In-memory compilation<2>.
* Ahead-of-time compilation: Ahead-of-time compilation<2>.

Using Assembly Language with libgccjit++

* Adding assembler instructions within a function: Adding assembler instructions within a function<2>.
* Adding top-level assembler statements: Adding top-level assembler statements<2>.

Internals

* Working on the JIT library::
* Running the test suite::
* Environment variables::
* Packaging notes::
* Overview of code structure::
* Design notes::
* Submitting patches::

Running the test suite

* Running under valgrind::

---------- Footnotes ----------

(1) https://gcc.gnu.org/wiki/JIT


File: libgccjit.info,  Node: Tutorial,  Next: Topic Reference,  Prev: Top,  Up: Top

1 Tutorial
**********

* Menu:

* Tutorial part 1; “Hello world”: Tutorial part 1 “Hello world”.
* Tutorial part 2; Creating a trivial machine code function: Tutorial part 2 Creating a trivial machine code function.
* Tutorial part 3; Loops and variables: Tutorial part 3 Loops and variables.
* Tutorial part 4; Adding JIT-compilation to a toy interpreter: Tutorial part 4 Adding JIT-compilation to a toy interpreter.
* Tutorial part 5; Implementing an Ahead-of-Time compiler: Tutorial part 5 Implementing an Ahead-of-Time compiler.


File: libgccjit.info,  Node: Tutorial part 1 “Hello world”,  Next: Tutorial part 2 Creating a trivial machine code function,  Up: Tutorial

1.1 Tutorial part 1: “Hello world”
======================================

Before we look at the details of the API, let’s look at building and
running programs that use the library.

Here’s a toy “hello world” program that uses the library to
synthesize a call to `printf' and uses it to write a message to stdout.

Don’t worry about the content of the program for now; we’ll cover
the details in later parts of this tutorial.

         /* Smoketest example for libgccjit.so
            Copyright (C) 2014-2024 Free Software Foundation, Inc.

         This file is part of GCC.

         GCC is free software; you can redistribute it and/or modify it
         under the terms of the GNU General Public License as published by
         the Free Software Foundation; either version 3, or (at your option)
         any later version.

         GCC is distributed in the hope that it will be useful, but
         WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
         General Public License for more details.

         You should have received a copy of the GNU General Public License
         along with GCC; see the file COPYING3.  If not see
         <http://www.gnu.org/licenses/>.  */

         #include <libgccjit.h>

         #include <stdlib.h>
         #include <stdio.h>

         static void
         create_code (gcc_jit_context *ctxt)
         {
           /* Let's try to inject the equivalent of:
              void
              greet (const char *name)
              {
                 printf ("hello %s\n", name);
              }
           */
           gcc_jit_type *void_type =
             gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
           gcc_jit_type *const_char_ptr_type =
             gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_CONST_CHAR_PTR);
           gcc_jit_param *param_name =
             gcc_jit_context_new_param (ctxt, NULL, const_char_ptr_type, "name");
           gcc_jit_function *func =
             gcc_jit_context_new_function (ctxt, NULL,
                                           GCC_JIT_FUNCTION_EXPORTED,
                                           void_type,
                                           "greet",
                                           1, &param_name,
                                           0);

           gcc_jit_param *param_format =
             gcc_jit_context_new_param (ctxt, NULL, const_char_ptr_type, "format");
           gcc_jit_function *printf_func =
             gcc_jit_context_new_function (ctxt, NULL,
         				  GCC_JIT_FUNCTION_IMPORTED,
         				  gcc_jit_context_get_type (
         				     ctxt, GCC_JIT_TYPE_INT),
         				  "printf",
         				  1, &param_format,
         				  1);
           gcc_jit_rvalue *args[2];
           args[0] = gcc_jit_context_new_string_literal (ctxt, "hello %s\n");
           args[1] = gcc_jit_param_as_rvalue (param_name);

           gcc_jit_block *block = gcc_jit_function_new_block (func, NULL);

           gcc_jit_block_add_eval (
             block, NULL,
             gcc_jit_context_new_call (ctxt,
                                       NULL,
                                       printf_func,
                                       2, args));
           gcc_jit_block_end_with_void_return (block, NULL);
         }

         int
         main (int argc, char **argv)
         {
           gcc_jit_context *ctxt;
           gcc_jit_result *result;

           /* Get a "context" object for working with the library.  */
           ctxt = gcc_jit_context_acquire ();
           if (!ctxt)
             {
               fprintf (stderr, "NULL ctxt");
               exit (1);
             }

           /* Set some options on the context.
              Let's see the code being generated, in assembler form.  */
           gcc_jit_context_set_bool_option (
             ctxt,
             GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
             0);

           /* Populate the context.  */
           create_code (ctxt);

           /* Compile the code.  */
           result = gcc_jit_context_compile (ctxt);
           if (!result)
             {
               fprintf (stderr, "NULL result");
               exit (1);
             }

           /* Extract the generated code from "result".  */
           typedef void (*fn_type) (const char *);
           fn_type greet =
             (fn_type)gcc_jit_result_get_code (result, "greet");
           if (!greet)
             {
               fprintf (stderr, "NULL greet");
               exit (1);
             }

           /* Now call the generated function: */
           greet ("world");
           fflush (stdout);

           gcc_jit_context_release (ctxt);
           gcc_jit_result_release (result);
           return 0;
         }

Copy the above to `tut01-hello-world.c'.

Assuming you have the jit library installed, build the test program
using:

    $ gcc \
        tut01-hello-world.c \
        -o tut01-hello-world \
        -lgccjit

You should then be able to run the built program:

    $ ./tut01-hello-world
    hello world


File: libgccjit.info,  Node: Tutorial part 2 Creating a trivial machine code function,  Next: Tutorial part 3 Loops and variables,  Prev: Tutorial part 1 “Hello world”,  Up: Tutorial

1.2 Tutorial part 2: Creating a trivial machine code function
=============================================================

Consider this C function:

    int square (int i)
    {
      return i * i;
    }

How can we construct this at run-time using libgccjit?

First we need to include the relevant header:

    #include <libgccjit.h>

All state associated with compilation is associated with a *Note
gcc_jit_context *: 8.

Create one using *Note gcc_jit_context_acquire(): 9.:

    gcc_jit_context *ctxt;
    ctxt = gcc_jit_context_acquire ();

The JIT library has a system of types.  It is statically-typed: every
expression is of a specific type, fixed at compile-time.  In our
example, all of the expressions are of the C `int' type, so let’s
obtain this from the context, as a *Note gcc_jit_type *: a, using *Note
gcc_jit_context_get_type(): b.:

    gcc_jit_type *int_type =
      gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);

*Note gcc_jit_type *: a. is an example of a “contextual” object:
every entity in the API is associated with a *Note gcc_jit_context *: 8.

Memory management is easy: all such “contextual” objects are
automatically cleaned up for you when the context is released, using
*Note gcc_jit_context_release(): c.:

    gcc_jit_context_release (ctxt);

so you don’t need to manually track and cleanup all objects, just the
contexts.

Although the API is C-based, there is a form of class hierarchy, which
looks like this:

    +- gcc_jit_object
        +- gcc_jit_location
        +- gcc_jit_type
           +- gcc_jit_struct
        +- gcc_jit_field
        +- gcc_jit_function
        +- gcc_jit_block
        +- gcc_jit_rvalue
            +- gcc_jit_lvalue
               +- gcc_jit_param

There are casting methods for upcasting from subclasses to parent
classes.  For example, *Note gcc_jit_type_as_object(): d.:

    gcc_jit_object *obj = gcc_jit_type_as_object (int_type);

One thing you can do with a *Note gcc_jit_object *: e. is to ask it for
a human-readable description, using *Note
gcc_jit_object_get_debug_string(): f.:

    printf ("obj: %s\n", gcc_jit_object_get_debug_string (obj));

giving this text on stdout:

    obj: int

This is invaluable when debugging.

Let’s create the function.  To do so, we first need to construct its
single parameter, specifying its type and giving it a name, using *Note
gcc_jit_context_new_param(): 10.:

    gcc_jit_param *param_i =
      gcc_jit_context_new_param (ctxt, NULL, int_type, "i");

Now we can create the function, using *Note
gcc_jit_context_new_function(): 11.:

    gcc_jit_function *func =
      gcc_jit_context_new_function (ctxt, NULL,
                                    GCC_JIT_FUNCTION_EXPORTED,
                                    int_type,
                                    "square",
                                    1, &param_i,
                                    0);

To define the code within the function, we must create basic blocks
containing statements.

Every basic block contains a list of statements, eventually terminated
by a statement that either returns, or jumps to another basic block.

Our function has no control-flow, so we just need one basic block:

    gcc_jit_block *block = gcc_jit_function_new_block (func, NULL);

Our basic block is relatively simple: it immediately terminates by
returning the value of an expression.

We can build the expression using *Note
gcc_jit_context_new_binary_op(): 12.:

    gcc_jit_rvalue *expr =
      gcc_jit_context_new_binary_op (
        ctxt, NULL,
        GCC_JIT_BINARY_OP_MULT, int_type,
        gcc_jit_param_as_rvalue (param_i),
        gcc_jit_param_as_rvalue (param_i));

A *Note gcc_jit_rvalue *: 13. is another example of a *Note
gcc_jit_object *: e. subclass.  We can upcast it using *Note
gcc_jit_rvalue_as_object(): 14. and as before print it with *Note
gcc_jit_object_get_debug_string(): f.

    printf ("expr: %s\n",
            gcc_jit_object_get_debug_string (
              gcc_jit_rvalue_as_object (expr)));

giving this output:

    expr: i * i

Creating the expression in itself doesn’t do anything; we have to add
this expression to a statement within the block.  In this case, we use
it to build a return statement, which terminates the basic block:

    gcc_jit_block_end_with_return (block, NULL, expr);

OK, we’ve populated the context.  We can now compile it using *Note
gcc_jit_context_compile(): 15.:

    gcc_jit_result *result;
    result = gcc_jit_context_compile (ctxt);

and get a *Note gcc_jit_result *: 16.

At this point we’re done with the context; we can release it:

    gcc_jit_context_release (ctxt);

We can now use *Note gcc_jit_result_get_code(): 17. to look up a
specific machine code routine within the result, in this case, the
function we created above.

    void *fn_ptr = gcc_jit_result_get_code (result, "square");
    if (!fn_ptr)
      {
        fprintf (stderr, "NULL fn_ptr");
        goto error;
      }

We can now cast the pointer to an appropriate function pointer type, and
then call it:

    typedef int (*fn_type) (int);
    fn_type square = (fn_type)fn_ptr;
    printf ("result: %d", square (5));

    result: 25

Once we’re done with the code, we can release the result:

    gcc_jit_result_release (result);

We can’t call `square' anymore once we’ve released `result'.

* Menu:

* Error-handling::
* Options::
* Full example::


File: libgccjit.info,  Node: Error-handling,  Next: Options,  Up: Tutorial part 2 Creating a trivial machine code function

1.2.1 Error-handling
--------------------

Various kinds of errors are possible when using the API, such as
mismatched types in an assignment.  You can only compile and get code
from a context if no errors occur.

Errors are printed on stderr; they typically contain the name of the API
entrypoint where the error occurred, and pertinent information on the
problem:

    ./buggy-program: error: gcc_jit_block_add_assignment: mismatching types: assignment to i (type: int) from "hello world" (type: const char *)

The API is designed to cope with errors without crashing, so you can get
away with having a single error-handling check in your code:

    void *fn_ptr = gcc_jit_result_get_code (result, "square");
    if (!fn_ptr)
      {
        fprintf (stderr, "NULL fn_ptr");
        goto error;
      }

For more information, see the *Note error-handling guide: 19.  within
the Topic eference.


File: libgccjit.info,  Node: Options,  Next: Full example,  Prev: Error-handling,  Up: Tutorial part 2 Creating a trivial machine code function

1.2.2 Options
-------------

To get more information on what’s going on, you can set debugging
flags on the context using *Note gcc_jit_context_set_bool_option(): 1b.

Setting *Note GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE: 1c. will dump a
C-like representation to stderr when you compile (GCC’s “GIMPLE”
representation):

    gcc_jit_context_set_bool_option (
      ctxt,
      GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE,
      1);
    result = gcc_jit_context_compile (ctxt);

    square (signed int i)
    {
      signed int D.260;

      entry:
      D.260 = i * i;
      return D.260;
    }

We can see the generated machine code in assembler form (on stderr) by
setting *Note GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE: 1d. on the
context before compiling:

    gcc_jit_context_set_bool_option (
      ctxt,
      GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
      1);
    result = gcc_jit_context_compile (ctxt);

          .file   "fake.c"
          .text
          .globl  square
          .type   square, @function
    square:
    .LFB6:
          .cfi_startproc
          pushq   %rbp
          .cfi_def_cfa_offset 16
          .cfi_offset 6, -16
          movq    %rsp, %rbp
          .cfi_def_cfa_register 6
          movl    %edi, -4(%rbp)
    .L14:
          movl    -4(%rbp), %eax
          imull   -4(%rbp), %eax
          popq    %rbp
          .cfi_def_cfa 7, 8
          ret
          .cfi_endproc
    .LFE6:
          .size   square, .-square
          .ident  "GCC: (GNU) 4.9.0 20131023 (Red Hat 0.2-0.5.1920c315ff984892399893b380305ab36e07b455.fc20)"
          .section       .note.GNU-stack,"",@progbits

By default, no optimizations are performed, the equivalent of GCC’s
`-O0' option.  We can turn things up to e.g. `-O3' by calling *Note
gcc_jit_context_set_int_option(): 1e. with *Note
GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL: 1f.:

    gcc_jit_context_set_int_option (
      ctxt,
      GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL,
      3);

          .file   "fake.c"
          .text
          .p2align 4,,15
          .globl  square
          .type   square, @function
    square:
    .LFB7:
          .cfi_startproc
    .L16:
          movl    %edi, %eax
          imull   %edi, %eax
          ret
          .cfi_endproc
    .LFE7:
          .size   square, .-square
          .ident  "GCC: (GNU) 4.9.0 20131023 (Red Hat 0.2-0.5.1920c315ff984892399893b380305ab36e07b455.fc20)"
          .section        .note.GNU-stack,"",@progbits

Naturally this has only a small effect on such a trivial function.


File: libgccjit.info,  Node: Full example,  Prev: Options,  Up: Tutorial part 2 Creating a trivial machine code function

1.2.3 Full example
------------------

Here’s what the above looks like as a complete program:

         /* Usage example for libgccjit.so
            Copyright (C) 2014-2024 Free Software Foundation, Inc.

         This file is part of GCC.

         GCC is free software; you can redistribute it and/or modify it
         under the terms of the GNU General Public License as published by
         the Free Software Foundation; either version 3, or (at your option)
         any later version.

         GCC is distributed in the hope that it will be useful, but
         WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
         General Public License for more details.

         You should have received a copy of the GNU General Public License
         along with GCC; see the file COPYING3.  If not see
         <http://www.gnu.org/licenses/>.  */

         #include <libgccjit.h>

         #include <stdlib.h>
         #include <stdio.h>

         void
         create_code (gcc_jit_context *ctxt)
         {
           /* Let's try to inject the equivalent of:

               int square (int i)
               {
                 return i * i;
               }
           */
           gcc_jit_type *int_type =
             gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
           gcc_jit_param *param_i =
             gcc_jit_context_new_param (ctxt, NULL, int_type, "i");
           gcc_jit_function *func =
             gcc_jit_context_new_function (ctxt, NULL,
                                           GCC_JIT_FUNCTION_EXPORTED,
                                           int_type,
                                           "square",
                                           1, &param_i,
                                           0);

           gcc_jit_block *block = gcc_jit_function_new_block (func, NULL);

           gcc_jit_rvalue *expr =
             gcc_jit_context_new_binary_op (
               ctxt, NULL,
               GCC_JIT_BINARY_OP_MULT, int_type,
               gcc_jit_param_as_rvalue (param_i),
               gcc_jit_param_as_rvalue (param_i));

            gcc_jit_block_end_with_return (block, NULL, expr);
         }

         int
         main (int argc, char **argv)
         {
           gcc_jit_context *ctxt = NULL;
           gcc_jit_result *result = NULL;

           /* Get a "context" object for working with the library.  */
           ctxt = gcc_jit_context_acquire ();
           if (!ctxt)
             {
               fprintf (stderr, "NULL ctxt");
               goto error;
             }

           /* Set some options on the context.
              Let's see the code being generated, in assembler form.  */
           gcc_jit_context_set_bool_option (
             ctxt,
             GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
             0);

           /* Populate the context.  */
           create_code (ctxt);

           /* Compile the code.  */
           result = gcc_jit_context_compile (ctxt);
           if (!result)
             {
               fprintf (stderr, "NULL result");
               goto error;
             }

           /* We're done with the context; we can release it: */
           gcc_jit_context_release (ctxt);
           ctxt = NULL;

           /* Extract the generated code from "result".  */
           void *fn_ptr = gcc_jit_result_get_code (result, "square");
           if (!fn_ptr)
              {
                fprintf (stderr, "NULL fn_ptr");
                goto error;
              }

           typedef int (*fn_type) (int);
           fn_type square = (fn_type)fn_ptr;
           printf ("result: %d\n", square (5));

          error:
           if (ctxt)
             gcc_jit_context_release (ctxt);
           if (result)
             gcc_jit_result_release (result);
           return 0;
         }

Building and running it:

    $ gcc \
        tut02-square.c \
        -o tut02-square \
        -lgccjit

    # Run the built program:
    $ ./tut02-square
    result: 25


File: libgccjit.info,  Node: Tutorial part 3 Loops and variables,  Next: Tutorial part 4 Adding JIT-compilation to a toy interpreter,  Prev: Tutorial part 2 Creating a trivial machine code function,  Up: Tutorial

1.3 Tutorial part 3: Loops and variables
========================================

Consider this C function:

         int loop_test (int n)
         {
           int sum = 0;
           for (int i = 0; i < n; i++)
             sum += i * i;
           return sum;
         }

This example demonstrates some more features of libgccjit, with local
variables and a loop.

To break this down into libgccjit terms, it’s usually easier to reword
the `for' loop as a `while' loop, giving:

         int loop_test (int n)
         {
           int sum = 0;
           int i = 0;
           while (i < n)
           {
             sum += i * i;
             i++;
           }
           return sum;
         }

Here’s what the final control flow graph will look like:

       Figure


As before, we include the libgccjit header and make a *Note
gcc_jit_context *: 8.

    #include <libgccjit.h>

    void test (void)
    {
      gcc_jit_context *ctxt;
      ctxt = gcc_jit_context_acquire ();

The function works with the C `int' type:

    gcc_jit_type *the_type =
      gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
    gcc_jit_type *return_type = the_type;

though we could equally well make it work on, say, `double':

    gcc_jit_type *the_type =
      gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_DOUBLE);

Let’s build the function:

    gcc_jit_param *n =
      gcc_jit_context_new_param (ctxt, NULL, the_type, "n");
    gcc_jit_param *params[1] = {n};
    gcc_jit_function *func =
      gcc_jit_context_new_function (ctxt, NULL,
                                    GCC_JIT_FUNCTION_EXPORTED,
                                    return_type,
                                    "loop_test",
                                    1, params, 0);

* Menu:

* Expressions; lvalues and rvalues: Expressions lvalues and rvalues.
* Control flow::
* Visualizing the control flow graph::
* Full example: Full example<2>.


File: libgccjit.info,  Node: Expressions lvalues and rvalues,  Next: Control flow,  Up: Tutorial part 3 Loops and variables

1.3.1 Expressions: lvalues and rvalues
--------------------------------------

The base class of expression is the *Note gcc_jit_rvalue *: 13,
representing an expression that can be on the `right'-hand side of an
assignment: a value that can be computed somehow, and assigned `to' a
storage area (such as a variable).  It has a specific *Note
gcc_jit_type *: a.

Anothe important class is *Note gcc_jit_lvalue *: 24.  A *Note
gcc_jit_lvalue *: 24. is something that can of the `left'-hand side of
an assignment: a storage area (such as a variable).

In other words, every assignment can be thought of as:

    LVALUE = RVALUE;

Note that *Note gcc_jit_lvalue *: 24. is a subclass of *Note
gcc_jit_rvalue *: 13, where in an assignment of the form:

    LVALUE_A = LVALUE_B;

the `LVALUE_B' implies reading the current value of that storage area,
assigning it into the `LVALUE_A'.

So far the only expressions we’ve seen are `i * i':

    gcc_jit_rvalue *expr =
      gcc_jit_context_new_binary_op (
        ctxt, NULL,
        GCC_JIT_BINARY_OP_MULT, int_type,
        gcc_jit_param_as_rvalue (param_i),
        gcc_jit_param_as_rvalue (param_i));

which is a *Note gcc_jit_rvalue *: 13, and the various function
parameters: `param_i' and `param_n', instances of *Note gcc_jit_param
*: 25, which is a subclass of *Note gcc_jit_lvalue *: 24. (and, in
turn, of *Note gcc_jit_rvalue *: 13.): we can both read from and write
to function parameters within the body of a function.

Our new example has a couple of local variables.  We create them by
calling *Note gcc_jit_function_new_local(): 26, supplying a type and a
name:

    /* Build locals:  */
    gcc_jit_lvalue *i =
      gcc_jit_function_new_local (func, NULL, the_type, "i");
    gcc_jit_lvalue *sum =
      gcc_jit_function_new_local (func, NULL, the_type, "sum");

These are instances of *Note gcc_jit_lvalue *: 24. - they can be read
from and written to.

Note that there is no precanned way to create `and' initialize a
variable like in C:

    int i = 0;

Instead, having added the local to the function, we have to separately
add an assignment of `0' to `local_i' at the beginning of the function.


File: libgccjit.info,  Node: Control flow,  Next: Visualizing the control flow graph,  Prev: Expressions lvalues and rvalues,  Up: Tutorial part 3 Loops and variables

1.3.2 Control flow
------------------

This function has a loop, so we need to build some basic blocks to
handle the control flow.  In this case, we need 4 blocks:

  1. before the loop (initializing the locals)

  2. the conditional at the top of the loop (comparing `i < n')

  3. the body of the loop

  4. after the loop terminates (`return sum')

so we create these as *Note gcc_jit_block *: 28. instances within the
*Note gcc_jit_function *: 29.:

    gcc_jit_block *b_initial =
      gcc_jit_function_new_block (func, "initial");
    gcc_jit_block *b_loop_cond =
      gcc_jit_function_new_block (func, "loop_cond");
    gcc_jit_block *b_loop_body =
      gcc_jit_function_new_block (func, "loop_body");
    gcc_jit_block *b_after_loop =
      gcc_jit_function_new_block (func, "after_loop");

We now populate each block with statements.

The entry block `b_initial' consists of initializations followed by a
jump to the conditional.  We assign `0' to `i' and to `sum', using
*Note gcc_jit_block_add_assignment(): 2a. to add an assignment
statement, and using *Note gcc_jit_context_zero(): 2b. to get the
constant value `0' for the relevant type for the right-hand side of the
assignment:

    /* sum = 0; */
    gcc_jit_block_add_assignment (
      b_initial, NULL,
      sum,
      gcc_jit_context_zero (ctxt, the_type));

    /* i = 0; */
    gcc_jit_block_add_assignment (
      b_initial, NULL,
      i,
      gcc_jit_context_zero (ctxt, the_type));

We can then terminate the entry block by jumping to the conditional:

    gcc_jit_block_end_with_jump (b_initial, NULL, b_loop_cond);

The conditional block is equivalent to the line `while (i < n)' from our
C example. It contains a single statement: a conditional, which jumps to
one of two destination blocks depending on a boolean *Note
gcc_jit_rvalue *: 13, in this case the comparison of `i' and `n'.  We
build the comparison using *Note gcc_jit_context_new_comparison(): 2c.:

    /* (i >= n) */
     gcc_jit_rvalue *guard =
       gcc_jit_context_new_comparison (
         ctxt, NULL,
         GCC_JIT_COMPARISON_GE,
         gcc_jit_lvalue_as_rvalue (i),
         gcc_jit_param_as_rvalue (n));

and can then use this to add `b_loop_cond'’s sole statement, via
*Note gcc_jit_block_end_with_conditional(): 2d.:

    /* Equivalent to:
         if (guard)
           goto after_loop;
         else
           goto loop_body;  */
    gcc_jit_block_end_with_conditional (
      b_loop_cond, NULL,
      guard,
      b_after_loop, /* on_true */
      b_loop_body); /* on_false */

Next, we populate the body of the loop.

The C statement `sum += i * i;' is an assignment operation, where an
lvalue is modified “in-place”.  We use *Note
gcc_jit_block_add_assignment_op(): 2e. to handle these operations:

    /* sum += i * i */
    gcc_jit_block_add_assignment_op (
      b_loop_body, NULL,
      sum,
      GCC_JIT_BINARY_OP_PLUS,
      gcc_jit_context_new_binary_op (
        ctxt, NULL,
        GCC_JIT_BINARY_OP_MULT, the_type,
        gcc_jit_lvalue_as_rvalue (i),
        gcc_jit_lvalue_as_rvalue (i)));

The `i++' can be thought of as `i += 1', and can thus be handled in a
similar way.  We use *Note gcc_jit_context_one(): 2f. to get the
constant value `1' (for the relevant type) for the right-hand side of
the assignment.

    /* i++ */
    gcc_jit_block_add_assignment_op (
      b_loop_body, NULL,
      i,
      GCC_JIT_BINARY_OP_PLUS,
      gcc_jit_context_one (ctxt, the_type));

     Note: For numeric constants other than 0 or 1, we could use *Note
     gcc_jit_context_new_rvalue_from_int(): 30. and *Note
     gcc_jit_context_new_rvalue_from_double(): 31.

The loop body completes by jumping back to the conditional:

    gcc_jit_block_end_with_jump (b_loop_body, NULL, b_loop_cond);

Finally, we populate the `b_after_loop' block, reached when the loop
conditional is false.  We want to generate the equivalent of:

    return sum;

so the block is just one statement:

    /* return sum */
    gcc_jit_block_end_with_return (
      b_after_loop,
      NULL,
      gcc_jit_lvalue_as_rvalue (sum));

     Note: You can intermingle block creation with statement creation,
     but given that the terminator statements generally include
     references to other blocks, I find it’s clearer to create all
     the blocks, `then' all the statements.

We’ve finished populating the function.  As before, we can now
compile it to machine code:

    gcc_jit_result *result;
    result = gcc_jit_context_compile (ctxt);

    typedef int (*loop_test_fn_type) (int);
    loop_test_fn_type loop_test =
     (loop_test_fn_type)gcc_jit_result_get_code (result, "loop_test");
    if (!loop_test)
      goto error;
    printf ("result: %d", loop_test (10));

    result: 285


File: libgccjit.info,  Node: Visualizing the control flow graph,  Next: Full example<2>,  Prev: Control flow,  Up: Tutorial part 3 Loops and variables

1.3.3 Visualizing the control flow graph
----------------------------------------

You can see the control flow graph of a function using *Note
gcc_jit_function_dump_to_dot(): 33.:

    gcc_jit_function_dump_to_dot (func, "/tmp/sum-of-squares.dot");

giving a .dot file in GraphViz format.

You can convert this to an image using `dot':

    $ dot -Tpng /tmp/sum-of-squares.dot -o /tmp/sum-of-squares.png

or use a viewer (my preferred one is xdot.py; see
<https://github.com/jrfonseca/xdot.py>; on Fedora you can install it
with `yum install python-xdot'):

       Figure



File: libgccjit.info,  Node: Full example<2>,  Prev: Visualizing the control flow graph,  Up: Tutorial part 3 Loops and variables

1.3.4 Full example
------------------

         /* Usage example for libgccjit.so
            Copyright (C) 2014-2024 Free Software Foundation, Inc.

         This file is part of GCC.

         GCC is free software; you can redistribute it and/or modify it
         under the terms of the GNU General Public License as published by
         the Free Software Foundation; either version 3, or (at your option)
         any later version.

         GCC is distributed in the hope that it will be useful, but
         WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
         General Public License for more details.

         You should have received a copy of the GNU General Public License
         along with GCC; see the file COPYING3.  If not see
         <http://www.gnu.org/licenses/>.  */

         #include <libgccjit.h>

         #include <stdlib.h>
         #include <stdio.h>

         void
         create_code (gcc_jit_context *ctxt)
         {
           /*
             Simple sum-of-squares, to test conditionals and looping

             int loop_test (int n)
             {
               int i;
               int sum = 0;
               for (i = 0; i < n ; i ++)
               {
         	sum += i * i;
               }
               return sum;
            */
           gcc_jit_type *the_type =
             gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
           gcc_jit_type *return_type = the_type;

           gcc_jit_param *n =
             gcc_jit_context_new_param (ctxt, NULL, the_type, "n");
           gcc_jit_param *params[1] = {n};
           gcc_jit_function *func =
             gcc_jit_context_new_function (ctxt, NULL,
         				  GCC_JIT_FUNCTION_EXPORTED,
         				  return_type,
         				  "loop_test",
         				  1, params, 0);

           /* Build locals:  */
           gcc_jit_lvalue *i =
             gcc_jit_function_new_local (func, NULL, the_type, "i");
           gcc_jit_lvalue *sum =
             gcc_jit_function_new_local (func, NULL, the_type, "sum");

           gcc_jit_block *b_initial =
             gcc_jit_function_new_block (func, "initial");
           gcc_jit_block *b_loop_cond =
             gcc_jit_function_new_block (func, "loop_cond");
           gcc_jit_block *b_loop_body =
             gcc_jit_function_new_block (func, "loop_body");
           gcc_jit_block *b_after_loop =
             gcc_jit_function_new_block (func, "after_loop");

           /* sum = 0; */
           gcc_jit_block_add_assignment (
             b_initial, NULL,
             sum,
             gcc_jit_context_zero (ctxt, the_type));

           /* i = 0; */
           gcc_jit_block_add_assignment (
             b_initial, NULL,
             i,
             gcc_jit_context_zero (ctxt, the_type));

           gcc_jit_block_end_with_jump (b_initial, NULL, b_loop_cond);

           /* if (i >= n) */
           gcc_jit_block_end_with_conditional (
             b_loop_cond, NULL,
             gcc_jit_context_new_comparison (
                ctxt, NULL,
                GCC_JIT_COMPARISON_GE,
                gcc_jit_lvalue_as_rvalue (i),
                gcc_jit_param_as_rvalue (n)),
             b_after_loop,
             b_loop_body);

           /* sum += i * i */
           gcc_jit_block_add_assignment_op (
             b_loop_body, NULL,
             sum,
             GCC_JIT_BINARY_OP_PLUS,
             gcc_jit_context_new_binary_op (
               ctxt, NULL,
               GCC_JIT_BINARY_OP_MULT, the_type,
               gcc_jit_lvalue_as_rvalue (i),
               gcc_jit_lvalue_as_rvalue (i)));

           /* i++ */
           gcc_jit_block_add_assignment_op (
             b_loop_body, NULL,
             i,
             GCC_JIT_BINARY_OP_PLUS,
             gcc_jit_context_one (ctxt, the_type));

           gcc_jit_block_end_with_jump (b_loop_body, NULL, b_loop_cond);

           /* return sum */
           gcc_jit_block_end_with_return (
             b_after_loop,
             NULL,
             gcc_jit_lvalue_as_rvalue (sum));
         }

         int
         main (int argc, char **argv)
         {
           gcc_jit_context *ctxt = NULL;
           gcc_jit_result *result = NULL;

           /* Get a "context" object for working with the library.  */
           ctxt = gcc_jit_context_acquire ();
           if (!ctxt)
             {
               fprintf (stderr, "NULL ctxt");
               goto error;
             }

           /* Set some options on the context.
              Let's see the code being generated, in assembler form.  */
           gcc_jit_context_set_bool_option (
             ctxt,
             GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
             0);

           /* Populate the context.  */
           create_code (ctxt);

           /* Compile the code.  */
           result = gcc_jit_context_compile (ctxt);
           if (!result)
             {
               fprintf (stderr, "NULL result");
               goto error;
             }

           /* Extract the generated code from "result".  */
           typedef int (*loop_test_fn_type) (int);
           loop_test_fn_type loop_test =
             (loop_test_fn_type)gcc_jit_result_get_code (result, "loop_test");
           if (!loop_test)
             {
               fprintf (stderr, "NULL loop_test");
               goto error;
             }

           /* Run the generated code.  */
           int val = loop_test (10);
           printf("loop_test returned: %d\n", val);

          error:
           gcc_jit_context_release (ctxt);
           gcc_jit_result_release (result);
           return 0;
         }

Building and running it:

    $ gcc \
        tut03-sum-of-squares.c \
        -o tut03-sum-of-squares \
        -lgccjit

    # Run the built program:
    $ ./tut03-sum-of-squares
    loop_test returned: 285


File: libgccjit.info,  Node: Tutorial part 4 Adding JIT-compilation to a toy interpreter,  Next: Tutorial part 5 Implementing an Ahead-of-Time compiler,  Prev: Tutorial part 3 Loops and variables,  Up: Tutorial

1.4 Tutorial part 4: Adding JIT-compilation to a toy interpreter
================================================================

In this example we construct a “toy” interpreter, and add
JIT-compilation to it.

* Menu:

* Our toy interpreter::
* Compiling to machine code::
* Setting things up::
* Populating the function::
* Verifying the control flow graph::
* Compiling the context::
* Single-stepping through the generated code::
* Examining the generated code::
* Putting it all together::
* Behind the curtain; How does our code get optimized?: Behind the curtain How does our code get optimized?.


File: libgccjit.info,  Node: Our toy interpreter,  Next: Compiling to machine code,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter

1.4.1 Our toy interpreter
-------------------------

It’s a stack-based interpreter, and is intended as a (very simple)
example of the kind of bytecode interpreter seen in dynamic languages
such as Python, Ruby etc.

For the sake of simplicity, our toy virtual machine is very limited:

        * The only data type is `int'

        * It can only work on one function at a time (so that the only
          function call that can be made is to recurse).

        * Functions can only take one parameter.

        * Functions have a stack of `int' values.

        * We’ll implement function call within the interpreter by
          calling a function in our implementation, rather than
          implementing our own frame stack.

        * The parser is only good enough to get the examples to work.

Naturally, a real interpreter would be much more complicated that this.

The following operations are supported:

Operation                  Meaning                      Old Stack           New Stack
------------------------------------------------------------------------------------------------- 
DUP                        Duplicate top of stack.      `[..., x]'          `[..., x, x]'
ROT                        Swap top two elements of     `[..., x, y]'       `[..., y, x]'
                           stack.                                           
BINARY_ADD                 Add the top two elements on  `[..., x, y]'       `[..., (x+y)]'
                           the stack.                                       
BINARY_SUBTRACT            Likewise, but subtract.      `[..., x, y]'       `[..., (x-y)]'
BINARY_MULT                Likewise, but multiply.      `[..., x, y]'       `[..., (x*y)]'
BINARY_COMPARE_LT          Compare the top two          `[..., x, y]'       `[..., (x<y)]'
                           elements on the stack and                        
                           push a nonzero/zero if                           
                           (x<y).                                           
RECURSE                    Recurse, passing the top of  `[..., x]'          `[..., fn(x)]'
                           the stack, and popping the                       
                           result.                                          
RETURN                     Return the top of the stack. `[x]'               `[]'
PUSH_CONST `arg'           Push an int const.           `[...]'             `[..., arg]'
JUMP_ABS_IF_TRUE `arg'     Pop; if top of stack was     `[..., x]'          `[...]'
                           nonzero, jump to `arg'.                          

Programs can be interpreted, disassembled, and compiled to machine code.

The interpreter reads `.toy' scripts.  Here’s what a simple recursive
factorial program looks like, the script `factorial.toy'.  The parser
ignores lines beginning with a `#'.

         # Simple recursive factorial implementation, roughly equivalent to:
         #
         #  int factorial (int arg)
         #  {
         #     if (arg < 2)
         #       return arg
         #     return arg * factorial (arg - 1)
         #  }

         # Initial state:
         # stack: [arg]

         # 0:
         DUP
         # stack: [arg, arg]

         # 1:
         PUSH_CONST 2
         # stack: [arg, arg, 2]

         # 2:
         BINARY_COMPARE_LT
         # stack: [arg, (arg < 2)]

         # 3:
         JUMP_ABS_IF_TRUE 9
         # stack: [arg]

         # 4:
         DUP
         # stack: [arg, arg]

         # 5:
         PUSH_CONST 1
         # stack: [arg, arg, 1]

         # 6:
         BINARY_SUBTRACT
         # stack: [arg,  (arg - 1)

         # 7:
         RECURSE
         # stack: [arg, factorial(arg - 1)]

         # 8:
         BINARY_MULT
         # stack: [arg * factorial(arg - 1)]

         # 9:
         RETURN

The interpreter is a simple infinite loop with a big `switch' statement
based on what the next opcode is:


         static int
         toyvm_function_interpret (toyvm_function *fn, int arg, FILE *trace)
         {
           toyvm_frame frame;
         #define PUSH(ARG) (toyvm_frame_push (&frame, (ARG)))
         #define POP(ARG) (toyvm_frame_pop (&frame))

           frame.frm_function = fn;
           frame.frm_pc = 0;
           frame.frm_cur_depth = 0;

           PUSH (arg);

           while (1)
             {
               toyvm_op *op;
               int x, y;
               assert (frame.frm_pc < fn->fn_num_ops);
               op = &fn->fn_ops[frame.frm_pc++];

               if (trace)
         	{
         	  toyvm_frame_dump_stack (&frame, trace);
         	  toyvm_function_disassemble_op (fn, op, frame.frm_pc, trace);
         	}

               switch (op->op_opcode)
         	{
         	  /* Ops taking no operand.  */
         	case DUP:
         	  x = POP ();
         	  PUSH (x);
         	  PUSH (x);
         	  break;

         	case ROT:
         	  y = POP ();
         	  x = POP ();
         	  PUSH (y);
         	  PUSH (x);
         	  break;

         	case BINARY_ADD:
         	  y = POP ();
         	  x = POP ();
         	  PUSH (x + y);
         	  break;

         	case BINARY_SUBTRACT:
         	  y = POP ();
         	  x = POP ();
         	  PUSH (x - y);
         	  break;

         	case BINARY_MULT:
         	  y = POP ();
         	  x = POP ();
         	  PUSH (x * y);
         	  break;

         	case BINARY_COMPARE_LT:
         	  y = POP ();
         	  x = POP ();
         	  PUSH (x < y);
         	  break;

         	case RECURSE:
         	  x = POP ();
         	  x = toyvm_function_interpret (fn, x, trace);
         	  PUSH (x);
         	  break;

         	case RETURN:
         	  return POP ();

         	  /* Ops taking an operand.  */
         	case PUSH_CONST:
         	  PUSH (op->op_operand);
         	  break;

         	case JUMP_ABS_IF_TRUE:
         	  x = POP ();
         	  if (x)
         	    frame.frm_pc = op->op_operand;
         	  break;

         	default:
         	  assert (0); /* unknown opcode */

         	} /* end of switch on opcode */
             } /* end of while loop */

         #undef PUSH
         #undef POP
         }


File: libgccjit.info,  Node: Compiling to machine code,  Next: Setting things up,  Prev: Our toy interpreter,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter

1.4.2 Compiling to machine code
-------------------------------

We want to generate machine code that can be cast to this type and then
directly executed in-process:

         typedef int (*toyvm_compiled_code) (int);

The lifetime of the code is tied to that of a *Note gcc_jit_result *:
16.  We’ll handle this by bundling them up in a structure, so that we
can clean them up together by calling *Note gcc_jit_result_release():
39.:


         struct toyvm_compiled_function
         {
           gcc_jit_result *cf_jit_result;
           toyvm_compiled_code cf_code;
         };

Our compiler isn’t very sophisticated; it takes the implementation of
each opcode above, and maps it directly to the operations supported by
the libgccjit API.

How should we handle the stack?  In theory we could calculate what the
stack depth will be at each opcode, and optimize away the stack
manipulation “by hand”.  We’ll see below that libgccjit is able
to do this for us, so we’ll implement stack manipulation in a direct
way, by creating a `stack' array and `stack_depth' variables, local
within the generated function, equivalent to this C code:

    int stack_depth;
    int stack[MAX_STACK_DEPTH];

We’ll also have local variables `x' and `y' for use when implementing
the opcodes, equivalent to this:

    int x;
    int y;

This means our compiler has the following state:


         struct compilation_state
         {
           gcc_jit_context *ctxt;

           gcc_jit_type *int_type;
           gcc_jit_type *bool_type;
           gcc_jit_type *stack_type; /* int[MAX_STACK_DEPTH] */

           gcc_jit_rvalue *const_one;

           gcc_jit_function *fn;
           gcc_jit_param *param_arg;
           gcc_jit_lvalue *stack;
           gcc_jit_lvalue *stack_depth;
           gcc_jit_lvalue *x;
           gcc_jit_lvalue *y;

           gcc_jit_location *op_locs[MAX_OPS];
           gcc_jit_block *initial_block;
           gcc_jit_block *op_blocks[MAX_OPS];

         };


File: libgccjit.info,  Node: Setting things up,  Next: Populating the function,  Prev: Compiling to machine code,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter

1.4.3 Setting things up
-----------------------

First we create our types:

           state.int_type =
             gcc_jit_context_get_type (state.ctxt, GCC_JIT_TYPE_INT);
           state.bool_type =
             gcc_jit_context_get_type (state.ctxt, GCC_JIT_TYPE_BOOL);
           state.stack_type =
             gcc_jit_context_new_array_type (state.ctxt, NULL,
         				    state.int_type, MAX_STACK_DEPTH);

along with extracting a useful `int' constant:

           state.const_one = gcc_jit_context_one (state.ctxt, state.int_type);

We’ll implement push and pop in terms of the `stack' array and
`stack_depth'.  Here are helper functions for adding statements to a
block, implementing pushing and popping values:


         static void
         add_push (compilation_state *state,
         	  gcc_jit_block *block,
         	  gcc_jit_rvalue *rvalue,
         	  gcc_jit_location *loc)
         {
           /* stack[stack_depth] = RVALUE */
           gcc_jit_block_add_assignment (
             block,
             loc,
             /* stack[stack_depth] */
             gcc_jit_context_new_array_access (
               state->ctxt,
               loc,
               gcc_jit_lvalue_as_rvalue (state->stack),
               gcc_jit_lvalue_as_rvalue (state->stack_depth)),
             rvalue);

           /* "stack_depth++;".  */
           gcc_jit_block_add_assignment_op (
             block,
             loc,
             state->stack_depth,
             GCC_JIT_BINARY_OP_PLUS,
             state->const_one);
         }

         static void
         add_pop (compilation_state *state,
         	 gcc_jit_block *block,
         	 gcc_jit_lvalue *lvalue,
         	 gcc_jit_location *loc)
         {
           /* "--stack_depth;".  */
           gcc_jit_block_add_assignment_op (
             block,
             loc,
             state->stack_depth,
             GCC_JIT_BINARY_OP_MINUS,
             state->const_one);

           /* "LVALUE = stack[stack_depth];".  */
           gcc_jit_block_add_assignment (
             block,
             loc,
             lvalue,
             /* stack[stack_depth] */
             gcc_jit_lvalue_as_rvalue (
               gcc_jit_context_new_array_access (
         	state->ctxt,
         	loc,
         	gcc_jit_lvalue_as_rvalue (state->stack),
         	gcc_jit_lvalue_as_rvalue (state->stack_depth))));
         }

We will support single-stepping through the generated code in the
debugger, so we need to create *Note gcc_jit_location: 3b. instances,
one per operation in the source code.  These will reference the lines of
e.g. `factorial.toy'.

           for (pc = 0; pc < fn->fn_num_ops; pc++)
             {
               toyvm_op *op = &fn->fn_ops[pc];

               state.op_locs[pc] = gcc_jit_context_new_location (state.ctxt,
         							fn->fn_filename,
         							op->op_linenum,
         							0); /* column */
             }

Let’s create the function itself.  As usual, we create its parameter
first, then use the parameter to create the function:

           state.param_arg =
             gcc_jit_context_new_param (state.ctxt, state.op_locs[0],
         			       state.int_type, "arg");
           state.fn =
             gcc_jit_context_new_function (state.ctxt,
         				  state.op_locs[0],
         				  GCC_JIT_FUNCTION_EXPORTED,
         				  state.int_type,
         				  funcname,
         				  1, &state.param_arg, 0);

We create the locals within the function.

           state.stack =
             gcc_jit_function_new_local (state.fn, NULL,
         				state.stack_type, "stack");
           state.stack_depth =
             gcc_jit_function_new_local (state.fn, NULL,
         				state.int_type, "stack_depth");
           state.x =
             gcc_jit_function_new_local (state.fn, NULL,
         				state.int_type, "x");
           state.y =
             gcc_jit_function_new_local (state.fn, NULL,
         				state.int_type, "y");


File: libgccjit.info,  Node: Populating the function,  Next: Verifying the control flow graph,  Prev: Setting things up,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter

1.4.4 Populating the function
-----------------------------

There’s some one-time initialization, and the API treats the first
block you create as the entrypoint of the function, so we need to
create that block first:

           state.initial_block = gcc_jit_function_new_block (state.fn, "initial");

We can now create blocks for each of the operations.  Most of these will
be consolidated into larger blocks when the optimizer runs.

           for (pc = 0; pc < fn->fn_num_ops; pc++)
             {
               char buf[100];
               sprintf (buf, "instr%i", pc);
               state.op_blocks[pc] = gcc_jit_function_new_block (state.fn, buf);
             }

Now that we have a block it can jump to when it’s done, we can
populate the initial block:


           /* "stack_depth = 0;".  */
           gcc_jit_block_add_assignment (
             state.initial_block,
             state.op_locs[0],
             state.stack_depth,
             gcc_jit_context_zero (state.ctxt, state.int_type));

           /* "PUSH (arg);".  */
           add_push (&state,
         	    state.initial_block,
         	    gcc_jit_param_as_rvalue (state.param_arg),
         	    state.op_locs[0]);

           /* ...and jump to insn 0.  */
           gcc_jit_block_end_with_jump (state.initial_block,
         			       state.op_locs[0],
         			       state.op_blocks[0]);

We can now populate the blocks for the individual operations.  We loop
through them, adding instructions to their blocks:

           for (pc = 0; pc < fn->fn_num_ops; pc++)
             {
               gcc_jit_location *loc = state.op_locs[pc];

               gcc_jit_block *block = state.op_blocks[pc];
               gcc_jit_block *next_block = (pc < fn->fn_num_ops
         				   ? state.op_blocks[pc + 1]
         				   : NULL);

               toyvm_op *op;
               op = &fn->fn_ops[pc];

We’re going to have another big `switch' statement for implementing
the opcodes, this time for compiling them, rather than interpreting
them.  It’s helpful to have macros for implementing push and pop, so
that we can make the `switch' statement that’s coming up look as much
as possible like the one above within the interpreter:


    #define X_EQUALS_POP()\
          add_pop (&state, block, state.x, loc)
    #define Y_EQUALS_POP()\
          add_pop (&state, block, state.y, loc)
    #define PUSH_RVALUE(RVALUE)\
          add_push (&state, block, (RVALUE), loc)
    #define PUSH_X()\
          PUSH_RVALUE (gcc_jit_lvalue_as_rvalue (state.x))
    #define PUSH_Y() \
          PUSH_RVALUE (gcc_jit_lvalue_as_rvalue (state.y))

     Note: A particularly clever implementation would have an
     `identical' `switch' statement shared by the interpreter and the
     compiler, with some preprocessor “magic”.  We’re not doing
     that here, for the sake of simplicity.

When I first implemented this compiler, I accidentally missed an edit
when copying and pasting the `Y_EQUALS_POP' macro, so that popping the
stack into `y' instead erroneously assigned it to `x', leaving `y'
uninitialized.

To track this kind of thing down, we can use *Note
gcc_jit_block_add_comment(): 3d. to add descriptive comments to the
internal representation.  This is invaluable when looking through the
generated IR for, say `factorial':


               gcc_jit_block_add_comment (block, loc, opcode_names[op->op_opcode]);

We can now write the big `switch' statement that implements the
individual opcodes, populating the relevant block with statements:


               switch (op->op_opcode)
         	{
         	case DUP:
         	  X_EQUALS_POP ();
         	  PUSH_X ();
         	  PUSH_X ();
         	  break;

         	case ROT:
         	  Y_EQUALS_POP ();
         	  X_EQUALS_POP ();
         	  PUSH_Y ();
         	  PUSH_X ();
         	  break;

         	case BINARY_ADD:
         	  Y_EQUALS_POP ();
         	  X_EQUALS_POP ();
         	  PUSH_RVALUE (
         	   gcc_jit_context_new_binary_op (
         	     state.ctxt,
         	     loc,
         	     GCC_JIT_BINARY_OP_PLUS,
         	     state.int_type,
         	     gcc_jit_lvalue_as_rvalue (state.x),
         	     gcc_jit_lvalue_as_rvalue (state.y)));
         	  break;

         	case BINARY_SUBTRACT:
         	  Y_EQUALS_POP ();
         	  X_EQUALS_POP ();
         	  PUSH_RVALUE (
         	   gcc_jit_context_new_binary_op (
         	     state.ctxt,
         	     loc,
         	     GCC_JIT_BINARY_OP_MINUS,
         	     state.int_type,
         	     gcc_jit_lvalue_as_rvalue (state.x),
         	     gcc_jit_lvalue_as_rvalue (state.y)));
         	  break;

         	case BINARY_MULT:
         	  Y_EQUALS_POP ();
         	  X_EQUALS_POP ();
         	  PUSH_RVALUE (
         	   gcc_jit_context_new_binary_op (
         	     state.ctxt,
         	     loc,
         	     GCC_JIT_BINARY_OP_MULT,
         	     state.int_type,
         	     gcc_jit_lvalue_as_rvalue (state.x),
         	     gcc_jit_lvalue_as_rvalue (state.y)));
         	  break;

         	case BINARY_COMPARE_LT:
         	  Y_EQUALS_POP ();
         	  X_EQUALS_POP ();
         	  PUSH_RVALUE (
         	     /* cast of bool to int */
         	     gcc_jit_context_new_cast (
         	       state.ctxt,
         	       loc,
         	       /* (x < y) as a bool */
         	       gcc_jit_context_new_comparison (
         		 state.ctxt,
         		 loc,
         		 GCC_JIT_COMPARISON_LT,
         		 gcc_jit_lvalue_as_rvalue (state.x),
         		 gcc_jit_lvalue_as_rvalue (state.y)),
         	       state.int_type));
         	  break;

         	case RECURSE:
         	  {
         	    X_EQUALS_POP ();
         	    gcc_jit_rvalue *arg = gcc_jit_lvalue_as_rvalue (state.x);
         	    PUSH_RVALUE (
         	      gcc_jit_context_new_call (
         		state.ctxt,
         		loc,
         		state.fn,
         		1, &arg));
         	    break;
         	  }

         	case RETURN:
         	  X_EQUALS_POP ();
         	  gcc_jit_block_end_with_return (
         	    block,
         	    loc,
         	    gcc_jit_lvalue_as_rvalue (state.x));
         	  break;

         	  /* Ops taking an operand.  */
         	case PUSH_CONST:
         	  PUSH_RVALUE (
         	    gcc_jit_context_new_rvalue_from_int (
         	      state.ctxt,
         	      state.int_type,
         	      op->op_operand));
         	  break;

         	case JUMP_ABS_IF_TRUE:
         	  X_EQUALS_POP ();
         	  gcc_jit_block_end_with_conditional (
         	    block,
         	    loc,
         	    /* "(bool)x".  */
         	    gcc_jit_context_new_cast (
         	      state.ctxt,
         	      loc,
         	      gcc_jit_lvalue_as_rvalue (state.x),
         	      state.bool_type),
         	    state.op_blocks[op->op_operand], /* on_true */
         	    next_block); /* on_false */
         	  break;

         	default:
         	  assert(0);
         	} /* end of switch on opcode */

Every block must be terminated, via a call to one of the
`gcc_jit_block_end_with_' entrypoints.  This has been done for two of
the opcodes, but we need to do it for the other ones, by jumping to the
next block.

               if (op->op_opcode != JUMP_ABS_IF_TRUE
         	  && op->op_opcode != RETURN)
         	gcc_jit_block_end_with_jump (
         	  block,
         	  loc,
         	  next_block);

This is analogous to simply incrementing the program counter.


File: libgccjit.info,  Node: Verifying the control flow graph,  Next: Compiling the context,  Prev: Populating the function,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter

1.4.5 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 *Note gcc_jit_function_dump_to_dot(): 33.:

    gcc_jit_function_dump_to_dot (state.fn, "/tmp/factorial.dot");

and viewing the result.  Note how the label names, comments, and
variable names show up in the dump, to make it easier to spot errors in
our compiler.

       Figure



File: libgccjit.info,  Node: Compiling the context,  Next: Single-stepping through the generated code,  Prev: Verifying the control flow graph,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter

1.4.6 Compiling the context
---------------------------

Having finished looping over the blocks and populating them with
statements, the context is complete.

We can now compile it, and extract machine code from the result:


We can now run the result:

           toyvm_compiled_function *compiled_fn
             = toyvm_function_compile (fn);

           toyvm_compiled_code code = compiled_fn->cf_code;
           printf ("compiler result: %d\n",
         	  code (atoi (argv[2])));

           gcc_jit_result_release (compiled_fn->cf_jit_result);
           free (compiled_fn);


File: libgccjit.info,  Node: Single-stepping through the generated code,  Next: Examining the generated code,  Prev: Compiling the context,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter

1.4.7 Single-stepping through the generated code
------------------------------------------------

It’s possible to debug the generated code.  To do this we need to
both:

        * Set up source code locations for our statements, so that we
          can meaningfully step through the code.  We did this above by
          calling *Note gcc_jit_context_new_location(): 41. and using
          the results.

        * Enable the generation of debugging information, by setting
          *Note GCC_JIT_BOOL_OPTION_DEBUGINFO: 42. on the *Note
          gcc_jit_context: 8. via *Note
          gcc_jit_context_set_bool_option(): 1b.:

              gcc_jit_context_set_bool_option (
                ctxt,
                GCC_JIT_BOOL_OPTION_DEBUGINFO,
                1);

Having done this, we can put a breakpoint on the generated function:

    $ gdb --args ./toyvm factorial.toy 10
    (gdb) break factorial
    Function "factorial" not defined.
    Make breakpoint pending on future shared library load? (y or [n]) y
    Breakpoint 1 (factorial) pending.
    (gdb) run
    Breakpoint 1, factorial (arg=10) at factorial.toy:14
    14    DUP

We’ve set up location information, which references `factorial.toy'.
This allows us to use e.g. `list' to see where we are in the script:

    (gdb) list
    9
    10    # Initial state:
    11    # stack: [arg]
    12
    13    # 0:
    14    DUP
    15    # stack: [arg, arg]
    16
    17    # 1:
    18    PUSH_CONST 2

and to step through the function, examining the data:

    (gdb) n
    18    PUSH_CONST 2
    (gdb) n
    22    BINARY_COMPARE_LT
    (gdb) print stack
    $5 = {10, 10, 2, 0, -7152, 32767, 0, 0}
    (gdb) print stack_depth
    $6 = 3

You’ll see that the parts of the `stack' array that haven’t been
touched yet are uninitialized.

     Note: Turning on optimizations may lead to unpredictable results
     when stepping through the generated code: the execution may appear
     to “jump around” the source code.  This is analogous to
     turning up the optimization level in a regular compiler.


File: libgccjit.info,  Node: Examining the generated code,  Next: Putting it all together,  Prev: Single-stepping through the generated code,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter

1.4.8 Examining the generated code
----------------------------------

How good is the optimized code?

We can turn up optimizations, by calling *Note
gcc_jit_context_set_int_option(): 1e. with *Note
GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL: 1f.:

    gcc_jit_context_set_int_option (
      ctxt,
      GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL,
      3);

One of GCC’s internal representations is called “gimple”.  A dump
of the initial gimple representation of the code can be seen by setting:

    gcc_jit_context_set_bool_option (ctxt,
                                     GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE,
                                     1);

With optimization on and source locations displayed, this gives:

    factorial (signed int arg)
    {
      <unnamed type> D.80;
      signed int D.81;
      signed int D.82;
      signed int D.83;
      signed int D.84;
      signed int D.85;
      signed int y;
      signed int x;
      signed int stack_depth;
      signed int stack[8];

      try
        {
          initial:
          stack_depth = 0;
          stack[stack_depth] = arg;
          stack_depth = stack_depth + 1;
          goto instr0;
          instr0:
          /* DUP */:
          stack_depth = stack_depth + -1;
          x = stack[stack_depth];
          stack[stack_depth] = x;
          stack_depth = stack_depth + 1;
          stack[stack_depth] = x;
          stack_depth = stack_depth + 1;
          goto instr1;
          instr1:
          /* PUSH_CONST */:
          stack[stack_depth] = 2;
          stack_depth = stack_depth + 1;
          goto instr2;

          /* etc */

You can see the generated machine code in assembly form via:

    gcc_jit_context_set_bool_option (
      ctxt,
      GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
      1);
    result = gcc_jit_context_compile (ctxt);

which shows that (on this x86_64 box) the compiler has unrolled the loop
and is using MMX instructions to perform several multiplications
simultaneously:

            .file   "fake.c"
            .text
    .Ltext0:
            .p2align 4,,15
            .globl  factorial
            .type   factorial, @function
    factorial:
    .LFB0:
            .file 1 "factorial.toy"
            .loc 1 14 0
            .cfi_startproc
    .LVL0:
    .L2:
            .loc 1 26 0
            cmpl    $1, %edi
            jle     .L13
            leal    -1(%rdi), %edx
            movl    %edx, %ecx
            shrl    $2, %ecx
            leal    0(,%rcx,4), %esi
            testl   %esi, %esi
            je      .L14
            cmpl    $9, %edx
            jbe     .L14
            leal    -2(%rdi), %eax
            movl    %eax, -16(%rsp)
            leal    -3(%rdi), %eax
            movd    -16(%rsp), %xmm0
            movl    %edi, -16(%rsp)
            movl    %eax, -12(%rsp)
            movd    -16(%rsp), %xmm1
            xorl    %eax, %eax
            movl    %edx, -16(%rsp)
            movd    -12(%rsp), %xmm4
            movd    -16(%rsp), %xmm6
            punpckldq       %xmm4, %xmm0
            movdqa  .LC1(%rip), %xmm4
            punpckldq       %xmm6, %xmm1
            punpcklqdq      %xmm0, %xmm1
            movdqa  .LC0(%rip), %xmm0
            jmp     .L5
            # etc - edited for brevity

This is clearly overkill for a function that will likely overflow the
`int' type before the vectorization is worthwhile - but then again, this
is a toy example.

Turning down the optimization level to 2:

    gcc_jit_context_set_int_option (
      ctxt,
      GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL,
      3);

yields this code, which is simple enough to quote in its entirety:

            .file   "fake.c"
            .text
            .p2align 4,,15
            .globl  factorial
            .type   factorial, @function
    factorial:
    .LFB0:
            .cfi_startproc
    .L2:
            cmpl    $1, %edi
            jle     .L8
            movl    $1, %edx
            jmp     .L4
            .p2align 4,,10
            .p2align 3
    .L6:
            movl    %eax, %edi
    .L4:
    .L5:
            leal    -1(%rdi), %eax
            imull   %edi, %edx
            cmpl    $1, %eax
            jne     .L6
    .L3:
    .L7:
            imull   %edx, %eax
            ret
    .L8:
            movl    %edi, %eax
            movl    $1, %edx
            jmp     .L7
            .cfi_endproc
    .LFE0:
            .size   factorial, .-factorial
            .ident  "GCC: (GNU) 4.9.0 20131023 (Red Hat 0.2-%{gcc_release})"
            .section        .note.GNU-stack,"",@progbits

Note that the stack pushing and popping have been eliminated, as has the
recursive call (in favor of an iteration).


File: libgccjit.info,  Node: Putting it all together,  Next: Behind the curtain How does our code get optimized?,  Prev: Examining the generated code,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter

1.4.9 Putting it all together
-----------------------------

The complete example can be seen in the source tree at
`gcc/jit/docs/examples/tut04-toyvm/toyvm.c'

along with a Makefile and a couple of sample .toy scripts:

    $ ls -al
    drwxrwxr-x. 2 david david   4096 Sep 19 17:46 .
    drwxrwxr-x. 3 david david   4096 Sep 19 15:26 ..
    -rw-rw-r--. 1 david david    615 Sep 19 12:43 factorial.toy
    -rw-rw-r--. 1 david david    834 Sep 19 13:08 fibonacci.toy
    -rw-rw-r--. 1 david david    238 Sep 19 14:22 Makefile
    -rw-rw-r--. 1 david david  16457 Sep 19 17:07 toyvm.c

    $ make toyvm
    g++ -Wall -g -o toyvm toyvm.c -lgccjit

    $ ./toyvm factorial.toy 10
    interpreter result: 3628800
    compiler result: 3628800

    $ ./toyvm fibonacci.toy 10
    interpreter result: 55
    compiler result: 55


File: libgccjit.info,  Node: Behind the curtain How does our code get optimized?,  Prev: Putting it all together,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter

1.4.10 Behind the curtain: How does our code get optimized?
-----------------------------------------------------------

Our example is done, but you may be wondering about exactly how the
compiler turned what we gave it into the machine code seen above.

We can examine what the compiler is doing in detail by setting:

    gcc_jit_context_set_bool_option (state.ctxt,
                                     GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING,
                                     1);
    gcc_jit_context_set_bool_option (state.ctxt,
                                     GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES,
                                     1);

This will dump detailed information about the compiler’s state to a
directory under `/tmp', and keep it from being cleaned up.

The precise names and their formats of these files is subject to change.
Higher optimization levels lead to more files.  Here’s what I saw
(edited for brevity; there were almost 200 files):

    intermediate files written to /tmp/libgccjit-KPQbGw
    $ ls /tmp/libgccjit-KPQbGw/
    fake.c.000i.cgraph
    fake.c.000i.type-inheritance
    fake.c.004t.gimple
    fake.c.007t.omplower
    fake.c.008t.lower
    fake.c.011t.eh
    fake.c.012t.cfg
    fake.c.014i.visibility
    fake.c.015i.early_local_cleanups
    fake.c.016t.ssa
    # etc

The gimple code is converted into Static Single Assignment form, with
annotations for use when generating the debuginfo:

    $ less /tmp/libgccjit-KPQbGw/fake.c.016t.ssa

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    factorial (signed int arg)
    {
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int _44;
      signed int _51;
      signed int _56;

    initial:
      stack_depth_3 = 0;
      # DEBUG stack_depth => stack_depth_3
      stack[stack_depth_3] = arg_5(D);
      stack_depth_7 = stack_depth_3 + 1;
      # DEBUG stack_depth => stack_depth_7
      # DEBUG instr0 => NULL
      # DEBUG /* DUP */ => NULL
      stack_depth_8 = stack_depth_7 + -1;
      # DEBUG stack_depth => stack_depth_8
      x_9 = stack[stack_depth_8];
      # DEBUG x => x_9
      stack[stack_depth_8] = x_9;
      stack_depth_11 = stack_depth_8 + 1;
      # DEBUG stack_depth => stack_depth_11
      stack[stack_depth_11] = x_9;
      stack_depth_13 = stack_depth_11 + 1;
      # DEBUG stack_depth => stack_depth_13
      # DEBUG instr1 => NULL
      # DEBUG /* PUSH_CONST */ => NULL
      stack[stack_depth_13] = 2;

      /* etc; edited for brevity */

We can perhaps better see the code by turning off *Note
GCC_JIT_BOOL_OPTION_DEBUGINFO: 42. to suppress all those `DEBUG'
statements, giving:

    $ less /tmp/libgccjit-1Hywc0/fake.c.016t.ssa

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    factorial (signed int arg)
    {
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int _44;
      signed int _51;
      signed int _56;

    initial:
      stack_depth_3 = 0;
      stack[stack_depth_3] = arg_5(D);
      stack_depth_7 = stack_depth_3 + 1;
      stack_depth_8 = stack_depth_7 + -1;
      x_9 = stack[stack_depth_8];
      stack[stack_depth_8] = x_9;
      stack_depth_11 = stack_depth_8 + 1;
      stack[stack_depth_11] = x_9;
      stack_depth_13 = stack_depth_11 + 1;
      stack[stack_depth_13] = 2;
      stack_depth_15 = stack_depth_13 + 1;
      stack_depth_16 = stack_depth_15 + -1;
      y_17 = stack[stack_depth_16];
      stack_depth_18 = stack_depth_16 + -1;
      x_19 = stack[stack_depth_18];
      _20 = x_19 < y_17;
      _21 = (signed int) _20;
      stack[stack_depth_18] = _21;
      stack_depth_23 = stack_depth_18 + 1;
      stack_depth_24 = stack_depth_23 + -1;
      x_25 = stack[stack_depth_24];
      if (x_25 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      stack_depth_26 = stack_depth_24 + -1;
      x_27 = stack[stack_depth_26];
      stack[stack_depth_26] = x_27;
      stack_depth_29 = stack_depth_26 + 1;
      stack[stack_depth_29] = x_27;
      stack_depth_31 = stack_depth_29 + 1;
      stack[stack_depth_31] = 1;
      stack_depth_33 = stack_depth_31 + 1;
      stack_depth_34 = stack_depth_33 + -1;
      y_35 = stack[stack_depth_34];
      stack_depth_36 = stack_depth_34 + -1;
      x_37 = stack[stack_depth_36];
      _38 = x_37 - y_35;
      stack[stack_depth_36] = _38;
      stack_depth_40 = stack_depth_36 + 1;
      stack_depth_41 = stack_depth_40 + -1;
      x_42 = stack[stack_depth_41];
      _44 = factorial (x_42);
      stack[stack_depth_41] = _44;
      stack_depth_46 = stack_depth_41 + 1;
      stack_depth_47 = stack_depth_46 + -1;
      y_48 = stack[stack_depth_47];
      stack_depth_49 = stack_depth_47 + -1;
      x_50 = stack[stack_depth_49];
      _51 = x_50 * y_48;
      stack[stack_depth_49] = _51;
      stack_depth_53 = stack_depth_49 + 1;

      # stack_depth_1 = PHI <stack_depth_24(2), stack_depth_53(3)>
    instr9:
    /* RETURN */:
      stack_depth_54 = stack_depth_1 + -1;
      x_55 = stack[stack_depth_54];
      _56 = x_55;
      stack ={v} {CLOBBER};
      return _56;

    }

Note in the above how all the *Note gcc_jit_block: 28. instances we
created have been consolidated into just 3 blocks in GCC’s internal
representation: `initial', `instr4' and `instr9'.

* Menu:

* Optimizing away stack manipulation::
* Elimination of tail recursion::


File: libgccjit.info,  Node: Optimizing away stack manipulation,  Next: Elimination of tail recursion,  Up: Behind the curtain How does our code get optimized?

1.4.10.1 Optimizing away stack manipulation
...........................................

Recall our simple implementation of stack operations.  Let’s examine
how the stack operations are optimized away.

After a pass of constant-propagation, the depth of the stack at each
opcode can be determined at compile-time:

    $ less /tmp/libgccjit-1Hywc0/fake.c.021t.ccp1

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    factorial (signed int arg)
    {
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int _44;
      signed int _51;

    initial:
      stack[0] = arg_5(D);
      x_9 = stack[0];
      stack[0] = x_9;
      stack[1] = x_9;
      stack[2] = 2;
      y_17 = stack[2];
      x_19 = stack[1];
      _20 = x_19 < y_17;
      _21 = (signed int) _20;
      stack[1] = _21;
      x_25 = stack[1];
      if (x_25 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      x_27 = stack[0];
      stack[0] = x_27;
      stack[1] = x_27;
      stack[2] = 1;
      y_35 = stack[2];
      x_37 = stack[1];
      _38 = x_37 - y_35;
      stack[1] = _38;
      x_42 = stack[1];
      _44 = factorial (x_42);
      stack[1] = _44;
      y_48 = stack[1];
      x_50 = stack[0];
      _51 = x_50 * y_48;
      stack[0] = _51;

    instr9:
    /* RETURN */:
      x_55 = stack[0];
      x_56 = x_55;
      stack ={v} {CLOBBER};
      return x_56;

    }

Note how, in the above, all those `stack_depth' values are now just
constants: we’re accessing specific stack locations at each opcode.

The “esra” pass (“Early Scalar Replacement of Aggregates”)
breaks out our “stack” array into individual elements:

    $ less /tmp/libgccjit-1Hywc0/fake.c.024t.esra

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    Created a replacement for stack offset: 0, size: 32: stack$0
    Created a replacement for stack offset: 32, size: 32: stack$1
    Created a replacement for stack offset: 64, size: 32: stack$2

    Symbols to be put in SSA form
    { D.89 D.90 D.91 }
    Incremental SSA update started at block: 0
    Number of blocks in CFG: 5
    Number of blocks to update: 4 ( 80%)


    factorial (signed int arg)
    {
      signed int stack$2;
      signed int stack$1;
      signed int stack$0;
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int _44;
      signed int _51;

    initial:
      stack$0_45 = arg_5(D);
      x_9 = stack$0_45;
      stack$0_39 = x_9;
      stack$1_32 = x_9;
      stack$2_30 = 2;
      y_17 = stack$2_30;
      x_19 = stack$1_32;
      _20 = x_19 < y_17;
      _21 = (signed int) _20;
      stack$1_28 = _21;
      x_25 = stack$1_28;
      if (x_25 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      x_27 = stack$0_39;
      stack$0_22 = x_27;
      stack$1_14 = x_27;
      stack$2_12 = 1;
      y_35 = stack$2_12;
      x_37 = stack$1_14;
      _38 = x_37 - y_35;
      stack$1_10 = _38;
      x_42 = stack$1_10;
      _44 = factorial (x_42);
      stack$1_6 = _44;
      y_48 = stack$1_6;
      x_50 = stack$0_22;
      _51 = x_50 * y_48;
      stack$0_1 = _51;

      # stack$0_52 = PHI <stack$0_39(2), stack$0_1(3)>
    instr9:
    /* RETURN */:
      x_55 = stack$0_52;
      x_56 = x_55;
      stack ={v} {CLOBBER};
      return x_56;

    }

Hence at this point, all those pushes and pops of the stack are now
simply assignments to specific temporary variables.

After some copy propagation, the stack manipulation has been completely
optimized away:

    $ less /tmp/libgccjit-1Hywc0/fake.c.026t.copyprop1

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    factorial (signed int arg)
    {
      signed int stack$2;
      signed int stack$1;
      signed int stack$0;
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int _44;
      signed int _51;

    initial:
      stack$0_39 = arg_5(D);
      _20 = arg_5(D) <= 1;
      _21 = (signed int) _20;
      if (_21 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      _38 = arg_5(D) + -1;
      _44 = factorial (_38);
      _51 = arg_5(D) * _44;
      stack$0_1 = _51;

      # stack$0_52 = PHI <arg_5(D)(2), _51(3)>
    instr9:
    /* RETURN */:
      stack ={v} {CLOBBER};
      return stack$0_52;

    }

Later on, another pass finally eliminated `stack_depth' local and the
unused parts of the `stack`' array altogether:

    $ less /tmp/libgccjit-1Hywc0/fake.c.036t.release_ssa

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    Released 44 names, 314.29%, removed 44 holes
    factorial (signed int arg)
    {
      signed int stack$0;
      signed int mult_acc_1;
      <unnamed type> _5;
      signed int _6;
      signed int _7;
      signed int mul_tmp_10;
      signed int mult_acc_11;
      signed int mult_acc_13;

      # arg_9 = PHI <arg_8(D)(0)>
      # mult_acc_13 = PHI <1(0)>
    initial:

      <bb 5>:
      # arg_4 = PHI <arg_9(2), _7(3)>
      # mult_acc_1 = PHI <mult_acc_13(2), mult_acc_11(3)>
      _5 = arg_4 <= 1;
      _6 = (signed int) _5;
      if (_6 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      _7 = arg_4 + -1;
      mult_acc_11 = mult_acc_1 * arg_4;
      goto <bb 5>;

      # stack$0_12 = PHI <arg_4(5)>
    instr9:
    /* RETURN */:
      mul_tmp_10 = mult_acc_1 * stack$0_12;
      return mul_tmp_10;

    }


File: libgccjit.info,  Node: Elimination of tail recursion,  Prev: Optimizing away stack manipulation,  Up: Behind the curtain How does our code get optimized?

1.4.10.2 Elimination of tail recursion
......................................

Another significant optimization is the detection that the call to
`factorial' is tail recursion, which can be eliminated in favor of an
iteration:

    $ less /tmp/libgccjit-1Hywc0/fake.c.030t.tailr1

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)


    Symbols to be put in SSA form
    { D.88 }
    Incremental SSA update started at block: 0
    Number of blocks in CFG: 5
    Number of blocks to update: 4 ( 80%)


    factorial (signed int arg)
    {
      signed int stack$2;
      signed int stack$1;
      signed int stack$0;
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      signed int mult_acc_1;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int mul_tmp_44;
      signed int mult_acc_51;

      # arg_5 = PHI <arg_39(D)(0), _38(3)>
      # mult_acc_1 = PHI <1(0), mult_acc_51(3)>
    initial:
      _20 = arg_5 <= 1;
      _21 = (signed int) _20;
      if (_21 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      _38 = arg_5 + -1;
      mult_acc_51 = mult_acc_1 * arg_5;
      goto <bb 2> (initial);

      # stack$0_52 = PHI <arg_5(2)>
    instr9:
    /* RETURN */:
      stack ={v} {CLOBBER};
      mul_tmp_44 = mult_acc_1 * stack$0_52;
      return mul_tmp_44;

    }


File: libgccjit.info,  Node: Tutorial part 5 Implementing an Ahead-of-Time compiler,  Prev: Tutorial part 4 Adding JIT-compilation to a toy interpreter,  Up: Tutorial

1.5 Tutorial part 5: Implementing an Ahead-of-Time compiler
===========================================================

If you have a pre-existing language frontend that’s compatible with
libgccjit’s license, it’s possible to hook it up to libgccjit as a
backend.  In the previous example we showed how to do that for
in-memory JIT-compilation, but libgccjit can also compile code directly
to a file, allowing you to implement a more traditional ahead-of-time
compiler (“JIT” is something of a misnomer for this use-case).

The essential difference is to compile the context using *Note
gcc_jit_context_compile_to_file(): 4a. rather than *Note
gcc_jit_context_compile(): 15.

* Menu:

* The “brainf” language::
* Converting a brainf script to libgccjit IR::
* Compiling a context to a file::
* Other forms of ahead-of-time-compilation::


File: libgccjit.info,  Node: The “brainf” language,  Next: Converting a brainf script to libgccjit IR,  Up: Tutorial part 5 Implementing an Ahead-of-Time compiler

1.5.1 The “brainf” language
-------------------------------

In this example we use libgccjit to construct an ahead-of-time compiler
for an esoteric programming language that we shall refer to as
“brainf”.

brainf scripts operate on an array of bytes, with a notional data
pointer within the array.

brainf is hard for humans to read, but it’s trivial to write a parser
for it, as there is no lexing; just a stream of bytes.  The operations
are:

Character                  Meaning
------------------------------------------------------------- 
`>'                        `idx += 1'
`<'                        `idx -= 1'
`+'                        `data[idx] += 1'
`-'                        `data[idx] -= 1'
`.'                        `output (data[idx])'
`,'                        `data[idx] = input ()'
`['                        loop until `data[idx] == 0'
`]'                        end of loop
Anything else              ignored

Unlike the previous example, we’ll implement an ahead-of-time
compiler, which reads `.bf' scripts and outputs executables (though it
would be trivial to have it run them JIT-compiled in-process).

Here’s what a simple `.bf' script looks like:

         [
           Emit the uppercase alphabet
         ]

         cell 0 = 26
         ++++++++++++++++++++++++++

         cell 1 = 65
         >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<

         while cell#0 != 0
         [
          >
          .      emit cell#1
          +      increment cell@1
          <-     decrement cell@0
         ]

     Note: This example makes use of whitespace and comments for
     legibility, but could have been written as:

         ++++++++++++++++++++++++++
         >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<
         [>.+<-]

     It’s not a particularly useful language, except for providing
     compiler-writers with a test case that’s easy to parse.  The
     point is that you can use *Note gcc_jit_context_compile_to_file():
     4a.  to use libgccjit as a backend for a pre-existing language
     frontend (provided that the pre-existing frontend is compatible
     with libgccjit’s license).


File: libgccjit.info,  Node: Converting a brainf script to libgccjit IR,  Next: Compiling a context to a file,  Prev: The “brainf” language,  Up: Tutorial part 5 Implementing an Ahead-of-Time compiler

1.5.2 Converting a brainf script to libgccjit IR
------------------------------------------------

As before we write simple code to populate a *Note gcc_jit_context *: 8.


         typedef struct bf_compiler
         {
           const char *filename;
           int line;
           int column;

           gcc_jit_context *ctxt;

           gcc_jit_type *void_type;
           gcc_jit_type *int_type;
           gcc_jit_type *byte_type;
           gcc_jit_type *array_type;

           gcc_jit_function *func_getchar;
           gcc_jit_function *func_putchar;

           gcc_jit_function *func;
           gcc_jit_block *curblock;

           gcc_jit_rvalue *int_zero;
           gcc_jit_rvalue *int_one;
           gcc_jit_rvalue *byte_zero;
           gcc_jit_rvalue *byte_one;
           gcc_jit_lvalue *data_cells;
           gcc_jit_lvalue *idx;

           int num_open_parens;
           gcc_jit_block *paren_test[MAX_OPEN_PARENS];
           gcc_jit_block *paren_body[MAX_OPEN_PARENS];
           gcc_jit_block *paren_after[MAX_OPEN_PARENS];

         } bf_compiler;

         /* Bail out, with a message on stderr.  */

         static void
         fatal_error (bf_compiler *bfc, const char *msg)
         {
           fprintf (stderr,
         	   "%s:%i:%i: %s",
         	   bfc->filename, bfc->line, bfc->column, msg);
           abort ();
         }

         /* Get "data_cells[idx]" as an lvalue.  */

         static gcc_jit_lvalue *
         bf_get_current_data (bf_compiler *bfc, gcc_jit_location *loc)
         {
           return gcc_jit_context_new_array_access (
             bfc->ctxt,
             loc,
             gcc_jit_lvalue_as_rvalue (bfc->data_cells),
             gcc_jit_lvalue_as_rvalue (bfc->idx));
         }

         /* Get "data_cells[idx] == 0" as a boolean rvalue.  */

         static gcc_jit_rvalue *
         bf_current_data_is_zero (bf_compiler *bfc, gcc_jit_location *loc)
         {
           return gcc_jit_context_new_comparison (
             bfc->ctxt,
             loc,
             GCC_JIT_COMPARISON_EQ,
             gcc_jit_lvalue_as_rvalue (bf_get_current_data (bfc, loc)),
             bfc->byte_zero);
         }

         /* Compile one bf character.  */

         static void
         bf_compile_char (bf_compiler *bfc,
         		 unsigned char ch)
         {
           gcc_jit_location *loc =
             gcc_jit_context_new_location (bfc->ctxt,
         				  bfc->filename,
         				  bfc->line,
         				  bfc->column);

           /* Turn this on to trace execution, by injecting putchar ()
              of each source char. */
           if (0)
             {
               gcc_jit_rvalue *arg =
         	gcc_jit_context_new_rvalue_from_int (
         					     bfc->ctxt,
         					     bfc->int_type,
         					     ch);
               gcc_jit_rvalue *call =
         	gcc_jit_context_new_call (bfc->ctxt,
         				  loc,
         				  bfc->func_putchar,
         				  1, &arg);
               gcc_jit_block_add_eval (bfc->curblock,
         			      loc,
         			      call);
             }

           switch (ch)
             {
               case '>':
         	gcc_jit_block_add_comment (bfc->curblock,
         				   loc,
         				   "'>': idx += 1;");
         	gcc_jit_block_add_assignment_op (bfc->curblock,
         					 loc,
         					 bfc->idx,
         					 GCC_JIT_BINARY_OP_PLUS,
         					 bfc->int_one);
         	break;

               case '<':
         	gcc_jit_block_add_comment (bfc->curblock,
         				   loc,
         				   "'<': idx -= 1;");
         	gcc_jit_block_add_assignment_op (bfc->curblock,
         					 loc,
         					 bfc->idx,
         					 GCC_JIT_BINARY_OP_MINUS,
         					 bfc->int_one);
         	break;

               case '+':
         	gcc_jit_block_add_comment (bfc->curblock,
         				   loc,
         				   "'+': data[idx] += 1;");
         	gcc_jit_block_add_assignment_op (bfc->curblock,
         					 loc,
         					 bf_get_current_data (bfc, loc),
         					 GCC_JIT_BINARY_OP_PLUS,
         					 bfc->byte_one);
         	break;

               case '-':
         	gcc_jit_block_add_comment (bfc->curblock,
         				   loc,
         				   "'-': data[idx] -= 1;");
         	gcc_jit_block_add_assignment_op (bfc->curblock,
         					 loc,
         					 bf_get_current_data (bfc, loc),
         					 GCC_JIT_BINARY_OP_MINUS,
         					 bfc->byte_one);
         	break;

               case '.':
         	{
         	  gcc_jit_rvalue *arg =
         	    gcc_jit_context_new_cast (
         	      bfc->ctxt,
         	      loc,
         	      gcc_jit_lvalue_as_rvalue (bf_get_current_data (bfc, loc)),
         	      bfc->int_type);
         	  gcc_jit_rvalue *call =
         	    gcc_jit_context_new_call (bfc->ctxt,
         				      loc,
         				      bfc->func_putchar,
         				      1, &arg);
         	  gcc_jit_block_add_comment (bfc->curblock,
         				     loc,
         				     "'.': putchar ((int)data[idx]);");
         	  gcc_jit_block_add_eval (bfc->curblock,
         				  loc,
         				  call);
         	}
         	break;

               case ',':
         	{
         	  gcc_jit_rvalue *call =
         	    gcc_jit_context_new_call (bfc->ctxt,
         				      loc,
         				      bfc->func_getchar,
         				      0, NULL);
         	  gcc_jit_block_add_comment (
         	    bfc->curblock,
         	    loc,
         	    "',': data[idx] = (unsigned char)getchar ();");
         	  gcc_jit_block_add_assignment (bfc->curblock,
         					loc,
         					bf_get_current_data (bfc, loc),
         					gcc_jit_context_new_cast (
         					  bfc->ctxt,
         					  loc,
         					  call,
         					  bfc->byte_type));
         	}
         	break;

               case '[':
         	{
         	  gcc_jit_block *loop_test =
         	    gcc_jit_function_new_block (bfc->func, NULL);
         	  gcc_jit_block *on_zero =
         	    gcc_jit_function_new_block (bfc->func, NULL);
         	  gcc_jit_block *on_non_zero =
         	    gcc_jit_function_new_block (bfc->func, NULL);

         	  if (bfc->num_open_parens == MAX_OPEN_PARENS)
         	    fatal_error (bfc, "too many open parens");

         	  gcc_jit_block_end_with_jump (
         	    bfc->curblock,
         	    loc,
         	    loop_test);

         	  gcc_jit_block_add_comment (
         	    loop_test,
         	    loc,
         	    "'['");
         	  gcc_jit_block_end_with_conditional (
         	    loop_test,
         	    loc,
         	    bf_current_data_is_zero (bfc, loc),
         	    on_zero,
         	    on_non_zero);
         	  bfc->paren_test[bfc->num_open_parens] = loop_test;
         	  bfc->paren_body[bfc->num_open_parens] = on_non_zero;
         	  bfc->paren_after[bfc->num_open_parens] = on_zero;
         	  bfc->num_open_parens += 1;
         	  bfc->curblock = on_non_zero;
         	}
         	break;

               case ']':
         	{
         	  gcc_jit_block_add_comment (
         	    bfc->curblock,
         	    loc,
         	    "']'");

         	  if (bfc->num_open_parens == 0)
         	    fatal_error (bfc, "mismatching parens");
         	  bfc->num_open_parens -= 1;
         	  gcc_jit_block_end_with_jump (
         	    bfc->curblock,
         	    loc,
         	    bfc->paren_test[bfc->num_open_parens]);
         	  bfc->curblock = bfc->paren_after[bfc->num_open_parens];
         	}
         	break;

             case '\n':
               bfc->line +=1;
               bfc->column = 0;
               break;
             }

           if (ch != '\n')
             bfc->column += 1;
         }

         /* Compile the given .bf file into a gcc_jit_context, containing a
            single "main" function suitable for compiling into an executable.  */

         gcc_jit_context *
         bf_compile (const char *filename)
         {
           bf_compiler bfc;
           FILE *f_in;
           int ch;

           memset (&bfc, 0, sizeof (bfc));

           bfc.filename = filename;
           f_in = fopen (filename, "r");
           if (!f_in)
             fatal_error (&bfc, "unable to open file");
           bfc.line = 1;

           bfc.ctxt = gcc_jit_context_acquire ();

           gcc_jit_context_set_int_option (
             bfc.ctxt,
             GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL,
             3);
           gcc_jit_context_set_bool_option (
             bfc.ctxt,
             GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE,
             0);
           gcc_jit_context_set_bool_option (
             bfc.ctxt,
             GCC_JIT_BOOL_OPTION_DEBUGINFO,
             1);
           gcc_jit_context_set_bool_option (
             bfc.ctxt,
             GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING,
             0);
           gcc_jit_context_set_bool_option (
             bfc.ctxt,
             GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES,
             0);

           bfc.void_type =
             gcc_jit_context_get_type (bfc.ctxt, GCC_JIT_TYPE_VOID);
           bfc.int_type =
             gcc_jit_context_get_type (bfc.ctxt, GCC_JIT_TYPE_INT);
           bfc.byte_type =
             gcc_jit_context_get_type (bfc.ctxt, GCC_JIT_TYPE_UNSIGNED_CHAR);
           bfc.array_type =
             gcc_jit_context_new_array_type (bfc.ctxt,
         				    NULL,
         				    bfc.byte_type,
         				    30000);

           bfc.func_getchar =
             gcc_jit_context_new_function (bfc.ctxt, NULL,
         				  GCC_JIT_FUNCTION_IMPORTED,
         				  bfc.int_type,
         				  "getchar",
         				  0, NULL,
         				  0);

           gcc_jit_param *param_c =
             gcc_jit_context_new_param (bfc.ctxt, NULL, bfc.int_type, "c");
           bfc.func_putchar =
             gcc_jit_context_new_function (bfc.ctxt, NULL,
         				  GCC_JIT_FUNCTION_IMPORTED,
         				  bfc.void_type,
         				  "putchar",
         				  1, &param_c,
         				  0);

           bfc.func = make_main (bfc.ctxt);
            bfc.curblock =
             gcc_jit_function_new_block (bfc.func, "initial");
           bfc.int_zero = gcc_jit_context_zero (bfc.ctxt, bfc.int_type);
           bfc.int_one = gcc_jit_context_one (bfc.ctxt, bfc.int_type);
           bfc.byte_zero = gcc_jit_context_zero (bfc.ctxt, bfc.byte_type);
           bfc.byte_one = gcc_jit_context_one (bfc.ctxt, bfc.byte_type);

           bfc.data_cells =
             gcc_jit_context_new_global (bfc.ctxt, NULL,
         				 GCC_JIT_GLOBAL_INTERNAL,
         				 bfc.array_type,
         				 "data_cells");
           bfc.idx =
             gcc_jit_function_new_local (bfc.func, NULL,
         				bfc.int_type,
         				"idx");

           gcc_jit_block_add_comment (bfc.curblock,
         			     NULL,
         			     "idx = 0;");
           gcc_jit_block_add_assignment (bfc.curblock,
         				NULL,
         				bfc.idx,
         				bfc.int_zero);

           bfc.num_open_parens = 0;

           while ( EOF != (ch = fgetc (f_in)))
             bf_compile_char (&bfc, (unsigned char)ch);

           gcc_jit_block_end_with_return (bfc.curblock, NULL, bfc.int_zero);

           fclose (f_in);

           return bfc.ctxt;
         }


File: libgccjit.info,  Node: Compiling a context to a file,  Next: Other forms of ahead-of-time-compilation,  Prev: Converting a brainf script to libgccjit IR,  Up: Tutorial part 5 Implementing an Ahead-of-Time compiler

1.5.3 Compiling a context to a file
-----------------------------------

Unlike the previous tutorial, this time we’ll compile the context
directly to an executable, using *Note
gcc_jit_context_compile_to_file(): 4a.:

    gcc_jit_context_compile_to_file (ctxt,
                                     GCC_JIT_OUTPUT_KIND_EXECUTABLE,
                                     output_file);

Here’s the top-level of the compiler, which is what actually calls
into *Note gcc_jit_context_compile_to_file(): 4a.:


         int
         main (int argc, char **argv)
         {
           const char *input_file;
           const char *output_file;
           gcc_jit_context *ctxt;
           const char *err;

           if (argc != 3)
             {
               fprintf (stderr, "%s: INPUT_FILE OUTPUT_FILE\n", argv[0]);
               return 1;
             }

           input_file = argv[1];
           output_file = argv[2];
           ctxt = bf_compile (input_file);

           gcc_jit_context_compile_to_file (ctxt,
         				   GCC_JIT_OUTPUT_KIND_EXECUTABLE,
         				   output_file);

           err = gcc_jit_context_get_first_error (ctxt);

           if (err)
             {
               gcc_jit_context_release (ctxt);
               return 1;
             }

           gcc_jit_context_release (ctxt);
           return 0;
         }

Note how once the context is populated you could trivially instead
compile it to memory using *Note gcc_jit_context_compile(): 15. and run
it in-process as in the previous tutorial.

To create an executable, we need to export a `main' function.  Here’s
how to create one from the JIT API:


         /* Make "main" function:
              int
              main (int argc, char **argv)
              {
                ...
              }
         */
         static gcc_jit_function *
         make_main (gcc_jit_context *ctxt)
         {
           gcc_jit_type *int_type =
             gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
           gcc_jit_param *param_argc =
             gcc_jit_context_new_param (ctxt, NULL, int_type, "argc");
           gcc_jit_type *char_ptr_ptr_type =
             gcc_jit_type_get_pointer (
               gcc_jit_type_get_pointer (
         	gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_CHAR)));
           gcc_jit_param *param_argv =
             gcc_jit_context_new_param (ctxt, NULL, char_ptr_ptr_type, "argv");
           gcc_jit_param *params[2] = {param_argc, param_argv};
           gcc_jit_function *func_main =
             gcc_jit_context_new_function (ctxt, NULL,
         				  GCC_JIT_FUNCTION_EXPORTED,
         				  int_type,
         				  "main",
         				  2, params,
         				  0);
           return func_main;
         }

     Note: The above implementation ignores `argc' and `argv', but you
     could make use of them by exposing `param_argc' and `param_argv'
     to the caller.

Upon compiling this C code, we obtain a bf-to-machine-code compiler;
let’s call it `bfc':

    $ gcc \
        tut05-bf.c \
        -o bfc \
        -lgccjit

We can now use `bfc' to compile .bf files into machine code executables:

    $ ./bfc \
         emit-alphabet.bf \
         a.out

which we can run directly:

    $ ./a.out
    ABCDEFGHIJKLMNOPQRSTUVWXYZ

Success!

We can also inspect the generated executable using standard tools:

    $ objdump -d a.out |less

which shows that libgccjit has managed to optimize the function
somewhat (for example, the runs of 26 and 65 increment operations have
become integer constants 0x1a and 0x41):

    0000000000400620 <main>:
      400620:     80 3d 39 0a 20 00 00    cmpb   $0x0,0x200a39(%rip)        # 601060 <data
      400627:     74 07                   je     400630 <main
      400629:     eb fe                   jmp    400629 <main+0x9>
      40062b:     0f 1f 44 00 00          nopl   0x0(%rax,%rax,1)
      400630:     48 83 ec 08             sub    $0x8,%rsp
      400634:     0f b6 05 26 0a 20 00    movzbl 0x200a26(%rip),%eax        # 601061 <data_cells+0x1>
      40063b:     c6 05 1e 0a 20 00 1a    movb   $0x1a,0x200a1e(%rip)       # 601060 <data_cells>
      400642:     8d 78 41                lea    0x41(%rax),%edi
      400645:     40 88 3d 15 0a 20 00    mov    %dil,0x200a15(%rip)        # 601061 <data_cells+0x1>
      40064c:     0f 1f 40 00             nopl   0x0(%rax)
      400650:     40 0f b6 ff             movzbl %dil,%edi
      400654:     e8 87 fe ff ff          callq  4004e0 <putchar@plt>
      400659:     0f b6 05 01 0a 20 00    movzbl 0x200a01(%rip),%eax        # 601061 <data_cells+0x1>
      400660:     80 2d f9 09 20 00 01    subb   $0x1,0x2009f9(%rip)        # 601060 <data_cells>
      400667:     8d 78 01                lea    0x1(%rax),%edi
      40066a:     40 88 3d f0 09 20 00    mov    %dil,0x2009f0(%rip)        # 601061 <data_cells+0x1>
      400671:     75 dd                   jne    400650 <main+0x30>
      400673:     31 c0                   xor    %eax,%eax
      400675:     48 83 c4 08             add    $0x8,%rsp
      400679:     c3                      retq
      40067a:     66 0f 1f 44 00 00       nopw   0x0(%rax,%rax,1)

We also set up debugging information (via *Note
gcc_jit_context_new_location(): 41. and *Note
GCC_JIT_BOOL_OPTION_DEBUGINFO: 42.), so it’s possible to use `gdb' to
singlestep through the generated binary and inspect the internal state
`idx' and `data_cells':

    (gdb) break main
    Breakpoint 1 at 0x400790
    (gdb) run
    Starting program: a.out

    Breakpoint 1, 0x0000000000400790 in main (argc=1, argv=0x7fffffffe448)
    (gdb) stepi
    0x0000000000400797 in main (argc=1, argv=0x7fffffffe448)
    (gdb) stepi
    0x00000000004007a0 in main (argc=1, argv=0x7fffffffe448)
    (gdb) stepi
    9     >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<
    (gdb) list
    4
    5     cell 0 = 26
    6     ++++++++++++++++++++++++++
    7
    8     cell 1 = 65
    9     >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<
    10
    11    while cell#0 != 0
    12    [
    13     >
    (gdb) n
    6     ++++++++++++++++++++++++++
    (gdb) n
    9     >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<
    (gdb) p idx
    $1 = 1
    (gdb) p data_cells
    $2 = "\032", '\000' <repeats 29998 times>
    (gdb) p data_cells[0]
    $3 = 26 '\032'
    (gdb) p data_cells[1]
    $4 = 0 '\000'
    (gdb) list
    4
    5     cell 0 = 26
    6     ++++++++++++++++++++++++++
    7
    8     cell 1 = 65
    9     >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<
    10
    11    while cell#0 != 0
    12    [
    13     >


File: libgccjit.info,  Node: Other forms of ahead-of-time-compilation,  Prev: Compiling a context to a file,  Up: Tutorial part 5 Implementing an Ahead-of-Time compiler

1.5.4 Other forms of ahead-of-time-compilation
----------------------------------------------

The above demonstrates compiling a *Note gcc_jit_context *: 8. directly
to an executable.  It’s also possible to compile it to an object file,
and to a dynamic library.  See the documentation of *Note
gcc_jit_context_compile_to_file(): 4a. for more information.


File: libgccjit.info,  Node: Topic Reference,  Next: C++ bindings for libgccjit,  Prev: Tutorial,  Up: Top

2 Topic Reference
*****************

* Menu:

* Compilation contexts::
* Objects::
* Types::
* Expressions::
* Creating and using functions::
* Function pointers: Function pointers<2>.
* Source Locations::
* Compiling a context::
* ABI and API compatibility::
* Performance::
* Using Assembly Language with libgccjit::


File: libgccjit.info,  Node: Compilation contexts,  Next: Objects,  Up: Topic Reference

2.1 Compilation contexts
========================

 -- C Type: gcc_jit_context

The top-level of the API is the *Note gcc_jit_context: 8. type.

A *Note gcc_jit_context: 8. instance encapsulates the state of a
compilation.

You can set up options on it, and add types, functions and code.
Invoking *Note gcc_jit_context_compile(): 15. on it gives you a *Note
gcc_jit_result: 16.

* Menu:

* Lifetime-management::
* Thread-safety::
* Error-handling: Error-handling<2>.
* Debugging::
* Options: Options<2>.


File: libgccjit.info,  Node: Lifetime-management,  Next: Thread-safety,  Up: Compilation contexts

2.1.1 Lifetime-management
-------------------------

Contexts are the unit of lifetime-management within the API: objects
have their lifetime bounded by the context they are created within, and
cleanup of such objects is done for you when the context is released.

 -- C Function: gcc_jit_context *gcc_jit_context_acquire (void)
     This function acquires a new *Note gcc_jit_context *: 8. instance,
     which is independent of any others that may be present within this
     process.

 -- C Function: void gcc_jit_context_release (gcc_jit_context *ctxt)
     This function releases all resources associated with the given
     context.  Both the context itself and all of its *Note
     gcc_jit_object *: e.  instances are cleaned up.  It should be
     called exactly once on a given context.

     It is invalid to use the context or any of its “contextual”
     objects after calling this.

         gcc_jit_context_release (ctxt);

 -- C Function: gcc_jit_context * gcc_jit_context_new_child_context
          (gcc_jit_context *parent_ctxt)
     Given an existing JIT context, create a child context.

     The child inherits a copy of all option-settings from the parent.

     The child can reference objects created within the parent, but not
     vice-versa.

     The lifetime of the child context must be bounded by that of the
     parent: you should release a child context before releasing the
     parent context.

     If you use a function from a parent context within a child context,
     you have to compile the parent context before you can compile the
     child context, and the gcc_jit_result of the parent context must
     outlive the gcc_jit_result of the child context.

     This allows caching of shared initializations.  For example, you
     could create types and declarations of global functions in a
     parent context once within a process, and then create child
     contexts whenever a function or loop becomes hot. Each such child
     context can be used for JIT-compiling just one function or loop,
     but can reference types and helper functions created within the
     parent context.

     Contexts can be arbitrarily nested, provided the above rules are
     followed, but it’s probably not worth going above 2 or 3 levels,
     and there will likely be a performance hit for such nesting.


File: libgccjit.info,  Node: Thread-safety,  Next: Error-handling<2>,  Prev: Lifetime-management,  Up: Compilation contexts

2.1.2 Thread-safety
-------------------

Instances of *Note gcc_jit_context *: 8. created via *Note
gcc_jit_context_acquire(): 9. 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 *Note gcc_jit_context_new_child_context(): 54. 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, and if you’re using multiple threads you should provide your
own locking around entire such context partitions.


File: libgccjit.info,  Node: Error-handling<2>,  Next: Debugging,  Prev: Thread-safety,  Up: Compilation contexts

2.1.3 Error-handling
--------------------

Various kinds of errors are possible when using the API, such as
mismatched types in an assignment.  You can only compile and get code
from a context if no errors occur.

Errors are printed on stderr and can be queried using *Note
gcc_jit_context_get_first_error(): 57.

They typically contain the name of the API entrypoint where the error
occurred, and pertinent information on the problem:

    ./buggy-program: error: gcc_jit_block_add_assignment: mismatching types: assignment to i (type: int) from "hello world" (type: const char *)

In general, if an error occurs when using an API entrypoint, the
entrypoint returns NULL.  You don’t have to check everywhere for NULL
results, since the API handles a NULL being passed in for any argument
by issuing another error.  This typically leads to a cascade of
followup error messages, but is safe (albeit verbose).  The first error
message is usually the one to pay attention to, since it is likely to
be responsible for all of the rest:

 -- C Function: const char * gcc_jit_context_get_first_error
          (gcc_jit_context *ctxt)
     Returns the first error message that occurred on the context.

     The returned string is valid for the rest of the lifetime of the
     context.

     If no errors occurred, this will be NULL.

If you are wrapping the C API for a higher-level language that supports
exception-handling, you may instead be interested in the last error that
occurred on the context, so that you can embed this in an exception:

 -- C Function: const char * gcc_jit_context_get_last_error
          (gcc_jit_context *ctxt)
     Returns the last error message that occurred on the context.

     If no errors occurred, this will be NULL.

     If non-NULL, the returned string is only guaranteed to be valid
     until the next call to libgccjit relating to this context.


File: libgccjit.info,  Node: Debugging,  Next: Options<2>,  Prev: Error-handling<2>,  Up: Compilation contexts

2.1.4 Debugging
---------------

 -- C Function: void gcc_jit_context_dump_to_file
          (gcc_jit_context *ctxt, const char *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 *Note
     gcc_jit_location: 3b.  information throughout the context,
     pointing at the dump file as if it were a source file.  This may
     be of use in conjunction with *Note GCC_JIT_BOOL_OPTION_DEBUGINFO:
     42. to allow stepping through the code in a debugger.

 -- C Function: void gcc_jit_context_set_logfile
          (gcc_jit_context *ctxt, FILE *logfile, int flags,
          int verbosity)
     To help with debugging; enable ongoing logging of the context’s
     activity to the given file.

     For example, the following will enable logging to stderr.

         gcc_jit_context_set_logfile (ctxt, stderr, 0, 0);

     Examples of information logged include:

        * API calls

        * the various steps involved within compilation

        * activity on any *Note gcc_jit_result: 16. instances created by
          the context

        * activity within any child contexts

     An example of a log can be seen *Note here: 5c, though the precise
     format and kinds of information logged is subject to change.

     The caller remains responsible for closing `logfile', and it must
     not be closed until all users are released.  In particular, note
     that child contexts and *Note gcc_jit_result: 16. instances
     created by the context will use the logfile.

     There may a performance cost for logging.

     You can turn off logging on `ctxt' by passing `NULL' for `logfile'.
     Doing so only affects the context; it does not affect child
     contexts or *Note gcc_jit_result: 16. instances already created by
     the context.

     The parameters “flags” and “verbosity” are reserved for
     future expansion, and must be zero for now.

To contrast the above: *Note gcc_jit_context_dump_to_file(): 5a. dumps
the current state of a context to the given path, whereas *Note
gcc_jit_context_set_logfile(): 5b. enables on-going logging of future
activies on a context to the given `FILE *'.

 -- C Function: void gcc_jit_context_dump_reproducer_to_file
          (gcc_jit_context *ctxt, const char *path)
     Write C source code into `path' that can be compiled into a
     self-contained executable (i.e. with libgccjit as the only
     dependency).  The generated code will attempt to replay the API
     calls that have been made into the given context.

     This may be useful when debugging the library or client code, for
     reducing a complicated recipe for reproducing a bug into a simpler
     form.  For example, consider client code that parses some source
     file into some internal representation, and then walks this IR,
     calling into libgccjit.  If this encounters a bug, a call to
     `gcc_jit_context_dump_reproducer_to_file' will write out C code for
     a much simpler executable that performs the equivalent calls into
     libgccjit, without needing the client code and its data.

     Typically you need to supply `-Wno-unused-variable' when compiling
     the generated file (since the result of each API call is assigned
     to a unique variable within the generated C source, and not all
     are necessarily then used).

 -- C Function: void gcc_jit_context_enable_dump
          (gcc_jit_context *ctxt, const char *dumpname, char **out_ptr)
     Enable the dumping of a specific set of internal state from the
     compilation, capturing the result in-memory as a buffer.

     Parameter “dumpname” corresponds to the equivalent gcc
     command-line option, without the “-fdump-” prefix.  For
     example, to get the equivalent of `-fdump-tree-vrp1', supply
     `"tree-vrp1"':

         static char *dump_vrp1;

         void
         create_code (gcc_jit_context *ctxt)
         {
            gcc_jit_context_enable_dump (ctxt, "tree-vrp1", &dump_vrp1);
            /* (other API calls omitted for brevity) */
         }

     The context directly stores the dumpname as a `(const char *)', so
     the passed string must outlive the context.

     *Note gcc_jit_context_compile(): 15. will capture the dump as a
     dynamically-allocated buffer, writing it to `*out_ptr'.

     The caller becomes responsible for calling:

         free (*out_ptr)

     each time that *Note gcc_jit_context_compile(): 15. is called.
     `*out_ptr' will be written to, either with the address of a buffer,
     or with `NULL' if an error occurred.

          Warning: This API entrypoint is likely to be less stable than
          the others.  In particular, both the precise dumpnames, and
          the format and content of the dumps are subject to change.

          It exists primarily for writing the library’s own test
          suite.


File: libgccjit.info,  Node: Options<2>,  Prev: Debugging,  Up: Compilation contexts

2.1.5 Options
-------------

Options present in the initial release of libgccjit were handled using
enums, whereas those added subsequently have their own per-option API
entrypoints.

Adding entrypoints for each new option means that client code that use
the new options can be identified directly from binary metadata, which
would not be possible if we instead extended the various `enum
gcc_jit_*_option'.

* Menu:

* String Options::
* Boolean options::
* Integer options::
* Additional command-line options::


File: libgccjit.info,  Node: String Options,  Next: Boolean options,  Up: Options<2>

2.1.5.1 String Options
......................

 -- C Function: void gcc_jit_context_set_str_option
          (gcc_jit_context *ctxt, enum gcc_jit_str_option opt, const
          char *value)
     Set a string option of the context.

      -- C Type: enum gcc_jit_str_option

     The parameter `value' can be NULL.   If non-NULL, the call takes a
     copy of the underlying string, so it is valid to pass in a pointer
     to an on-stack buffer.

     There is just one string option specified this way:

      -- C Macro: GCC_JIT_STR_OPTION_PROGNAME
          The name of the program, for use as a prefix when printing
          error messages to stderr.  If `NULL', or default,
          “libgccjit.so” is used.


File: libgccjit.info,  Node: Boolean options,  Next: Integer options,  Prev: String Options,  Up: Options<2>

2.1.5.2 Boolean options
.......................

 -- C Function: void gcc_jit_context_set_bool_option
          (gcc_jit_context *ctxt, enum gcc_jit_bool_option opt,
          int value)
     Set a boolean option of the context.  Zero is “false” (the
     default), non-zero is “true”.

      -- C Type: enum gcc_jit_bool_option

      -- C Macro: GCC_JIT_BOOL_OPTION_DEBUGINFO
          If true, *Note gcc_jit_context_compile(): 15. will attempt to
          do the right thing so that if you attach a debugger to the
          process, it will be able to inspect variables and step
          through your code.

          Note that you can’t step through code unless you set up
          source location information for the code (by creating and
          passing in *Note gcc_jit_location: 3b. instances).

      -- C Macro: GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE
          If true, *Note gcc_jit_context_compile(): 15. will dump its
          initial “tree” representation of your code to stderr
          (before any optimizations).

          Here’s some sample output (from the `square' example):

              <statement_list 0x7f4875a62cc0
                 type <void_type 0x7f4875a64bd0 VOID
                     align 8 symtab 0 alias set -1 canonical type 0x7f4875a64bd0
                     pointer_to_this <pointer_type 0x7f4875a64c78>>
                 side-effects head 0x7f4875a761e0 tail 0x7f4875a761f8 stmts 0x7f4875a62d20 0x7f4875a62d00

                 stmt <label_expr 0x7f4875a62d20 type <void_type 0x7f4875a64bd0>
                     side-effects
                     arg 0 <label_decl 0x7f4875a79080 entry type <void_type 0x7f4875a64bd0>
                         VOID file (null) line 0 col 0
                         align 1 context <function_decl 0x7f4875a77500 square>>>
                 stmt <return_expr 0x7f4875a62d00
                     type <integer_type 0x7f4875a645e8 public SI
                         size <integer_cst 0x7f4875a623a0 constant 32>
                         unit size <integer_cst 0x7f4875a623c0 constant 4>
                         align 32 symtab 0 alias set -1 canonical type 0x7f4875a645e8 precision 32 min <integer_cst 0x7f4875a62340 -2147483648> max <integer_cst 0x7f4875a62360 2147483647>
                         pointer_to_this <pointer_type 0x7f4875a6b348>>
                     side-effects
                     arg 0 <modify_expr 0x7f4875a72a78 type <integer_type 0x7f4875a645e8>
                         side-effects arg 0 <result_decl 0x7f4875a7a000 D.54>
                         arg 1 <mult_expr 0x7f4875a72a50 type <integer_type 0x7f4875a645e8>
                             arg 0 <parm_decl 0x7f4875a79000 i> arg 1 <parm_decl 0x7f4875a79000 i>>>>>

      -- C Macro: GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE
          If true, *Note gcc_jit_context_compile(): 15. will dump the
          “gimple” representation of your code to stderr, before
          any optimizations are performed.  The dump resembles C code:

              square (signed int i)
              {
                signed int D.56;

                entry:
                D.56 = i * i;
                return D.56;
              }

      -- C Macro: GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE
          If true, *Note gcc_jit_context_compile(): 15. will dump the
          final generated code to stderr, in the form of assembly
          language:

                  .file    "fake.c"
                  .text
                  .globl    square
                  .type    square, @function
              square:
              .LFB0:
                  .cfi_startproc
                  pushq    %rbp
                  .cfi_def_cfa_offset 16
                  .cfi_offset 6, -16
                  movq    %rsp, %rbp
                  .cfi_def_cfa_register 6
                  movl    %edi, -4(%rbp)
              .L2:
                  movl    -4(%rbp), %eax
                  imull    -4(%rbp), %eax
                  popq    %rbp
                  .cfi_def_cfa 7, 8
                  ret
                  .cfi_endproc
              .LFE0:
                  .size    square, .-square
                  .ident    "GCC: (GNU) 4.9.0 20131023 (Red Hat 0.1-%{gcc_release})"
                  .section    .note.GNU-stack,"",@progbits

      -- C Macro: GCC_JIT_BOOL_OPTION_DUMP_SUMMARY
          If true, *Note gcc_jit_context_compile(): 15. will print
          information to stderr on the actions it is performing.

      -- C Macro: GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING
          If true, *Note gcc_jit_context_compile(): 15. will dump
          copious amount of information on what it’s doing to various
          files within a temporary directory.  Use *Note
          GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES: 69. (see below) to
          see the results.  The files are intended to be human-readable,
          but the exact files and their formats are subject to change.

      -- C Macro: GCC_JIT_BOOL_OPTION_SELFCHECK_GC
          If true, libgccjit will aggressively run its garbage
          collector, to shake out bugs (greatly slowing down the
          compile).  This is likely to only be of interest to
          developers `of' the library.  It is used when running the
          selftest suite.

      -- C Macro: GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES
          If true, the *Note gcc_jit_context: 8. will not clean up
          intermediate files written to the filesystem, and will
          display their location on stderr.

 -- C Function: void gcc_jit_context_set_bool_allow_unreachable_blocks
          (gcc_jit_context *ctxt, int bool_value)
     By default, libgccjit will issue an error about unreachable blocks
     within a function.

     This entrypoint can be used to disable that error.

     This entrypoint was added in *Note LIBGCCJIT_ABI_2: 6c.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_allow_unreachable_blocks

 -- C Function: void gcc_jit_context_set_bool_use_external_driver
          (gcc_jit_context *ctxt, int bool_value)
     libgccjit internally generates assembler, and uses “driver”
     code for converting it to other formats (e.g. shared libraries).

     By default, libgccjit will use an embedded copy of the driver code.

     This option can be used to instead invoke an external driver
     executable as a subprocess.

     This entrypoint was added in *Note LIBGCCJIT_ABI_5: 6e.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_use_external_driver

 -- C Function: void gcc_jit_context_set_bool_print_errors_to_stderr
          (gcc_jit_context *ctxt, int enabled)
     By default, libgccjit will print errors to stderr.

     This entrypoint can be used to disable the printing.

     This entrypoint was added in *Note LIBGCCJIT_ABI_23: 70.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_print_errors_to_stderr


File: libgccjit.info,  Node: Integer options,  Next: Additional command-line options,  Prev: Boolean options,  Up: Options<2>

2.1.5.3 Integer options
.......................

 -- C Function: void gcc_jit_context_set_int_option
          (gcc_jit_context *ctxt, enum gcc_jit_int_option opt,
          int value)
     Set an integer option of the context.

      -- C Type: enum gcc_jit_int_option

     There is just one integer option specified this way:

      -- C Macro: GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL
          How much to optimize the code.

          Valid values are 0-3, corresponding to GCC’s command-line
          options -O0 through -O3.

          The default value is 0 (unoptimized).


File: libgccjit.info,  Node: Additional command-line options,  Prev: Integer options,  Up: Options<2>

2.1.5.4 Additional command-line options
.......................................

 -- C Function: void gcc_jit_context_add_command_line_option
          (gcc_jit_context *ctxt, const char *optname)
     Add an arbitrary gcc command-line option to the context, for use
     by *Note gcc_jit_context_compile(): 15. and *Note
     gcc_jit_context_compile_to_file(): 4a.

     The parameter `optname' must be non-NULL.  The underlying buffer is
     copied, so that it does not need to outlive the call.

     Extra options added by `gcc_jit_context_add_command_line_option'
     are applied `after' the regular options above, potentially
     overriding them.  Options from parent contexts are inherited by
     child contexts; options from the parent are applied `before' those
     from the child.

     For example:

         gcc_jit_context_add_command_line_option (ctxt, "-ffast-math");
         gcc_jit_context_add_command_line_option (ctxt, "-fverbose-asm");

     Note that only some options are likely to be meaningful; there is
     no “frontend” within libgccjit, so typically only those
     affecting optimization and code-generation are likely to be useful.

     This entrypoint was added in *Note LIBGCCJIT_ABI_1: 75.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_add_command_line_option

 -- C Function: void gcc_jit_context_add_driver_option
          (gcc_jit_context *ctxt, const char *optname)
     Add an arbitrary gcc driver option to the context, for use by
     *Note gcc_jit_context_compile(): 15. and *Note
     gcc_jit_context_compile_to_file(): 4a.

     The parameter `optname' must be non-NULL.  The underlying buffer is
     copied, so that it does not need to outlive the call.

     Extra options added by `gcc_jit_context_add_driver_option' are
     applied `after' all other options potentially overriding them.
     Options from parent contexts are inherited by child contexts;
     options from the parent are applied `before' those from the child.

     For example:

         gcc_jit_context_add_driver_option (ctxt, "-lm");
         gcc_jit_context_add_driver_option (ctxt, "-fuse-linker-plugin");

         gcc_jit_context_add_driver_option (ctxt, "obj.o");

         gcc_jit_context_add_driver_option (ctxt, "-L.");
         gcc_jit_context_add_driver_option (ctxt, "-lwhatever");

     Note that only some options are likely to be meaningful; there is
     no “frontend” within libgccjit, so typically only those
     affecting assembler and linker are likely to be useful.

     This entrypoint was added in *Note LIBGCCJIT_ABI_11: 77.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_add_driver_option


File: libgccjit.info,  Node: Objects,  Next: Types,  Prev: Compilation contexts,  Up: Topic Reference

2.2 Objects
===========

 -- C Type: gcc_jit_object

Almost every entity in the API (with the exception of *Note
gcc_jit_context *: 8. and *Note gcc_jit_result *: 16.) is a
“contextual” object, a *Note gcc_jit_object *: e.

A JIT object:

        * is associated with a *Note gcc_jit_context *: 8.

        * is automatically cleaned up for you when its context is
          released so you don’t need to manually track and cleanup
          all objects, just the contexts.

Although the API is C-based, there is a form of class hierarchy, which
looks like this:

    +- gcc_jit_object
        +- gcc_jit_location
        +- gcc_jit_type
           +- gcc_jit_struct
        +- gcc_jit_field
        +- gcc_jit_function
        +- gcc_jit_block
        +- gcc_jit_rvalue
            +- gcc_jit_lvalue
               +- gcc_jit_param
        +- gcc_jit_case
        +- gcc_jit_extended_asm

There are casting methods for upcasting from subclasses to parent
classes.  For example, *Note gcc_jit_type_as_object(): d.:

    gcc_jit_object *obj = gcc_jit_type_as_object (int_type);

The object “base class” has the following operations:

 -- C Function: gcc_jit_context *gcc_jit_object_get_context
          (gcc_jit_object *obj)
     Which context is “obj” within?

 -- C Function: const char *gcc_jit_object_get_debug_string
          (gcc_jit_object *obj)
     Generate a human-readable description for the given object.

     For example,

         printf ("obj: %s\n", gcc_jit_object_get_debug_string (obj));

     might give this text on stdout:

         obj: 4.0 * (float)i

          Note: If you call this on an object, the `const char *'
          buffer is allocated and generated on the first call for that
          object, and the buffer will have the same lifetime as the
          object  i.e. it will exist until the object’s context is
          released.


File: libgccjit.info,  Node: Types,  Next: Expressions,  Prev: Objects,  Up: Topic Reference

2.3 Types
=========

 -- C Type: gcc_jit_type
     gcc_jit_type represents a type within the library.

 -- C Function: gcc_jit_object *gcc_jit_type_as_object
          (gcc_jit_type *type)
     Upcast a type to an object.

Types can be created in several ways:

   * fundamental types can be accessed using *Note
     gcc_jit_context_get_type(): b.:

         gcc_jit_type *int_type = gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);

     See *Note gcc_jit_context_get_type(): b. for the available types.

   * derived types can be accessed by using functions such as *Note
     gcc_jit_type_get_pointer(): 7d. and *Note
     gcc_jit_type_get_const(): 7e.:

         gcc_jit_type *const_int_star = gcc_jit_type_get_pointer (gcc_jit_type_get_const (int_type));
         gcc_jit_type *int_const_star = gcc_jit_type_get_const (gcc_jit_type_get_pointer (int_type));

   * by creating structures (see below).

* Menu:

* Standard types::
* Pointers, const, and volatile: Pointers const and volatile.
* Vector types::
* Structures and unions::
* Function pointer types::
* Reflection API::


File: libgccjit.info,  Node: Standard types,  Next: Pointers const and volatile,  Up: Types

2.3.1 Standard types
--------------------

 -- C Function: gcc_jit_type *gcc_jit_context_get_type
          (gcc_jit_context *ctxt, enum gcc_jit_types type_)
     Access a specific type.  The available types are:

     `enum gcc_jit_types' value                     Meaning
     ------------------------------------------------------------------------------------- 
     `GCC_JIT_TYPE_VOID'                            C’s `void' type.
     `GCC_JIT_TYPE_VOID_PTR'                        C’s `void *'.
     `GCC_JIT_TYPE_BOOL'                            C++’s `bool' type; also C99’s
                                                    `_Bool' type, aka `bool' if using
                                                    stdbool.h.
     `GCC_JIT_TYPE_CHAR'                            C’s `char' (of some signedness)
     `GCC_JIT_TYPE_SIGNED_CHAR'                     C’s `signed char'
     `GCC_JIT_TYPE_UNSIGNED_CHAR'                   C’s `unsigned char'
     `GCC_JIT_TYPE_SHORT'                           C’s `short' (signed)
     `GCC_JIT_TYPE_UNSIGNED_SHORT'                  C’s `unsigned short'
     `GCC_JIT_TYPE_INT'                             C’s `int' (signed)
     `GCC_JIT_TYPE_UNSIGNED_INT'                    C’s `unsigned int'
     `GCC_JIT_TYPE_LONG'                            C’s `long' (signed)
     `GCC_JIT_TYPE_UNSIGNED_LONG'                   C’s `unsigned long'
     `GCC_JIT_TYPE_LONG_LONG'                       C99’s `long long' (signed)
     `GCC_JIT_TYPE_UNSIGNED_LONG_LONG'              C99’s `unsigned long long'
     `GCC_JIT_TYPE_UINT8_T'                         C99’s `uint8_t'
     `GCC_JIT_TYPE_UINT16_T'                        C99’s `uint16_t'
     `GCC_JIT_TYPE_UINT32_T'                        C99’s `uint32_t'
     `GCC_JIT_TYPE_UINT64_T'                        C99’s `uint64_t'
     `GCC_JIT_TYPE_UINT128_T'                       C99’s `__uint128_t'
     `GCC_JIT_TYPE_INT8_T'                          C99’s `int8_t'
     `GCC_JIT_TYPE_INT16_T'                         C99’s `int16_t'
     `GCC_JIT_TYPE_INT32_T'                         C99’s `int32_t'
     `GCC_JIT_TYPE_INT64_T'                         C99’s `int64_t'
     `GCC_JIT_TYPE_INT128_T'                        C99’s `__int128_t'
     `GCC_JIT_TYPE_FLOAT'                           
     `GCC_JIT_TYPE_DOUBLE'                          
     `GCC_JIT_TYPE_LONG_DOUBLE'                     
     `GCC_JIT_TYPE_CONST_CHAR_PTR'                  C type: `(const char *)'
     `GCC_JIT_TYPE_SIZE_T'                          C’s `size_t' type
     `GCC_JIT_TYPE_FILE_PTR'                        C type: `(FILE *)'
     `GCC_JIT_TYPE_COMPLEX_FLOAT'                   C99’s `_Complex float'
     `GCC_JIT_TYPE_COMPLEX_DOUBLE'                  C99’s `_Complex double'
     `GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE'             C99’s `_Complex long double'


 -- C Function: gcc_jit_type * gcc_jit_context_get_int_type
          (gcc_jit_context *ctxt, int num_bytes, int is_signed)
     Access the integer type of the given size.


File: libgccjit.info,  Node: Pointers const and volatile,  Next: Vector types,  Prev: Standard types,  Up: Types

2.3.2 Pointers, `const', and `volatile'
---------------------------------------

 -- C Function: gcc_jit_type *gcc_jit_type_get_pointer
          (gcc_jit_type *type)
     Given type “T”, get type “T*”.

 -- C Function: gcc_jit_type *gcc_jit_type_get_const
          (gcc_jit_type *type)
     Given type “T”, get type “const T”.

 -- C Function: gcc_jit_type *gcc_jit_type_get_volatile
          (gcc_jit_type *type)
     Given type “T”, get type “volatile T”.

 -- C Function: gcc_jit_type * gcc_jit_context_new_array_type
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_type *element_type, int num_elements)
     Given non-`void' type “T”, get type “T[N]” (for a constant
     N).

 -- C Function: gcc_jit_type * gcc_jit_type_get_aligned
          (gcc_jit_type *type, size_t alignment_in_bytes)
     Given non-`void' type “T”, get type:

         T __attribute__ ((aligned (ALIGNMENT_IN_BYTES)))

     The alignment must be a power of two.

     This entrypoint was added in *Note LIBGCCJIT_ABI_7: 85.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_type_get_aligned


File: libgccjit.info,  Node: Vector types,  Next: Structures and unions,  Prev: Pointers const and volatile,  Up: Types

2.3.3 Vector types
------------------

 -- C Function: gcc_jit_type * gcc_jit_type_get_vector
          (gcc_jit_type *type, size_t num_units)
     Given type “T”, get type:

         T  __attribute__ ((vector_size (sizeof(T) * num_units))

     T must be integral or floating point; num_units must be a power of
     two.

     This can be used to construct a vector type in which operations
     are applied element-wise.  The compiler will automatically use
     SIMD instructions where possible.  See:
     <https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html>

     For example, assuming 4-byte `ints', then:

         typedef int v4si __attribute__ ((vector_size (16)));

     can be obtained using:

         gcc_jit_type *int_type = gcc_jit_context_get_type (ctxt,
                                                            GCC_JIT_TYPE_INT);
         gcc_jit_type *v4si_type = gcc_jit_type_get_vector (int_type, 4);

     This API entrypoint was added in *Note LIBGCCJIT_ABI_8: 88.; you
     can test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_type_get_vector

     Vector rvalues can be generated using *Note
     gcc_jit_context_new_rvalue_from_vector(): 89.


File: libgccjit.info,  Node: Structures and unions,  Next: Function pointer types,  Prev: Vector types,  Up: Types

2.3.4 Structures and unions
---------------------------

 -- C Type: gcc_jit_struct

A compound type analagous to a C `struct'.

 -- C Type: gcc_jit_field

A field within a *Note gcc_jit_struct: 8b.

You can model C `struct' types by creating *Note gcc_jit_struct: 8b. and
*Note gcc_jit_field: 8c. instances, in either order:

   * by creating the fields, then the structure.  For example, to model:

         struct coord {double x; double y; };

     you could call:

         gcc_jit_field *field_x =
           gcc_jit_context_new_field (ctxt, NULL, double_type, "x");
         gcc_jit_field *field_y =
           gcc_jit_context_new_field (ctxt, NULL, double_type, "y");
         gcc_jit_field *fields[2] = {field_x, field_y};
         gcc_jit_struct *coord =
           gcc_jit_context_new_struct_type (ctxt, NULL, "coord", 2, fields);

   * by creating the structure, then populating it with fields,
     typically to allow modelling self-referential structs such as:

         struct node { int m_hash; struct node *m_next; };

     like this:

         gcc_jit_type *node =
           gcc_jit_context_new_opaque_struct (ctxt, NULL, "node");
         gcc_jit_type *node_ptr =
           gcc_jit_type_get_pointer (node);
         gcc_jit_field *field_hash =
           gcc_jit_context_new_field (ctxt, NULL, int_type, "m_hash");
         gcc_jit_field *field_next =
           gcc_jit_context_new_field (ctxt, NULL, node_ptr, "m_next");
         gcc_jit_field *fields[2] = {field_hash, field_next};
         gcc_jit_struct_set_fields (node, NULL, 2, fields);

 -- C Function: gcc_jit_field * gcc_jit_context_new_field
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_type *type, const char *name)
     Construct a new field, with the given type and name.

     The parameter `type' must be non-`void'.

     The parameter `name' must be non-NULL.  The call takes a copy of
     the underlying string, so it is valid to pass in a pointer to an
     on-stack buffer.

 -- C Function: gcc_jit_field * gcc_jit_context_new_bitfield
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_type *type, int width, const char *name)
     Construct a new bit field, with the given type width and name.

     The parameter `name' must be non-NULL.  The call takes a copy of
     the underlying string, so it is valid to pass in a pointer to an
     on-stack buffer.

     The parameter `type' must be an integer type.

     The parameter `width' must be a positive integer that does not
     exceed the size of `type'.

     This API entrypoint was added in *Note LIBGCCJIT_ABI_12: 8f.; you
     can test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_bitfield

 -- C Function: gcc_jit_object * gcc_jit_field_as_object
          (gcc_jit_field *field)
     Upcast from field to object.

 -- C Function: gcc_jit_struct *gcc_jit_context_new_struct_type
          (gcc_jit_context *ctxt, gcc_jit_location *loc, const
          char *name, int num_fields, gcc_jit_field **fields)
          Construct a new struct type, with the given name and fields.

          The parameter `name' must be non-NULL.  The call takes a copy
          of the underlying string, so it is valid to pass in a pointer
          to an on-stack buffer.

 -- C Function: gcc_jit_struct * gcc_jit_context_new_opaque_struct
          (gcc_jit_context *ctxt, gcc_jit_location *loc, const
          char *name)
     Construct a new struct type, with the given name, but without
     specifying the fields.   The fields can be omitted (in which case
     the size of the struct is not known), or later specified using
     *Note gcc_jit_struct_set_fields(): 93.

     The parameter `name' must be non-NULL.  The call takes a copy of
     the underlying string, so it is valid to pass in a pointer to an
     on-stack buffer.

 -- C Function: gcc_jit_type * gcc_jit_struct_as_type
          (gcc_jit_struct *struct_type)
     Upcast from struct to type.

 -- C Function: void gcc_jit_struct_set_fields
          (gcc_jit_struct *struct_type, gcc_jit_location *loc,
          int num_fields, gcc_jit_field **fields)
     Populate the fields of a formerly-opaque struct type.

     This can only be called once on a given struct type.

 -- C Function: gcc_jit_type * gcc_jit_context_new_union_type
          (gcc_jit_context *ctxt, gcc_jit_location *loc, const
          char *name, int num_fields, gcc_jit_field **fields)
     Construct a new union type, with the given name and fields.

     The parameter `name' must be non-NULL.  It is copied, so the input
     buffer does not need to outlive the call.

     Example of use:


         union int_or_float
         {
           int as_int;
           float as_float;
         };

         void
         create_code (gcc_jit_context *ctxt, void *user_data)
         {
           /* Let's try to inject the equivalent of:
              float
              test_union (int i)
              {
                 union int_or_float u;
         	u.as_int = i;
         	return u.as_float;
              }
           */
           gcc_jit_type *int_type =
             gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
           gcc_jit_type *float_type =
             gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_FLOAT);
           gcc_jit_field *as_int =
             gcc_jit_context_new_field (ctxt,
                                        NULL,
                                        int_type,
                                        "as_int");
           gcc_jit_field *as_float =
             gcc_jit_context_new_field (ctxt,
                                        NULL,
                                        float_type,
                                        "as_float");
           gcc_jit_field *fields[] = {as_int, as_float};
           gcc_jit_type *union_type =
             gcc_jit_context_new_union_type (ctxt, NULL,
         				    "int_or_float", 2, fields);

           /* Build the test function.  */
           gcc_jit_param *param_i =
             gcc_jit_context_new_param (ctxt, NULL, int_type, "i");
           gcc_jit_function *test_fn =
             gcc_jit_context_new_function (ctxt, NULL,
                                           GCC_JIT_FUNCTION_EXPORTED,
                                           float_type,
                                           "test_union",
                                           1, &param_i,
                                           0);

           gcc_jit_lvalue *u =
             gcc_jit_function_new_local (test_fn, NULL,
         				union_type, "u");

           gcc_jit_block *block = gcc_jit_function_new_block (test_fn, NULL);

           /* u.as_int = i; */
           gcc_jit_block_add_assignment (
             block,
             NULL,
             /* "u.as_int = ..." */
             gcc_jit_lvalue_access_field (u,
         				 NULL,
         				 as_int),
             gcc_jit_param_as_rvalue (param_i));

           /* return u.as_float; */
           gcc_jit_block_end_with_return (
             block, NULL,
             gcc_jit_rvalue_access_field (gcc_jit_lvalue_as_rvalue (u),
         				 NULL,
         				 as_float));
         }


File: libgccjit.info,  Node: Function pointer types,  Next: Reflection API,  Prev: Structures and unions,  Up: Types

2.3.5 Function pointer types
----------------------------

Function pointer types can be created using *Note
gcc_jit_context_new_function_ptr_type(): 97.


File: libgccjit.info,  Node: Reflection API,  Prev: Function pointer types,  Up: Types

2.3.6 Reflection API
--------------------

 -- C Function: gcc_jit_type * gcc_jit_type_dyncast_array
          (gcc_jit_type *type)
     Get the element type of an array type or NULL if it’s not an
     array.

 -- C Function: int gcc_jit_type_is_bool (gcc_jit_type *type)
     Return non-zero if the type is a bool.

 -- C Function: gcc_jit_function_type *
          gcc_jit_type_dyncast_function_ptr_type (gcc_jit_type *type)
     Return the function type if it is one or NULL.

 -- C Function: gcc_jit_type * gcc_jit_function_type_get_return_type
          (gcc_jit_function_type *function_type)
     Given a function type, return its return type.

 -- C Function: size_t gcc_jit_function_type_get_param_count
          (gcc_jit_function_type *function_type)
     Given a function type, return its number of parameters.

 -- C Function: gcc_jit_type * gcc_jit_function_type_get_param_type
          (gcc_jit_function_type *function_type, size_t index)
     Given a function type, return the type of the specified parameter.

 -- C Function: int gcc_jit_type_is_integral (gcc_jit_type *type)
     Return non-zero if the type is an integral.

 -- C Function: gcc_jit_type * gcc_jit_type_is_pointer
          (gcc_jit_type *type)
     Return the type pointed by the pointer type or NULL if it’s not
     a pointer.

 -- C Function: gcc_jit_vector_type * gcc_jit_type_dyncast_vector
          (gcc_jit_type *type)
     Given a type, return a dynamic cast to a vector type or NULL.

 -- C Function: gcc_jit_struct * gcc_jit_type_is_struct
          (gcc_jit_type *type)
     Given a type, return a dynamic cast to a struct type or NULL.

 -- C Function: size_t gcc_jit_vector_type_get_num_units
          (gcc_jit_vector_type *vector_type)
     Given a vector type, return the number of units it contains.

 -- C Function: gcc_jit_type * gcc_jit_vector_type_get_element_type
          (gcc_jit_vector_type * vector_type)
     Given a vector type, return the type of its elements.

 -- C Function: gcc_jit_type * gcc_jit_type_unqualified
          (gcc_jit_type *type)
     Given a type, return the unqualified type, removing “const”,
     “volatile” and alignment qualifiers.

 -- C Function: gcc_jit_field * gcc_jit_struct_get_field
          (gcc_jit_struct *struct_type, size_t index)
     Get a struct field by index.

 -- C Function: size_t gcc_jit_struct_get_field_count
          (gcc_jit_struct *struct_type)
          Get the number of fields in the struct.

     The API entrypoints related to the reflection API:

             * *Note gcc_jit_function_type_get_return_type(): 9c.

             * *Note gcc_jit_function_type_get_param_count(): 9d.

             * *Note gcc_jit_function_type_get_param_type(): 9e.

             * *Note gcc_jit_type_unqualified(): a5.

             * *Note gcc_jit_type_dyncast_array(): 99.

             * *Note gcc_jit_type_is_bool(): 9a.

             * *Note gcc_jit_type_dyncast_function_ptr_type(): 9b.

             * *Note gcc_jit_type_is_integral(): 9f.

             * *Note gcc_jit_type_is_pointer(): a0.

             * *Note gcc_jit_type_dyncast_vector(): a1.

             * *Note gcc_jit_vector_type_get_element_type(): a4.

             * *Note gcc_jit_vector_type_get_num_units(): a3.

             * *Note gcc_jit_struct_get_field(): a6.

             * *Note gcc_jit_type_is_struct(): a2.

             * *Note gcc_jit_struct_get_field_count(): a7.

     were added in *Note LIBGCCJIT_ABI_16: a8.; you can test for their
     presence using

         #ifdef LIBGCCJIT_HAVE_REFLECTION

      -- C Type: gcc_jit_case

 -- C Function: int gcc_jit_compatible_types (gcc_jit_type *ltype,
          gcc_jit_type *rtype)
          Return non-zero if the two types are compatible. For instance,
          if `GCC_JIT_TYPE_UINT64_T' and `GCC_JIT_TYPE_UNSIGNED_LONG'
          are the same size on the target, this will return non-zero.
          The parameters `ltype' and `rtype' must be non-NULL.  Return
          0 on errors.

     This entrypoint was added in *Note LIBGCCJIT_ABI_20: ab.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_SIZED_INTEGERS

 -- C Function: ssize_t gcc_jit_type_get_size (gcc_jit_type *type)
          Return the size of a type, in bytes. It only works on integer
          types for now.  The parameter `type' must be non-NULL.
          Return -1 on errors.

     This entrypoint was added in *Note LIBGCCJIT_ABI_20: ab.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_SIZED_INTEGERS


File: libgccjit.info,  Node: Expressions,  Next: Creating and using functions,  Prev: Types,  Up: Topic Reference

2.4 Expressions
===============

* Menu:

* Rvalues::
* Lvalues::
* Working with pointers, structs and unions: Working with pointers structs and unions.


File: libgccjit.info,  Node: Rvalues,  Next: Lvalues,  Up: Expressions

2.4.1 Rvalues
-------------

 -- C Type: gcc_jit_rvalue

A *Note gcc_jit_rvalue: 13. is an expression that can be computed.

It can be simple, e.g.:

        * an integer value e.g. `0' or `42'

        * a string literal e.g. `“Hello world”'

        * a variable e.g. `i'.  These are also lvalues (see below).

or compound e.g.:

        * a unary expression e.g. `!cond'

        * a binary expression e.g. `(a + b)'

        * a function call e.g. `get_distance (&player_ship, &target)'

        * etc.

Every rvalue has an associated type, and the API will check to ensure
that types match up correctly (otherwise the context will emit an
error).

 -- C Function: gcc_jit_type *gcc_jit_rvalue_get_type
          (gcc_jit_rvalue *rvalue)
     Get the type of this rvalue.

 -- C Function: gcc_jit_object *gcc_jit_rvalue_as_object
          (gcc_jit_rvalue *rvalue)
     Upcast the given rvalue to be an object.

* Menu:

* Simple expressions::
* Constructor expressions::
* Vector expressions::
* Unary Operations::
* Binary Operations::
* Comparisons::
* Function calls::
* Function pointers::
* Type-coercion::


File: libgccjit.info,  Node: Simple expressions,  Next: Constructor expressions,  Up: Rvalues

2.4.1.1 Simple expressions
..........................

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_int
          (gcc_jit_context *ctxt, gcc_jit_type *numeric_type, int value)
     Given a numeric type (integer or floating point), build an rvalue
     for the given constant `int' value.

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_long
          (gcc_jit_context *ctxt, gcc_jit_type *numeric_type,
          long value)
     Given a numeric type (integer or floating point), build an rvalue
     for the given constant `long' value.

 -- C Function: gcc_jit_rvalue *gcc_jit_context_zero
          (gcc_jit_context *ctxt, gcc_jit_type *numeric_type)
     Given a numeric type (integer or floating point), get the rvalue
     for zero.  Essentially this is just a shortcut for:

         gcc_jit_context_new_rvalue_from_int (ctxt, numeric_type, 0)

 -- C Function: gcc_jit_rvalue *gcc_jit_context_one
          (gcc_jit_context *ctxt, gcc_jit_type *numeric_type)
     Given a numeric type (integer or floating point), get the rvalue
     for one.  Essentially this is just a shortcut for:

         gcc_jit_context_new_rvalue_from_int (ctxt, numeric_type, 1)

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_double
          (gcc_jit_context *ctxt, gcc_jit_type *numeric_type,
          double value)
     Given a numeric type (integer or floating point), build an rvalue
     for the given constant `double' value.

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_ptr
          (gcc_jit_context *ctxt, gcc_jit_type *pointer_type,
          void *value)
     Given a pointer type, build an rvalue for the given address.

 -- C Function: gcc_jit_rvalue *gcc_jit_context_null
          (gcc_jit_context *ctxt, gcc_jit_type *pointer_type)
     Given a pointer type, build an rvalue for `NULL'.  Essentially this
     is just a shortcut for:

         gcc_jit_context_new_rvalue_from_ptr (ctxt, pointer_type, NULL)

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_string_literal
          (gcc_jit_context *ctxt, const char *value)
     Generate an rvalue for the given NIL-terminated string, of type
     `GCC_JIT_TYPE_CONST_CHAR_PTR'.

     The parameter `value' must be non-NULL.  The call takes a copy of
     the underlying string, so it is valid to pass in a pointer to an
     on-stack buffer.


File: libgccjit.info,  Node: Constructor expressions,  Next: Vector expressions,  Prev: Simple expressions,  Up: Rvalues

2.4.1.2 Constructor expressions
...............................

     The following functions make constructors for array, struct and
     union types.

     The constructor rvalue can be used for assignment to locals.  It
     can be used to initialize global variables with *Note
     gcc_jit_global_set_initializer_rvalue(): b7. It can also be used
     as a temporary value for function calls and return values, but its
     address can’t be taken.

     Note that arrays in libgccjit do not collapse to pointers like in
     C. I.e. if an array constructor is used as e.g. a return value,
     the whole array would be returned by value - array constructors
     can be assigned to array variables.

     The constructor can contain nested constructors.

     Note that a string literal rvalue can’t be used to construct a
     char array; the latter needs one rvalue for each char.

     These entrypoints were added in *Note LIBGCCJIT_ABI_19: b8.; you
     can test for their presence using:

         #ifdef LIBGCCJIT_HAVE_CTORS

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_array_constructor
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_type *type, size_t num_values,
          gcc_jit_rvalue **values)
     Create a constructor for an array as an rvalue.

     Returns NULL on error. `values' are copied and do not have to
     outlive the context.

     `type' specifies what the constructor will build and has to be an
     array.

     `num_values' specifies the number of elements in `values' and it
     can’t have more elements than the array type.

     Each value in `values' sets the corresponding value in the array.
     If the array type itself has more elements than `values', the
     left-over elements will be zeroed.

     Each value in `values' need to be the same unqualified type as the
     array type’s element type.

     If `num_values' is 0, the `values' parameter will be ignored and
     zero initialization will be used.

     This entrypoint was added in *Note LIBGCCJIT_ABI_19: b8.; you can
     test for its presence using:

         #ifdef LIBGCCJIT_HAVE_CTORS

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_struct_constructor
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_type *type, size_t num_values,
          gcc_jit_field **fields, gcc_jit_rvalue **values)
     Create a constructor for a struct as an rvalue.

     Returns NULL on error. The two parameter arrays are copied and do
     not have to outlive the context.

     `type' specifies what the constructor will build and has to be a
     struct.

     `num_values' specifies the number of elements in `values'.

     `fields' need to have the same length as `values', or be NULL.

     If `fields' is null, the values are applied in definition order.

     Otherwise, each field in `fields' specifies which field in the
     struct to set to the corresponding value in `values'. `fields' and
     `values' are paired by index.

     The fields in `fields' have to be in definition order, but there
     can be gaps. Any field in the struct that is not specified in
     `fields' will be zeroed.

     The fields in `fields' need to be the same objects that were used
     to create the struct.

     Each value has to have have the same unqualified type as the field
     it is applied to.

     A NULL value element  in `values' is a shorthand for zero
     initialization of the corresponding field.

     If `num_values' is 0, the array parameters will be ignored and
     zero initialization will be used.

     This entrypoint was added in *Note LIBGCCJIT_ABI_19: b8.; you can
     test for its presence using:

         #ifdef LIBGCCJIT_HAVE_CTORS

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_union_constructor
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_type *type, gcc_jit_field *field,
          gcc_jit_rvalue *value)
     Create a constructor for a union as an rvalue.

     Returns NULL on error.

     `type' specifies what the constructor will build and has to be an
     union.

     `field' specifies which field to set. If it is NULL, the first
     field in the union will be set.``field`` need to be the same object
     that were used to create the union.

     `value' specifies what value to set the corresponding field to.
     If `value' is NULL, zero initialization will be used.

     Each value has to have have the same unqualified type as the field
     it is applied to.

     This entrypoint was added in *Note LIBGCCJIT_ABI_19: b8.; you can
     test for its presence using:

         #ifdef LIBGCCJIT_HAVE_CTORS


File: libgccjit.info,  Node: Vector expressions,  Next: Unary Operations,  Prev: Constructor expressions,  Up: Rvalues

2.4.1.3 Vector expressions
..........................

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_vector
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_type *vec_type, size_t num_elements,
          gcc_jit_rvalue **elements)
     Build a vector rvalue from an array of elements.

     “vec_type” should be a vector type, created using *Note
     gcc_jit_type_get_vector(): 87.

     “num_elements” should match that of the vector type.

     This entrypoint was added in *Note LIBGCCJIT_ABI_10: bd.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_rvalue_from_vector


File: libgccjit.info,  Node: Unary Operations,  Next: Binary Operations,  Prev: Vector expressions,  Up: Rvalues

2.4.1.4 Unary Operations
........................

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_unary_op
          (gcc_jit_context *ctxt, gcc_jit_location *loc, enum
          gcc_jit_unary_op op, gcc_jit_type *result_type,
          gcc_jit_rvalue *rvalue)
     Build a unary operation out of an input rvalue.

     The parameter `result_type' must be a numeric type.

 -- C Type: enum gcc_jit_unary_op

The available unary operations are:

Unary Operation                                C equivalent
---------------------------------------------------------------- 
*Note GCC_JIT_UNARY_OP_MINUS: c1.              `-(EXPR)'
*Note GCC_JIT_UNARY_OP_BITWISE_NEGATE: c2.     `~(EXPR)'
*Note GCC_JIT_UNARY_OP_LOGICAL_NEGATE: c3.     `!(EXPR)'
*Note GCC_JIT_UNARY_OP_ABS: c4.                `abs (EXPR)'

 -- C Macro: GCC_JIT_UNARY_OP_MINUS
     Negate an arithmetic value; analogous to:

         -(EXPR)

     in C.

 -- C Macro: GCC_JIT_UNARY_OP_BITWISE_NEGATE
     Bitwise negation of an integer value (one’s complement);
     analogous to:

         ~(EXPR)

     in C.

 -- C Macro: GCC_JIT_UNARY_OP_LOGICAL_NEGATE
     Logical negation of an arithmetic or pointer value; analogous to:

         !(EXPR)

     in C.

 -- C Macro: GCC_JIT_UNARY_OP_ABS
     Absolute value of an arithmetic expression; analogous to:

         abs (EXPR)

     in C.


File: libgccjit.info,  Node: Binary Operations,  Next: Comparisons,  Prev: Unary Operations,  Up: Rvalues

2.4.1.5 Binary Operations
.........................

 -- C Function: gcc_jit_rvalue *gcc_jit_context_new_binary_op
          (gcc_jit_context *ctxt, gcc_jit_location *loc, enum
          gcc_jit_binary_op op, gcc_jit_type *result_type,
          gcc_jit_rvalue *a, gcc_jit_rvalue *b)
     Build a binary operation out of two constituent rvalues.

     The parameter `result_type' must be a numeric type.

 -- C Type: enum gcc_jit_binary_op

The available binary operations are:

Binary Operation                             C equivalent
-------------------------------------------------------------- 
*Note GCC_JIT_BINARY_OP_PLUS: c7.            `x + y'
*Note GCC_JIT_BINARY_OP_MINUS: c8.           `x - y'
*Note GCC_JIT_BINARY_OP_MULT: c9.            `x * y'
*Note GCC_JIT_BINARY_OP_DIVIDE: ca.          `x / y'
*Note GCC_JIT_BINARY_OP_MODULO: cb.          `x % y'
*Note GCC_JIT_BINARY_OP_BITWISE_AND: cc.     `x & y'
*Note GCC_JIT_BINARY_OP_BITWISE_XOR: cd.     `x ^ y'
*Note GCC_JIT_BINARY_OP_BITWISE_OR: ce.      `x | y'
*Note GCC_JIT_BINARY_OP_LOGICAL_AND: cf.     `x && y'
*Note GCC_JIT_BINARY_OP_LOGICAL_OR: d0.      `x || y'
*Note GCC_JIT_BINARY_OP_LSHIFT: d1.          `x << y'
*Note GCC_JIT_BINARY_OP_RSHIFT: d2.          `x >> y'

 -- C Macro: GCC_JIT_BINARY_OP_PLUS
     Addition of arithmetic values; analogous to:

         (EXPR_A) + (EXPR_B)

     in C.

     For pointer addition, use *Note
     gcc_jit_context_new_array_access(): d3.

 -- C Macro: GCC_JIT_BINARY_OP_MINUS
     Subtraction of arithmetic values; analogous to:

         (EXPR_A) - (EXPR_B)

     in C.

 -- C Macro: GCC_JIT_BINARY_OP_MULT
     Multiplication of a pair of arithmetic values; analogous to:

         (EXPR_A) * (EXPR_B)

     in C.

 -- C Macro: GCC_JIT_BINARY_OP_DIVIDE
     Quotient of division of arithmetic values; analogous to:

         (EXPR_A) / (EXPR_B)

     in C.

     The result type affects the kind of division: if the result type is
     integer-based, then the result is truncated towards zero, whereas
     a floating-point result type indicates floating-point division.

 -- C Macro: GCC_JIT_BINARY_OP_MODULO
     Remainder of division of arithmetic values; analogous to:

         (EXPR_A) % (EXPR_B)

     in C.

 -- C Macro: GCC_JIT_BINARY_OP_BITWISE_AND
     Bitwise AND; analogous to:

         (EXPR_A) & (EXPR_B)

     in C.

 -- C Macro: GCC_JIT_BINARY_OP_BITWISE_XOR
     Bitwise exclusive OR; analogous to:

         (EXPR_A) ^ (EXPR_B)

     in C.

 -- C Macro: GCC_JIT_BINARY_OP_BITWISE_OR
     Bitwise inclusive OR; analogous to:

         (EXPR_A) | (EXPR_B)

     in C.

 -- C Macro: GCC_JIT_BINARY_OP_LOGICAL_AND
     Logical AND; analogous to:

         (EXPR_A) && (EXPR_B)

     in C.

 -- C Macro: GCC_JIT_BINARY_OP_LOGICAL_OR
     Logical OR; analogous to:

         (EXPR_A) || (EXPR_B)

     in C.

 -- C Macro: GCC_JIT_BINARY_OP_LSHIFT
     Left shift; analogous to:

         (EXPR_A) << (EXPR_B)

     in C.

 -- C Macro: GCC_JIT_BINARY_OP_RSHIFT
     Right shift; analogous to:

         (EXPR_A) >> (EXPR_B)

     in C.


File: libgccjit.info,  Node: Comparisons,  Next: Function calls,  Prev: Binary Operations,  Up: Rvalues

2.4.1.6 Comparisons
...................

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_comparison
          (gcc_jit_context *ctxt, gcc_jit_location *loc, enum
          gcc_jit_comparison op, gcc_jit_rvalue *a, gcc_jit_rvalue *b)
     Build a boolean rvalue out of the comparison of two other rvalues.

 -- C Type: enum gcc_jit_comparison

Comparison                                  C equivalent
------------------------------------------------------------- 
`GCC_JIT_COMPARISON_EQ'                     `x == y'
`GCC_JIT_COMPARISON_NE'                     `x != y'
`GCC_JIT_COMPARISON_LT'                     `x < y'
`GCC_JIT_COMPARISON_LE'                     `x <= y'
`GCC_JIT_COMPARISON_GT'                     `x > y'
`GCC_JIT_COMPARISON_GE'                     `x >= y'


File: libgccjit.info,  Node: Function calls,  Next: Function pointers,  Prev: Comparisons,  Up: Rvalues

2.4.1.7 Function calls
......................

 -- 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 call to the function, with the result as an rvalue.

          Note: *Note gcc_jit_context_new_call(): d7. merely builds a
          *Note gcc_jit_rvalue: 13. i.e. an expression that can be
          evaluated, perhaps as part of a more complicated expression.
          The call `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 `void' return type), use
          *Note gcc_jit_block_add_eval(): d8.:

              /* Add "(void)printf (arg0, arg1);".  */
              gcc_jit_block_add_eval (
                block, NULL,
                gcc_jit_context_new_call (
                  ctxt,
                  NULL,
                  printf_func,
                  2, args));

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_call_through_ptr
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_rvalue *fn_ptr, int numargs, gcc_jit_rvalue **args)
     Given an rvalue of function pointer type (e.g. from *Note
     gcc_jit_context_new_function_ptr_type(): 97.), and the given table
     of argument rvalues, construct a call to the function pointer,
     with the result as an rvalue.

          Note: The same caveat as for *Note
          gcc_jit_context_new_call(): d7. applies.

 -- C Function: void gcc_jit_rvalue_set_bool_require_tail_call
          (gcc_jit_rvalue *call, int require_tail_call)
     Given an *Note gcc_jit_rvalue: 13. for a call created through
     *Note gcc_jit_context_new_call(): d7. or *Note
     gcc_jit_context_new_call_through_ptr(): d9, mark/clear the call as
     needing tail-call optimization.  The optimizer will attempt to
     optimize the call into a jump instruction; if it is unable to do
     do, an error will be emitted.

     This may be useful when implementing functions that use the
     continuation-passing style (e.g. for functional programming
     languages), in which every function “returns” by calling a
     “continuation” function pointer.  This call must be guaranteed
     to be implemented as a jump, otherwise the program could consume
     an arbitrary amount of stack space as it executed.

     This entrypoint was added in *Note LIBGCCJIT_ABI_6: db.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_rvalue_set_bool_require_tail_call


File: libgccjit.info,  Node: Function pointers,  Next: Type-coercion,  Prev: Function calls,  Up: Rvalues

2.4.1.8 Function pointers
.........................

Function pointers can be obtained:

        * from a *Note gcc_jit_function: 29. using *Note
          gcc_jit_function_get_address(): dd, or

        * from an existing function using *Note
          gcc_jit_context_new_rvalue_from_ptr(): b3, using a function
          pointer type obtained using *Note
          gcc_jit_context_new_function_ptr_type(): 97.


File: libgccjit.info,  Node: Type-coercion,  Prev: Function pointers,  Up: Rvalues

2.4.1.9 Type-coercion
.....................

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_cast
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_rvalue *rvalue, gcc_jit_type *type)
     Given an rvalue of T, construct another rvalue of another type.

     Currently only a limited set of conversions are possible:

             * int <-> float

             * int <-> bool

             * P*  <-> Q*, for pointer types P and Q

 -- C Function: gcc_jit_rvalue * gcc_jit_context_new_bitcast
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_rvalue *rvalue, gcc_jit_type *type)
     Given an rvalue of T, bitcast it to another type, meaning that
     this will generate a new rvalue by interpreting the bits of
     `rvalue' to the layout of `type'.

     The type of rvalue must be the same size as the size of `type'.

     This entrypoint was added in *Note LIBGCCJIT_ABI_21: e1.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_bitcast


File: libgccjit.info,  Node: Lvalues,  Next: Working with pointers structs and unions,  Prev: Rvalues,  Up: Expressions

2.4.2 Lvalues
-------------

 -- C Type: gcc_jit_lvalue

An lvalue is something that can of the `left'-hand side of an
assignment: a storage area (such as a variable).  It is also usable as
an rvalue, where the rvalue is computed by reading from the storage
area.

 -- C Function: gcc_jit_object * gcc_jit_lvalue_as_object
          (gcc_jit_lvalue *lvalue)
     Upcast an lvalue to be an object.

 -- C Function: gcc_jit_rvalue * gcc_jit_lvalue_as_rvalue
          (gcc_jit_lvalue *lvalue)
     Upcast an lvalue to be an rvalue.

 -- C Function: gcc_jit_rvalue * gcc_jit_lvalue_get_address
          (gcc_jit_lvalue *lvalue, gcc_jit_location *loc)
     Take the address of an lvalue; analogous to:

         &(EXPR)

     in C.

 -- C Function: void gcc_jit_lvalue_set_tls_model
          (gcc_jit_lvalue *lvalue, enum gcc_jit_tls_model model)
     Make a variable a thread-local variable.

     The “model” parameter determines the thread-local storage
     model of the “lvalue”:

      -- C Type: enum gcc_jit_tls_model

      -- C Macro: GCC_JIT_TLS_MODEL_NONE
          Don’t set the TLS model.

      -- C Macro: GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC

      -- C Macro: GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC

      -- C Macro: GCC_JIT_TLS_MODEL_INITIAL_EXEC

      -- C Macro: GCC_JIT_TLS_MODEL_LOCAL_EXEC

     This is analogous to:

         _Thread_local int foo __attribute__ ((tls_model("MODEL")));

     in C.

     This entrypoint was added in *Note LIBGCCJIT_ABI_17: ed.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model

 -- C Function: void gcc_jit_lvalue_set_link_section
          (gcc_jit_lvalue *lvalue, const char *section_name)
     Set the link section of a variable.  The parameter `section_name'
     must be non-NULL and must contain the leading dot. Analogous to:

         int variable __attribute__((section(".section")));

     in C.

     This entrypoint was added in *Note LIBGCCJIT_ABI_18: ef.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section

 -- C Function: void gcc_jit_lvalue_set_register_name (gcc_jit_lvalue
          *lvalue, const char *reg_name);
     Set the register name of a variable.  The parameter `reg_name'
     must be non-NULL. Analogous to:

         register int variable asm ("r12");

     in C.

     This entrypoint was added in *Note LIBGCCJIT_ABI_22: f0.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_register_name

 -- C Function: void gcc_jit_lvalue_set_alignment
          (gcc_jit_lvalue *lvalue, unsigned bytes)
     Set the alignment of a variable, in bytes.  Analogous to:

         int variable __attribute__((aligned (16)));

     in C.

     This entrypoint was added in *Note LIBGCCJIT_ABI_24: f2.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_ALIGNMENT

 -- C Function: unsigned gcc_jit_lvalue_get_alignment
          (gcc_jit_lvalue *lvalue)
     Return the alignment of a variable set by
     `gcc_jit_lvalue_set_alignment'.  Return 0 if the alignment was not
     set. Analogous to:

         _Alignof (variable)

     in C.

     This entrypoint was added in *Note LIBGCCJIT_ABI_24: f2.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_ALIGNMENT

* Menu:

* Global variables::


File: libgccjit.info,  Node: Global variables,  Up: Lvalues

2.4.2.1 Global variables
........................

 -- C Function: gcc_jit_lvalue * gcc_jit_context_new_global
          (gcc_jit_context *ctxt, gcc_jit_location *loc, enum
          gcc_jit_global_kind kind, gcc_jit_type *type, const
          char *name)
     Add a new global variable of the given type and name to the
     context.

     The parameter `type' must be non-`void'.

     The parameter `name' must be non-NULL.  The call takes a copy of
     the underlying string, so it is valid to pass in a pointer to an
     on-stack buffer.

     The “kind” parameter determines the visibility of the
     “global” outside of the *Note gcc_jit_result: 16.:

      -- C Type: enum gcc_jit_global_kind

      -- C Macro: GCC_JIT_GLOBAL_EXPORTED
          Global is defined by the client code and is visible by name
          outside of this JIT context via *Note
          gcc_jit_result_get_global(): f8. (and this value is required
          for the global to be accessible via that entrypoint).

      -- C Macro: GCC_JIT_GLOBAL_INTERNAL
          Global is defined by the client code, but is invisible
          outside of it.  Analogous to a “static” global within a
          .c file.  Specifically, the variable will only be visible
          within this context and within child contexts.

      -- C Macro: GCC_JIT_GLOBAL_IMPORTED
          Global is not defined by the client code; we’re merely
          referring to it.  Analogous to using an “extern” global
          from a header file.

 -- C Function: gcc_jit_lvalue * gcc_jit_global_set_initializer
          (gcc_jit_lvalue *global, const void *blob, size_t num_bytes)
     Set an initializer for `global' using the memory content pointed
     by `blob' for `num_bytes'.  `global' must be an array of an
     integral type.  Return the global itself.

     The parameter `blob' must be non-NULL. The call copies the memory
     pointed by `blob' for `num_bytes' bytes, so it is valid to pass in
     a pointer to an on-stack buffer.  The content will be stored in
     the compilation unit and used as initialization value of the array.

     This entrypoint was added in *Note LIBGCCJIT_ABI_14: fc.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_global_set_initializer

 -- C Function: gcc_jit_lvalue * gcc_jit_global_set_initializer_rvalue
          (gcc_jit_lvalue *global, gcc_jit_rvalue *init_value)
     Set the initial value of a global with an rvalue.

     The rvalue needs to be a constant expression, e.g. no function
     calls.

     The global can’t have the `kind' *Note GCC_JIT_GLOBAL_IMPORTED:
     fa.

     As a non-comprehensive example it is OK to do the equivalent of:

         int foo = 3 * 2; /* rvalue from gcc_jit_context_new_binary_op.  */
         int arr[] = {1,2,3,4}; /* rvalue from gcc_jit_context_new_constructor.  */
         int *bar = &arr[2] + 1; /* rvalue from nested "get address" of "array access".  */
         const int baz = 3; /* rvalue from gcc_jit_context_rvalue_from_int.  */
         int boz = baz; /* rvalue from gcc_jit_lvalue_as_rvalue.  */

     Use together with *Note gcc_jit_context_new_struct_constructor():
     ba, *Note gcc_jit_context_new_union_constructor(): bb, *Note
     gcc_jit_context_new_array_constructor(): b9.  to initialize
     structs, unions and arrays.

     On success, returns the `global' parameter unchanged. Otherwise,
     `NULL'.

     This entrypoint was added in *Note LIBGCCJIT_ABI_19: b8.; you can
     test for its presence using:

         #ifdef LIBGCCJIT_HAVE_CTORS


File: libgccjit.info,  Node: Working with pointers structs and unions,  Prev: Lvalues,  Up: Expressions

2.4.3 Working with pointers, structs and unions
-----------------------------------------------

 -- C Function: gcc_jit_lvalue * gcc_jit_rvalue_dereference
          (gcc_jit_rvalue *rvalue, gcc_jit_location *loc)
     Given an rvalue of pointer type `T *', dereferencing the pointer,
     getting an lvalue of type `T'.  Analogous to:

         *(EXPR)

     in C.

Field access is provided separately for both lvalues and rvalues.

 -- C Function: gcc_jit_lvalue * gcc_jit_lvalue_access_field
          (gcc_jit_lvalue *struct_, gcc_jit_location *loc,
          gcc_jit_field *field)
     Given an lvalue of struct or union type, access the given field,
     getting an lvalue of the field’s type.  Analogous to:

         (EXPR).field = ...;

     in C.

 -- C Function: gcc_jit_rvalue * gcc_jit_rvalue_access_field
          (gcc_jit_rvalue *struct_, gcc_jit_location *loc,
          gcc_jit_field *field)
     Given an rvalue of struct or union type, access the given field as
     an rvalue.  Analogous to:

         (EXPR).field

     in C.

 -- C Function: gcc_jit_lvalue * gcc_jit_rvalue_dereference_field
          (gcc_jit_rvalue *ptr, gcc_jit_location *loc,
          gcc_jit_field *field)
     Given an rvalue of pointer type `T *' where T is of struct or union
     type, access the given field as an lvalue.  Analogous to:

         (EXPR)->field

     in C, itself equivalent to `(*EXPR).FIELD'.

 -- C Function: gcc_jit_lvalue * gcc_jit_context_new_array_access
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_rvalue *ptr, gcc_jit_rvalue *index)
     Given an rvalue of pointer type `T *', get at the element `T' at
     the given index, using standard C array indexing rules i.e. each
     increment of `index' corresponds to `sizeof(T)' bytes.  Analogous
     to:

         PTR[INDEX]

     in C (or, indeed, to `PTR + INDEX').


File: libgccjit.info,  Node: Creating and using functions,  Next: Function pointers<2>,  Prev: Expressions,  Up: Topic Reference

2.5 Creating and using functions
================================

* Menu:

* Params::
* Functions::
* Blocks::
* Statements::


File: libgccjit.info,  Node: Params,  Next: Functions,  Up: Creating and using functions

2.5.1 Params
------------

 -- C Type: gcc_jit_param
     A `gcc_jit_param' represents a parameter to a function.

 -- C Function: gcc_jit_param * gcc_jit_context_new_param
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_type *type, const char *name)
     In preparation for creating a function, create a new parameter of
     the given type and name.

     The parameter `type' must be non-`void'.

     The parameter `name' must be non-NULL.  The call takes a copy of
     the underlying string, so it is valid to pass in a pointer to an
     on-stack buffer.

Parameters are lvalues, and thus are also rvalues (and objects), so the
following upcasts are available:

 -- C Function: gcc_jit_lvalue * gcc_jit_param_as_lvalue
          (gcc_jit_param *param)
     Upcasting from param to lvalue.

 -- C Function: gcc_jit_rvalue * gcc_jit_param_as_rvalue
          (gcc_jit_param *param)
     Upcasting from param to rvalue.

 -- C Function: gcc_jit_object * gcc_jit_param_as_object
          (gcc_jit_param *param)
     Upcasting from param to object.


File: libgccjit.info,  Node: Functions,  Next: Blocks,  Prev: Params,  Up: Creating and using functions

2.5.2 Functions
---------------

 -- C Type: gcc_jit_function
     A `gcc_jit_function' represents a function - either one that
     we’re creating ourselves, or one that we’re referencing.

 -- C Function: gcc_jit_function * gcc_jit_context_new_function
          (gcc_jit_context *ctxt, gcc_jit_location *loc, enum
          gcc_jit_function_kind kind, gcc_jit_type *return_type, const
          char *name, int num_params, gcc_jit_param **params,
          int is_variadic)
     Create a gcc_jit_function with the given name and parameters.

      -- C Type: enum gcc_jit_function_kind

     This enum controls the kind of function created, and has the
     following values:

           -- C Macro: GCC_JIT_FUNCTION_EXPORTED
               Function is defined by the client code and visible by
               name outside of the JIT.

               This value is required if you want to extract machine
               code for this function from a *Note gcc_jit_result: 16.
               via *Note gcc_jit_result_get_code(): 17.

           -- C Macro: GCC_JIT_FUNCTION_INTERNAL
               Function is defined by the client code, but is invisible
               outside of the JIT.  Analogous to a “static”
               function.

           -- C Macro: GCC_JIT_FUNCTION_IMPORTED
               Function is not defined by the client code; we’re
               merely referring to it.  Analogous to using an
               “extern” function from a header file.

           -- C Macro: GCC_JIT_FUNCTION_ALWAYS_INLINE
               Function is only ever inlined into other functions, and
               is invisible outside of the JIT.

               Analogous to prefixing with `inline' and adding
               `__attribute__((always_inline))'

               Inlining will only occur when the optimization level is
               above 0; when optimization is off, this is essentially
               the same as GCC_JIT_FUNCTION_INTERNAL.

     The parameter `name' must be non-NULL.  The call takes a copy of
     the underlying string, so it is valid to pass in a pointer to an
     on-stack buffer.

 -- C Function: gcc_jit_function * gcc_jit_context_get_builtin_function
          (gcc_jit_context *ctxt, const char *name)
     Get the *Note gcc_jit_function: 29. for the built-in function with
     the given name.  For example:

         gcc_jit_function *fn
           = gcc_jit_context_get_builtin_function (ctxt, "__builtin_memcpy");

          Note: Due to technical limitations with how libgccjit
          interacts with the insides of GCC, not all built-in functions
          are supported.  More precisely, not all types are supported
          for parameters of built-in functions from libgccjit.
          Attempts to get a built-in function that uses such a
          parameter will lead to an error being emitted within the
          context.

 -- C Function: gcc_jit_object * gcc_jit_function_as_object
          (gcc_jit_function *func)
     Upcasting from function to object.

 -- C Function: gcc_jit_param * gcc_jit_function_get_param
          (gcc_jit_function *func, int index)
     Get the param of the given index (0-based).

 -- C Function: void gcc_jit_function_dump_to_dot
          (gcc_jit_function *func, const char *path)
     Emit the function in graphviz format to the given path.

 -- C Function: gcc_jit_lvalue * gcc_jit_function_new_local
          (gcc_jit_function *func, gcc_jit_location *loc,
          gcc_jit_type *type, const char *name)
     Create a new local variable within the function, of the given type
     and name.

     The parameter `type' must be non-`void'.

     The parameter `name' must be non-NULL.  The call takes a copy of
     the underlying string, so it is valid to pass in a pointer to an
     on-stack buffer.

 -- C Function: size_t gcc_jit_function_get_param_count
          (gcc_jit_function *func)
     Get the number of parameters of the function.

 -- C Function: gcc_jit_type * gcc_jit_function_get_return_type
          (gcc_jit_function *func)
     Get the return type of the function.

     The API entrypoints relating to getting info about parameters and
     return types:

             * *Note gcc_jit_function_get_return_type(): 112.

             * *Note gcc_jit_function_get_param_count(): 111.

     were added in *Note LIBGCCJIT_ABI_16: a8.; you can test for their
     presence using

         #ifdef LIBGCCJIT_HAVE_REFLECTION

      -- C Type: gcc_jit_case


File: libgccjit.info,  Node: Blocks,  Next: Statements,  Prev: Functions,  Up: Creating and using functions

2.5.3 Blocks
------------

 -- C Type: gcc_jit_block
     A `gcc_jit_block' represents a basic block within a function  i.e.
     a sequence of statements with a single entry point and a single
     exit point.

     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, a return, or a
     switch.

     It’s legal to have multiple basic blocks that return within one
     function.

 -- C Function: gcc_jit_block * gcc_jit_function_new_block
          (gcc_jit_function *func, const char *name)
     Create a basic block of the given name.  The name may be NULL, but
     providing meaningful names is often helpful when debugging: it may
     show up in dumps of the internal representation, and in error
     messages.  It is copied, so the input buffer does not need to
     outlive the call; you can pass in a pointer to an on-stack buffer,
     e.g.:

         for (pc = 0; pc < fn->fn_num_ops; pc++)
          {
            char buf[16];
            sprintf (buf, "instr%i", pc);
            state.op_blocks[pc] = gcc_jit_function_new_block (state.fn, buf);
          }

 -- C Function: gcc_jit_object * gcc_jit_block_as_object
          (gcc_jit_block *block)
     Upcast from block to object.

 -- C Function: gcc_jit_function * gcc_jit_block_get_function
          (gcc_jit_block *block)
     Which function is this block within?


File: libgccjit.info,  Node: Statements,  Prev: Blocks,  Up: Creating and using functions

2.5.4 Statements
----------------

 -- C Function: void gcc_jit_block_add_eval (gcc_jit_block *block,
          gcc_jit_location *loc, gcc_jit_rvalue *rvalue)
     Add evaluation of an rvalue, discarding the result (e.g. a
     function call that “returns” void).

     This is equivalent to this C code:

         (void)expression;

 -- C Function: void gcc_jit_block_add_assignment
          (gcc_jit_block *block, gcc_jit_location *loc,
          gcc_jit_lvalue *lvalue, gcc_jit_rvalue *rvalue)
     Add evaluation of an rvalue, assigning the result to the given
     lvalue.

     This is roughly equivalent to this C code:

         lvalue = rvalue;

 -- C Function: void gcc_jit_block_add_assignment_op
          (gcc_jit_block *block, gcc_jit_location *loc,
          gcc_jit_lvalue *lvalue, enum gcc_jit_binary_op op,
          gcc_jit_rvalue *rvalue)
     Add evaluation of an rvalue, using the result to modify an lvalue.

     This is analogous to “+=” and friends:

         lvalue += rvalue;
         lvalue *= rvalue;
         lvalue /= rvalue;

     etc.  For example:

         /* "i++" */
         gcc_jit_block_add_assignment_op (
           loop_body, NULL,
           i,
           GCC_JIT_BINARY_OP_PLUS,
           gcc_jit_context_one (ctxt, int_type));

 -- C Function: void gcc_jit_block_add_comment (gcc_jit_block *block,
          gcc_jit_location *loc, const char *text)
     Add a no-op textual comment to the internal representation of the
     code.  It will be optimized away, but will be visible in the dumps
     seen via *Note GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE: 66.  and
     *Note GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE: 1c, and thus may be
     of use when debugging how your project’s internal representation
     gets converted to the libgccjit IR.

     The parameter `text' must be non-NULL.  It is copied, so the input
     buffer does not need to outlive the call.  For example:

         char buf[100];
         snprintf (buf, sizeof (buf),
                   "op%i: %s",
                   pc, opcode_names[op->op_opcode]);
         gcc_jit_block_add_comment (block, loc, buf);

 -- C Function: void gcc_jit_block_end_with_conditional
          (gcc_jit_block *block, gcc_jit_location *loc,
          gcc_jit_rvalue *boolval, gcc_jit_block *on_true,
          gcc_jit_block *on_false)
     Terminate a block by adding evaluation of an rvalue, branching on
     the result to the appropriate successor block.

     This is roughly equivalent to this C code:

         if (boolval)
           goto on_true;
         else
           goto on_false;

     block, boolval, on_true, and on_false must be non-NULL.

 -- C Function: void gcc_jit_block_end_with_jump (gcc_jit_block *block,
          gcc_jit_location *loc, gcc_jit_block *target)
     Terminate a block by adding a jump to the given target block.

     This is roughly equivalent to this C code:

         goto target;

 -- C Function: void gcc_jit_block_end_with_return
          (gcc_jit_block *block, gcc_jit_location *loc,
          gcc_jit_rvalue *rvalue)
     Terminate a block by adding evaluation of an rvalue, returning the
     value.

     This is roughly equivalent to this C code:

         return expression;

 -- C Function: void gcc_jit_block_end_with_void_return
          (gcc_jit_block *block, gcc_jit_location *loc)
     Terminate a block by adding a valueless return, for use within a
     function with “void” return type.

     This is equivalent to this C code:

         return;

 -- C Function: void gcc_jit_block_end_with_switch
          (gcc_jit_block *block, gcc_jit_location *loc,
          gcc_jit_rvalue *expr, gcc_jit_block *default_block,
          int num_cases, gcc_jit_case **cases)
     Terminate a block by adding evalation of an rvalue, then performing
     a multiway branch.

     This is roughly equivalent to this C code:

         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;
         }

     `block', `expr', `default_block' and `cases' must all be non-NULL.

     `expr' must be of the same integer type as all of the `min_value'
     and `max_value' within the cases.

     `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:

             * *Note gcc_jit_block_end_with_switch(): 11c.

             * *Note gcc_jit_case_as_object(): 11d.

             * *Note gcc_jit_context_new_case(): 11e.

     were added in *Note LIBGCCJIT_ABI_3: 11f.; you can test for their
     presence using

         #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS

      -- C Type: gcc_jit_case

     A `gcc_jit_case' represents a case within a switch statement, and
     is created within a particular *Note gcc_jit_context: 8. using
     *Note gcc_jit_context_new_case(): 11e.

     Each case expresses a multivalued range of integer values.  You
     can express single-valued cases by passing in the same value for
     both `min_value' and `max_value'.

      -- C Function: gcc_jit_case * gcc_jit_context_new_case
               (gcc_jit_context *ctxt, gcc_jit_rvalue *min_value,
               gcc_jit_rvalue *max_value, gcc_jit_block *dest_block)
          Create a new gcc_jit_case instance for use in a switch
          statement.  `min_value' and `max_value' must be constants of
          an integer type, which must match that of the expression of
          the switch statement.

          `dest_block' must be within the same function as the switch
          statement.

      -- C Function: gcc_jit_object * gcc_jit_case_as_object
               (gcc_jit_case *case_)
          Upcast from a case to an object.

     Here’s an example of creating a switch statement:


              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));
              }

See also *Note gcc_jit_extended_asm: 120. for entrypoints for adding
inline assembler statements to a function.


File: libgccjit.info,  Node: Function pointers<2>,  Next: Source Locations,  Prev: Creating and using functions,  Up: Topic Reference

2.6 Function pointers
=====================

You can generate calls that use a function pointer via *Note
gcc_jit_context_new_call_through_ptr(): d9.

To do requires a *Note gcc_jit_rvalue: 13. of the correct function
pointer type.

Function pointers for a *Note gcc_jit_function: 29. can be obtained via
*Note gcc_jit_function_get_address(): dd.

 -- C Function: gcc_jit_rvalue * gcc_jit_function_get_address
          (gcc_jit_function *fn, gcc_jit_location *loc)
     Get the address of a function as an rvalue, of function pointer
     type.

     This entrypoint was added in *Note LIBGCCJIT_ABI_9: 123.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_function_get_address

Alternatively, given an existing function, you can obtain a pointer to
it in *Note gcc_jit_rvalue: 13. form using *Note
gcc_jit_context_new_rvalue_from_ptr(): b3, using a function pointer
type obtained using *Note gcc_jit_context_new_function_ptr_type(): 97.

Here’s an example of creating a function pointer type corresponding
to C’s `void (*) (int, int, int)':

    gcc_jit_type *void_type =
      gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
    gcc_jit_type *int_type =
      gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);

    /* Build the function ptr type.  */
    gcc_jit_type *param_types[3];
    param_types[0] = int_type;
    param_types[1] = int_type;
    param_types[2] = int_type;

    gcc_jit_type *fn_ptr_type =
      gcc_jit_context_new_function_ptr_type (ctxt, NULL,
                                             void_type,
                                             3, param_types, 0);

 -- C Function: gcc_jit_type * gcc_jit_context_new_function_ptr_type
          (gcc_jit_context *ctxt, gcc_jit_location *loc,
          gcc_jit_type *return_type, int num_params,
          gcc_jit_type **param_types, int is_variadic)
     Generate a *Note gcc_jit_type: a. for a function pointer with the
     given return type and parameters.

     Each of `param_types' must be non-`void'; `return_type' may be
     `void'.


File: libgccjit.info,  Node: Source Locations,  Next: Compiling a context,  Prev: Function pointers<2>,  Up: Topic Reference

2.7 Source Locations
====================

 -- C Type: gcc_jit_location
     A `gcc_jit_location' encapsulates a source code location, so that
     you can (optionally) associate locations in your language with
     statements in the JIT-compiled code, allowing the debugger to
     single-step through your language.

     `gcc_jit_location' instances are optional: you can always pass
     NULL to any API entrypoint accepting one.

     You can construct them using *Note gcc_jit_context_new_location():
     41.

     You need to enable *Note GCC_JIT_BOOL_OPTION_DEBUGINFO: 42. on the
     *Note gcc_jit_context: 8. for these locations to actually be
     usable by the debugger:

         gcc_jit_context_set_bool_option (
           ctxt,
           GCC_JIT_BOOL_OPTION_DEBUGINFO,
           1);

 -- C Function: gcc_jit_location * gcc_jit_context_new_location
          (gcc_jit_context *ctxt, const char *filename, int line,
          int column)
     Create a `gcc_jit_location' instance representing the given source
     location.

     The parameter `filename' must be non-NULL.  The call takes a copy
     of the underlying string, so it is valid to pass in a pointer to an
     on-stack buffer.

* Menu:

* Faking it::


File: libgccjit.info,  Node: Faking it,  Up: Source Locations

2.7.1 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 *Note gcc_jit_context_dump_to_file():
5a.:

    gcc_jit_context_dump_to_file (ctxt, "/tmp/something.c",
                                  1 /* update_locations */);

This will dump C-like code to the given path.  If the `update_locations'
argument is true, this will also set up `gcc_jit_location' information
throughout the context, pointing at the dump file as if it were a source
file, giving you `something' you can step through in the debugger.


File: libgccjit.info,  Node: Compiling a context,  Next: ABI and API compatibility,  Prev: Source Locations,  Up: Topic Reference

2.8 Compiling a context
=======================

Once populated, a *Note gcc_jit_context *: 8. can be compiled to
machine code, either in-memory via *Note gcc_jit_context_compile(): 15.
or to disk via *Note gcc_jit_context_compile_to_file(): 4a.

You can compile a context multiple times (using either form of
compilation), although any errors that occur on the context will
prevent any future compilation of that context.

* Menu:

* In-memory compilation::
* Ahead-of-time compilation::


File: libgccjit.info,  Node: In-memory compilation,  Next: Ahead-of-time compilation,  Up: Compiling a context

2.8.1 In-memory compilation
---------------------------

 -- C Function: gcc_jit_result * gcc_jit_context_compile
          (gcc_jit_context *ctxt)
     This calls into GCC and builds the code, returning a
     `gcc_jit_result *'.

     If the result is non-NULL, the caller becomes responsible for
     calling *Note gcc_jit_result_release(): 39. on it once they’re
     done with it.

 -- C Type: gcc_jit_result
     A `gcc_jit_result' encapsulates the result of compiling a context
     in-memory, and the lifetimes of any machine code functions or
     globals that are within the result.

 -- C Function: void * gcc_jit_result_get_code (gcc_jit_result *result,
          const char *funcname)
     Locate a given function within the built machine code.

     Functions are looked up by name.  For this to succeed, a function
     with a name matching `funcname' must have been created on
     `result'’s context (or a parent context) via a call to *Note
     gcc_jit_context_new_function(): 11. with `kind' *Note
     GCC_JIT_FUNCTION_EXPORTED: 10a.:

         gcc_jit_context_new_function (ctxt,
                                       any_location, /* or NULL */
                                       /* Required for func to be visible to
                                          gcc_jit_result_get_code: */
                                       GCC_JIT_FUNCTION_EXPORTED,
                                       any_return_type,
                                       /* Must string-compare equal: */
                                       funcname,
                                       /* etc */);

     If such a function is not found (or `result' or `funcname' are
     `NULL'), an error message will be emitted on stderr and `NULL'
     will be returned.

     If the function is found, the result will need to be cast to a
     function pointer of the correct type before it can be called.

     Note that the resulting machine code becomes invalid after *Note
     gcc_jit_result_release(): 39. is called on the *Note
     gcc_jit_result *: 16.; attempting to call it after that may lead
     to a segmentation fault.

 -- C Function: void * gcc_jit_result_get_global
          (gcc_jit_result *result, const char *name)
     Locate a given global within the built machine code.

     Globals are looked up by name.  For this to succeed, a global with
     a name matching `name' must have been created on `result'’s
     context (or a parent context) via a call to *Note
     gcc_jit_context_new_global(): f5. with `kind' *Note
     GCC_JIT_GLOBAL_EXPORTED: f7.

     If the global is found, the result will need to be cast to a
     pointer of the correct type before it can be called.

     This is a `pointer' to the global, so e.g. for an `int' this is an
     `int *'.

     For example, given an `int foo;' created this way:

         gcc_jit_lvalue *exported_global =
           gcc_jit_context_new_global (ctxt,
           any_location, /* or NULL */
           GCC_JIT_GLOBAL_EXPORTED,
           int_type,
           "foo");

     we can access it like this:

         int *ptr_to_foo =
           (int *)gcc_jit_result_get_global (result, "foo");

     If such a global is not found (or `result' or `name' are `NULL'),
     an error message will be emitted on stderr and `NULL' will be
     returned.

     Note that the resulting address becomes invalid after *Note
     gcc_jit_result_release(): 39. is called on the *Note
     gcc_jit_result *: 16.; attempting to use it after that may lead to
     a segmentation fault.

 -- C Function: void gcc_jit_result_release (gcc_jit_result *result)
     Once we’re done with the code, this unloads the built .so file.
     This cleans up the result; after calling this, it’s no longer
     valid to use the result, or any code or globals that were obtained
     by calling *Note gcc_jit_result_get_code(): 17. or *Note
     gcc_jit_result_get_global(): f8. on it.


File: libgccjit.info,  Node: Ahead-of-time compilation,  Prev: In-memory compilation,  Up: Compiling a context

2.8.2 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 *Note gcc_jit_context_compile_to_file(): 4a.  API
entrypoint.

For linking in object files, use *Note
gcc_jit_context_add_driver_option(): 76.

 -- C Function: void gcc_jit_context_compile_to_file
          (gcc_jit_context *ctxt, enum gcc_jit_output_kind output_kind,
          const char *output_path)
     Compile the *Note gcc_jit_context *: 8. to a file of the given
     kind.

*Note gcc_jit_context_compile_to_file(): 4a. ignores the suffix of
`output_path', and insteads uses the given `enum gcc_jit_output_kind'
to decide what to do.

     Note: This is different from the `gcc' program, which does make
     use of the suffix of the output file when determining what to do.

 -- C Type: enum gcc_jit_output_kind

The available kinds of output are:

Output kind                                        Typical suffix
---------------------------------------------------------------------- 
*Note GCC_JIT_OUTPUT_KIND_ASSEMBLER: 12c.          .s
*Note GCC_JIT_OUTPUT_KIND_OBJECT_FILE: 12d.        .o
*Note GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY: 12e.    .so or .dll
*Note GCC_JIT_OUTPUT_KIND_EXECUTABLE: 12f.         None, or .exe

 -- C Macro: GCC_JIT_OUTPUT_KIND_ASSEMBLER
     Compile the context to an assembler file.

 -- C Macro: GCC_JIT_OUTPUT_KIND_OBJECT_FILE
     Compile the context to an object file.

 -- C Macro: GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY
     Compile the context to a dynamic library.

 -- C Macro: GCC_JIT_OUTPUT_KIND_EXECUTABLE
     Compile the context to an executable.


File: libgccjit.info,  Node: ABI and API compatibility,  Next: Performance,  Prev: Compiling a context,  Up: Topic Reference

2.9 ABI and API compatibility
=============================

The libgccjit developers strive for ABI and API backward-compatibility:
programs built against libgccjit.so stand a good chance of running
without recompilation against newer versions of libgccjit.so, and ought
to recompile without modification against newer versions of libgccjit.h.

     Note: The libgccjit++.h C++ API is more experimental, and less
     locked-down at this time.

API compatibility is achieved by extending the API rather than changing
it.  For ABI compatiblity, we avoid bumping the SONAME, and instead use
symbol versioning to tag each symbol, so that a binary linked against
libgccjit.so is tagged according to the symbols that it uses.

For example, *Note gcc_jit_context_add_command_line_option(): 74. was
added in `LIBGCCJIT_ABI_1'.  If a client program uses it, this can be
detected from metadata by using `objdump':

    $ objdump -p testsuite/jit/test-extra-options.c.exe | tail -n 8

    Version References:
      required from libgccjit.so.0:
        0x00824161 0x00 04 LIBGCCJIT_ABI_1
        0x00824160 0x00 03 LIBGCCJIT_ABI_0
      required from libc.so.6:

You can see the symbol tags provided by libgccjit.so using `objdump':

    $ objdump -p libgccjit.so | less
    [...snip...]
    Version definitions:
    1 0x01 0x0ff81f20 libgccjit.so.0
    2 0x00 0x00824160 LIBGCCJIT_ABI_0
    3 0x00 0x00824161 LIBGCCJIT_ABI_1
            LIBGCCJIT_ABI_0
    [...snip...]

* Menu:

* Programmatically checking version::
* ABI symbol tags::


File: libgccjit.info,  Node: Programmatically checking version,  Next: ABI symbol tags,  Up: ABI and API compatibility

2.9.1 Programmatically checking version
---------------------------------------

Client code can programmatically check libgccjit version using:

 -- C Function: int gcc_jit_version_major (void)
     Return libgccjit major version.  This is analogous to __GNUC__ in
     C code.

 -- C Function: int gcc_jit_version_minor (void)
     Return libgccjit minor version.  This is analogous to
     __GNUC_MINOR__ in C code.

 -- C Function: int gcc_jit_version_patchlevel (void)
     Return libgccjit patchlevel version.  This is analogous to
     __GNUC_PATCHLEVEL__ in C code.

     Note: These entry points has been added with `LIBGCCJIT_ABI_13'
     (see below).


File: libgccjit.info,  Node: ABI symbol tags,  Prev: Programmatically checking version,  Up: ABI and API compatibility

2.9.2 ABI symbol tags
---------------------

The initial release of libgccjit (in gcc 5.1) did not use symbol
versioning.

Newer releases use the following tags.

* Menu:

* LIBGCCJIT_ABI_0::
* LIBGCCJIT_ABI_1::
* LIBGCCJIT_ABI_2::
* LIBGCCJIT_ABI_3::
* LIBGCCJIT_ABI_4::
* LIBGCCJIT_ABI_5::
* LIBGCCJIT_ABI_6::
* LIBGCCJIT_ABI_7::
* LIBGCCJIT_ABI_8::
* LIBGCCJIT_ABI_9::
* LIBGCCJIT_ABI_10::
* LIBGCCJIT_ABI_11::
* LIBGCCJIT_ABI_12::
* LIBGCCJIT_ABI_13::
* LIBGCCJIT_ABI_14::
* LIBGCCJIT_ABI_15::
* LIBGCCJIT_ABI_16::
* LIBGCCJIT_ABI_17::
* LIBGCCJIT_ABI_18::
* LIBGCCJIT_ABI_19::
* LIBGCCJIT_ABI_20::
* LIBGCCJIT_ABI_21::
* LIBGCCJIT_ABI_22::
* LIBGCCJIT_ABI_23::
* LIBGCCJIT_ABI_24::


File: libgccjit.info,  Node: LIBGCCJIT_ABI_0,  Next: LIBGCCJIT_ABI_1,  Up: ABI symbol tags

2.9.2.1 `LIBGCCJIT_ABI_0'
.........................

All entrypoints in the initial release of libgccjit are tagged with
`LIBGCCJIT_ABI_0', to signify the transition to symbol versioning.

Binaries built against older copies of `libgccjit.so' should continue
to work, with this being handled transparently by the linker (see this
post(1))

---------- Footnotes ----------

(1) https://gcc.gnu.org/ml/gcc-patches/2015-06/msg02126.html


File: libgccjit.info,  Node: LIBGCCJIT_ABI_1,  Next: LIBGCCJIT_ABI_2,  Prev: LIBGCCJIT_ABI_0,  Up: ABI symbol tags

2.9.2.2 `LIBGCCJIT_ABI_1'
.........................

`LIBGCCJIT_ABI_1' covers the addition of *Note
gcc_jit_context_add_command_line_option(): 74.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_2,  Next: LIBGCCJIT_ABI_3,  Prev: LIBGCCJIT_ABI_1,  Up: ABI symbol tags

2.9.2.3 `LIBGCCJIT_ABI_2'
.........................

`LIBGCCJIT_ABI_2' covers the addition of *Note
gcc_jit_context_set_bool_allow_unreachable_blocks(): 6b.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_3,  Next: LIBGCCJIT_ABI_4,  Prev: LIBGCCJIT_ABI_2,  Up: ABI symbol tags

2.9.2.4 `LIBGCCJIT_ABI_3'
.........................

`LIBGCCJIT_ABI_3' covers the addition of switch statements via API
entrypoints:

        * *Note gcc_jit_block_end_with_switch(): 11c.

        * *Note gcc_jit_case_as_object(): 11d.

        * *Note gcc_jit_context_new_case(): 11e.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_4,  Next: LIBGCCJIT_ABI_5,  Prev: LIBGCCJIT_ABI_3,  Up: ABI symbol tags

2.9.2.5 `LIBGCCJIT_ABI_4'
.........................

`LIBGCCJIT_ABI_4' covers the addition of timers via API entrypoints:

        * *Note gcc_jit_context_get_timer(): 13e.

        * *Note gcc_jit_context_set_timer(): 13f.

        * *Note gcc_jit_timer_new(): 140.

        * *Note gcc_jit_timer_release(): 141.

        * *Note gcc_jit_timer_push(): 142.

        * *Note gcc_jit_timer_pop(): 143.

        * *Note gcc_jit_timer_print(): 144.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_5,  Next: LIBGCCJIT_ABI_6,  Prev: LIBGCCJIT_ABI_4,  Up: ABI symbol tags

2.9.2.6 `LIBGCCJIT_ABI_5'
.........................

`LIBGCCJIT_ABI_5' covers the addition of *Note
gcc_jit_context_set_bool_use_external_driver(): 6d.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_6,  Next: LIBGCCJIT_ABI_7,  Prev: LIBGCCJIT_ABI_5,  Up: ABI symbol tags

2.9.2.7 `LIBGCCJIT_ABI_6'
.........................

`LIBGCCJIT_ABI_6' covers the addition of *Note
gcc_jit_rvalue_set_bool_require_tail_call(): da.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_7,  Next: LIBGCCJIT_ABI_8,  Prev: LIBGCCJIT_ABI_6,  Up: ABI symbol tags

2.9.2.8 `LIBGCCJIT_ABI_7'
.........................

`LIBGCCJIT_ABI_7' covers the addition of *Note
gcc_jit_type_get_aligned(): 84.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_8,  Next: LIBGCCJIT_ABI_9,  Prev: LIBGCCJIT_ABI_7,  Up: ABI symbol tags

2.9.2.9 `LIBGCCJIT_ABI_8'
.........................

`LIBGCCJIT_ABI_8' covers the addition of *Note
gcc_jit_type_get_vector(): 87.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_9,  Next: LIBGCCJIT_ABI_10,  Prev: LIBGCCJIT_ABI_8,  Up: ABI symbol tags

2.9.2.10 `LIBGCCJIT_ABI_9'
..........................

`LIBGCCJIT_ABI_9' covers the addition of *Note
gcc_jit_function_get_address(): dd.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_10,  Next: LIBGCCJIT_ABI_11,  Prev: LIBGCCJIT_ABI_9,  Up: ABI symbol tags

2.9.2.11 `LIBGCCJIT_ABI_10'
...........................

`LIBGCCJIT_ABI_10' covers the addition of *Note
gcc_jit_context_new_rvalue_from_vector(): 89.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_11,  Next: LIBGCCJIT_ABI_12,  Prev: LIBGCCJIT_ABI_10,  Up: ABI symbol tags

2.9.2.12 `LIBGCCJIT_ABI_11'
...........................

`LIBGCCJIT_ABI_11' covers the addition of *Note
gcc_jit_context_add_driver_option(): 76.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_12,  Next: LIBGCCJIT_ABI_13,  Prev: LIBGCCJIT_ABI_11,  Up: ABI symbol tags

2.9.2.13 `LIBGCCJIT_ABI_12'
...........................

`LIBGCCJIT_ABI_12' covers the addition of *Note
gcc_jit_context_new_bitfield(): 8e.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_13,  Next: LIBGCCJIT_ABI_14,  Prev: LIBGCCJIT_ABI_12,  Up: ABI symbol tags

2.9.2.14 `LIBGCCJIT_ABI_13'
...........................

`LIBGCCJIT_ABI_13' covers the addition of version functions via API
entrypoints:

        * *Note gcc_jit_version_major(): 133.

        * *Note gcc_jit_version_minor(): 134.

        * *Note gcc_jit_version_patchlevel(): 135.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_14,  Next: LIBGCCJIT_ABI_15,  Prev: LIBGCCJIT_ABI_13,  Up: ABI symbol tags

2.9.2.15 `LIBGCCJIT_ABI_14'
...........................

`LIBGCCJIT_ABI_14' covers the addition of *Note
gcc_jit_global_set_initializer(): fb.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_15,  Next: LIBGCCJIT_ABI_16,  Prev: LIBGCCJIT_ABI_14,  Up: ABI symbol tags

2.9.2.16 `LIBGCCJIT_ABI_15'
...........................

`LIBGCCJIT_ABI_15' covers the addition of API entrypoints for directly
embedding assembler instructions:

        * *Note gcc_jit_block_add_extended_asm(): 152.

        * *Note gcc_jit_block_end_with_extended_asm_goto(): 153.

        * *Note gcc_jit_extended_asm_as_object(): 154.

        * *Note gcc_jit_extended_asm_set_volatile_flag(): 155.

        * *Note gcc_jit_extended_asm_set_inline_flag(): 156.

        * *Note gcc_jit_extended_asm_add_output_operand(): 157.

        * *Note gcc_jit_extended_asm_add_input_operand(): 158.

        * *Note gcc_jit_extended_asm_add_clobber(): 159.

        * *Note gcc_jit_context_add_top_level_asm(): 15a.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_16,  Next: LIBGCCJIT_ABI_17,  Prev: LIBGCCJIT_ABI_15,  Up: ABI symbol tags

2.9.2.17 `LIBGCCJIT_ABI_16'
...........................

`LIBGCCJIT_ABI_16' covers the addition of reflection functions via API
entrypoints:

        * *Note gcc_jit_function_get_return_type(): 112.

        * *Note gcc_jit_function_get_param_count(): 111.

        * *Note gcc_jit_type_dyncast_array(): 99.

        * *Note gcc_jit_type_is_bool(): 9a.

        * *Note gcc_jit_type_is_integral(): 9f.

        * *Note gcc_jit_type_is_pointer(): a0.

        * *Note gcc_jit_type_is_struct(): a2.

        * *Note gcc_jit_type_dyncast_vector(): a1.

        * *Note gcc_jit_type_unqualified(): a5.

        * *Note gcc_jit_type_dyncast_function_ptr_type(): 9b.

        * *Note gcc_jit_function_type_get_return_type(): 9c.

        * *Note gcc_jit_function_type_get_param_count(): 9d.

        * *Note gcc_jit_function_type_get_param_type(): 9e.

        * *Note gcc_jit_vector_type_get_num_units(): a3.

        * *Note gcc_jit_vector_type_get_element_type(): a4.

        * *Note gcc_jit_struct_get_field(): a6.

        * *Note gcc_jit_struct_get_field_count(): a7.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_17,  Next: LIBGCCJIT_ABI_18,  Prev: LIBGCCJIT_ABI_16,  Up: ABI symbol tags

2.9.2.18 `LIBGCCJIT_ABI_17'
...........................

`LIBGCCJIT_ABI_17' covers the addition of an API entrypoint to set the
thread-local storage model of a variable:

        * *Note gcc_jit_lvalue_set_tls_model(): e6.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_18,  Next: LIBGCCJIT_ABI_19,  Prev: LIBGCCJIT_ABI_17,  Up: ABI symbol tags

2.9.2.19 `LIBGCCJIT_ABI_18'
...........................

`LIBGCCJIT_ABI_18' covers the addition of an API entrypoint to set the
link section of a variable:

        * *Note gcc_jit_lvalue_set_link_section(): ee.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_19,  Next: LIBGCCJIT_ABI_20,  Prev: LIBGCCJIT_ABI_18,  Up: ABI symbol tags

2.9.2.20 `LIBGCCJIT_ABI_19'
...........................

`LIBGCCJIT_ABI_19' covers the addition of API entrypoints to set the
initial value of a global with an rvalue and to use constructors:

        * *Note gcc_jit_context_new_array_constructor(): b9.

        * *Note gcc_jit_context_new_struct_constructor(): ba.

        * *Note gcc_jit_context_new_union_constructor(): bb.

        * *Note gcc_jit_global_set_initializer_rvalue(): b7.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_20,  Next: LIBGCCJIT_ABI_21,  Prev: LIBGCCJIT_ABI_19,  Up: ABI symbol tags

2.9.2.21 `LIBGCCJIT_ABI_20'
...........................

`LIBGCCJIT_ABI_20' covers the addition of sized integer types, including
128-bit integers and helper functions for types:

        * *Note gcc_jit_compatible_types(): aa.

        * *Note gcc_jit_type_get_size(): ac.

        * `GCC_JIT_TYPE_UINT8_T'

        * `GCC_JIT_TYPE_UINT16_T'

        * `GCC_JIT_TYPE_UINT32_T'

        * `GCC_JIT_TYPE_UINT64_T'

        * `GCC_JIT_TYPE_UINT128_T'

        * `GCC_JIT_TYPE_INT8_T'

        * `GCC_JIT_TYPE_INT16_T'

        * `GCC_JIT_TYPE_INT32_T'

        * `GCC_JIT_TYPE_INT64_T'

        * `GCC_JIT_TYPE_INT128_T'


File: libgccjit.info,  Node: LIBGCCJIT_ABI_21,  Next: LIBGCCJIT_ABI_22,  Prev: LIBGCCJIT_ABI_20,  Up: ABI symbol tags

2.9.2.22 `LIBGCCJIT_ABI_21'
...........................

`LIBGCCJIT_ABI_21' covers the addition of an API entrypoint to bitcast a
value from one type to another:

        * *Note gcc_jit_context_new_bitcast(): e0.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_22,  Next: LIBGCCJIT_ABI_23,  Prev: LIBGCCJIT_ABI_21,  Up: ABI symbol tags

2.9.2.23 `LIBGCCJIT_ABI_22'
...........................

`LIBGCCJIT_ABI_22' covers the addition of an API entrypoint to set the
register name of a variable:

        * `gcc_jit_lvalue_set_register_name()'


File: libgccjit.info,  Node: LIBGCCJIT_ABI_23,  Next: LIBGCCJIT_ABI_24,  Prev: LIBGCCJIT_ABI_22,  Up: ABI symbol tags

2.9.2.24 `LIBGCCJIT_ABI_23'
...........................

`LIBGCCJIT_ABI_23' covers the addition of an API entrypoint to hide
stderr logs:

        * *Note gcc_jit_context_set_bool_print_errors_to_stderr(): 6f.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_24,  Prev: LIBGCCJIT_ABI_23,  Up: ABI symbol tags

2.9.2.25 `LIBGCCJIT_ABI_24'
...........................

`LIBGCCJIT_ABI_24' covers the addition of functions to get and set the
alignment of a variable:

        * *Note gcc_jit_lvalue_set_alignment(): f1.

        * *Note gcc_jit_lvalue_get_alignment(): f3.


File: libgccjit.info,  Node: Performance,  Next: Using Assembly Language with libgccjit,  Prev: ABI and API compatibility,  Up: Topic Reference

2.10 Performance
================

* Menu:

* The timing API::


File: libgccjit.info,  Node: The timing API,  Up: Performance

2.10.1 The timing API
---------------------

As of GCC 6, libgccjit exposes a timing API, for printing reports on
how long was spent in different parts of code.

You can create a *Note gcc_jit_timer: 167. instance, which will measure
time spent since its creation.  The timer maintains a stack of “timer
items”: as control flow moves through your code, you can push and pop
named items relating to your code onto the stack, and the timer will
account the time spent accordingly.

You can also asssociate a timer with a *Note gcc_jit_context: 8, in
which case the time spent inside compilation will be subdivided.

For example, the following code uses a timer, recording client items
“create_code”, “compile”, and “running code”:

    /* Create a timer.  */
    gcc_jit_timer *timer = gcc_jit_timer_new ();
    if (!timer)
      {
         error ("gcc_jit_timer_new failed");
         return -1;
      }

    /* Let's repeatedly compile and run some code, accumulating it
       all into the timer.  */
    for (int i = 0; i < num_iterations; i++)
      {
        /* Create a context and associate it with the timer.  */
        gcc_jit_context *ctxt = gcc_jit_context_acquire ();
        if (!ctxt)
          {
            error ("gcc_jit_context_acquire failed");
            return -1;
          }
        gcc_jit_context_set_timer (ctxt, timer);

        /* Populate the context, timing it as client item "create_code".  */
        gcc_jit_timer_push (timer, "create_code");
        create_code (ctxt);
        gcc_jit_timer_pop (timer, "create_code");

        /* Compile the context, timing it as client item "compile".  */
        gcc_jit_timer_push (timer, "compile");
        result = gcc_jit_context_compile (ctxt);
        gcc_jit_timer_pop (timer, "compile");

        /* Run the generated code, timing it as client item "running code".  */
        gcc_jit_timer_push (timer, "running code");
        run_the_code (ctxt, result);
        gcc_jit_timer_pop (timer, "running code");

        /* Clean up.  */
        gcc_jit_context_release (ctxt);
        gcc_jit_result_release (result);
    }

    /* Print the accumulated timings.  */
    gcc_jit_timer_print (timer, stderr);
    gcc_jit_timer_release (timer);

giving output like this, showing the internal GCC items at the top, then
client items, then the total:

    Execution times (seconds)
    GCC items:
     phase setup             :   0.29 (14%) usr   0.00 ( 0%) sys   0.32 ( 5%) wall   10661 kB (50%) ggc
     phase parsing           :   0.02 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall     653 kB ( 3%) ggc
     phase finalize          :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall       0 kB ( 0%) ggc
     dump files              :   0.02 ( 1%) usr   0.00 ( 0%) sys   0.01 ( 0%) wall       0 kB ( 0%) ggc
     callgraph construction  :   0.02 ( 1%) usr   0.01 ( 6%) sys   0.01 ( 0%) wall     242 kB ( 1%) ggc
     callgraph optimization  :   0.03 ( 2%) usr   0.00 ( 0%) sys   0.02 ( 0%) wall     142 kB ( 1%) ggc
     trivially dead code     :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall       0 kB ( 0%) ggc
     df scan insns           :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall       9 kB ( 0%) ggc
     df live regs            :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.01 ( 0%) wall       0 kB ( 0%) ggc
     inline parameters       :   0.02 ( 1%) usr   0.00 ( 0%) sys   0.01 ( 0%) wall      82 kB ( 0%) ggc
     tree CFG cleanup        :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall       0 kB ( 0%) ggc
     tree PHI insertion      :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.02 ( 0%) wall      64 kB ( 0%) ggc
     tree SSA other          :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.01 ( 0%) wall      18 kB ( 0%) ggc
     expand                  :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall     398 kB ( 2%) ggc
     jump                    :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall       0 kB ( 0%) ggc
     loop init               :   0.01 ( 0%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall      67 kB ( 0%) ggc
     integrated RA           :   0.02 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall    2468 kB (12%) ggc
     thread pro- & epilogue  :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall     162 kB ( 1%) ggc
     final                   :   0.01 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall     216 kB ( 1%) ggc
     rest of compilation     :   1.37 (69%) usr   0.00 ( 0%) sys   1.13 (18%) wall    1391 kB ( 6%) ggc
     assemble JIT code       :   0.01 ( 1%) usr   0.00 ( 0%) sys   4.04 (66%) wall       0 kB ( 0%) ggc
     load JIT result         :   0.02 ( 1%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall       0 kB ( 0%) ggc
     JIT client code         :   0.00 ( 0%) usr   0.01 ( 6%) sys   0.00 ( 0%) wall       0 kB ( 0%) ggc
    Client items:
     create_code             :   0.00 ( 0%) usr   0.01 ( 6%) sys   0.00 ( 0%) wall       0 kB ( 0%) ggc
     compile                 :   0.36 (18%) usr   0.15 (83%) sys   0.86 (14%) wall   14939 kB (70%) ggc
     running code            :   0.00 ( 0%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall       0 kB ( 0%) ggc
     TOTAL                   :   2.00             0.18             6.12              21444 kB

The exact format is intended to be human-readable, and is subject to
change.

 -- C Macro: LIBGCCJIT_HAVE_TIMING_API
     The timer API was added to libgccjit in GCC 6.  This macro is only
     defined in versions of libgccjit.h which have the timer API, and
     so can be used to guard code that may need to compile against
     earlier releases:

         #ifdef LIBGCCJIT_HAVE_TIMING_API
         gcc_jit_timer *t = gcc_jit_timer_new ();
         gcc_jit_context_set_timer (ctxt, t);
         #endif

 -- C Type: gcc_jit_timer

 -- C Function: gcc_jit_timer * gcc_jit_timer_new (void)
     Create a *Note gcc_jit_timer: 167. instance, and start timing:

         gcc_jit_timer *t = gcc_jit_timer_new ();

     This API entrypoint was added in *Note LIBGCCJIT_ABI_4: 13d.; you
     can test for its presence using

         #ifdef LIBGCCJIT_HAVE_TIMING_API

 -- C Function: void gcc_jit_timer_release (gcc_jit_timer *timer)
     Release a *Note gcc_jit_timer: 167. instance:

         gcc_jit_timer_release (t);

     This should be called exactly once on a timer.

     This API entrypoint was added in *Note LIBGCCJIT_ABI_4: 13d.; you
     can test for its presence using

         #ifdef LIBGCCJIT_HAVE_TIMING_API

 -- C Function: void gcc_jit_context_set_timer (gcc_jit_context *ctxt,
          gcc_jit_timer *timer)
     Associate a *Note gcc_jit_timer: 167. instance with a context:

         gcc_jit_context_set_timer (ctxt, t);

     A timer instance can be shared between multiple *Note
     gcc_jit_context: 8. instances.

     Timers have no locking, so if you have a multithreaded program, you
     must provide your own locks if more than one thread could be
     working with the same timer via timer-associated contexts.

     This API entrypoint was added in *Note LIBGCCJIT_ABI_4: 13d.; you
     can test for its presence using

         #ifdef LIBGCCJIT_HAVE_TIMING_API

 -- C Function: gcc_jit_timer *gcc_jit_context_get_timer
          (gcc_jit_context *ctxt)
     Get the timer associated with a context (if any).

     This API entrypoint was added in *Note LIBGCCJIT_ABI_4: 13d.; you
     can test for its presence using

         #ifdef LIBGCCJIT_HAVE_TIMING_API

 -- C Function: void gcc_jit_timer_push (gcc_jit_timer *timer, const
          char *item_name)
     Push the given item onto the timer’s stack:

         gcc_jit_timer_push (t, "running code");
         run_the_code (ctxt, result);
         gcc_jit_timer_pop (t, "running code");

     This API entrypoint was added in *Note LIBGCCJIT_ABI_4: 13d.; you
     can test for its presence using

         #ifdef LIBGCCJIT_HAVE_TIMING_API

 -- C Function: void gcc_jit_timer_pop (gcc_jit_timer *timer, const
          char *item_name)
     Pop the top item from the timer’s stack.

     If “item_name” is provided, it must match that of the top item.
     Alternatively, `NULL' can be passed in, to suppress checking.

     This API entrypoint was added in *Note LIBGCCJIT_ABI_4: 13d.; you
     can test for its presence using

         #ifdef LIBGCCJIT_HAVE_TIMING_API

 -- C Function: void gcc_jit_timer_print (gcc_jit_timer *timer,
          FILE *f_out)
     Print timing information to the given stream about activity since
     the timer was started.

     This API entrypoint was added in *Note LIBGCCJIT_ABI_4: 13d.; you
     can test for its presence using

         #ifdef LIBGCCJIT_HAVE_TIMING_API


File: libgccjit.info,  Node: Using Assembly Language with libgccjit,  Prev: Performance,  Up: Topic Reference

2.11 Using Assembly Language with libgccjit
===========================================

libgccjit has some support for directly embedding assembler
instructions.  This is based on GCC’s support for inline `asm' in C
code, and the following assumes a familiarity with that functionality.
See How to Use Inline Assembly Language in C Code(1) in GCC’s
documentation, the “Extended Asm” section in particular.

These entrypoints were added in *Note LIBGCCJIT_ABI_15: 151.; you can
test for their presence using

         #ifdef LIBGCCJIT_HAVE_ASM_STATEMENTS

* Menu:

* Adding assembler instructions within a function::
* Adding top-level assembler statements::

---------- Footnotes ----------

(1)
https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-with-C.html


File: libgccjit.info,  Node: Adding assembler instructions within a function,  Next: Adding top-level assembler statements,  Up: Using Assembly Language with libgccjit

2.11.1 Adding assembler instructions within a function
------------------------------------------------------

 -- C Type: gcc_jit_extended_asm
     A `gcc_jit_extended_asm' represents an extended `asm' statement: a
     series of low-level instructions inside a function that convert
     inputs to outputs.

     To avoid having an API entrypoint with a very large number of
     parameters, an extended `asm' statement is made in stages: an
     initial call to create the *Note gcc_jit_extended_asm: 120,
     followed by calls to add operands and set other properties of the
     statement.

     There are two API entrypoints for creating a *Note
     gcc_jit_extended_asm: 120.:

        * *Note gcc_jit_block_add_extended_asm(): 152. for an `asm'
          statement with no control flow, and

        * *Note gcc_jit_block_end_with_extended_asm_goto(): 153. for an
          `asm goto'.

     For example, to create the equivalent of:

                asm ("mov %1, %0\n\t"
                     "add $1, %0"
                     : "=r" (dst)
                     : "r" (src));

     the following API calls could be used:

           gcc_jit_extended_asm *ext_asm
             = gcc_jit_block_add_extended_asm (block, NULL,
         				      "mov %1, %0\n\t"
         				      "add $1, %0");
           gcc_jit_extended_asm_add_output_operand (ext_asm, NULL, "=r", dst);
           gcc_jit_extended_asm_add_input_operand (ext_asm, NULL, "r",
         					  gcc_jit_lvalue_as_rvalue (src));

          Warning: When considering the numbering of operands within an
          extended `asm' statement (e.g. the `%0' and `%1' above), the
          equivalent to the C syntax is followed i.e. all output
          operands, then all input operands, regardless of what order
          the calls to *Note gcc_jit_extended_asm_add_output_operand():
          157. and *Note gcc_jit_extended_asm_add_input_operand(): 158.
          were made in.

     As in the C syntax, operands can be given symbolic names to avoid
     having to number them.  For example, to create the equivalent of:

                asm ("bsfl %[aMask], %[aIndex]"
                     : [aIndex] "=r" (Index)
                     : [aMask] "r" (Mask)
                     : "cc");

     the following API calls could be used:

           gcc_jit_extended_asm *ext_asm
             = gcc_jit_block_add_extended_asm (block, NULL,
         				      "bsfl %[aMask], %[aIndex]");
           gcc_jit_extended_asm_add_output_operand (ext_asm, "aIndex", "=r", index);
           gcc_jit_extended_asm_add_input_operand (ext_asm, "aMask", "r",
         					  gcc_jit_param_as_rvalue (mask));
           gcc_jit_extended_asm_add_clobber (ext_asm, "cc");

 -- C Function: gcc_jit_extended_asm * gcc_jit_block_add_extended_asm
          (gcc_jit_block *block, gcc_jit_location *loc, const
          char *asm_template)
     Create a *Note gcc_jit_extended_asm: 120. for an extended `asm'
     statement with no control flow (i.e. without the `goto' qualifier).

     The parameter `asm_template' corresponds to the `AssemblerTemplate'
     within C’s extended `asm' syntax.  It must be non-NULL.  The
     call takes a copy of the underlying string, so it is valid to pass
     in a pointer to an on-stack buffer.

 -- C Function: gcc_jit_extended_asm *
          gcc_jit_block_end_with_extended_asm_goto
          (gcc_jit_block *block, gcc_jit_location *loc, const
          char *asm_template, int num_goto_blocks,
          gcc_jit_block **goto_blocks, gcc_jit_block *fallthrough_block)
     Create a *Note gcc_jit_extended_asm: 120. for an extended `asm'
     statement that may perform jumps, and use it to terminate the
     given block.  This is equivalent to the `goto' qualifier in C’s
     extended `asm' syntax.

     For example, to create the equivalent of:

                asm goto ("btl %1, %0\n\t"
                          "jc %l[carry]"
                          : // No outputs
                          : "r" (p1), "r" (p2)
                          : "cc"
                          : carry);

     the following API calls could be used:

           const char *asm_template =
             (use_name
              ? /* Label referred to by name: "%l[carry]".  */
                ("btl %1, %0\n\t"
                 "jc %l[carry]")
              : /* Label referred to numerically: "%l2".  */
                ("btl %1, %0\n\t"
                 "jc %l2"));

           gcc_jit_extended_asm *ext_asm
             = gcc_jit_block_end_with_extended_asm_goto (b_start, NULL,
         						asm_template,
         						1, &b_carry,
         						b_fallthru);
           gcc_jit_extended_asm_add_input_operand (ext_asm, NULL, "r",
         					  gcc_jit_param_as_rvalue (p1));
           gcc_jit_extended_asm_add_input_operand (ext_asm, NULL, "r",
         					  gcc_jit_param_as_rvalue (p2));
           gcc_jit_extended_asm_add_clobber (ext_asm, "cc");

     here referencing a *Note gcc_jit_block: 28. named “carry”.

     `num_goto_blocks' must be >= 0.

     `goto_blocks' must be non-NULL.  This corresponds to the
     `GotoLabels' parameter within C’s extended `asm' syntax.  The
     block names can be referenced within the assembler template.

     `fallthrough_block' can be NULL.  If non-NULL, it specifies the
     block to fall through to after the statement.

          Note: This is needed since each *Note gcc_jit_block: 28. must
          have a single exit point, as a basic block: you can’t jump
          from the middle of a block.  A “goto” is implicitly added
          after the asm to handle the fallthrough case, which is
          equivalent to what would have happened in the C case.

 -- C Function: void gcc_jit_extended_asm_set_volatile_flag
          (gcc_jit_extended_asm *ext_asm, int flag)
     Set whether the *Note gcc_jit_extended_asm: 120. has side-effects,
     equivalent to the volatile(1) qualifier in C’s extended asm
     syntax.

     For example, to create the equivalent of:

         asm volatile ("rdtsc\n\t"    // Returns the time in EDX:EAX.
                        "shl $32, %%rdx\n\t"  // Shift the upper bits left.
                        "or %%rdx, %0"        // 'Or' in the lower bits.
                        : "=a" (msr)
                        :
                        : "rdx");

     the following API calls could be used:

           gcc_jit_extended_asm *ext_asm
             = gcc_jit_block_add_extended_asm
         	(block, NULL,
         	 "rdtsc\n\t"  /* Returns the time in EDX:EAX.  */
         	 "shl $32, %%rdx\n\t"  /* Shift the upper bits left.  */
         	 "or %%rdx, %0");  /* 'Or' in the lower bits.  */
           gcc_jit_extended_asm_set_volatile_flag (ext_asm, 1);
           gcc_jit_extended_asm_add_output_operand (ext_asm, NULL, "=a", msr);
           gcc_jit_extended_asm_add_clobber (ext_asm, "rdx");

     where the *Note gcc_jit_extended_asm: 120. is flagged as volatile.

 -- C Function: void gcc_jit_extended_asm_set_inline_flag
          (gcc_jit_extended_asm *ext_asm, int flag)
     Set the equivalent of the inline(2) qualifier in C’s extended
     `asm' syntax.

 -- C Function: void gcc_jit_extended_asm_add_output_operand
          (gcc_jit_extended_asm *ext_asm, const
          char *asm_symbolic_name, const char *constraint,
          gcc_jit_lvalue *dest)
     Add an output operand to the extended `asm' statement.  See the
     Output Operands(3) section of the documentation of the C syntax.

     `asm_symbolic_name' corresponds to the `asmSymbolicName' component
     of C’s extended `asm' syntax.  It can be NULL.  If non-NULL it
     specifies the symbolic name for the operand.

     `constraint' corresponds to the `constraint' component of C’s
     extended `asm' syntax.  It must be non-NULL.

     `dest' corresponds to the `cvariablename' component of C’s
     extended `asm' syntax.  It must be non-NULL.

         // Example with a NULL symbolic name, the equivalent of:
         //   : "=r" (dst)
         gcc_jit_extended_asm_add_output_operand (ext_asm, NULL, "=r", dst);

         // Example with a symbolic name ("aIndex"), the equivalent of:
         //   : [aIndex] "=r" (index)
         gcc_jit_extended_asm_add_output_operand (ext_asm, "aIndex", "=r", index);

     This function can’t be called on an `asm goto' as such
     instructions can’t have outputs; see the Goto Labels(4) section
     of GCC’s “Extended Asm” documentation.

 -- C Function: void gcc_jit_extended_asm_add_input_operand
          (gcc_jit_extended_asm *ext_asm, const
          char *asm_symbolic_name, const char *constraint,
          gcc_jit_rvalue *src)
     Add an input operand to the extended `asm' statement.  See the
     Input Operands(5) section of the documentation of the C syntax.

     `asm_symbolic_name' corresponds to the `asmSymbolicName' component
     of C’s extended `asm' syntax.  It can be NULL.  If non-NULL it
     specifies the symbolic name for the operand.

     `constraint' corresponds to the `constraint' component of C’s
     extended `asm' syntax.  It must be non-NULL.

     `src' corresponds to the `cexpression' component of C’s extended
     `asm' syntax.  It must be non-NULL.

         // Example with a NULL symbolic name, the equivalent of:
         //   : "r" (src)
         gcc_jit_extended_asm_add_input_operand (ext_asm, NULL, "r",
                                                 gcc_jit_lvalue_as_rvalue (src));

         // Example with a symbolic name ("aMask"), the equivalent of:
         //   : [aMask] "r" (Mask)
         gcc_jit_extended_asm_add_input_operand (ext_asm, "aMask", "r",
                                                 gcc_jit_lvalue_as_rvalue (mask));

 -- C Function: void gcc_jit_extended_asm_add_clobber
          (gcc_jit_extended_asm *ext_asm, const char *victim)
     Add `victim' to the list of registers clobbered by the extended
     `asm' statement.  It must be non-NULL.  See the Clobbers and
     Scratch Registers(6) section of the documentation of the C syntax.

     Statements with multiple clobbers will require multiple calls, one
     per clobber.

     For example:

         gcc_jit_extended_asm_add_clobber (ext_asm, "r0");
         gcc_jit_extended_asm_add_clobber (ext_asm, "cc");
         gcc_jit_extended_asm_add_clobber (ext_asm, "memory");

A *Note gcc_jit_extended_asm: 120. is a *Note gcc_jit_object: e.
“owned” by the block’s context.  The following upcast is
available:

 -- C Function: gcc_jit_object * gcc_jit_extended_asm_as_object
          (gcc_jit_extended_asm *ext_asm)
     Upcast from extended `asm' to object.

---------- Footnotes ----------

(1) https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#Volatile

(2)
https://gcc.gnu.org/onlinedocs/gcc/Size-of-an-asm.html#Size-of-an-asm

(3) https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#OutputOperands

(4) https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#GotoLabels

(5) https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands

(6)
https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#Clobbers-and-Scratch-Registers#


File: libgccjit.info,  Node: Adding top-level assembler statements,  Prev: Adding assembler instructions within a function,  Up: Using Assembly Language with libgccjit

2.11.2 Adding top-level assembler statements
--------------------------------------------

In addition to creating extended `asm' instructions within a function,
there is support for creating “top-level” assembler statements,
outside of any function.

 -- C Function: void gcc_jit_context_add_top_level_asm
          (gcc_jit_context *ctxt, gcc_jit_location *loc, const
          char *asm_stmts)
     Create a set of top-level asm statements, analogous to those
     created by GCC’s “basic” `asm' syntax in C at file scope.

     For example, to create the equivalent of:

              asm ("\t.pushsection .text\n"
                   "\t.globl add_asm\n"
                   "\t.type add_asm, @function\n"
                   "add_asm:\n"
                   "\tmovq %rdi, %rax\n"
                   "\tadd %rsi, %rax\n"
                   "\tret\n"
                   "\t.popsection\n");

     the following API calls could be used:

           gcc_jit_context_add_top_level_asm (ctxt, NULL,
                                              "\t.pushsection .text\n"
                                              "\t.globl add_asm\n"
                                              "\t.type add_asm, @function\n"
                                              "add_asm:\n"
                                              "\tmovq %rdi, %rax\n"
                                              "\tadd %rsi, %rax\n"
                                              "\tret\n"
                                              "\t# some asm here\n"
                                              "\t.popsection\n");


File: libgccjit.info,  Node: C++ bindings for libgccjit,  Next: Internals,  Prev: Topic Reference,  Up: Top

3 C++ bindings for libgccjit
****************************

This document describes the C++ bindings to libgccjit(1), an API for
embedding GCC inside programs and libraries.

The C++ bindings consist of a single header file `libgccjit++.h'.

This is a collection of “thin” wrapper classes around the C API.
Everything is an inline function, implemented in terms of the C API, so
there is nothing extra to link against.

Contents:

* Menu:

* Tutorial: Tutorial<2>.
* Topic Reference: Topic Reference<2>.

---------- Footnotes ----------

(1) https://gcc.gnu.org/wiki/JIT


File: libgccjit.info,  Node: Tutorial<2>,  Next: Topic Reference<2>,  Up: C++ bindings for libgccjit

3.1 Tutorial
============

* Menu:

* Tutorial part 1; “Hello world”: Tutorial part 1 “Hello world”<2>.
* Tutorial part 2; Creating a trivial machine code function: Tutorial part 2 Creating a trivial machine code function<2>.
* Tutorial part 3; Loops and variables: Tutorial part 3 Loops and variables<2>.
* Tutorial part 4; Adding JIT-compilation to a toy interpreter: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>.


File: libgccjit.info,  Node: Tutorial part 1 “Hello world”<2>,  Next: Tutorial part 2 Creating a trivial machine code function<2>,  Up: Tutorial<2>

3.1.1 Tutorial part 1: “Hello world”
----------------------------------------

Before we look at the details of the API, let’s look at building and
running programs that use the library.

Here’s a toy “hello world” program that uses the library’s C++
API to synthesize a call to `printf' and uses it to write a message to
stdout.

Don’t worry about the content of the program for now; we’ll cover
the details in later parts of this tutorial.

         /* Smoketest example for libgccjit.so C++ API
            Copyright (C) 2014-2024 Free Software Foundation, Inc.

         This file is part of GCC.

         GCC is free software; you can redistribute it and/or modify it
         under the terms of the GNU General Public License as published by
         the Free Software Foundation; either version 3, or (at your option)
         any later version.

         GCC is distributed in the hope that it will be useful, but
         WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
         General Public License for more details.

         You should have received a copy of the GNU General Public License
         along with GCC; see the file COPYING3.  If not see
         <http://www.gnu.org/licenses/>.  */

         #include <libgccjit++.h>

         #include <stdlib.h>
         #include <stdio.h>

         static void
         create_code (gccjit::context ctxt)
         {
           /* Let's try to inject the equivalent of this C code:
              void
              greet (const char *name)
              {
                 printf ("hello %s\n", name);
              }
           */
           gccjit::type void_type = ctxt.get_type (GCC_JIT_TYPE_VOID);
           gccjit::type const_char_ptr_type =
             ctxt.get_type (GCC_JIT_TYPE_CONST_CHAR_PTR);
           gccjit::param param_name =
             ctxt.new_param (const_char_ptr_type, "name");
           std::vector<gccjit::param> func_params;
           func_params.push_back (param_name);
           gccjit::function func =
             ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
                                void_type,
                                "greet",
                                func_params, 0);

           gccjit::param param_format =
             ctxt.new_param (const_char_ptr_type, "format");
           std::vector<gccjit::param> printf_params;
           printf_params.push_back (param_format);
           gccjit::function printf_func =
             ctxt.new_function (GCC_JIT_FUNCTION_IMPORTED,
                                ctxt.get_type (GCC_JIT_TYPE_INT),
                                "printf",
                                printf_params, 1);

           gccjit::block block = func.new_block ();
           block.add_eval (ctxt.new_call (printf_func,
                                          ctxt.new_rvalue ("hello %s\n"),
                                          param_name));
           block.end_with_return ();
         }

         int
         main (int argc, char **argv)
         {
           gccjit::context ctxt;
           gcc_jit_result *result;

           /* Get a "context" object for working with the library.  */
           ctxt = gccjit::context::acquire ();

           /* Set some options on the context.
              Turn this on to see the code being generated, in assembler form.  */
           ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE, 0);

           /* Populate the context.  */
           create_code (ctxt);

           /* Compile the code.  */
           result = ctxt.compile ();
           if (!result)
             {
               fprintf (stderr, "NULL result");
               exit (1);
             }

           ctxt.release ();

           /* Extract the generated code from "result".  */
           typedef void (*fn_type) (const char *);
           fn_type greet =
             (fn_type)gcc_jit_result_get_code (result, "greet");
           if (!greet)
             {
               fprintf (stderr, "NULL greet");
               exit (1);
             }

           /* Now call the generated function: */
           greet ("world");
           fflush (stdout);

           gcc_jit_result_release (result);
           return 0;
         }

Copy the above to `tut01-hello-world.cc'.

Assuming you have the jit library installed, build the test program
using:

    $ gcc \
        tut01-hello-world.cc \
        -o tut01-hello-world \
        -lgccjit

You should then be able to run the built program:

    $ ./tut01-hello-world
    hello world


File: libgccjit.info,  Node: Tutorial part 2 Creating a trivial machine code function<2>,  Next: Tutorial part 3 Loops and variables<2>,  Prev: Tutorial part 1 “Hello world”<2>,  Up: Tutorial<2>

3.1.2 Tutorial part 2: Creating a trivial machine code function
---------------------------------------------------------------

Consider this C function:

    int square (int i)
    {
      return i * i;
    }

How can we construct this at run-time using libgccjit’s C++ API?

First we need to include the relevant header:

    #include <libgccjit++.h>

All state associated with compilation is associated with a *Note
gccjit;;context: 175, which is a thin C++ wrapper around the C API’s
*Note gcc_jit_context *: 8.

Create one using *Note gccjit;;context;;acquire(): 176.:

    gccjit::context ctxt;
    ctxt = gccjit::context::acquire ();

The JIT library has a system of types.  It is statically-typed: every
expression is of a specific type, fixed at compile-time.  In our
example, all of the expressions are of the C `int' type, so let’s
obtain this from the context, as a *Note gccjit;;type: 177, using *Note
gccjit;;context;;get_type(): 178.:

    gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);

*Note gccjit;;type: 177. is an example of a “contextual” object:
every entity in the API is associated with a *Note gccjit;;context: 175.

Memory management is easy: all such “contextual” objects are
automatically cleaned up for you when the context is released, using
*Note gccjit;;context;;release(): 179.:

    ctxt.release ();

so you don’t need to manually track and cleanup all objects, just the
contexts.

All of the C++ classes in the API are thin wrappers around pointers to
types in the C API.

The C++ class hierarchy within the `gccjit' namespace looks like this:

    +- object
        +- location
        +- type
           +- struct
        +- field
        +- function
        +- block
        +- rvalue
            +- lvalue
               +- param

One thing you can do with a *Note gccjit;;object: 17a. is to ask it for
a human-readable description as a `std::string', using *Note
gccjit;;object;;get_debug_string(): 17b.:

    printf ("obj: %s\n", obj.get_debug_string ().c_str ());

giving this text on stdout:

    obj: int

This is invaluable when debugging.

Let’s create the function.  To do so, we first need to construct its
single parameter, specifying its type and giving it a name, using *Note
gccjit;;context;;new_param(): 17c.:

    gccjit::param param_i = ctxt.new_param (int_type, "i");

and we can then make a vector of all of the params of the function, in
this case just one:

    std::vector<gccjit::param> params;
    params.push_back (param_i);

Now we can create the function, using `gccjit::context::new_function()':

    gccjit::function func =
      ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
                         int_type,
                         "square",
                         params,
                         0);

To define the code within the function, we must create basic blocks
containing statements.

Every basic block contains a list of statements, eventually terminated
by a statement that either returns, or jumps to another basic block.

Our function has no control-flow, so we just need one basic block:

    gccjit::block block = func.new_block ();

Our basic block is relatively simple: it immediately terminates by
returning the value of an expression.

We can build the expression using *Note
gccjit;;context;;new_binary_op(): 17d.:

    gccjit::rvalue expr =
      ctxt.new_binary_op (
        GCC_JIT_BINARY_OP_MULT, int_type,
        param_i, param_i);

A *Note gccjit;;rvalue: 17e. is another example of a *Note
gccjit;;object: 17a. subclass.  As before, we can print it with *Note
gccjit;;object;;get_debug_string(): 17b.

    printf ("expr: %s\n", expr.get_debug_string ().c_str ());

giving this output:

    expr: i * i

Note that *Note gccjit;;rvalue: 17e. provides numerous overloaded
operators which can be used to dramatically reduce the amount of typing
needed.  We can build the above binary operation more directly with
this one-liner:

    gccjit::rvalue expr = param_i * param_i;

Creating the expression in itself doesn’t do anything; we have to add
this expression to a statement within the block.  In this case, we use
it to build a return statement, which terminates the basic block:

    block.end_with_return (expr);

OK, we’ve populated the context.  We can now compile it using *Note
gccjit;;context;;compile(): 17f.:

    gcc_jit_result *result;
    result = ctxt.compile ();

and get a *Note gcc_jit_result *: 16.

We can now use *Note gcc_jit_result_get_code(): 17. to look up a
specific machine code routine within the result, in this case, the
function we created above.

    void *fn_ptr = gcc_jit_result_get_code (result, "square");
    if (!fn_ptr)
      {
        fprintf (stderr, "NULL fn_ptr");
        goto error;
      }

We can now cast the pointer to an appropriate function pointer type, and
then call it:

    typedef int (*fn_type) (int);
    fn_type square = (fn_type)fn_ptr;
    printf ("result: %d", square (5));

    result: 25

* Menu:

* Options: Options<3>.
* Full example: Full example<3>.


File: libgccjit.info,  Node: Options<3>,  Next: Full example<3>,  Up: Tutorial part 2 Creating a trivial machine code function<2>

3.1.2.1 Options
...............

To get more information on what’s going on, you can set debugging
flags on the context using *Note gccjit;;context;;set_bool_option():
181.

Setting *Note GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE: 1c. will dump a
C-like representation to stderr when you compile (GCC’s “GIMPLE”
representation):

    ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE, 1);
    result = ctxt.compile ();

    square (signed int i)
    {
      signed int D.260;

      entry:
      D.260 = i * i;
      return D.260;
    }

We can see the generated machine code in assembler form (on stderr) by
setting *Note GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE: 1d. on the
context before compiling:

    ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE, 1);
    result = ctxt.compile ();

          .file   "fake.c"
          .text
          .globl  square
          .type   square, @function
    square:
    .LFB6:
          .cfi_startproc
          pushq   %rbp
          .cfi_def_cfa_offset 16
          .cfi_offset 6, -16
          movq    %rsp, %rbp
          .cfi_def_cfa_register 6
          movl    %edi, -4(%rbp)
    .L14:
          movl    -4(%rbp), %eax
          imull   -4(%rbp), %eax
          popq    %rbp
          .cfi_def_cfa 7, 8
          ret
          .cfi_endproc
    .LFE6:
          .size   square, .-square
          .ident  "GCC: (GNU) 4.9.0 20131023 (Red Hat 0.2-0.5.1920c315ff984892399893b380305ab36e07b455.fc20)"
          .section       .note.GNU-stack,"",@progbits

By default, no optimizations are performed, the equivalent of GCC’s
`-O0' option.  We can turn things up to e.g. `-O3' by calling *Note
gccjit;;context;;set_int_option(): 182. with *Note
GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL: 1f.:

    ctxt.set_int_option (GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL, 3);

          .file   "fake.c"
          .text
          .p2align 4,,15
          .globl  square
          .type   square, @function
    square:
    .LFB7:
          .cfi_startproc
    .L16:
          movl    %edi, %eax
          imull   %edi, %eax
          ret
          .cfi_endproc
    .LFE7:
          .size   square, .-square
          .ident  "GCC: (GNU) 4.9.0 20131023 (Red Hat 0.2-0.5.1920c315ff984892399893b380305ab36e07b455.fc20)"
          .section        .note.GNU-stack,"",@progbits

Naturally this has only a small effect on such a trivial function.


File: libgccjit.info,  Node: Full example<3>,  Prev: Options<3>,  Up: Tutorial part 2 Creating a trivial machine code function<2>

3.1.2.2 Full example
....................

Here’s what the above looks like as a complete program:

         /* Usage example for libgccjit.so's C++ API
            Copyright (C) 2014-2024 Free Software Foundation, Inc.

         This file is part of GCC.

         GCC is free software; you can redistribute it and/or modify it
         under the terms of the GNU General Public License as published by
         the Free Software Foundation; either version 3, or (at your option)
         any later version.

         GCC is distributed in the hope that it will be useful, but
         WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
         General Public License for more details.

         You should have received a copy of the GNU General Public License
         along with GCC; see the file COPYING3.  If not see
         <http://www.gnu.org/licenses/>.  */

         #include <libgccjit++.h>

         #include <stdlib.h>
         #include <stdio.h>

         void
         create_code (gccjit::context ctxt)
         {
           /* Let's try to inject the equivalent of this C code:

               int square (int i)
               {
                 return i * i;
               }
           */
           gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);
           gccjit::param param_i = ctxt.new_param (int_type, "i");
           std::vector<gccjit::param> params;
           params.push_back (param_i);
           gccjit::function func = ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
                                                      int_type,
                                                      "square",
                                                      params, 0);

           gccjit::block block = func.new_block ();

           gccjit::rvalue expr =
             ctxt.new_binary_op (GCC_JIT_BINARY_OP_MULT, int_type,
                                 param_i, param_i);

           block.end_with_return (expr);
         }

         int
         main (int argc, char **argv)
         {
           /* Get a "context" object for working with the library.  */
           gccjit::context ctxt = gccjit::context::acquire ();

           /* Set some options on the context.
              Turn this on to see the code being generated, in assembler form.  */
           ctxt.set_bool_option (
             GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
             0);

           /* Populate the context.  */
           create_code (ctxt);

           /* Compile the code.  */
           gcc_jit_result *result = ctxt.compile ();

           /* We're done with the context; we can release it: */
           ctxt.release ();

           if (!result)
             {
               fprintf (stderr, "NULL result");
               return 1;
             }

           /* Extract the generated code from "result".  */
           void *fn_ptr = gcc_jit_result_get_code (result, "square");
           if (!fn_ptr)
              {
                fprintf (stderr, "NULL fn_ptr");
                gcc_jit_result_release (result);
                return 1;
              }

           typedef int (*fn_type) (int);
           fn_type square = (fn_type)fn_ptr;
           printf ("result: %d\n", square (5));

           gcc_jit_result_release (result);
           return 0;
         }

Building and running it:

    $ gcc \
        tut02-square.cc \
        -o tut02-square \
        -lgccjit

    # Run the built program:
    $ ./tut02-square
    result: 25


File: libgccjit.info,  Node: Tutorial part 3 Loops and variables<2>,  Next: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>,  Prev: Tutorial part 2 Creating a trivial machine code function<2>,  Up: Tutorial<2>

3.1.3 Tutorial part 3: Loops and variables
------------------------------------------

Consider this C function:

         int loop_test (int n)
         {
           int sum = 0;
           for (int i = 0; i < n; i++)
             sum += i * i;
           return sum;
         }

This example demonstrates some more features of libgccjit, with local
variables and a loop.

To break this down into libgccjit terms, it’s usually easier to reword
the `for' loop as a `while' loop, giving:

         int loop_test (int n)
         {
           int sum = 0;
           int i = 0;
           while (i < n)
           {
             sum += i * i;
             i++;
           }
           return sum;
         }

Here’s what the final control flow graph will look like:

       Figure


As before, we include the libgccjit++ header and make a *Note
gccjit;;context: 175.

    #include <libgccjit++.h>

    void test (void)
    {
      gccjit::context ctxt;
      ctxt = gccjit::context::acquire ();

The function works with the C `int' type.

In the previous tutorial we acquired this via

    gccjit::type the_type = ctxt.get_type (ctxt, GCC_JIT_TYPE_INT);

though we could equally well make it work on, say, `double':

    gccjit::type the_type = ctxt.get_type (ctxt, GCC_JIT_TYPE_DOUBLE);

For integer types we can use `gccjit::context::get_int_type' to
directly bind a specific type:

    gccjit::type the_type = ctxt.get_int_type <int> ();

Let’s build the function:

    gcc_jit_param n = ctxt.new_param (the_type, "n");
    std::vector<gccjit::param> params;
    params.push_back (n);
    gccjit::function func =
      ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
                         return_type,
                         "loop_test",
                         params, 0);

* Menu:

* Expressions; lvalues and rvalues: Expressions lvalues and rvalues<2>.
* Control flow: Control flow<2>.
* Visualizing the control flow graph: Visualizing the control flow graph<2>.
* Full example: Full example<4>.


File: libgccjit.info,  Node: Expressions lvalues and rvalues<2>,  Next: Control flow<2>,  Up: Tutorial part 3 Loops and variables<2>

3.1.3.1 Expressions: lvalues and rvalues
........................................

The base class of expression is the *Note gccjit;;rvalue: 17e,
representing an expression that can be on the `right'-hand side of an
assignment: a value that can be computed somehow, and assigned `to' a
storage area (such as a variable).  It has a specific *Note
gccjit;;type: 177.

Anothe important class is *Note gccjit;;lvalue: 187.  A *Note
gccjit;;lvalue: 187. is something that can of the `left'-hand side of
an assignment: a storage area (such as a variable).

In other words, every assignment can be thought of as:

    LVALUE = RVALUE;

Note that *Note gccjit;;lvalue: 187. is a subclass of *Note
gccjit;;rvalue: 17e, where in an assignment of the form:

    LVALUE_A = LVALUE_B;

the `LVALUE_B' implies reading the current value of that storage area,
assigning it into the `LVALUE_A'.

So far the only expressions we’ve seen are from the previous tutorial:

  1. the multiplication `i * i':

         gccjit::rvalue expr =
           ctxt.new_binary_op (
             GCC_JIT_BINARY_OP_MULT, int_type,
             param_i, param_i);

         /* Alternatively, using operator-overloading: */
         gccjit::rvalue expr = param_i * param_i;

     which is a *Note gccjit;;rvalue: 17e, and

  2. the various function parameters: `param_i' and `param_n',
     instances of *Note gccjit;;param: 188, which is a subclass of
     *Note gccjit;;lvalue: 187.  (and, in turn, of *Note
     gccjit;;rvalue: 17e.): we can both read from and write to function
     parameters within the body of a function.

Our new example has a new kind of expression: we have two local
variables.  We create them by calling *Note
gccjit;;function;;new_local(): 189, supplying a type and a name:

    /* Build locals:  */
    gccjit::lvalue i = func.new_local (the_type, "i");
    gccjit::lvalue sum = func.new_local (the_type, "sum");

These are instances of *Note gccjit;;lvalue: 187. - they can be read
from and written to.

Note that there is no precanned way to create `and' initialize a
variable like in C:

    int i = 0;

Instead, having added the local to the function, we have to separately
add an assignment of `0' to `local_i' at the beginning of the function.


File: libgccjit.info,  Node: Control flow<2>,  Next: Visualizing the control flow graph<2>,  Prev: Expressions lvalues and rvalues<2>,  Up: Tutorial part 3 Loops and variables<2>

3.1.3.2 Control flow
....................

This function has a loop, so we need to build some basic blocks to
handle the control flow.  In this case, we need 4 blocks:

  1. before the loop (initializing the locals)

  2. the conditional at the top of the loop (comparing `i < n')

  3. the body of the loop

  4. after the loop terminates (`return sum')

so we create these as *Note gccjit;;block: 18b. instances within the
*Note gccjit;;function: 18c.:

    gccjit::block b_initial = func.new_block ("initial");
    gccjit::block b_loop_cond = func.new_block ("loop_cond");
    gccjit::block b_loop_body = func.new_block ("loop_body");
    gccjit::block b_after_loop = func.new_block ("after_loop");

We now populate each block with statements.

The entry block `b_initial' consists of initializations followed by a
jump to the conditional.  We assign `0' to `i' and to `sum', using
*Note gccjit;;block;;add_assignment(): 18d. to add an assignment
statement, and using *Note gccjit;;context;;zero(): 18e. to get the
constant value `0' for the relevant type for the right-hand side of the
assignment:

    /* sum = 0; */
    b_initial.add_assignment (sum, ctxt.zero (the_type));

    /* i = 0; */
    b_initial.add_assignment (i, ctxt.zero (the_type));

We can then terminate the entry block by jumping to the conditional:

    b_initial.end_with_jump (b_loop_cond);

The conditional block is equivalent to the line `while (i < n)' from our
C example. It contains a single statement: a conditional, which jumps to
one of two destination blocks depending on a boolean *Note
gccjit;;rvalue: 17e, in this case the comparison of `i' and `n'.

We could build the comparison using *Note
gccjit;;context;;new_comparison(): 18f.:

    gccjit::rvalue guard =
      ctxt.new_comparison (GCC_JIT_COMPARISON_GE,
                           i, n);

and can then use this to add `b_loop_cond'’s sole statement, via
*Note gccjit;;block;;end_with_conditional(): 190.:

    b_loop_cond.end_with_conditional (guard,
                                      b_after_loop, // on_true
                                      b_loop_body); // on_false

However *Note gccjit;;rvalue: 17e. has overloaded operators for this,
so we express the conditional as

    gccjit::rvalue guard = (i >= n);

and hence we can write the block more concisely as:

    b_loop_cond.end_with_conditional (
      i >= n,
      b_after_loop, // on_true
      b_loop_body); // on_false

Next, we populate the body of the loop.

The C statement `sum += i * i;' is an assignment operation, where an
lvalue is modified “in-place”.  We use *Note
gccjit;;block;;add_assignment_op(): 191. to handle these operations:

    /* sum += i * i */
    b_loop_body.add_assignment_op (sum,
                                   GCC_JIT_BINARY_OP_PLUS,
                                   i * i);

The `i++' can be thought of as `i += 1', and can thus be handled in a
similar way.  We use *Note gcc_jit_context_one(): 2f. to get the
constant value `1' (for the relevant type) for the right-hand side of
the assignment.

    /* i++ */
    b_loop_body.add_assignment_op (i,
                                   GCC_JIT_BINARY_OP_PLUS,
                                   ctxt.one (the_type));

     Note: For numeric constants other than 0 or 1, we could use *Note
     gccjit;;context;;new_rvalue(): 192, which has overloads for both
     `int' and `double'.

The loop body completes by jumping back to the conditional:

    b_loop_body.end_with_jump (b_loop_cond);

Finally, we populate the `b_after_loop' block, reached when the loop
conditional is false.  We want to generate the equivalent of:

    return sum;

so the block is just one statement:

    /* return sum */
    b_after_loop.end_with_return (sum);

     Note: You can intermingle block creation with statement creation,
     but given that the terminator statements generally include
     references to other blocks, I find it’s clearer to create all
     the blocks, `then' all the statements.

We’ve finished populating the function.  As before, we can now
compile it to machine code:

    gcc_jit_result *result;
    result = ctxt.compile ();

    ctxt.release ();

    if (!result)
      {
        fprintf (stderr, "NULL result");
        return 1;
      }

    typedef int (*loop_test_fn_type) (int);
    loop_test_fn_type loop_test =
     (loop_test_fn_type)gcc_jit_result_get_code (result, "loop_test");
    if (!loop_test)
      {
        fprintf (stderr, "NULL loop_test");
        gcc_jit_result_release (result);
        return 1;
      }
    printf ("result: %d", loop_test (10));

    result: 285


File: libgccjit.info,  Node: Visualizing the control flow graph<2>,  Next: Full example<4>,  Prev: Control flow<2>,  Up: Tutorial part 3 Loops and variables<2>

3.1.3.3 Visualizing the control flow graph
..........................................

You can see the control flow graph of a function using *Note
gccjit;;function;;dump_to_dot(): 194.:

    func.dump_to_dot ("/tmp/sum-of-squares.dot");

giving a .dot file in GraphViz format.

You can convert this to an image using `dot':

    $ dot -Tpng /tmp/sum-of-squares.dot -o /tmp/sum-of-squares.png

or use a viewer (my preferred one is xdot.py; see
<https://github.com/jrfonseca/xdot.py>; on Fedora you can install it
with `yum install python-xdot'):

       Figure



File: libgccjit.info,  Node: Full example<4>,  Prev: Visualizing the control flow graph<2>,  Up: Tutorial part 3 Loops and variables<2>

3.1.3.4 Full example
....................

         /* Usage example for libgccjit.so's C++ API
            Copyright (C) 2014-2024 Free Software Foundation, Inc.

         This file is part of GCC.

         GCC is free software; you can redistribute it and/or modify it
         under the terms of the GNU General Public License as published by
         the Free Software Foundation; either version 3, or (at your option)
         any later version.

         GCC is distributed in the hope that it will be useful, but
         WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
         General Public License for more details.

         You should have received a copy of the GNU General Public License
         along with GCC; see the file COPYING3.  If not see
         <http://www.gnu.org/licenses/>.  */

         #include <libgccjit++.h>

         #include <stdlib.h>
         #include <stdio.h>

         void
         create_code (gccjit::context ctxt)
         {
           /*
             Simple sum-of-squares, to test conditionals and looping

             int loop_test (int n)
             {
               int i;
               int sum = 0;
               for (i = 0; i < n ; i ++)
               {
         	sum += i * i;
               }
               return sum;
            */
           gccjit::type the_type = ctxt.get_int_type <int> ();
           gccjit::type return_type = the_type;

           gccjit::param n = ctxt.new_param (the_type, "n");
           std::vector<gccjit::param> params;
           params.push_back (n);
           gccjit::function func =
             ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
                                return_type,
                                "loop_test",
                                params, 0);

           /* Build locals:  */
           gccjit::lvalue i = func.new_local (the_type, "i");
           gccjit::lvalue sum = func.new_local (the_type, "sum");

           gccjit::block b_initial = func.new_block ("initial");
           gccjit::block b_loop_cond = func.new_block ("loop_cond");
           gccjit::block b_loop_body = func.new_block ("loop_body");
           gccjit::block b_after_loop = func.new_block ("after_loop");

           /* sum = 0; */
           b_initial.add_assignment (sum, ctxt.zero (the_type));

           /* i = 0; */
           b_initial.add_assignment (i, ctxt.zero (the_type));

           b_initial.end_with_jump (b_loop_cond);

           /* if (i >= n) */
           b_loop_cond.end_with_conditional (
             i >= n,
             b_after_loop,
             b_loop_body);

           /* sum += i * i */
           b_loop_body.add_assignment_op (sum,
                                          GCC_JIT_BINARY_OP_PLUS,
                                          i * i);

           /* i++ */
           b_loop_body.add_assignment_op (i,
                                         GCC_JIT_BINARY_OP_PLUS,
                                         ctxt.one (the_type));

           b_loop_body.end_with_jump (b_loop_cond);

           /* return sum */
           b_after_loop.end_with_return (sum);
         }

         int
         main (int argc, char **argv)
         {
           gccjit::context ctxt;
           gcc_jit_result *result = NULL;

           /* Get a "context" object for working with the library.  */
           ctxt = gccjit::context::acquire ();

           /* Set some options on the context.
              Turn this on to see the code being generated, in assembler form.  */
           ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
                                 0);

           /* Populate the context.  */
           create_code (ctxt);

           /* Compile the code.  */
           result = ctxt.compile ();

           ctxt.release ();

           if (!result)
             {
               fprintf (stderr, "NULL result");
               return 1;
             }

           /* Extract the generated code from "result".  */
           typedef int (*loop_test_fn_type) (int);
           loop_test_fn_type loop_test =
             (loop_test_fn_type)gcc_jit_result_get_code (result, "loop_test");
           if (!loop_test)
             {
               fprintf (stderr, "NULL loop_test");
               gcc_jit_result_release (result);
               return 1;
             }

           /* Run the generated code.  */
           int val = loop_test (10);
           printf("loop_test returned: %d\n", val);

           gcc_jit_result_release (result);
           return 0;
         }

Building and running it:

    $ gcc \
        tut03-sum-of-squares.cc \
        -o tut03-sum-of-squares \
        -lgccjit

    # Run the built program:
    $ ./tut03-sum-of-squares
    loop_test returned: 285


File: libgccjit.info,  Node: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>,  Prev: Tutorial part 3 Loops and variables<2>,  Up: Tutorial<2>

3.1.4 Tutorial part 4: Adding JIT-compilation to a toy interpreter
------------------------------------------------------------------

In this example we construct a “toy” interpreter, and add
JIT-compilation to it.

* Menu:

* Our toy interpreter: Our toy interpreter<2>.
* Compiling to machine code: Compiling to machine code<2>.
* Setting things up: Setting things up<2>.
* Populating the function: Populating the function<2>.
* Verifying the control flow graph: Verifying the control flow graph<2>.
* Compiling the context: Compiling the context<2>.
* Single-stepping through the generated code: Single-stepping through the generated code<2>.
* Examining the generated code: Examining the generated code<2>.
* Putting it all together: Putting it all together<2>.
* Behind the curtain; How does our code get optimized?: Behind the curtain How does our code get optimized?<2>.


File: libgccjit.info,  Node: Our toy interpreter<2>,  Next: Compiling to machine code<2>,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>

3.1.4.1 Our toy interpreter
...........................

It’s a stack-based interpreter, and is intended as a (very simple)
example of the kind of bytecode interpreter seen in dynamic languages
such as Python, Ruby etc.

For the sake of simplicity, our toy virtual machine is very limited:

        * The only data type is `int'

        * It can only work on one function at a time (so that the only
          function call that can be made is to recurse).

        * Functions can only take one parameter.

        * Functions have a stack of `int' values.

        * We’ll implement function call within the interpreter by
          calling a function in our implementation, rather than
          implementing our own frame stack.

        * The parser is only good enough to get the examples to work.

Naturally, a real interpreter would be much more complicated that this.

The following operations are supported:

Operation                  Meaning                      Old Stack           New Stack
------------------------------------------------------------------------------------------------- 
DUP                        Duplicate top of stack.      `[..., x]'          `[..., x, x]'
ROT                        Swap top two elements of     `[..., x, y]'       `[..., y, x]'
                           stack.                                           
BINARY_ADD                 Add the top two elements on  `[..., x, y]'       `[..., (x+y)]'
                           the stack.                                       
BINARY_SUBTRACT            Likewise, but subtract.      `[..., x, y]'       `[..., (x-y)]'
BINARY_MULT                Likewise, but multiply.      `[..., x, y]'       `[..., (x*y)]'
BINARY_COMPARE_LT          Compare the top two          `[..., x, y]'       `[..., (x<y)]'
                           elements on the stack and                        
                           push a nonzero/zero if                           
                           (x<y).                                           
RECURSE                    Recurse, passing the top of  `[..., x]'          `[..., fn(x)]'
                           the stack, and popping the                       
                           result.                                          
RETURN                     Return the top of the stack. `[x]'               `[]'
PUSH_CONST `arg'           Push an int const.           `[...]'             `[..., arg]'
JUMP_ABS_IF_TRUE `arg'     Pop; if top of stack was     `[..., x]'          `[...]'
                           nonzero, jump to `arg'.                          

Programs can be interpreted, disassembled, and compiled to machine code.

The interpreter reads `.toy' scripts.  Here’s what a simple recursive
factorial program looks like, the script `factorial.toy'.  The parser
ignores lines beginning with a `#'.

         # Simple recursive factorial implementation, roughly equivalent to:
         #
         #  int factorial (int arg)
         #  {
         #     if (arg < 2)
         #       return arg
         #     return arg * factorial (arg - 1)
         #  }

         # Initial state:
         # stack: [arg]

         # 0:
         DUP
         # stack: [arg, arg]

         # 1:
         PUSH_CONST 2
         # stack: [arg, arg, 2]

         # 2:
         BINARY_COMPARE_LT
         # stack: [arg, (arg < 2)]

         # 3:
         JUMP_ABS_IF_TRUE 9
         # stack: [arg]

         # 4:
         DUP
         # stack: [arg, arg]

         # 5:
         PUSH_CONST 1
         # stack: [arg, arg, 1]

         # 6:
         BINARY_SUBTRACT
         # stack: [arg,  (arg - 1)

         # 7:
         RECURSE
         # stack: [arg, factorial(arg - 1)]

         # 8:
         BINARY_MULT
         # stack: [arg * factorial(arg - 1)]

         # 9:
         RETURN

The interpreter is a simple infinite loop with a big `switch' statement
based on what the next opcode is:


         int
         toyvm_function::interpret (int arg, FILE *trace)
         {
           toyvm_frame frame;
         #define PUSH(ARG) (frame.push (ARG))
         #define POP(ARG) (frame.pop ())

           frame.frm_function = this;
           frame.frm_pc = 0;
           frame.frm_cur_depth = 0;

           PUSH (arg);

           while (1)
             {
               toyvm_op *op;
               int x, y;
               assert (frame.frm_pc < fn_num_ops);
               op = &fn_ops[frame.frm_pc++];

               if (trace)
         	{
         	  frame.dump_stack (trace);
         	  disassemble_op (op, frame.frm_pc, trace);
         	}

               switch (op->op_opcode)
         	{
         	  /* Ops taking no operand.  */
         	case DUP:
         	  x = POP ();
         	  PUSH (x);
         	  PUSH (x);
         	  break;

         	case ROT:
         	  y = POP ();
         	  x = POP ();
         	  PUSH (y);
         	  PUSH (x);
         	  break;

         	case BINARY_ADD:
         	  y = POP ();
         	  x = POP ();
         	  PUSH (x + y);
         	  break;

         	case BINARY_SUBTRACT:
         	  y = POP ();
         	  x = POP ();
         	  PUSH (x - y);
         	  break;

         	case BINARY_MULT:
         	  y = POP ();
         	  x = POP ();
         	  PUSH (x * y);
         	  break;

         	case BINARY_COMPARE_LT:
         	  y = POP ();
         	  x = POP ();
         	  PUSH (x < y);
         	  break;

         	case RECURSE:
         	  x = POP ();
         	  x = interpret (x, trace);
         	  PUSH (x);
         	  break;

         	case RETURN:
         	  return POP ();

         	  /* Ops taking an operand.  */
         	case PUSH_CONST:
         	  PUSH (op->op_operand);
         	  break;

         	case JUMP_ABS_IF_TRUE:
         	  x = POP ();
         	  if (x)
         	    frame.frm_pc = op->op_operand;
         	  break;

         	default:
         	  assert (0); /* unknown opcode */

         	} /* end of switch on opcode */
             } /* end of while loop */

         #undef PUSH
         #undef POP
         }


File: libgccjit.info,  Node: Compiling to machine code<2>,  Next: Setting things up<2>,  Prev: Our toy interpreter<2>,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>

3.1.4.2 Compiling to machine code
.................................

We want to generate machine code that can be cast to this type and then
directly executed in-process:

         typedef int (*toyvm_compiled_func) (int);

Our compiler isn’t very sophisticated; it takes the implementation of
each opcode above, and maps it directly to the operations supported by
the libgccjit API.

How should we handle the stack?  In theory we could calculate what the
stack depth will be at each opcode, and optimize away the stack
manipulation “by hand”.  We’ll see below that libgccjit is able
to do this for us, so we’ll implement stack manipulation in a direct
way, by creating a `stack' array and `stack_depth' variables, local
within the generated function, equivalent to this C code:

    int stack_depth;
    int stack[MAX_STACK_DEPTH];

We’ll also have local variables `x' and `y' for use when implementing
the opcodes, equivalent to this:

    int x;
    int y;

This means our compiler has the following state:


           toyvm_function &toyvmfn;

           gccjit::context ctxt;

           gccjit::type int_type;
           gccjit::type bool_type;
           gccjit::type stack_type; /* int[MAX_STACK_DEPTH] */

           gccjit::rvalue const_one;

           gccjit::function fn;
           gccjit::param param_arg;
           gccjit::lvalue stack;
           gccjit::lvalue stack_depth;
           gccjit::lvalue x;
           gccjit::lvalue y;

           gccjit::location op_locs[MAX_OPS];
           gccjit::block initial_block;
           gccjit::block op_blocks[MAX_OPS];


File: libgccjit.info,  Node: Setting things up<2>,  Next: Populating the function<2>,  Prev: Compiling to machine code<2>,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>

3.1.4.3 Setting things up
.........................

First we create our types:


         void
         compilation_state::create_types ()
         {
           /* Create types.  */
           int_type = ctxt.get_type (GCC_JIT_TYPE_INT);
           bool_type = ctxt.get_type (GCC_JIT_TYPE_BOOL);
           stack_type = ctxt.new_array_type (int_type, MAX_STACK_DEPTH);

along with extracting a useful `int' constant:

           const_one = ctxt.one (int_type);

         }

We’ll implement push and pop in terms of the `stack' array and
`stack_depth'.  Here are helper functions for adding statements to a
block, implementing pushing and popping values:


         void
         compilation_state::add_push (gccjit::block block,
                                      gccjit::rvalue rvalue,
                                      gccjit::location loc)
         {
           /* stack[stack_depth] = RVALUE */
           block.add_assignment (
             /* stack[stack_depth] */
             ctxt.new_array_access (
               stack,
               stack_depth,
               loc),
             rvalue,
             loc);

           /* "stack_depth++;".  */
           block.add_assignment_op (
             stack_depth,
             GCC_JIT_BINARY_OP_PLUS,
             const_one,
             loc);
         }

         void
         compilation_state::add_pop (gccjit::block block,
                                     gccjit::lvalue lvalue,
                                     gccjit::location loc)
         {
           /* "--stack_depth;".  */
           block.add_assignment_op (
             stack_depth,
             GCC_JIT_BINARY_OP_MINUS,
             const_one,
             loc);

           /* "LVALUE = stack[stack_depth];".  */
           block.add_assignment (
             lvalue,
             /* stack[stack_depth] */
             ctxt.new_array_access (stack,
                                    stack_depth,
                                    loc),
             loc);
         }

We will support single-stepping through the generated code in the
debugger, so we need to create *Note gccjit;;location: 19b. instances,
one per operation in the source code.  These will reference the lines of
e.g. `factorial.toy'.


         void
         compilation_state::create_locations ()
         {
           for (int pc = 0; pc < toyvmfn.fn_num_ops; pc++)
             {
               toyvm_op *op = &toyvmfn.fn_ops[pc];

               op_locs[pc] = ctxt.new_location (toyvmfn.fn_filename,
                                                op->op_linenum,
                                                0); /* column */
             }
         }

Let’s create the function itself.  As usual, we create its parameter
first, then use the parameter to create the function:


         void
         compilation_state::create_function (const char *funcname)
         {
           std::vector <gccjit::param> params;
           param_arg = ctxt.new_param (int_type, "arg", op_locs[0]);
           params.push_back (param_arg);
           fn = ctxt.new_function (GCC_JIT_FUNCTION_EXPORTED,
                                   int_type,
                                   funcname,
                                   params, 0,
                                   op_locs[0]);

We create the locals within the function.

           stack = fn.new_local (stack_type, "stack");
           stack_depth = fn.new_local (int_type, "stack_depth");
           x = fn.new_local (int_type, "x");
           y = fn.new_local (int_type, "y");


File: libgccjit.info,  Node: Populating the function<2>,  Next: Verifying the control flow graph<2>,  Prev: Setting things up<2>,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>

3.1.4.4 Populating the function
...............................

There’s some one-time initialization, and the API treats the first
block you create as the entrypoint of the function, so we need to
create that block first:

           initial_block = fn.new_block ("initial");

We can now create blocks for each of the operations.  Most of these will
be consolidated into larger blocks when the optimizer runs.

           for (int pc = 0; pc < toyvmfn.fn_num_ops; pc++)
             {
               char buf[100];
               sprintf (buf, "instr%i", pc);
               op_blocks[pc] = fn.new_block (buf);
             }

Now that we have a block it can jump to when it’s done, we can
populate the initial block:


           /* "stack_depth = 0;".  */
           initial_block.add_assignment (stack_depth,
                                         ctxt.zero (int_type),
                                         op_locs[0]);

           /* "PUSH (arg);".  */
           add_push (initial_block,
         	    param_arg,
                     op_locs[0]);

           /* ...and jump to insn 0.  */
           initial_block.end_with_jump (op_blocks[0],
                                        op_locs[0]);

We can now populate the blocks for the individual operations.  We loop
through them, adding instructions to their blocks:

           for (int pc = 0; pc < toyvmfn.fn_num_ops; pc++)
             {
               gccjit::location loc = op_locs[pc];

               gccjit::block block = op_blocks[pc];
               gccjit::block next_block = (pc < toyvmfn.fn_num_ops
                                           ? op_blocks[pc + 1]
                                           : NULL);

               toyvm_op *op;
               op = &toyvmfn.fn_ops[pc];

We’re going to have another big `switch' statement for implementing
the opcodes, this time for compiling them, rather than interpreting
them.  It’s helpful to have macros for implementing push and pop, so
that we can make the `switch' statement that’s coming up look as much
as possible like the one above within the interpreter:


    #define X_EQUALS_POP()\
          add_pop (block, x, loc)
    #define Y_EQUALS_POP()\
          add_pop (block, y, loc)
    #define PUSH_RVALUE(RVALUE)\
          add_push (block, (RVALUE), loc)
    #define PUSH_X()\
          PUSH_RVALUE (x)
    #define PUSH_Y() \
          PUSH_RVALUE (y)

     Note: A particularly clever implementation would have an
     `identical' `switch' statement shared by the interpreter and the
     compiler, with some preprocessor “magic”.  We’re not doing
     that here, for the sake of simplicity.

When I first implemented this compiler, I accidentally missed an edit
when copying and pasting the `Y_EQUALS_POP' macro, so that popping the
stack into `y' instead erroneously assigned it to `x', leaving `y'
uninitialized.

To track this kind of thing down, we can use *Note
gccjit;;block;;add_comment(): 19d. to add descriptive comments to the
internal representation.  This is invaluable when looking through the
generated IR for, say `factorial':


               block.add_comment (opcode_names[op->op_opcode], loc);

We can now write the big `switch' statement that implements the
individual opcodes, populating the relevant block with statements:


               switch (op->op_opcode)
         	{
         	case DUP:
         	  X_EQUALS_POP ();
         	  PUSH_X ();
         	  PUSH_X ();
         	  break;

         	case ROT:
         	  Y_EQUALS_POP ();
         	  X_EQUALS_POP ();
         	  PUSH_Y ();
         	  PUSH_X ();
         	  break;

         	case BINARY_ADD:
         	  Y_EQUALS_POP ();
         	  X_EQUALS_POP ();
         	  PUSH_RVALUE (
         	   ctxt.new_binary_op (
         	     GCC_JIT_BINARY_OP_PLUS,
         	     int_type,
                      x, y,
                      loc));
         	  break;

         	case BINARY_SUBTRACT:
         	  Y_EQUALS_POP ();
         	  X_EQUALS_POP ();
         	  PUSH_RVALUE (
                    ctxt.new_binary_op (
         	     GCC_JIT_BINARY_OP_MINUS,
         	     int_type,
                      x, y,
                      loc));
         	  break;

         	case BINARY_MULT:
         	  Y_EQUALS_POP ();
         	  X_EQUALS_POP ();
         	  PUSH_RVALUE (
                    ctxt.new_binary_op (
         	     GCC_JIT_BINARY_OP_MULT,
         	     int_type,
                      x, y,
                      loc));
         	  break;

         	case BINARY_COMPARE_LT:
         	  Y_EQUALS_POP ();
         	  X_EQUALS_POP ();
         	  PUSH_RVALUE (
         	     /* cast of bool to int */
         	     ctxt.new_cast (
         	       /* (x < y) as a bool */
         	       ctxt.new_comparison (
         		 GCC_JIT_COMPARISON_LT,
                          x, y,
                          loc),
         	       int_type,
                        loc));
         	  break;

         	case RECURSE:
         	  {
         	    X_EQUALS_POP ();
         	    PUSH_RVALUE (
         	      ctxt.new_call (
         		fn,
         		x,
                         loc));
         	    break;
         	  }

         	case RETURN:
         	  X_EQUALS_POP ();
         	  block.end_with_return (x, loc);
         	  break;

         	  /* Ops taking an operand.  */
         	case PUSH_CONST:
         	  PUSH_RVALUE (
         	    ctxt.new_rvalue (int_type, op->op_operand));
         	  break;

         	case JUMP_ABS_IF_TRUE:
         	  X_EQUALS_POP ();
         	  block.end_with_conditional (
         	    /* "(bool)x".  */
                     ctxt.new_cast (x, bool_type, loc),
         	    op_blocks[op->op_operand], /* on_true */
         	    next_block, /* on_false */
                     loc);
         	  break;

         	default:
         	  assert(0);
         	} /* end of switch on opcode */

Every block must be terminated, via a call to one of the
`gccjit::block::end_with_' entrypoints.  This has been done for two of
the opcodes, but we need to do it for the other ones, by jumping to the
next block.

               if (op->op_opcode != JUMP_ABS_IF_TRUE
         	  && op->op_opcode != RETURN)
         	block.end_with_jump (next_block, loc);

This is analogous to simply incrementing the program counter.


File: libgccjit.info,  Node: Verifying the control flow graph<2>,  Next: Compiling the context<2>,  Prev: Populating the function<2>,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>

3.1.4.5 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 *Note gccjit;;function;;dump_to_dot(): 194.:

    fn.dump_to_dot ("/tmp/factorial.dot");

and viewing the result.  Note how the label names, comments, and
variable names show up in the dump, to make it easier to spot errors in
our compiler.

       Figure



File: libgccjit.info,  Node: Compiling the context<2>,  Next: Single-stepping through the generated code<2>,  Prev: Verifying the control flow graph<2>,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>

3.1.4.6 Compiling the context
.............................

Having finished looping over the blocks and populating them with
statements, the context is complete.

We can now compile it, extract machine code from the result, and run it:


         class compilation_result
         {
         public:
           compilation_result (gcc_jit_result *result) :
             m_result (result)
           {
           }
           ~compilation_result ()
           {
             gcc_jit_result_release (m_result);
           }

           void *get_code (const char *funcname)
           {
             return gcc_jit_result_get_code (m_result, funcname);
           }

         private:
           gcc_jit_result *m_result;
         };

           compilation_result compiler_result = fn->compile ();

           const char *funcname = fn->get_function_name ();
           toyvm_compiled_func code
             = (toyvm_compiled_func)compiler_result.get_code (funcname);

           printf ("compiler result: %d\n",
         	  code (atoi (argv[2])));


File: libgccjit.info,  Node: Single-stepping through the generated code<2>,  Next: Examining the generated code<2>,  Prev: Compiling the context<2>,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>

3.1.4.7 Single-stepping through the generated code
..................................................

It’s possible to debug the generated code.  To do this we need to
both:

        * Set up source code locations for our statements, so that we
          can meaningfully step through the code.  We did this above by
          calling *Note gccjit;;context;;new_location(): 1a1. and using
          the results.

        * Enable the generation of debugging information, by setting
          *Note GCC_JIT_BOOL_OPTION_DEBUGINFO: 42. on the *Note
          gccjit;;context: 175. via *Note
          gccjit;;context;;set_bool_option(): 181.:

              ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DEBUGINFO, 1);

Having done this, we can put a breakpoint on the generated function:

    $ gdb --args ./toyvm factorial.toy 10
    (gdb) break factorial
    Function "factorial" not defined.
    Make breakpoint pending on future shared library load? (y or [n]) y
    Breakpoint 1 (factorial) pending.
    (gdb) run
    Breakpoint 1, factorial (arg=10) at factorial.toy:14
    14    DUP

We’ve set up location information, which references `factorial.toy'.
This allows us to use e.g. `list' to see where we are in the script:

    (gdb) list
    9
    10    # Initial state:
    11    # stack: [arg]
    12
    13    # 0:
    14    DUP
    15    # stack: [arg, arg]
    16
    17    # 1:
    18    PUSH_CONST 2

and to step through the function, examining the data:

    (gdb) n
    18    PUSH_CONST 2
    (gdb) n
    22    BINARY_COMPARE_LT
    (gdb) print stack
    $5 = {10, 10, 2, 0, -7152, 32767, 0, 0}
    (gdb) print stack_depth
    $6 = 3

You’ll see that the parts of the `stack' array that haven’t been
touched yet are uninitialized.

     Note: Turning on optimizations may lead to unpredictable results
     when stepping through the generated code: the execution may appear
     to “jump around” the source code.  This is analogous to
     turning up the optimization level in a regular compiler.


File: libgccjit.info,  Node: Examining the generated code<2>,  Next: Putting it all together<2>,  Prev: Single-stepping through the generated code<2>,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>

3.1.4.8 Examining the generated code
....................................

How good is the optimized code?

We can turn up optimizations, by calling *Note
gccjit;;context;;set_int_option(): 182. with *Note
GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL: 1f.:

    ctxt.set_int_option (GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL, 3);

One of GCC’s internal representations is called “gimple”.  A dump
of the initial gimple representation of the code can be seen by setting:

    ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE, 1);

With optimization on and source locations displayed, this gives:

    factorial (signed int arg)
    {
      <unnamed type> D.80;
      signed int D.81;
      signed int D.82;
      signed int D.83;
      signed int D.84;
      signed int D.85;
      signed int y;
      signed int x;
      signed int stack_depth;
      signed int stack[8];

      try
        {
          initial:
          stack_depth = 0;
          stack[stack_depth] = arg;
          stack_depth = stack_depth + 1;
          goto instr0;
          instr0:
          /* DUP */:
          stack_depth = stack_depth + -1;
          x = stack[stack_depth];
          stack[stack_depth] = x;
          stack_depth = stack_depth + 1;
          stack[stack_depth] = x;
          stack_depth = stack_depth + 1;
          goto instr1;
          instr1:
          /* PUSH_CONST */:
          stack[stack_depth] = 2;
          stack_depth = stack_depth + 1;
          goto instr2;

          /* etc */

You can see the generated machine code in assembly form via:

    ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE, 1);
    result = ctxt.compile ();

which shows that (on this x86_64 box) the compiler has unrolled the loop
and is using MMX instructions to perform several multiplications
simultaneously:

            .file   "fake.c"
            .text
    .Ltext0:
            .p2align 4,,15
            .globl  factorial
            .type   factorial, @function
    factorial:
    .LFB0:
            .file 1 "factorial.toy"
            .loc 1 14 0
            .cfi_startproc
    .LVL0:
    .L2:
            .loc 1 26 0
            cmpl    $1, %edi
            jle     .L13
            leal    -1(%rdi), %edx
            movl    %edx, %ecx
            shrl    $2, %ecx
            leal    0(,%rcx,4), %esi
            testl   %esi, %esi
            je      .L14
            cmpl    $9, %edx
            jbe     .L14
            leal    -2(%rdi), %eax
            movl    %eax, -16(%rsp)
            leal    -3(%rdi), %eax
            movd    -16(%rsp), %xmm0
            movl    %edi, -16(%rsp)
            movl    %eax, -12(%rsp)
            movd    -16(%rsp), %xmm1
            xorl    %eax, %eax
            movl    %edx, -16(%rsp)
            movd    -12(%rsp), %xmm4
            movd    -16(%rsp), %xmm6
            punpckldq       %xmm4, %xmm0
            movdqa  .LC1(%rip), %xmm4
            punpckldq       %xmm6, %xmm1
            punpcklqdq      %xmm0, %xmm1
            movdqa  .LC0(%rip), %xmm0
            jmp     .L5
            # etc - edited for brevity

This is clearly overkill for a function that will likely overflow the
`int' type before the vectorization is worthwhile - but then again, this
is a toy example.

Turning down the optimization level to 2:

    ctxt.set_int_option (GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL, 2);

yields this code, which is simple enough to quote in its entirety:

            .file   "fake.c"
            .text
            .p2align 4,,15
            .globl  factorial
            .type   factorial, @function
    factorial:
    .LFB0:
            .cfi_startproc
    .L2:
            cmpl    $1, %edi
            jle     .L8
            movl    $1, %edx
            jmp     .L4
            .p2align 4,,10
            .p2align 3
    .L6:
            movl    %eax, %edi
    .L4:
    .L5:
            leal    -1(%rdi), %eax
            imull   %edi, %edx
            cmpl    $1, %eax
            jne     .L6
    .L3:
    .L7:
            imull   %edx, %eax
            ret
    .L8:
            movl    %edi, %eax
            movl    $1, %edx
            jmp     .L7
            .cfi_endproc
    .LFE0:
            .size   factorial, .-factorial
            .ident  "GCC: (GNU) 4.9.0 20131023 (Red Hat 0.2-%{gcc_release})"
            .section        .note.GNU-stack,"",@progbits

Note that the stack pushing and popping have been eliminated, as has the
recursive call (in favor of an iteration).


File: libgccjit.info,  Node: Putting it all together<2>,  Next: Behind the curtain How does our code get optimized?<2>,  Prev: Examining the generated code<2>,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>

3.1.4.9 Putting it all together
...............................

The complete example can be seen in the source tree at
`gcc/jit/docs/examples/tut04-toyvm/toyvm.cc'

along with a Makefile and a couple of sample .toy scripts:

    $ ls -al
    drwxrwxr-x. 2 david david   4096 Sep 19 17:46 .
    drwxrwxr-x. 3 david david   4096 Sep 19 15:26 ..
    -rw-rw-r--. 1 david david    615 Sep 19 12:43 factorial.toy
    -rw-rw-r--. 1 david david    834 Sep 19 13:08 fibonacci.toy
    -rw-rw-r--. 1 david david    238 Sep 19 14:22 Makefile
    -rw-rw-r--. 1 david david  16457 Sep 19 17:07 toyvm.cc

    $ make toyvm
    g++ -Wall -g -o toyvm toyvm.cc -lgccjit

    $ ./toyvm factorial.toy 10
    interpreter result: 3628800
    compiler result: 3628800

    $ ./toyvm fibonacci.toy 10
    interpreter result: 55
    compiler result: 55


File: libgccjit.info,  Node: Behind the curtain How does our code get optimized?<2>,  Prev: Putting it all together<2>,  Up: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>

3.1.4.10 Behind the curtain: How does our code get optimized?
.............................................................

Our example is done, but you may be wondering about exactly how the
compiler turned what we gave it into the machine code seen above.

We can examine what the compiler is doing in detail by setting:

    state.ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING, 1);
    state.ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES, 1);

This will dump detailed information about the compiler’s state to a
directory under `/tmp', and keep it from being cleaned up.

The precise names and their formats of these files is subject to change.
Higher optimization levels lead to more files.  Here’s what I saw
(edited for brevity; there were almost 200 files):

    intermediate files written to /tmp/libgccjit-KPQbGw
    $ ls /tmp/libgccjit-KPQbGw/
    fake.c.000i.cgraph
    fake.c.000i.type-inheritance
    fake.c.004t.gimple
    fake.c.007t.omplower
    fake.c.008t.lower
    fake.c.011t.eh
    fake.c.012t.cfg
    fake.c.014i.visibility
    fake.c.015i.early_local_cleanups
    fake.c.016t.ssa
    # etc

The gimple code is converted into Static Single Assignment form, with
annotations for use when generating the debuginfo:

    $ less /tmp/libgccjit-KPQbGw/fake.c.016t.ssa

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    factorial (signed int arg)
    {
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int _44;
      signed int _51;
      signed int _56;

    initial:
      stack_depth_3 = 0;
      # DEBUG stack_depth => stack_depth_3
      stack[stack_depth_3] = arg_5(D);
      stack_depth_7 = stack_depth_3 + 1;
      # DEBUG stack_depth => stack_depth_7
      # DEBUG instr0 => NULL
      # DEBUG /* DUP */ => NULL
      stack_depth_8 = stack_depth_7 + -1;
      # DEBUG stack_depth => stack_depth_8
      x_9 = stack[stack_depth_8];
      # DEBUG x => x_9
      stack[stack_depth_8] = x_9;
      stack_depth_11 = stack_depth_8 + 1;
      # DEBUG stack_depth => stack_depth_11
      stack[stack_depth_11] = x_9;
      stack_depth_13 = stack_depth_11 + 1;
      # DEBUG stack_depth => stack_depth_13
      # DEBUG instr1 => NULL
      # DEBUG /* PUSH_CONST */ => NULL
      stack[stack_depth_13] = 2;

      /* etc; edited for brevity */

We can perhaps better see the code by turning off *Note
GCC_JIT_BOOL_OPTION_DEBUGINFO: 42. to suppress all those `DEBUG'
statements, giving:

    $ less /tmp/libgccjit-1Hywc0/fake.c.016t.ssa

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    factorial (signed int arg)
    {
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int _44;
      signed int _51;
      signed int _56;

    initial:
      stack_depth_3 = 0;
      stack[stack_depth_3] = arg_5(D);
      stack_depth_7 = stack_depth_3 + 1;
      stack_depth_8 = stack_depth_7 + -1;
      x_9 = stack[stack_depth_8];
      stack[stack_depth_8] = x_9;
      stack_depth_11 = stack_depth_8 + 1;
      stack[stack_depth_11] = x_9;
      stack_depth_13 = stack_depth_11 + 1;
      stack[stack_depth_13] = 2;
      stack_depth_15 = stack_depth_13 + 1;
      stack_depth_16 = stack_depth_15 + -1;
      y_17 = stack[stack_depth_16];
      stack_depth_18 = stack_depth_16 + -1;
      x_19 = stack[stack_depth_18];
      _20 = x_19 < y_17;
      _21 = (signed int) _20;
      stack[stack_depth_18] = _21;
      stack_depth_23 = stack_depth_18 + 1;
      stack_depth_24 = stack_depth_23 + -1;
      x_25 = stack[stack_depth_24];
      if (x_25 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      stack_depth_26 = stack_depth_24 + -1;
      x_27 = stack[stack_depth_26];
      stack[stack_depth_26] = x_27;
      stack_depth_29 = stack_depth_26 + 1;
      stack[stack_depth_29] = x_27;
      stack_depth_31 = stack_depth_29 + 1;
      stack[stack_depth_31] = 1;
      stack_depth_33 = stack_depth_31 + 1;
      stack_depth_34 = stack_depth_33 + -1;
      y_35 = stack[stack_depth_34];
      stack_depth_36 = stack_depth_34 + -1;
      x_37 = stack[stack_depth_36];
      _38 = x_37 - y_35;
      stack[stack_depth_36] = _38;
      stack_depth_40 = stack_depth_36 + 1;
      stack_depth_41 = stack_depth_40 + -1;
      x_42 = stack[stack_depth_41];
      _44 = factorial (x_42);
      stack[stack_depth_41] = _44;
      stack_depth_46 = stack_depth_41 + 1;
      stack_depth_47 = stack_depth_46 + -1;
      y_48 = stack[stack_depth_47];
      stack_depth_49 = stack_depth_47 + -1;
      x_50 = stack[stack_depth_49];
      _51 = x_50 * y_48;
      stack[stack_depth_49] = _51;
      stack_depth_53 = stack_depth_49 + 1;

      # stack_depth_1 = PHI <stack_depth_24(2), stack_depth_53(3)>
    instr9:
    /* RETURN */:
      stack_depth_54 = stack_depth_1 + -1;
      x_55 = stack[stack_depth_54];
      _56 = x_55;
      stack ={v} {CLOBBER};
      return _56;

    }

Note in the above how all the *Note gccjit;;block: 18b. instances we
created have been consolidated into just 3 blocks in GCC’s internal
representation: `initial', `instr4' and `instr9'.

* Menu:

* Optimizing away stack manipulation: Optimizing away stack manipulation<2>.
* Elimination of tail recursion: Elimination of tail recursion<2>.


File: libgccjit.info,  Node: Optimizing away stack manipulation<2>,  Next: Elimination of tail recursion<2>,  Up: Behind the curtain How does our code get optimized?<2>

3.1.4.11 Optimizing away stack manipulation
...........................................

Recall our simple implementation of stack operations.  Let’s examine
how the stack operations are optimized away.

After a pass of constant-propagation, the depth of the stack at each
opcode can be determined at compile-time:

    $ less /tmp/libgccjit-1Hywc0/fake.c.021t.ccp1

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    factorial (signed int arg)
    {
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int _44;
      signed int _51;

    initial:
      stack[0] = arg_5(D);
      x_9 = stack[0];
      stack[0] = x_9;
      stack[1] = x_9;
      stack[2] = 2;
      y_17 = stack[2];
      x_19 = stack[1];
      _20 = x_19 < y_17;
      _21 = (signed int) _20;
      stack[1] = _21;
      x_25 = stack[1];
      if (x_25 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      x_27 = stack[0];
      stack[0] = x_27;
      stack[1] = x_27;
      stack[2] = 1;
      y_35 = stack[2];
      x_37 = stack[1];
      _38 = x_37 - y_35;
      stack[1] = _38;
      x_42 = stack[1];
      _44 = factorial (x_42);
      stack[1] = _44;
      y_48 = stack[1];
      x_50 = stack[0];
      _51 = x_50 * y_48;
      stack[0] = _51;

    instr9:
    /* RETURN */:
      x_55 = stack[0];
      x_56 = x_55;
      stack ={v} {CLOBBER};
      return x_56;

    }

Note how, in the above, all those `stack_depth' values are now just
constants: we’re accessing specific stack locations at each opcode.

The “esra” pass (“Early Scalar Replacement of Aggregates”)
breaks out our “stack” array into individual elements:

    $ less /tmp/libgccjit-1Hywc0/fake.c.024t.esra

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    Created a replacement for stack offset: 0, size: 32: stack$0
    Created a replacement for stack offset: 32, size: 32: stack$1
    Created a replacement for stack offset: 64, size: 32: stack$2

    Symbols to be put in SSA form
    { D.89 D.90 D.91 }
    Incremental SSA update started at block: 0
    Number of blocks in CFG: 5
    Number of blocks to update: 4 ( 80%)


    factorial (signed int arg)
    {
      signed int stack$2;
      signed int stack$1;
      signed int stack$0;
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int _44;
      signed int _51;

    initial:
      stack$0_45 = arg_5(D);
      x_9 = stack$0_45;
      stack$0_39 = x_9;
      stack$1_32 = x_9;
      stack$2_30 = 2;
      y_17 = stack$2_30;
      x_19 = stack$1_32;
      _20 = x_19 < y_17;
      _21 = (signed int) _20;
      stack$1_28 = _21;
      x_25 = stack$1_28;
      if (x_25 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      x_27 = stack$0_39;
      stack$0_22 = x_27;
      stack$1_14 = x_27;
      stack$2_12 = 1;
      y_35 = stack$2_12;
      x_37 = stack$1_14;
      _38 = x_37 - y_35;
      stack$1_10 = _38;
      x_42 = stack$1_10;
      _44 = factorial (x_42);
      stack$1_6 = _44;
      y_48 = stack$1_6;
      x_50 = stack$0_22;
      _51 = x_50 * y_48;
      stack$0_1 = _51;

      # stack$0_52 = PHI <stack$0_39(2), stack$0_1(3)>
    instr9:
    /* RETURN */:
      x_55 = stack$0_52;
      x_56 = x_55;
      stack ={v} {CLOBBER};
      return x_56;

    }

Hence at this point, all those pushes and pops of the stack are now
simply assignments to specific temporary variables.

After some copy propagation, the stack manipulation has been completely
optimized away:

    $ less /tmp/libgccjit-1Hywc0/fake.c.026t.copyprop1

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    factorial (signed int arg)
    {
      signed int stack$2;
      signed int stack$1;
      signed int stack$0;
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int _44;
      signed int _51;

    initial:
      stack$0_39 = arg_5(D);
      _20 = arg_5(D) <= 1;
      _21 = (signed int) _20;
      if (_21 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      _38 = arg_5(D) + -1;
      _44 = factorial (_38);
      _51 = arg_5(D) * _44;
      stack$0_1 = _51;

      # stack$0_52 = PHI <arg_5(D)(2), _51(3)>
    instr9:
    /* RETURN */:
      stack ={v} {CLOBBER};
      return stack$0_52;

    }

Later on, another pass finally eliminated `stack_depth' local and the
unused parts of the `stack`' array altogether:

    $ less /tmp/libgccjit-1Hywc0/fake.c.036t.release_ssa

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)

    Released 44 names, 314.29%, removed 44 holes
    factorial (signed int arg)
    {
      signed int stack$0;
      signed int mult_acc_1;
      <unnamed type> _5;
      signed int _6;
      signed int _7;
      signed int mul_tmp_10;
      signed int mult_acc_11;
      signed int mult_acc_13;

      # arg_9 = PHI <arg_8(D)(0)>
      # mult_acc_13 = PHI <1(0)>
    initial:

      <bb 5>:
      # arg_4 = PHI <arg_9(2), _7(3)>
      # mult_acc_1 = PHI <mult_acc_13(2), mult_acc_11(3)>
      _5 = arg_4 <= 1;
      _6 = (signed int) _5;
      if (_6 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      _7 = arg_4 + -1;
      mult_acc_11 = mult_acc_1 * arg_4;
      goto <bb 5>;

      # stack$0_12 = PHI <arg_4(5)>
    instr9:
    /* RETURN */:
      mul_tmp_10 = mult_acc_1 * stack$0_12;
      return mul_tmp_10;

    }


File: libgccjit.info,  Node: Elimination of tail recursion<2>,  Prev: Optimizing away stack manipulation<2>,  Up: Behind the curtain How does our code get optimized?<2>

3.1.4.12 Elimination of tail recursion
......................................

Another significant optimization is the detection that the call to
`factorial' is tail recursion, which can be eliminated in favor of an
iteration:

    $ less /tmp/libgccjit-1Hywc0/fake.c.030t.tailr1

    ;; Function factorial (factorial, funcdef_no=0, decl_uid=53, symbol_order=0)


    Symbols to be put in SSA form
    { D.88 }
    Incremental SSA update started at block: 0
    Number of blocks in CFG: 5
    Number of blocks to update: 4 ( 80%)


    factorial (signed int arg)
    {
      signed int stack$2;
      signed int stack$1;
      signed int stack$0;
      signed int stack[8];
      signed int stack_depth;
      signed int x;
      signed int y;
      signed int mult_acc_1;
      <unnamed type> _20;
      signed int _21;
      signed int _38;
      signed int mul_tmp_44;
      signed int mult_acc_51;

      # arg_5 = PHI <arg_39(D)(0), _38(3)>
      # mult_acc_1 = PHI <1(0), mult_acc_51(3)>
    initial:
      _20 = arg_5 <= 1;
      _21 = (signed int) _20;
      if (_21 != 0)
        goto <bb 4> (instr9);
      else
        goto <bb 3> (instr4);

    instr4:
    /* DUP */:
      _38 = arg_5 + -1;
      mult_acc_51 = mult_acc_1 * arg_5;
      goto <bb 2> (initial);

      # stack$0_52 = PHI <arg_5(2)>
    instr9:
    /* RETURN */:
      stack ={v} {CLOBBER};
      mul_tmp_44 = mult_acc_1 * stack$0_52;
      return mul_tmp_44;

    }


File: libgccjit.info,  Node: Topic Reference<2>,  Prev: Tutorial<2>,  Up: C++ bindings for libgccjit

3.2 Topic Reference
===================

* Menu:

* Compilation contexts: Compilation contexts<2>.
* Objects: Objects<2>.
* Types: Types<2>.
* Expressions: Expressions<2>.
* Creating and using functions: Creating and using functions<2>.
* Source Locations: Source Locations<2>.
* Compiling a context: Compiling a context<2>.
* Using Assembly Language with libgccjit++::


File: libgccjit.info,  Node: Compilation contexts<2>,  Next: Objects<2>,  Up: Topic Reference<2>

3.2.1 Compilation contexts
--------------------------

 -- C++ Class: gccjit::context

The top-level of the C++ API is the *Note gccjit;;context: 175. type.

A *Note gccjit;;context: 175. instance encapsulates the state of a
compilation.

You can set up options on it, and add types, functions and code.
Invoking *Note gccjit;;context;;compile(): 17f. on it gives you a *Note
gcc_jit_result *: 16.

It is a thin wrapper around the C API’s *Note gcc_jit_context *: 8.

* Menu:

* Lifetime-management: Lifetime-management<2>.
* Thread-safety: Thread-safety<2>.
* Error-handling: Error-handling<3>.
* Debugging: Debugging<2>.
* Options: Options<4>.


File: libgccjit.info,  Node: Lifetime-management<2>,  Next: Thread-safety<2>,  Up: Compilation contexts<2>

3.2.1.1 Lifetime-management
...........................

Contexts are the unit of lifetime-management within the API: objects
have their lifetime bounded by the context they are created within, and
cleanup of such objects is done for you when the context is released.

 -- C++ Function: gccjit::*Note context: 175. gccjit::*Note context:
          175.::acquire ()
     This function acquires a new *Note gccjit;;context: 175. instance,
     which is independent of any others that may be present within this
     process.

 -- C++ Function: void gccjit::*Note context: 175.::release ()
     This function releases all resources associated with the given
     context.  Both the context itself and all of its `gccjit::object *'
     instances are cleaned up.  It should be called exactly once on a
     given context.

     It is invalid to use the context or any of its “contextual”
     objects after calling this.

         ctxt.release ();

 -- C++ Function: gccjit::*Note context: 175. gccjit::*Note context:
          175.::new_child_context ()
     Given an existing JIT context, create a child context.

     The child inherits a copy of all option-settings from the parent.

     The child can reference objects created within the parent, but not
     vice-versa.

     The lifetime of the child context must be bounded by that of the
     parent: you should release a child context before releasing the
     parent context.

     If you use a function from a parent context within a child context,
     you have to compile the parent context before you can compile the
     child context, and the gccjit::result of the parent context must
     outlive the gccjit::result of the child context.

     This allows caching of shared initializations.  For example, you
     could create types and declarations of global functions in a
     parent context once within a process, and then create child
     contexts whenever a function or loop becomes hot. Each such child
     context can be used for JIT-compiling just one function or loop,
     but can reference types and helper functions created within the
     parent context.

     Contexts can be arbitrarily nested, provided the above rules are
     followed, but it’s probably not worth going above 2 or 3 levels,
     and there will likely be a performance hit for such nesting.


File: libgccjit.info,  Node: Thread-safety<2>,  Next: Error-handling<3>,  Prev: Lifetime-management<2>,  Up: Compilation contexts<2>

3.2.1.2 Thread-safety
.....................

Instances of *Note gccjit;;context: 175. created via *Note
gccjit;;context;;acquire(): 176. 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 *Note gccjit;;context;;new_child_context(): 1b5.
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, and if you’re using multiple threads you should provide your
own locking around entire such context partitions.


File: libgccjit.info,  Node: Error-handling<3>,  Next: Debugging<2>,  Prev: Thread-safety<2>,  Up: Compilation contexts<2>

3.2.1.3 Error-handling
......................

You can only compile and get code from a context if no errors occur.

In general, if an error occurs when using an API entrypoint, it returns
NULL.  You don’t have to check everywhere for NULL results, since the
API gracefully handles a NULL being passed in for any argument.

Errors are printed on stderr and can be queried using *Note
gccjit;;context;;get_first_error(): 1bb.

 -- C++ Function: const char *gccjit::*Note context:
          175.::get_first_error (gccjit::context *ctxt)
     Returns the first error message that occurred on the context.

     The returned string is valid for the rest of the lifetime of the
     context.

     If no errors occurred, this will be NULL.


File: libgccjit.info,  Node: Debugging<2>,  Next: Options<4>,  Prev: Error-handling<3>,  Up: Compilation contexts<2>

3.2.1.4 Debugging
.................

 -- C++ Function: void gccjit::*Note context: 175.::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 *Note
     gccjit;;location: 19b.  information throughout the context,
     pointing at the dump file as if it were a source file.  This may
     be of use in conjunction with `GCCJIT::BOOL_OPTION_DEBUGINFO' to
     allow stepping through the code in a debugger.

 -- C++ Function: void gccjit::*Note context:
          175.::dump_reproducer_to_file (gcc_jit_context *ctxt, const
          char *path)
     This is a thin wrapper around the C API *Note
     gcc_jit_context_dump_reproducer_to_file(): 5d, and hence works the
     same way.

     Note that the generated source is C code, not C++; this might be
     of use for seeing what the C++ bindings are doing at the C level.


File: libgccjit.info,  Node: Options<4>,  Prev: Debugging<2>,  Up: Compilation contexts<2>

3.2.1.5 Options
...............

* Menu:

* String Options: String Options<2>.
* Boolean options: Boolean options<2>.
* Integer options: Integer options<2>.
* Additional command-line options: Additional command-line options<2>.


File: libgccjit.info,  Node: String Options<2>,  Next: Boolean options<2>,  Up: Options<4>

3.2.1.6 String Options
......................

 -- C++ Function: void gccjit::*Note context: 175.::set_str_option
          (enum gcc_jit_str_option, const char *value)
     Set a string option of the context.

     This is a thin wrapper around the C API *Note
     gcc_jit_context_set_str_option(): 61.; the options have the same
     meaning.


File: libgccjit.info,  Node: Boolean options<2>,  Next: Integer options<2>,  Prev: String Options<2>,  Up: Options<4>

3.2.1.7 Boolean options
.......................

 -- C++ Function: void gccjit::*Note context: 175.::set_bool_option
          (enum gcc_jit_bool_option, int value)
     Set a boolean option of the context.

     This is a thin wrapper around the C API *Note
     gcc_jit_context_set_bool_option(): 1b.; the options have the same
     meaning.

 -- C++ Function: void gccjit::*Note context:
          175.::set_bool_allow_unreachable_blocks (int bool_value)
     By default, libgccjit will issue an error about unreachable blocks
     within a function.

     This entrypoint can be used to disable that error; it is a thin
     wrapper around the C API *Note
     gcc_jit_context_set_bool_allow_unreachable_blocks(): 6b.

     This entrypoint was added in *Note LIBGCCJIT_ABI_2: 6c.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_allow_unreachable_blocks

 -- C++ Function: void gccjit::*Note context:
          175.::set_bool_use_external_driver (int bool_value)
     libgccjit internally generates assembler, and uses “driver”
     code for converting it to other formats (e.g. shared libraries).

     By default, libgccjit will use an embedded copy of the driver code.

     This option can be used to instead invoke an external driver
     executable as a subprocess; it is a thin wrapper around the C API
     *Note gcc_jit_context_set_bool_use_external_driver(): 6d.

     This entrypoint was added in *Note LIBGCCJIT_ABI_5: 6e.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_use_external_driver


File: libgccjit.info,  Node: Integer options<2>,  Next: Additional command-line options<2>,  Prev: Boolean options<2>,  Up: Options<4>

3.2.1.8 Integer options
.......................

 -- C++ Function: void gccjit::*Note context: 175.::set_int_option
          (enum gcc_jit_int_option, int value)
     Set an integer option of the context.

     This is a thin wrapper around the C API *Note
     gcc_jit_context_set_int_option(): 1e.; the options have the same
     meaning.


File: libgccjit.info,  Node: Additional command-line options<2>,  Prev: Integer options<2>,  Up: Options<4>

3.2.1.9 Additional command-line options
.......................................

 -- C++ Function: void gccjit::*Note context:
          175.::add_command_line_option (const char *optname)
     Add an arbitrary gcc command-line option to the context for use
     when compiling.

     This is a thin wrapper around the C API *Note
     gcc_jit_context_add_command_line_option(): 74.

     This entrypoint was added in *Note LIBGCCJIT_ABI_1: 75.; you can
     test for its presence using

         #ifdef LIBGCCJIT_HAVE_gcc_jit_context_add_command_line_option


File: libgccjit.info,  Node: Objects<2>,  Next: Types<2>,  Prev: Compilation contexts<2>,  Up: Topic Reference<2>

3.2.2 Objects
-------------

 -- C++ Class: gccjit::object

Almost every entity in the API (with the exception of *Note
gccjit;;context: 175. and *Note gcc_jit_result *: 16.) is a
“contextual” object, a *Note gccjit;;object: 17a.

A JIT object:

        * is associated with a *Note gccjit;;context: 175.

        * is automatically cleaned up for you when its context is
          released so you don’t need to manually track and cleanup
          all objects, just the contexts.

The C++ class hierarchy within the `gccjit' namespace looks like this:

    +- object
        +- location
        +- type
           +- struct
        +- field
        +- function
        +- block
        +- rvalue
            +- lvalue
               +- param
        +- case_

The *Note gccjit;;object: 17a. base class has the following operations:

 -- C++ Function: gccjit::*Note context: 175. gccjit::*Note object:
          17a.::get_context () const
     Which context is the obj within?

 -- C++ Function: std::string gccjit::*Note object:
          17a.::get_debug_string () const
     Generate a human-readable description for the given object.

     For example,

         printf ("obj: %s\n", obj.get_debug_string ().c_str ());

     might give this text on stdout:

         obj: 4.0 * (float)i


File: libgccjit.info,  Node: Types<2>,  Next: Expressions<2>,  Prev: Objects<2>,  Up: Topic Reference<2>

3.2.3 Types
-----------

 -- C++ Class: gccjit::type
     gccjit::type represents a type within the library.  It is a
     subclass of *Note gccjit;;object: 17a.

Types can be created in several ways:

   * fundamental types can be accessed using *Note
     gccjit;;context;;get_type(): 178.:

         gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);

     or using the `gccjit::context::get_int_type' template:

         gccjit::type t = ctxt.get_int_type <unsigned short> ();

     See *Note gcc_jit_context_get_type(): b. for the available types.

   * derived types can be accessed by using functions such as *Note
     gccjit;;type;;get_pointer(): 1f4. and *Note
     gccjit;;type;;get_const(): 1f5.:

         gccjit::type const_int_star = int_type.get_const ().get_pointer ();
         gccjit::type int_const_star = int_type.get_pointer ().get_const ();

   * by creating structures (see below).

* Menu:

* Standard types: Standard types<2>.
* Pointers, const, and volatile: Pointers const and volatile<2>.
* Vector types: Vector types<2>.
* Structures and unions: Structures and unions<2>.


File: libgccjit.info,  Node: Standard types<2>,  Next: Pointers const and volatile<2>,  Up: Types<2>

3.2.3.1 Standard types
......................

 -- C++ Function: gccjit::*Note type: 177. gccjit::*Note context:
          175.::get_type (enum gcc_jit_types)
     Access a specific type.  This is a thin wrapper around *Note
     gcc_jit_context_get_type(): b.; the parameter has the same meaning.

 -- C++ Function: gccjit::*Note type: 177. gccjit::*Note context:
          175.::get_int_type (size_t num_bytes, int is_signed)
     Access the integer type of the given size.

 -- C++ Function: template<>gccjit::*Note type: 177. gccjit::*Note
          context: 175.::get_int_type<T> ()
     Access the given integer type.  For example, you could map the
     `unsigned short' type into a gccjit::type via:

         gccjit::type t = ctxt.get_int_type <unsigned short> ();


File: libgccjit.info,  Node: Pointers const and volatile<2>,  Next: Vector types<2>,  Prev: Standard types<2>,  Up: Types<2>

3.2.3.2 Pointers, `const', and `volatile'
.........................................

 -- C++ Function: gccjit::*Note type: 177. gccjit::*Note type:
          177.::get_pointer ()
     Given type “T”, get type “T*”.

 -- C++ Function: gccjit::*Note type: 177. gccjit::*Note type:
          177.::get_const ()
     Given type “T”, get type “const T”.

 -- C++ Function: gccjit::*Note type: 177. gccjit::*Note type:
          177.::get_volatile ()
     Given type “T”, get type “volatile T”.

 -- C++ Function: gccjit::*Note type: 177. gccjit::*Note type:
          177.::get_aligned (size_t alignment_in_bytes)
     Given type “T”, get type:

         T __attribute__ ((aligned (ALIGNMENT_IN_BYTES)))

     The alignment must be a power of two.

 -- C++ Function: gccjit::*Note type: 177. gccjit::*Note context:
          175.::new_array_type (gccjit::type element_type, int
          num_elements, gccjit::location loc)
     Given type “T”, get type “T[N]” (for a constant N).  Param
     “loc” is optional.


File: libgccjit.info,  Node: Vector types<2>,  Next: Structures and unions<2>,  Prev: Pointers const and volatile<2>,  Up: Types<2>

3.2.3.3 Vector types
....................

 -- C++ Function: gccjit::*Note type: 177. gccjit::*Note type:
          177.::get_vector (size_t num_units)
     Given type “T”, get type:

         T  __attribute__ ((vector_size (sizeof(T) * num_units))

     T must be integral or floating point; num_units must be a power of
     two.


File: libgccjit.info,  Node: Structures and unions<2>,  Prev: Vector types<2>,  Up: Types<2>

3.2.3.4 Structures and unions
.............................

 -- C++ Class: gccjit::struct_

A compound type analagous to a C `struct'.

*Note gccjit;;struct_: 21a. is a subclass of *Note gccjit;;type: 177.
(and thus of *Note gccjit;;object: 17a. in turn).

 -- C++ Class: gccjit::field

A field within a *Note gccjit;;struct_: 21a.

*Note gccjit;;field: 21e. is a subclass of *Note gccjit;;object: 17a.

You can model C `struct' types by creating *Note gccjit;;struct_: 21a.
and *Note gccjit;;field: 21e. instances, in either order:

   * by creating the fields, then the structure.  For example, to model:

         struct coord {double x; double y; };

     you could call:

         gccjit::field field_x = ctxt.new_field (double_type, "x");
         gccjit::field field_y = ctxt.new_field (double_type, "y");
         std::vector fields;
         fields.push_back (field_x);
         fields.push_back (field_y);
         gccjit::struct_ coord = ctxt.new_struct_type ("coord", fields);

   * by creating the structure, then populating it with fields,
     typically to allow modelling self-referential structs such as:

         struct node { int m_hash; struct node *m_next; };

     like this:

         gccjit::struct_ node = ctxt.new_opaque_struct_type ("node");
         gccjit::type node_ptr = node.get_pointer ();
         gccjit::field field_hash = ctxt.new_field (int_type, "m_hash");
         gccjit::field field_next = ctxt.new_field (node_ptr, "m_next");
         std::vector fields;
         fields.push_back (field_hash);
         fields.push_back (field_next);
         node.set_fields (fields);

 -- C++ Function: gccjit::*Note field: 21e. gccjit::*Note context:
          175.::new_field (gccjit::type type, const char *name,
          gccjit::location loc)
     Construct a new field, with the given type and name.

 -- C++ Function: gccjit::*Note struct_: 21a. gccjit::*Note context:
          175.::new_struct_type (const std::string &name,
          std::vector<field> &fields, gccjit::location loc)
          Construct a new struct type, with the given name and fields.

 -- C++ Function: gccjit::*Note struct_: 21a. gccjit::*Note context:
          175.::new_opaque_struct (const std::string &name,
          gccjit::location loc)
     Construct a new struct type, with the given name, but without
     specifying the fields.   The fields can be omitted (in which case
     the size of the struct is not known), or later specified using
     *Note gcc_jit_struct_set_fields(): 93.


File: libgccjit.info,  Node: Expressions<2>,  Next: Creating and using functions<2>,  Prev: Types<2>,  Up: Topic Reference<2>

3.2.4 Expressions
-----------------

* Menu:

* Rvalues: Rvalues<2>.
* Lvalues: Lvalues<2>.
* Working with pointers, structs and unions: Working with pointers structs and unions<2>.


File: libgccjit.info,  Node: Rvalues<2>,  Next: Lvalues<2>,  Up: Expressions<2>

3.2.4.1 Rvalues
...............

 -- C++ Class: gccjit::rvalue

A *Note gccjit;;rvalue: 17e. is an expression that can be computed.  It
is a subclass of *Note gccjit;;object: 17a, and is a thin wrapper around
*Note gcc_jit_rvalue *: 13. from the C API.

It can be simple, e.g.:

        * an integer value e.g. `0' or `42'

        * a string literal e.g. `“Hello world”'

        * a variable e.g. `i'.  These are also lvalues (see below).

or compound e.g.:

        * a unary expression e.g. `!cond'

        * a binary expression e.g. `(a + b)'

        * a function call e.g. `get_distance (&player_ship, &target)'

        * etc.

Every rvalue has an associated type, and the API will check to ensure
that types match up correctly (otherwise the context will emit an
error).

 -- C++ Function: gccjit::*Note type: 177. gccjit::*Note rvalue:
          17e.::get_type ()
     Get the type of this rvalue.

* Menu:

* Simple expressions: Simple expressions<2>.
* Vector expressions: Vector expressions<2>.
* Unary Operations: Unary Operations<2>.
* Binary Operations: Binary Operations<2>.
* Comparisons: Comparisons<2>.
* Function calls: Function calls<2>.
* Function pointers: Function pointers<3>.
* Type-coercion: Type-coercion<2>.


File: libgccjit.info,  Node: Simple expressions<2>,  Next: Vector expressions<2>,  Up: Rvalues<2>

3.2.4.2 Simple expressions
..........................

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_rvalue (gccjit::type numeric_type, int value) const
     Given a numeric type (integer or floating point), build an rvalue
     for the given constant `int' value.

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_rvalue (gccjit::type numeric_type, long value) const
     Given a numeric type (integer or floating point), build an rvalue
     for the given constant `long' value.

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::zero (gccjit::type numeric_type) const
     Given a numeric type (integer or floating point), get the rvalue
     for zero.  Essentially this is just a shortcut for:

         ctxt.new_rvalue (numeric_type, 0)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::one (gccjit::type numeric_type) const
     Given a numeric type (integer or floating point), get the rvalue
     for one.  Essentially this is just a shortcut for:

         ctxt.new_rvalue (numeric_type, 1)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_rvalue (gccjit::type numeric_type, double value)
          const
     Given a numeric type (integer or floating point), build an rvalue
     for the given constant `double' value.

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_rvalue (gccjit::type pointer_type, void *value)
          const
     Given a pointer type, build an rvalue for the given address.

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_rvalue (const std::string &value) const
     Generate an rvalue of type `GCC_JIT_TYPE_CONST_CHAR_PTR' for the
     given string.  This is akin to a string literal.


File: libgccjit.info,  Node: Vector expressions<2>,  Next: Unary Operations<2>,  Prev: Simple expressions<2>,  Up: Rvalues<2>

3.2.4.3 Vector expressions
..........................

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_rvalue (gccjit::type vector_type,
          std::vector<gccjit::rvalue> elements) const
     Given a vector type, and a vector of scalar rvalue elements,
     generate a vector rvalue.

     The number of elements needs to match that of the vector type.


File: libgccjit.info,  Node: Unary Operations<2>,  Next: Binary Operations<2>,  Prev: Vector expressions<2>,  Up: Rvalues<2>

3.2.4.4 Unary Operations
........................

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_unary_op (enum gcc_jit_unary_op, gccjit::type
          result_type, gccjit::rvalue rvalue, gccjit::location loc)
     Build a unary operation out of an input rvalue.

     Parameter `loc' is optional.

     This is a thin wrapper around the C API’s *Note
     gcc_jit_context_new_unary_op(): bf. and the available unary
     operations are documented there.

There are shorter ways to spell the various specific kinds of unary
operation:

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_minus (gccjit::type result_type, gccjit::rvalue a,
          gccjit::location loc)
     Negate an arithmetic value; for example:

         gccjit::rvalue negpi = ctxt.new_minus (t_double, pi);

     builds the equivalent of this C expression:

         -pi

 -- C++ Function: gccjit::*Note rvalue: 17e. new_bitwise_negate
          (gccjit::type result_type, gccjit::rvalue a, gccjit::location
          loc)
     Bitwise negation of an integer value (one’s complement); for
     example:

         gccjit::rvalue mask = ctxt.new_bitwise_negate (t_int, a);

     builds the equivalent of this C expression:

         ~a

 -- C++ Function: gccjit::*Note rvalue: 17e. new_logical_negate
          (gccjit::type result_type, gccjit::rvalue a, gccjit::location
          loc)
     Logical negation of an arithmetic or pointer value; for example:

         gccjit::rvalue guard = ctxt.new_logical_negate (t_bool, cond);

     builds the equivalent of this C expression:

         !cond

The most concise way to spell them is with overloaded operators:

 -- C++ Function: gccjit::*Note rvalue: 17e. operator- (gccjit::rvalue
          a)
         gccjit::rvalue negpi = -pi;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator~ (gccjit::rvalue
          a)
         gccjit::rvalue mask = ~a;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator! (gccjit::rvalue
          a)
         gccjit::rvalue guard = !cond;


File: libgccjit.info,  Node: Binary Operations<2>,  Next: Comparisons<2>,  Prev: Unary Operations<2>,  Up: Rvalues<2>

3.2.4.5 Binary Operations
.........................

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::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.

     Parameter `loc' is optional.

     This is a thin wrapper around the C API’s *Note
     gcc_jit_context_new_binary_op(): 12. and the available binary
     operations are documented there.

There are shorter ways to spell the various specific kinds of binary
operation:

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_plus (gccjit::type result_type, gccjit::rvalue a,
          gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_minus (gccjit::type result_type, gccjit::rvalue a,
          gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_mult (gccjit::type result_type, gccjit::rvalue a,
          gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_divide (gccjit::type result_type, gccjit::rvalue a,
          gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_modulo (gccjit::type result_type, gccjit::rvalue a,
          gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_bitwise_and (gccjit::type result_type,
          gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_bitwise_xor (gccjit::type result_type,
          gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_bitwise_or (gccjit::type result_type,
          gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_logical_and (gccjit::type result_type,
          gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_logical_or (gccjit::type result_type,
          gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)

The most concise way to spell them is with overloaded operators:

 -- C++ Function: gccjit::*Note rvalue: 17e. operator+ (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue sum = a + b;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator- (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue diff = a - b;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator* (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue prod = a * b;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator/ (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue result = a / b;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator% (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue mod = a % b;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator& (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue x = a & b;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator^ (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue x = a ^ b;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator| (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue x = a | b;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator&& (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue cond = a && b;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator|| (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue cond = a || b;

These can of course be combined, giving a terse way to build compound
expressions:

         gccjit::rvalue discriminant = (b * b) - (four * a * c);


File: libgccjit.info,  Node: Comparisons<2>,  Next: Function calls<2>,  Prev: Binary Operations<2>,  Up: Rvalues<2>

3.2.4.6 Comparisons
...................

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::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.

     Parameter `loc' is optional.

     This is a thin wrapper around the C API’s *Note
     gcc_jit_context_new_comparison(): 2c. and the available kinds of
     comparison are documented there.

There are shorter ways to spell the various specific kinds of binary
operation:

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_eq (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_ne (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_lt (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_le (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_gt (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_ge (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

The most concise way to spell them is with overloaded operators:

 -- C++ Function: gccjit::*Note rvalue: 17e. operator== (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue cond = (a == ctxt.zero (t_int));

 -- C++ Function: gccjit::*Note rvalue: 17e. operator!= (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue cond = (i != j);

 -- C++ Function: gccjit::*Note rvalue: 17e. operator< (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue cond = i < n;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator<= (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue cond = i <= n;

 -- C++ Function: gccjit::*Note rvalue: 17e. operator> (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue cond = (ch > limit);

 -- C++ Function: gccjit::*Note rvalue: 17e. operator>= (gccjit::rvalue
          a, gccjit::rvalue b)
         gccjit::rvalue cond = (score >= ctxt.new_rvalue (t_int, 100));


File: libgccjit.info,  Node: Function calls<2>,  Next: Function pointers<3>,  Prev: Comparisons<2>,  Up: Rvalues<2>

3.2.4.7 Function calls
......................

 -- 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 call to the function, with the result as an rvalue.

          Note: `gccjit::context::new_call()' merely builds a *Note
          gccjit;;rvalue: 17e. i.e. an expression that can be evaluated,
          perhaps as part of a more complicated expression.  The call
          `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 `void' return type), use
          *Note gccjit;;block;;add_eval(): 302.:

              /* Add "(void)printf (arg0, arg1);".  */
              block.add_eval (ctxt.new_call (printf_func, arg0, arg1));


File: libgccjit.info,  Node: Function pointers<3>,  Next: Type-coercion<2>,  Prev: Function calls<2>,  Up: Rvalues<2>

3.2.4.8 Function pointers
.........................

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note function:
          18c.::get_address (gccjit::location loc)
     Get the address of a function as an rvalue, of function pointer
     type.


File: libgccjit.info,  Node: Type-coercion<2>,  Prev: Function pointers<3>,  Up: Rvalues<2>

3.2.4.9 Type-coercion
.....................

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note context:
          175.::new_cast (gccjit::rvalue rvalue, gccjit::type type,
          gccjit::location loc)
     Given an rvalue of T, construct another rvalue of another type.

     Currently only a limited set of conversions are possible:

             * int <-> float

             * int <-> bool

             * P*  <-> Q*, for pointer types P and Q


File: libgccjit.info,  Node: Lvalues<2>,  Next: Working with pointers structs and unions<2>,  Prev: Rvalues<2>,  Up: Expressions<2>

3.2.4.10 Lvalues
................

 -- C++ Class: gccjit::lvalue

An lvalue is something that can of the `left'-hand side of an
assignment: a storage area (such as a variable).  It is a subclass of
*Note gccjit;;rvalue: 17e, where the rvalue is computed by reading from
the storage area.

It iss a thin wrapper around *Note gcc_jit_lvalue *: 24. from the C API.

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note lvalue:
          187.::get_address (gccjit::location loc)
     Take the address of an lvalue; analogous to:

         &(EXPR)

     in C.

     Parameter “loc” is optional.

* Menu:

* Global variables: Global variables<2>.


File: libgccjit.info,  Node: Global variables<2>,  Up: Lvalues<2>

3.2.4.11 Global variables
.........................

 -- C++ Function: gccjit::*Note lvalue: 187. gccjit::*Note context:
          175.::new_global (enum gcc_jit_global_kind, gccjit::type
          type, const char *name, gccjit::location loc)
     Add a new global variable of the given type and name to the
     context.

     This is a thin wrapper around *Note gcc_jit_context_new_global():
     f5. from the C API; the “kind” parameter has the same meaning
     as there.


File: libgccjit.info,  Node: Working with pointers structs and unions<2>,  Prev: Lvalues<2>,  Up: Expressions<2>

3.2.4.12 Working with pointers, structs and unions
..................................................

 -- C++ Function: gccjit::*Note lvalue: 187. gccjit::*Note rvalue:
          17e.::dereference (gccjit::location loc)
     Given an rvalue of pointer type `T *', dereferencing the pointer,
     getting an lvalue of type `T'.  Analogous to:

         *(EXPR)

     in C.

     Parameter “loc” is optional.

If you don’t need to specify the location, this can also be expressed
using an overloaded operator:

 -- C++ Function: gccjit::*Note lvalue: 187. gccjit::*Note rvalue:
          17e.::operator* ()
         gccjit::lvalue content = *ptr;

Field access is provided separately for both lvalues and rvalues:

 -- C++ Function: gccjit::*Note lvalue: 187. gccjit::*Note lvalue:
          187.::access_field (gccjit::field field, gccjit::location loc)
     Given an lvalue of struct or union type, access the given field,
     getting an lvalue of the field’s type.  Analogous to:

         (EXPR).field = ...;

     in C.

 -- C++ Function: gccjit::*Note rvalue: 17e. gccjit::*Note rvalue:
          17e.::access_field (gccjit::field field, gccjit::location loc)
     Given an rvalue of struct or union type, access the given field as
     an rvalue.  Analogous to:

         (EXPR).field

     in C.

 -- C++ Function: gccjit::*Note lvalue: 187. gccjit::*Note rvalue:
          17e.::dereference_field (gccjit::field field,
          gccjit::location loc)
     Given an rvalue of pointer type `T *' where T is of struct or union
     type, access the given field as an lvalue.  Analogous to:

         (EXPR)->field

     in C, itself equivalent to `(*EXPR).FIELD'.

 -- C++ Function: gccjit::*Note lvalue: 187. gccjit::*Note context:
          175.::new_array_access (gccjit::rvalue ptr, gccjit::rvalue
          index, gccjit::location loc)
     Given an rvalue of pointer type `T *', get at the element `T' at
     the given index, using standard C array indexing rules i.e. each
     increment of `index' corresponds to `sizeof(T)' bytes.  Analogous
     to:

         PTR[INDEX]

     in C (or, indeed, to `PTR + INDEX').

     Parameter “loc” is optional.

For array accesses where you don’t need to specify a *Note
gccjit;;location: 19b, two overloaded operators are available:

     gccjit::lvalue gccjit::rvalue::operator[] (gccjit::rvalue index)

         gccjit::lvalue element = array[idx];

     gccjit::lvalue gccjit::rvalue::operator[] (int index)

         gccjit::lvalue element = array[0];


File: libgccjit.info,  Node: Creating and using functions<2>,  Next: Source Locations<2>,  Prev: Expressions<2>,  Up: Topic Reference<2>

3.2.5 Creating and using functions
----------------------------------

* Menu:

* Params: Params<2>.
* Functions: Functions<2>.
* Blocks: Blocks<2>.
* Statements: Statements<2>.


File: libgccjit.info,  Node: Params<2>,  Next: Functions<2>,  Up: Creating and using functions<2>

3.2.5.1 Params
..............

 -- C++ Class: gccjit::param
     A `gccjit::param' represents a parameter to a function.

 -- C++ Function: gccjit::*Note param: 188. gccjit::*Note context:
          175.::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.

*Note gccjit;;param: 188. is a subclass of *Note gccjit;;lvalue: 187.
(and thus of *Note gccjit;;rvalue: 17e. and *Note gccjit;;object:
17a.).  It is a thin wrapper around the C API’s *Note gcc_jit_param
*: 25.


File: libgccjit.info,  Node: Functions<2>,  Next: Blocks<2>,  Prev: Params<2>,  Up: Creating and using functions<2>

3.2.5.2 Functions
.................

 -- C++ Class: gccjit::function
     A `gccjit::function' represents a function - either one that
     we’re creating ourselves, or one that we’re referencing.

 -- C++ Function: gccjit::*Note function: 18c. gccjit::*Note context:
          175.::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.

     Parameters “is_variadic” and “loc” are optional.

     This is a wrapper around the C API’s *Note
     gcc_jit_context_new_function(): 11.

 -- C++ Function: gccjit::*Note function: 18c. gccjit::*Note context:
          175.::get_builtin_function (const char *name)
     This is a wrapper around the C API’s *Note
     gcc_jit_context_get_builtin_function(): 10e.

 -- C++ Function: gccjit::*Note param: 188. gccjit::*Note function:
          18c.::get_param (int index) const
     Get the param of the given index (0-based).

 -- C++ Function: void gccjit::*Note function: 18c.::dump_to_dot (const
          char *path)
     Emit the function in graphviz format to the given path.

 -- C++ Function: gccjit::*Note lvalue: 187. gccjit::*Note function:
          18c.::new_local (gccjit::type type, const char *name,
          gccjit::location loc)
     Create a new local variable within the function, of the given type
     and name.


File: libgccjit.info,  Node: Blocks<2>,  Next: Statements<2>,  Prev: Functions<2>,  Up: Creating and using functions<2>

3.2.5.3 Blocks
..............

 -- C++ Class: gccjit::block
     A `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.

     *Note gccjit;;block: 18b. is a subclass of *Note gccjit;;object:
     17a.

     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, a return, or a
     switch.

     It’s legal to have multiple basic blocks that return within one
     function.

 -- C++ Function: gccjit::*Note block: 18b. gccjit::*Note function:
          18c.::new_block (const char *name)
     Create a basic block of the given name.  The name may be NULL, but
     providing meaningful names is often helpful when debugging: it may
     show up in dumps of the internal representation, and in error
     messages.


File: libgccjit.info,  Node: Statements<2>,  Prev: Blocks<2>,  Up: Creating and using functions<2>

3.2.5.4 Statements
..................

 -- C++ Function: void gccjit::*Note block: 18b.::add_eval
          (gccjit::rvalue rvalue, gccjit::location loc)
     Add evaluation of an rvalue, discarding the result (e.g. a
     function call that “returns” void).

     This is equivalent to this C code:

         (void)expression;

 -- C++ Function: void gccjit::*Note block: 18b.::add_assignment
          (gccjit::lvalue lvalue, gccjit::rvalue rvalue,
          gccjit::location loc)
     Add evaluation of an rvalue, assigning the result to the given
     lvalue.

     This is roughly equivalent to this C code:

         lvalue = rvalue;

 -- C++ Function: void gccjit::*Note block: 18b.::add_assignment_op
          (gccjit::lvalue lvalue, enum gcc_jit_binary_op,
          gccjit::rvalue rvalue, gccjit::location loc)
     Add evaluation of an rvalue, using the result to modify an lvalue.

     This is analogous to “+=” and friends:

         lvalue += rvalue;
         lvalue *= rvalue;
         lvalue /= rvalue;

     etc.  For example:

         /* "i++" */
         loop_body.add_assignment_op (
           i,
           GCC_JIT_BINARY_OP_PLUS,
           ctxt.one (int_type));

 -- C++ Function: void gccjit::*Note block: 18b.::add_comment (const
          char *text, gccjit::location loc)
     Add a no-op textual comment to the internal representation of the
     code.  It will be optimized away, but will be visible in the dumps
     seen via *Note GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE: 66.  and
     *Note GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE: 1c, and thus may be
     of use when debugging how your project’s internal representation
     gets converted to the libgccjit IR.

     Parameter “loc” is optional.

 -- C++ Function: void gccjit::*Note block: 18b.::end_with_conditional
          (gccjit::rvalue boolval, gccjit::block on_true, gccjit::block
          on_false, gccjit::location loc)
     Terminate a block by adding evaluation of an rvalue, branching on
     the result to the appropriate successor block.

     This is roughly equivalent to this C code:

         if (boolval)
           goto on_true;
         else
           goto on_false;

     block, boolval, on_true, and on_false must be non-NULL.

 -- C++ Function: void gccjit::*Note block: 18b.::end_with_jump
          (gccjit::block target, gccjit::location loc)
     Terminate a block by adding a jump to the given target block.

     This is roughly equivalent to this C code:

         goto target;

 -- C++ Function: void gccjit::*Note block: 18b.::end_with_return
          (gccjit::rvalue rvalue, gccjit::location loc)
     Terminate a block.

     Both params are optional.

     An rvalue must be provided for a function returning non-void, and
     must not be provided by a function “returning” `void'.

     If an rvalue is provided, the block is terminated by evaluating the
     rvalue and returning the value.

     This is roughly equivalent to this C code:

         return expression;

     If an rvalue is not provided, the block is terminated by adding a
     valueless return, for use within a function with “void” return
     type.

     This is equivalent to this C code:

         return;

 -- C++ Function: void gccjit::*Note block: 18b.::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:

         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;
         }

     `expr' must be of the same integer type as all of the `min_value'
     and `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:

             * *Note gccjit;;block;;end_with_switch(): 372.

             * `gccjit::context::new_case()'

     were added in *Note LIBGCCJIT_ABI_3: 11f.; you can test for their
     presence using

         #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS

     A `gccjit::case_' represents a case within a switch statement, and
     is created within a particular *Note gccjit;;context: 175. using
     `gccjit::context::new_case()'.  It is a subclass of *Note
     gccjit;;object: 17a.

     Each case expresses a multivalued range of integer values.  You
     can express single-valued cases by passing in the same value for
     both `min_value' and `max_value'.

     Here’s an example of creating a switch statement:


              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));
              }


File: libgccjit.info,  Node: Source Locations<2>,  Next: Compiling a context<2>,  Prev: Creating and using functions<2>,  Up: Topic Reference<2>

3.2.6 Source Locations
----------------------

 -- C++ Class: gccjit::location
     A `gccjit::location' encapsulates a source code location, so that
     you can (optionally) associate locations in your language with
     statements in the JIT-compiled code, allowing the debugger to
     single-step through your language.

     `gccjit::location' instances are optional: you can always omit them
     from any C++ API entrypoint accepting one.

     You can construct them using *Note
     gccjit;;context;;new_location(): 1a1.

     You need to enable *Note GCC_JIT_BOOL_OPTION_DEBUGINFO: 42. on the
     *Note gccjit;;context: 175. for these locations to actually be
     usable by the debugger:

         ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DEBUGINFO, 1);

 -- C++ Function: gccjit::*Note location: 19b. gccjit::*Note context:
          175.::new_location (const char *filename, int line, int
          column)
     Create a `gccjit::location' instance representing the given source
     location.

* Menu:

* Faking it: Faking it<2>.


File: libgccjit.info,  Node: Faking it<2>,  Up: Source Locations<2>

3.2.6.1 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 *Note gccjit;;context;;dump_to_file():
1c0.:

    ctxt.dump_to_file ("/tmp/something.c",
                       1 /* update_locations */);

This will dump C-like code to the given path.  If the `update_locations'
argument is true, this will also set up `gccjit::location' information
throughout the context, pointing at the dump file as if it were a source
file, giving you `something' you can step through in the debugger.


File: libgccjit.info,  Node: Compiling a context<2>,  Next: Using Assembly Language with libgccjit++,  Prev: Source Locations<2>,  Up: Topic Reference<2>

3.2.7 Compiling a context
-------------------------

Once populated, a *Note gccjit;;context: 175. can be compiled to
machine code, either in-memory via *Note gccjit;;context;;compile():
17f. or to disk via *Note gccjit;;context;;compile_to_file(): 381.

You can compile a context multiple times (using either form of
compilation), although any errors that occur on the context will
prevent any future compilation of that context.

* Menu:

* In-memory compilation: In-memory compilation<2>.
* Ahead-of-time compilation: Ahead-of-time compilation<2>.


File: libgccjit.info,  Node: In-memory compilation<2>,  Next: Ahead-of-time compilation<2>,  Up: Compiling a context<2>

3.2.7.1 In-memory compilation
.............................

 -- C++ Function: gcc_jit_result *gccjit::*Note context: 175.::compile
          ()
     This calls into GCC and builds the code, returning a
     `gcc_jit_result *'.

     This is a thin wrapper around the *Note gcc_jit_context_compile():
     15. API entrypoint.


File: libgccjit.info,  Node: Ahead-of-time compilation<2>,  Prev: In-memory compilation<2>,  Up: Compiling a context<2>

3.2.7.2 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 *Note gccjit;;context;;compile_to_file(): 381.
method.

 -- C++ Function: void gccjit::*Note context: 175.::compile_to_file
          (enum gcc_jit_output_kind, const char *output_path)
     Compile the *Note gccjit;;context: 175. to a file of the given
     kind.

     This is a thin wrapper around the *Note
     gcc_jit_context_compile_to_file(): 4a. API entrypoint.


File: libgccjit.info,  Node: Using Assembly Language with libgccjit++,  Prev: Compiling a context<2>,  Up: Topic Reference<2>

3.2.8 Using Assembly Language with libgccjit++
----------------------------------------------

libgccjit has some support for directly embedding assembler
instructions.  This is based on GCC’s support for inline `asm' in C
code, and the following assumes a familiarity with that functionality.
See How to Use Inline Assembly Language in C Code(1) in GCC’s
documentation, the “Extended Asm” section in particular.

These entrypoints were added in *Note LIBGCCJIT_ABI_15: 151.; you can
test for their presence using

         #ifdef LIBGCCJIT_HAVE_ASM_STATEMENTS

* Menu:

* Adding assembler instructions within a function: Adding assembler instructions within a function<2>.
* Adding top-level assembler statements: Adding top-level assembler statements<2>.

---------- Footnotes ----------

(1)
https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-with-C.html


File: libgccjit.info,  Node: Adding assembler instructions within a function<2>,  Next: Adding top-level assembler statements<2>,  Up: Using Assembly Language with libgccjit++

3.2.8.1 Adding assembler instructions within a function
.......................................................

 -- C++ Class: gccjit::extended_asm
     A `gccjit::extended_asm' represents an extended `asm' statement: a
     series of low-level instructions inside a function that convert
     inputs to outputs.

     *Note gccjit;;extended_asm: 38d. is a subclass of *Note
     gccjit;;object: 17a.  It is a thin wrapper around the C API’s
     *Note gcc_jit_extended_asm *: 120.

     To avoid having an API entrypoint with a very large number of
     parameters, an extended `asm' statement is made in stages: an
     initial call to create the *Note gccjit;;extended_asm: 38d,
     followed by calls to add operands and set other properties of the
     statement.

     There are two API entrypoints for creating a *Note
     gccjit;;extended_asm: 38d.:

        * *Note gccjit;;block;;add_extended_asm(): 391. for an `asm'
          statement with no control flow, and

        * *Note gccjit;;block;;end_with_extended_asm_goto(): 392. for
          an `asm goto'.

     For example, to create the equivalent of:

                asm ("mov %1, %0\n\t"
                     "add $1, %0"
                     : "=r" (dst)
                     : "r" (src));

     the following API calls could be used:

             block.add_extended_asm ("mov %1, %0\n\t"
                                     "add $1, %0")
             .add_output_operand ("=r", dst)
             .add_input_operand ("r", src);

          Warning: When considering the numbering of operands within an
          extended `asm' statement (e.g. the `%0' and `%1' above), the
          equivalent to the C syntax is followed i.e. all output
          operands, then all input operands, regardless of what order
          the calls to *Note
          gccjit;;extended_asm;;add_output_operand(): 393. and *Note
          gccjit;;extended_asm;;add_input_operand(): 394. were made in.

     As in the C syntax, operands can be given symbolic names to avoid
     having to number them.  For example, to create the equivalent of:

                asm ("bsfl %[aMask], %[aIndex]"
                     : [aIndex] "=r" (Index)
                     : [aMask] "r" (Mask)
                     : "cc");

     the following API calls could be used:

             block.add_extended_asm ("bsfl %[aMask], %[aIndex]")
             .add_output_operand ("aIndex", "=r", index)
             .add_input_operand ("aMask", "r", mask)
             .add_clobber ("cc");

 -- C++ Function: *Note extended_asm: 38d. gccjit::*Note block:
          18b.::add_extended_asm (const std::string &asm_template,
          gccjit::location loc = location())
     Create a *Note gccjit;;extended_asm: 38d. for an extended `asm'
     statement with no control flow (i.e. without the `goto' qualifier).

     The parameter `asm_template' corresponds to the `AssemblerTemplate'
     within C’s extended `asm' syntax.  It must be non-NULL.  The
     call takes a copy of the underlying string, so it is valid to pass
     in a pointer to an on-stack buffer.

 -- C++ Function: *Note extended_asm: 38d. gccjit::*Note block:
          18b.::end_with_extended_asm_goto (const std::string
          &asm_template, std::vector<block> goto_blocks, block
          *fallthrough_block, location loc = location())
     Create a *Note gccjit;;extended_asm: 38d. for an extended `asm'
     statement that may perform jumps, and use it to terminate the
     given block.  This is equivalent to the `goto' qualifier in C’s
     extended `asm' syntax.

     For example, to create the equivalent of:

                asm goto ("btl %1, %0\n\t"
                          "jc %l[carry]"
                          : // No outputs
                          : "r" (p1), "r" (p2)
                          : "cc"
                          : carry);

     the following API calls could be used:

           const char *asm_template =
             (use_name
              ? /* Label referred to by name: "%l[carry]".  */
                ("btl %1, %0\n\t"
                 "jc %l[carry]")
              : /* Label referred to numerically: "%l2".  */
                ("btl %1, %0\n\t"
                 "jc %l2"));

           std::vector<gccjit::block> goto_blocks ({b_carry});
           gccjit::extended_asm ext_asm
             = (b_start.end_with_extended_asm_goto (asm_template,
         					  goto_blocks,
         					  &b_fallthru)
                .add_input_operand ("r", p1)
                .add_input_operand ("r", p2)
                .add_clobber ("cc"));

     here referencing a `gcc_jit_block' named “carry”.

     `num_goto_blocks' corresponds to the `GotoLabels' parameter within
     C’s extended `asm' syntax.  The block names can be referenced
     within the assembler template.

     `fallthrough_block' can be NULL.  If non-NULL, it specifies the
     block to fall through to after the statement.

          Note: This is needed since each *Note gccjit;;block: 18b.
          must have a single exit point, as a basic block: you can’t
          jump from the middle of a block.  A “goto” is implicitly
          added after the asm to handle the fallthrough case, which is
          equivalent to what would have happened in the C case.

 -- C++ Function: gccjit::*Note extended_asm: 38d. &gccjit::*Note
          extended_asm: 38d.::set_volatile_flag (bool flag)
     Set whether the *Note gccjit;;extended_asm: 38d. has side-effects,
     equivalent to the volatile(1) qualifier in C’s extended asm
     syntax.

     For example, to create the equivalent of:

         asm volatile ("rdtsc\n\t"    // Returns the time in EDX:EAX.
                        "shl $32, %%rdx\n\t"  // Shift the upper bits left.
                        "or %%rdx, %0"        // 'Or' in the lower bits.
                        : "=a" (msr)
                        :
                        : "rdx");

     the following API calls could be used:

           gccjit::extended_asm ext_asm
             = block.add_extended_asm
         	("rdtsc\n\t"  /* Returns the time in EDX:EAX.  */
         	 "shl $32, %%rdx\n\t"  /* Shift the upper bits left.  */
         	 "or %%rdx, %0")  /* 'Or' in the lower bits.  */
             .set_volatile_flag (true)
             .add_output_operand ("=a", msr)
             .add_clobber ("rdx");

     where the *Note gccjit;;extended_asm: 38d. is flagged as volatile.

 -- C++ Function: gccjit::*Note extended_asm: 38d. &gccjit::*Note
          extended_asm: 38d.::set_inline_flag (bool flag)
     Set the equivalent of the inline(2) qualifier in C’s extended
     `asm' syntax.

 -- C++ Function: gccjit::*Note extended_asm: 38d. &gccjit::*Note
          extended_asm: 38d.::add_output_operand (const std::string
          &asm_symbolic_name, const std::string &constraint,
          gccjit::lvalue dest)
     Add an output operand to the extended `asm' statement.  See the
     Output Operands(3) section of the documentation of the C syntax.

     `asm_symbolic_name' corresponds to the `asmSymbolicName' component
     of C’s extended `asm' syntax, and specifies the symbolic name
     for the operand.  See the overload below for an alternative that
     does not supply a symbolic name.

     `constraint' corresponds to the `constraint' component of C’s
     extended `asm' syntax.

     `dest' corresponds to the `cvariablename' component of C’s
     extended `asm' syntax.

         // Example with a symbolic name ("aIndex"), the equivalent of:
         //   : [aIndex] "=r" (index)
         ext_asm.add_output_operand ("aIndex", "=r", index);

     This function can’t be called on an `asm goto' as such
     instructions can’t have outputs; see the Goto Labels(4) section
     of GCC’s “Extended Asm” documentation.

 -- C++ Function: gccjit::*Note extended_asm: 38d. &gccjit::*Note
          extended_asm: 38d.::add_output_operand (const std::string
          &constraint, gccjit::lvalue dest)
     As above, but don’t supply a symbolic name for the operand.

         // Example without a symbolic name, the equivalent of:
         //   : "=r" (dst)
         ext_asm.add_output_operand ("=r", dst);

 -- C++ Function: gccjit::*Note extended_asm: 38d. &gccjit::*Note
          extended_asm: 38d.::add_input_operand (const std::string
          &asm_symbolic_name, const std::string &constraint,
          gccjit::rvalue src)
     Add an input operand to the extended `asm' statement.  See the
     Input Operands(5) section of the documentation of the C syntax.

     `asm_symbolic_name' corresponds to the `asmSymbolicName' component
     of C’s extended `asm' syntax.  See the overload below for an
     alternative that does not supply a symbolic name.

     `constraint' corresponds to the `constraint' component of C’s
     extended `asm' syntax.

     `src' corresponds to the `cexpression' component of C’s extended
     `asm' syntax.

         // Example with a symbolic name ("aMask"), the equivalent of:
         //   : [aMask] "r" (Mask)
         ext_asm.add_input_operand ("aMask", "r", mask);

 -- C++ Function: gccjit::*Note extended_asm: 38d. &gccjit::*Note
          extended_asm: 38d.::add_input_operand (const std::string
          &constraint, gccjit::rvalue src)
     As above, but don’t supply a symbolic name for the operand.

         // Example without a symbolic name, the equivalent of:
         //   : "r" (src)
         ext_asm.add_input_operand ("r", src);

 -- C++ Function: gccjit::*Note extended_asm: 38d. &gccjit::*Note
          extended_asm: 38d.::add_clobber (const std::string &victim)
     Add `victim' to the list of registers clobbered by the extended
     `asm' statement.  See the Clobbers and Scratch Registers(6)
     section of the documentation of the C syntax.

     Statements with multiple clobbers will require multiple calls, one
     per clobber.

     For example:

         ext_asm.add_clobber ("r0").add_clobber ("cc").add_clobber ("memory");

---------- Footnotes ----------

(1) https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#Volatile

(2)
https://gcc.gnu.org/onlinedocs/gcc/Size-of-an-asm.html#Size-of-an-asm

(3) https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#OutputOperands

(4) https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#GotoLabels

(5) https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands

(6)
https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#Clobbers-and-Scratch-Registers#


File: libgccjit.info,  Node: Adding top-level assembler statements<2>,  Prev: Adding assembler instructions within a function<2>,  Up: Using Assembly Language with libgccjit++

3.2.8.2 Adding top-level assembler statements
.............................................

In addition to creating extended `asm' instructions within a function,
there is support for creating “top-level” assembler statements,
outside of any function.

 -- C++ Function: void gccjit::*Note context: 175.::add_top_level_asm
          (const char *asm_stmts, gccjit::location loc = location())
     Create a set of top-level asm statements, analogous to those
     created by GCC’s “basic” `asm' syntax in C at file scope.

     For example, to create the equivalent of:

              asm ("\t.pushsection .text\n"
                   "\t.globl add_asm\n"
                   "\t.type add_asm, @function\n"
                   "add_asm:\n"
                   "\tmovq %rdi, %rax\n"
                   "\tadd %rsi, %rax\n"
                   "\tret\n"
                   "\t.popsection\n");

     the following API calls could be used:

           ctxt.add_top_level_asm ("\t.pushsection .text\n"
                                   "\t.globl add_asm\n"
                                   "\t.type add_asm, @function\n"
                                   "add_asm:\n"
                                   "\tmovq %rdi, %rax\n"
                                   "\tadd %rsi, %rax\n"
                                   "\tret\n"
                                   "\t# some asm here\n"
                                   "\t.popsection\n");


File: libgccjit.info,  Node: Internals,  Next: Indices and tables,  Prev: C++ bindings for libgccjit,  Up: Top

4 Internals
***********

* Menu:

* Working on the JIT library::
* Running the test suite::
* Environment variables::
* Packaging notes::
* Overview of code structure::
* Design notes::
* Submitting patches::


File: libgccjit.info,  Node: Working on the JIT library,  Next: Running the test suite,  Up: Internals

4.1 Working on the JIT library
==============================

Having checked out the source code (to “src”), you can configure
and build the JIT library like this:

    mkdir build
    mkdir install
    PREFIX=$(pwd)/install
    cd build
    ../src/configure \
       --enable-host-shared \
       --enable-languages=jit,c++ \
       --disable-bootstrap \
       --enable-checking=release \
       --prefix=$PREFIX
    nice make -j4 # altering the "4" to however many cores you have

This should build a libgccjit.so within jit/build/gcc:

    [build] $ file gcc/libgccjit.so*
    gcc/libgccjit.so:       symbolic link to `libgccjit.so.0'
    gcc/libgccjit.so.0:     symbolic link to `libgccjit.so.0.0.1'
    gcc/libgccjit.so.0.0.1: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, not stripped

Here’s what those configuration options mean:

 -- Option: --enable-host-shared
     Configuring with this option means that the compiler is built as
     position-independent code, which incurs a slight performance hit,
     but it necessary for a shared library.

 -- Option: --enable-languages=jit,c++
     This specifies which frontends to build.  The JIT library looks
     like a frontend to the rest of the code.

     The C++ portion of the JIT test suite requires the C++ frontend to
     be enabled at configure-time, or you may see errors like this when
     running the test suite:

         xgcc: error: /home/david/jit/src/gcc/testsuite/jit.dg/test-quadratic.cc: C++ compiler not installed on this system
         c++: error trying to exec 'cc1plus': execvp: No such file or directory

 -- Option: --disable-bootstrap
     For hacking on the “jit” subdirectory, performing a full
     bootstrap can be overkill, since it’s unused by a bootstrap.
     However, when submitting patches, you should remove this option,
     to ensure that the compiler can still bootstrap itself.

 -- Option: --enable-checking=release
     The compile can perform extensive self-checking as it runs, useful
     when debugging, but slowing things down.

     For maximum speed, configure with `--enable-checking=release' to
     disable this self-checking.


File: libgccjit.info,  Node: Running the test suite,  Next: Environment variables,  Prev: Working on the JIT library,  Up: Internals

4.2 Running the test suite
==========================

    [build] $ cd gcc
    [gcc] $ make check-jit RUNTESTFLAGS="-v -v -v"

A summary of the tests can then be seen in:

    jit/build/gcc/testsuite/jit/jit.sum

and detailed logs in:

    jit/build/gcc/testsuite/jit/jit.log

The test executables are normally deleted after each test is run.  For
debugging, they can be preserved by setting `PRESERVE_EXECUTABLES' in
the environment.  If so, they can then be seen as:

    jit/build/gcc/testsuite/jit/*.exe

which can be run independently.

You can compile and run individual tests by passing
“jit.exp=TESTNAME” to RUNTESTFLAGS e.g.:

    [gcc] $ PRESERVE_EXECUTABLES= \
              make check-jit \
                RUNTESTFLAGS="-v -v -v jit.exp=test-factorial.c"

and once a test has been compiled, you can debug it directly:

    [gcc] $ PATH=.:$PATH \
            LD_LIBRARY_PATH=. \
            LIBRARY_PATH=. \
              gdb --args \
                testsuite/jit/test-factorial.c.exe

* Menu:

* Running under valgrind::


File: libgccjit.info,  Node: Running under valgrind,  Up: Running the test suite

4.2.1 Running under valgrind
----------------------------

The jit testsuite detects if `RUN_UNDER_VALGRIND' is present in the
environment (with any value).  If it is present, it runs the test client
code under valgrind(1), specifcally, the default memcheck(2) tool with
-leak-check=full(3).

It automatically parses the output from valgrind, injecting XFAIL
results if any issues are found, or PASS results if the output is
clean.  The output is saved to `TESTNAME.exe.valgrind.txt'.

For example, the following invocation verbosely runs the testcase
`test-sum-of-squares.c' under valgrind, showing an issue:

    $ RUN_UNDER_VALGRIND= \
        make check-jit \
          RUNTESTFLAGS="-v -v -v jit.exp=test-sum-of-squares.c"

    (...verbose log contains detailed valgrind errors, if any...)

                    === jit Summary ===

    # of expected passes            28
    # of expected failures          2

    $ less testsuite/jit/jit.sum
    (...other results...)
    XFAIL: jit.dg/test-sum-of-squares.c: test-sum-of-squares.c.exe.valgrind.txt: definitely lost: 8 bytes in 1 blocks
    XFAIL: jit.dg/test-sum-of-squares.c: test-sum-of-squares.c.exe.valgrind.txt: unsuppressed errors: 1
    (...other results...)

    $ less testsuite/jit/test-sum-of-squares.c.exe.valgrind.txt
    (...shows full valgrind report for this test case...)

When running under valgrind, it’s best to have configured gcc with
`--enable-valgrind-annotations', which automatically suppresses various
known false positives.

---------- Footnotes ----------

(1) https://valgrind.org

(2) https://valgrind.org/docs/manual/mc-manual.html

(3) https://valgrind.org/docs/manual/mc-manual.html#opt.leak-check


File: libgccjit.info,  Node: Environment variables,  Next: Packaging notes,  Prev: Running the test suite,  Up: Internals

4.3 Environment variables
=========================

When running client code against a locally-built libgccjit, three
environment variables need to be set up:

 -- Environment Variable: LD_LIBRARY_PATH
          `libgccjit.so' is dynamically linked into client code, so if
          running against a locally-built library, `LD_LIBRARY_PATH'
          needs to be set up appropriately.  The library can be found
          within the “gcc” subdirectory of the build tree:

         $ file libgccjit.so*
         libgccjit.so:       symbolic link to `libgccjit.so.0'
         libgccjit.so.0:     symbolic link to `libgccjit.so.0.0.1'
         libgccjit.so.0.0.1: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, not stripped

 -- Environment Variable: PATH
     The library uses a driver executable for converting from .s
     assembler files to .so shared libraries.  Specifically, it looks
     for a name expanded from
     `${target_noncanonical}-gcc-${gcc_BASEVER}${exeext}' such as
     `x86_64-unknown-linux-gnu-gcc-5.0.0'.

     Hence `PATH' needs to include a directory where the library can
     locate this executable.

     The executable is normally installed to the installation bindir
     (e.g. /usr/bin), but a copy is also created within the “gcc”
     subdirectory of the build tree for running the testsuite, and for
     ease of development.

 -- Environment Variable: LIBRARY_PATH
     The driver executable invokes the linker, and the latter needs to
     locate support libraries needed by the generated code, or you will
     see errors like:

         ld: cannot find crtbeginS.o: No such file or directory
         ld: cannot find -lgcc
         ld: cannot find -lgcc_s

     Hence if running directly from a locally-built copy (without
     installing), `LIBRARY_PATH' needs to contain the “gcc”
     subdirectory of the build tree.

For example, to run a binary that uses the library against a
non-installed build of the library in LIBGCCJIT_BUILD_DIR you need an
invocation of the client code like this, to preprend the dir to each of
the environment variables:

    $ LD_LIBRARY_PATH=$(LIBGCCJIT_BUILD_DIR):$(LD_LIBRARY_PATH) \
      PATH=$(LIBGCCJIT_BUILD_DIR):$(PATH) \
      LIBRARY_PATH=$(LIBGCCJIT_BUILD_DIR):$(LIBRARY_PATH) \
        ./jit-hello-world
    hello world


File: libgccjit.info,  Node: Packaging notes,  Next: Overview of code structure,  Prev: Environment variables,  Up: Internals

4.4 Packaging notes
===================

The configure-time option *Note -enable-host-shared: 3bd. 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:

        * once without *Note -enable-host-shared: 3bd. for most
          languages, and

        * once with *Note -enable-host-shared: 3bd. for the jit

For example:

    # Configure and build with --enable-host-shared
    # for the jit:
    mkdir configuration-for-jit
    pushd configuration-for-jit
    $(SRCDIR)/configure \
      --enable-host-shared \
      --enable-languages=jit \
      --prefix=$(DESTDIR)
    make
    popd

    # Configure and build *without* --enable-host-shared
    # for maximum speed:
    mkdir standard-configuration
    pushd standard-configuration
    $(SRCDIR)/configure \
      --enable-languages=all \
      --prefix=$(DESTDIR)
    make
    popd

    # Both of the above are configured to install to $(DESTDIR)
    # Install the configuration with --enable-host-shared first
    # *then* the one without, so that the faster build
    # of "cc1" et al overwrites the slower build.
    pushd configuration-for-jit
    make install
    popd

    pushd standard-configuration
    make install
    popd


File: libgccjit.info,  Node: Overview of code structure,  Next: Design notes,  Prev: Packaging notes,  Up: Internals

4.5 Overview of code structure
==============================

The library is implemented in C++.  The source files have the `.c'
extension for legacy reasons.

   * `libgccjit.cc' implements the API entrypoints.  It performs error
     checking, then calls into classes of the gcc::jit::recording
     namespace within `jit-recording.cc' and `jit-recording.h'.

   * The gcc::jit::recording classes (within `jit-recording.cc' and
     `jit-recording.h') record the API calls that are made:


                /* Indentation indicates inheritance: */
                class context;
                class memento;
                  class string;
                  class location;
                  class type;
                    class function_type;
                    class compound_type;
                      class struct_;
              	class union_;
                    class vector_type;
                  class field;
                    class bitfield;
                  class fields;
                  class function;
                  class block;
                  class rvalue;
                    class lvalue;
                      class local;
              	class global;
                      class param;
                    class base_call;
                    class function_pointer;
                  class statement;
                    class extended_asm;
                  class case_;
                class top_level_asm;

   * When the context is compiled, the gcc::jit::playback classes
     (within `jit-playback.cc' and `jit-playback.h') replay the API
     calls within langhook:parse_file:


                /* Indentation indicates inheritance: */
                class context;
                class wrapper;
                  class type;
                    class compound_type;
                  class field;
                  class function;
                  class block;
                  class rvalue;
                    class lvalue;
                      class param;
                  class source_file;
                  class source_line;
                  class location;
                  class case_;

              Client Code   . Generated .            libgccjit.so
                            . code      .
                            .           . JIT API  . JIT "Frontend". (libbackend.a)
              ....................................................................................
                 │          .           .          .               .
                  ──────────────────────────>      .               .
                            .           .    │     .               .
                            .           .    V     .               .
                            .           .    ──> libgccjit.cc       .
                            .           .        │ (error-checking).
                            .           .        │                 .
                            .           .        ──> jit-recording.cc
                            .           .              (record API calls)
                            .           .    <───────              .
                            .           .    │     .               .
                 <───────────────────────────      .               .
                 │          .           .          .               .
                 │          .           .          .               .
                 V          .           .  gcc_jit_context_compile .
                  ──────────────────────────>      .               .
                            .           .    │ start of recording::context::compile ()
                            .           .    │     .               .
                            .           .    │ start of playback::context::compile ()
                            .           .    │   (create tempdir)  .
                            .           .    │     .               .
                            .           .    │ ACQUIRE MUTEX       .
                            .           .    │     .               .
                            .           .    V───────────────────────> toplev::main (for now)
                            .           .          .               .       │
                            .           .          .               .   (various code)
                            .           .          .               .       │
                            .           .          .               .       V
                            .           .          .    <───────────────── langhook:parse_file
                            .           .          .    │          .
                            .           .          .    │ (jit_langhook_parse_file)
                            .           .          .    │          .
              ..........................................│..................VVVVVVVVVVVVV...
                            .           .          .    │          .       No GC in here
                            .           .          .    │ jit-playback.cc
                            .           .          .    │   (playback of API calls)
                            .           .          .    ───────────────> creation of functions,
                            .           .          .               .     types, expression trees
                            .           .          .    <──────────────── etc
                            .           .          .    │(handle_locations: add locations to
                            .           .          .    │ linemap and associate them with trees)
                            .           .          .    │          .
                            .           .          .    │          .       No GC in here
              ..........................................│..................AAAAAAAAAAAAA...
                            .           .          .    │ for each function
                            .           .          .    ──> postprocess
                            .           .          .        │      .
                            .           .          .        ────────────> cgraph_finalize_function
                            .           .          .        <────────────
                            .           .          .     <──       .
                            .           .          .    │          .
                            .           .          .    ──────────────────> (end of
                            .           .          .               .       │ langhook_parse_file)
                            .           .          .               .       │
                            .           .          .               .   (various code)
                            .           .          .               .       │
                            .           .          .               .       ↓
                            .           .          .    <───────────────── langhook:write_globals
                            .           .          .    │          .
                            .           .          .    │ (jit_langhook_write_globals)
                            .           .          .    │          .
                            .           .          .    │          .
                            .           .          .    ──────────────────> finalize_compilation_unit
                            .           .          .               .       │
                            .           .          .               .   (the middle─end and backend)
                            .           .          .               .       ↓
                            .           .    <───────────────────────────── end of toplev::main
                            .           .    │     .               .
                            .           .    V───────────────────────> toplev::finalize
                            .           .          .               . │   (purge internal state)
                            .           .    <──────────────────────── end of toplev::finalize
                            .           .    │     .               .
                            .           .    V─> playback::context::postprocess:
                            .           .      │   .               .
                            .           .      │   (assuming an in-memory compile):
                            .           .      │   .               .
                            .           .      --> Convert assembler to DSO, via embedded
                            .           .          copy of driver:
                            .           .           driver::main ()
                            .           .             invocation of "as"
                            .           .             invocation of "ld"
                            .           .           driver::finalize ()
                            .           .      <----
                            .           .      │   .               .
                            .           .      │   . Load DSO (dlopen "fake.so")
                            .           .      │   .               .
                            .           .      │   . Bundle it up in a jit::result
                            .           .    <──   .               .
                            .           .    │     .               .
                            .           .    │ RELEASE MUTEX       .
                            .           .    │     .               .
                            .           .    │ end of playback::context::compile ()
                            .           .    │     .               .
                            .           .    │ playback::context dtor
                            .           .     ──>  .               .
                            .           .       │ Normally we cleanup the tempdir here:
                            .           .       │   ("fake.so" is unlinked from the
                            .           .       │    filesystem at this point)
                            .           .       │ If the client code requested debuginfo, the
                            .           .       │ cleanup happens later (in gcc_jit_result_release)
                            .           .       │ to make it easier on the debugger (see PR jit/64206)
                            .           .    <──   .               .
                            .           .    │     .               .
                            .           .    │ end of recording::context::compile ()
                 <───────────────────────────      .               .
                 │          .           .          .               .
                 V          .           .  gcc_jit_result_get_code .
                  ──────────────────────────>      .               .
                            .           .    │ dlsym () within loaded DSO
                 <───────────────────────────      .               .
                 Get (void*).           .          .               .
                 │          .           .          .               .
                 │ Call it  .           .          .               .
                 ───────────────>       .          .               .
                            .    │      .          .               .
                            .    │      .          .               .
                 <───────────────       .          .               .
                 │          .           .          .               .
              etc│          .           .          .               .
                 │          .           .          .               .
                 V          .           .  gcc_jit_result_release  .
                  ──────────────────────────>      .               .
                            .           .    │ dlclose () the loaded DSO
                            .           .    │    (code becomes uncallable)
                            .           .    │     .               .
                            .           .    │ If the client code requested debuginfo, then
                            .           .    │ cleanup of the tempdir was delayed.
                            .           .    │ If that was the case, clean it up now.
                 <───────────────────────────      .               .
                 │          .           .          .               .

Here is a high-level summary from `jit-common.h':

     In order to allow jit objects to be usable outside of a compile
     whilst working with the existing structure of GCC’s code the C
     API is implemented in terms of a gcc::jit::recording::context,
     which records the calls made to it.

     When a gcc_jit_context is compiled, the recording context creates a
     playback context.  The playback context invokes the bulk of the GCC
     code, and within the “frontend” parsing hook, plays back the
     recorded API calls, creating GCC tree objects.

     So there are two parallel families of classes: those relating to
     recording, and those relating to playback:

        * Visibility: recording objects are exposed back to client code,
          whereas playback objects are internal to the library.

        * Lifetime: recording objects have a lifetime equal to that of
          the recording context that created them, whereas playback
          objects only exist within the frontend hook.

        * Memory allocation: recording objects are allocated by the
          recording context, and automatically freed by it when the
          context is released, whereas playback objects are allocated
          within the GC heap, and garbage-collected; they can own
          GC-references.

        * Integration with rest of GCC: recording objects are unrelated
          to the rest of GCC, whereas playback objects are wrappers
          around “tree” instances.  Hence you can’t ask a
          recording rvalue or lvalue what its type is, whereas you can
          for a playback rvalue of lvalue (since it can work with the
          underlying GCC tree nodes).

        * Instancing: There can be multiple recording contexts
          “alive” at once (albeit it only one compiling at once),
          whereas there can only be one playback context alive at one
          time (since it interacts with the GC).

     Ultimately if GCC could support multiple GC heaps and contexts, and
     finer-grained initialization, then this recording vs playback
     distinction could be eliminated.

     During a playback, we associate objects from the recording with
     their counterparts during this playback.  For simplicity, we store
     this within the recording objects, as `void *m_playback_obj',
     casting it to the appropriate playback object subclass.  For these
     casts to make sense, the two class hierarchies need to have the
     same structure.

     Note that the playback objects that `m_playback_obj' points to are
     GC-allocated, but the recording objects don’t own references:
     these associations only exist within a part of the code where the
     GC doesn’t collect, and are set back to NULL before the GC can
     run.

Another way to understand the structure of the code is to enable
logging, via *Note gcc_jit_context_set_logfile(): 5b.  Here is an
example of a log generated via this call:

    JIT: libgccjit (GCC) version 6.0.0 20150803 (experimental) (x86_64-pc-linux-gnu)
    JIT:	compiled by GNU C version 4.8.3 20140911 (Red Hat 4.8.3-7), GMP version 5.1.2, MPFR version 3.1.2, MPC version 1.0.1
    JIT: entering: gcc_jit_context_set_str_option
    JIT:  GCC_JIT_STR_OPTION_PROGNAME: "./test-hello-world.c.exe"
    JIT: exiting: gcc_jit_context_set_str_option
    JIT: entering: gcc_jit_context_set_int_option
    JIT:  GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL: 3
    JIT: exiting: gcc_jit_context_set_int_option
    JIT: entering: gcc_jit_context_set_bool_option
    JIT:  GCC_JIT_BOOL_OPTION_DEBUGINFO: true
    JIT: exiting: gcc_jit_context_set_bool_option
    JIT: entering: gcc_jit_context_set_bool_option
    JIT:  GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE: false
    JIT: exiting: gcc_jit_context_set_bool_option
    JIT: entering: gcc_jit_context_set_bool_option
    JIT:  GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE: false
    JIT: exiting: gcc_jit_context_set_bool_option
    JIT: entering: gcc_jit_context_set_bool_option
    JIT:  GCC_JIT_BOOL_OPTION_SELFCHECK_GC: true
    JIT: exiting: gcc_jit_context_set_bool_option
    JIT: entering: gcc_jit_context_set_bool_option
    JIT:  GCC_JIT_BOOL_OPTION_DUMP_SUMMARY: false
    JIT: exiting: gcc_jit_context_set_bool_option
    JIT: entering: gcc_jit_context_get_type
    JIT: exiting: gcc_jit_context_get_type
    JIT: entering: gcc_jit_context_get_type
    JIT: exiting: gcc_jit_context_get_type
    JIT: entering: gcc_jit_context_new_param
    JIT: exiting: gcc_jit_context_new_param
    JIT: entering: gcc_jit_context_new_function
    JIT: exiting: gcc_jit_context_new_function
    JIT: entering: gcc_jit_context_new_param
    JIT: exiting: gcc_jit_context_new_param
    JIT: entering: gcc_jit_context_get_type
    JIT: exiting: gcc_jit_context_get_type
    JIT: entering: gcc_jit_context_new_function
    JIT: exiting: gcc_jit_context_new_function
    JIT: entering: gcc_jit_context_new_string_literal
    JIT: exiting: gcc_jit_context_new_string_literal
    JIT: entering: gcc_jit_function_new_block
    JIT: exiting: gcc_jit_function_new_block
    JIT: entering: gcc_jit_block_add_comment
    JIT: exiting: gcc_jit_block_add_comment
    JIT: entering: gcc_jit_context_new_call
    JIT: exiting: gcc_jit_context_new_call
    JIT: entering: gcc_jit_block_add_eval
    JIT: exiting: gcc_jit_block_add_eval
    JIT: entering: gcc_jit_block_end_with_void_return
    JIT: exiting: gcc_jit_block_end_with_void_return
    JIT: entering: gcc_jit_context_dump_reproducer_to_file
    JIT:  entering: void gcc::jit::recording::context::dump_reproducer_to_file(const char*)
    JIT:  exiting: void gcc::jit::recording::context::dump_reproducer_to_file(const char*)
    JIT: exiting: gcc_jit_context_dump_reproducer_to_file
    JIT: entering: gcc_jit_context_compile
    JIT:  in-memory compile of ctxt: 0x1283e20
    JIT:  entering: gcc::jit::result* gcc::jit::recording::context::compile()
    JIT:   GCC_JIT_STR_OPTION_PROGNAME: "./test-hello-world.c.exe"
    JIT:   GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL: 3
    JIT:   GCC_JIT_BOOL_OPTION_DEBUGINFO: true
    JIT:   GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE: false
    JIT:   GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE: false
    JIT:   GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE: false
    JIT:   GCC_JIT_BOOL_OPTION_DUMP_SUMMARY: false
    JIT:   GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING: false
    JIT:   GCC_JIT_BOOL_OPTION_SELFCHECK_GC: true
    JIT:   GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES: false
    JIT:   gcc_jit_context_set_bool_allow_unreachable_blocks: false
    JIT:   gcc_jit_context_set_bool_use_external_driver: false
    JIT:   entering: void gcc::jit::recording::context::validate()
    JIT:   exiting: void gcc::jit::recording::context::validate()
    JIT:   entering: gcc::jit::playback::context::context(gcc::jit::recording::context*)
    JIT:   exiting: gcc::jit::playback::context::context(gcc::jit::recording::context*)
    JIT:   entering: gcc::jit::playback::compile_to_memory::compile_to_memory(gcc::jit::recording::context*)
    JIT:   exiting: gcc::jit::playback::compile_to_memory::compile_to_memory(gcc::jit::recording::context*)
    JIT:   entering: void gcc::jit::playback::context::compile()
    JIT:    entering: gcc::jit::tempdir::tempdir(gcc::jit::logger*, int)
    JIT:    exiting: gcc::jit::tempdir::tempdir(gcc::jit::logger*, int)
    JIT:    entering: bool gcc::jit::tempdir::create()
    JIT:     m_path_template: /tmp/libgccjit-XXXXXX
    JIT:     m_path_tempdir: /tmp/libgccjit-CKq1M9
    JIT:    exiting: bool gcc::jit::tempdir::create()
    JIT:    entering: void gcc::jit::playback::context::acquire_mutex()
    JIT:    exiting: void gcc::jit::playback::context::acquire_mutex()
    JIT:    entering: void gcc::jit::playback::context::make_fake_args(vec<char*>*, const char*, vec<gcc::jit::recording::requested_dump>*)
    JIT:     reusing cached configure-time options
    JIT:     configure_time_options[0]: -mtune=generic
    JIT:     configure_time_options[1]: -march=x86-64
    JIT:    exiting: void gcc::jit::playback::context::make_fake_args(vec<char*>*, const char*, vec<gcc::jit::recording::requested_dump>*)
    JIT:    entering: toplev::main
    JIT:     argv[0]: ./test-hello-world.c.exe
    JIT:     argv[1]: /tmp/libgccjit-CKq1M9/fake.c
    JIT:     argv[2]: -fPIC
    JIT:     argv[3]: -O3
    JIT:     argv[4]: -g
    JIT:     argv[5]: -quiet
    JIT:     argv[6]: --param
    JIT:     argv[7]: ggc-min-expand=0
    JIT:     argv[8]: --param
    JIT:     argv[9]: ggc-min-heapsize=0
    JIT:     argv[10]: -mtune=generic
    JIT:     argv[11]: -march=x86-64
    JIT:     entering: bool jit_langhook_init()
    JIT:     exiting: bool jit_langhook_init()
    JIT:     entering: void gcc::jit::playback::context::replay()
    JIT:      entering: void gcc::jit::recording::context::replay_into(gcc::jit::replayer*)
    JIT:      exiting: void gcc::jit::recording::context::replay_into(gcc::jit::replayer*)
    JIT:      entering: void gcc::jit::recording::context::disassociate_from_playback()
    JIT:      exiting: void gcc::jit::recording::context::disassociate_from_playback()
    JIT:      entering: void gcc::jit::playback::context::handle_locations()
    JIT:      exiting: void gcc::jit::playback::context::handle_locations()
    JIT:      entering: void gcc::jit::playback::function::build_stmt_list()
    JIT:      exiting: void gcc::jit::playback::function::build_stmt_list()
    JIT:      entering: void gcc::jit::playback::function::build_stmt_list()
    JIT:      exiting: void gcc::jit::playback::function::build_stmt_list()
    JIT:      entering: void gcc::jit::playback::function::postprocess()
    JIT:      exiting: void gcc::jit::playback::function::postprocess()
    JIT:      entering: void gcc::jit::playback::function::postprocess()
    JIT:      exiting: void gcc::jit::playback::function::postprocess()
    JIT:     exiting: void gcc::jit::playback::context::replay()
    JIT:    exiting: toplev::main
    JIT:    entering: void gcc::jit::playback::context::extract_any_requested_dumps(vec<gcc::jit::recording::requested_dump>*)
    JIT:    exiting: void gcc::jit::playback::context::extract_any_requested_dumps(vec<gcc::jit::recording::requested_dump>*)
    JIT:    entering: toplev::finalize
    JIT:    exiting: toplev::finalize
    JIT:    entering: virtual void gcc::jit::playback::compile_to_memory::postprocess(const char*)
    JIT:     entering: void gcc::jit::playback::context::convert_to_dso(const char*)
    JIT:      entering: void gcc::jit::playback::context::invoke_driver(const char*, const char*, const char*, timevar_id_t, bool, bool)
    JIT:       entering: void gcc::jit::playback::context::add_multilib_driver_arguments(vec<char*>*)
    JIT:       exiting: void gcc::jit::playback::context::add_multilib_driver_arguments(vec<char*>*)
    JIT:       argv[0]: x86_64-unknown-linux-gnu-gcc-6.0.0
    JIT:       argv[1]: -m64
    JIT:       argv[2]: -shared
    JIT:       argv[3]: /tmp/libgccjit-CKq1M9/fake.s
    JIT:       argv[4]: -o
    JIT:       argv[5]: /tmp/libgccjit-CKq1M9/fake.so
    JIT:       argv[6]: -fno-use-linker-plugin
    JIT:       entering: void gcc::jit::playback::context::invoke_embedded_driver(const vec<char*>*)
    JIT:       exiting: void gcc::jit::playback::context::invoke_embedded_driver(const vec<char*>*)
    JIT:      exiting: void gcc::jit::playback::context::invoke_driver(const char*, const char*, const char*, timevar_id_t, bool, bool)
    JIT:     exiting: void gcc::jit::playback::context::convert_to_dso(const char*)
    JIT:     entering: gcc::jit::result* gcc::jit::playback::context::dlopen_built_dso()
    JIT:      GCC_JIT_BOOL_OPTION_DEBUGINFO was set: handing over tempdir to jit::result
    JIT:      entering: gcc::jit::result::result(gcc::jit::logger*, void*, gcc::jit::tempdir*)
    JIT:      exiting: gcc::jit::result::result(gcc::jit::logger*, void*, gcc::jit::tempdir*)
    JIT:     exiting: gcc::jit::result* gcc::jit::playback::context::dlopen_built_dso()
    JIT:    exiting: virtual void gcc::jit::playback::compile_to_memory::postprocess(const char*)
    JIT:    entering: void gcc::jit::playback::context::release_mutex()
    JIT:    exiting: void gcc::jit::playback::context::release_mutex()
    JIT:   exiting: void gcc::jit::playback::context::compile()
    JIT:   entering: gcc::jit::playback::context::~context()
    JIT:   exiting: gcc::jit::playback::context::~context()
    JIT:  exiting: gcc::jit::result* gcc::jit::recording::context::compile()
    JIT:  gcc_jit_context_compile: returning (gcc_jit_result *)0x12f75d0
    JIT: exiting: gcc_jit_context_compile
    JIT: entering: gcc_jit_result_get_code
    JIT:  locating fnname: hello_world
    JIT:  entering: void* gcc::jit::result::get_code(const char*)
    JIT:  exiting: void* gcc::jit::result::get_code(const char*)
    JIT:  gcc_jit_result_get_code: returning (void *)0x7ff6b8cd87f0
    JIT: exiting: gcc_jit_result_get_code
    JIT: entering: gcc_jit_context_release
    JIT:  deleting ctxt: 0x1283e20
    JIT:  entering: gcc::jit::recording::context::~context()
    JIT:  exiting: gcc::jit::recording::context::~context()
    JIT: exiting: gcc_jit_context_release
    JIT: entering: gcc_jit_result_release
    JIT:  deleting result: 0x12f75d0
    JIT:  entering: virtual gcc::jit::result::~result()
    JIT:   entering: gcc::jit::tempdir::~tempdir()
    JIT:    unlinking .s file: /tmp/libgccjit-CKq1M9/fake.s
    JIT:    unlinking .so file: /tmp/libgccjit-CKq1M9/fake.so
    JIT:    removing tempdir: /tmp/libgccjit-CKq1M9
    JIT:   exiting: gcc::jit::tempdir::~tempdir()
    JIT:  exiting: virtual gcc::jit::result::~result()
    JIT: exiting: gcc_jit_result_release
    JIT: gcc::jit::logger::~logger()


File: libgccjit.info,  Node: Design notes,  Next: Submitting patches,  Prev: Overview of code structure,  Up: Internals

4.6 Design notes
================

It should not be possible for client code to cause an internal compiler
error.  If this `does' happen, the root cause should be isolated
(perhaps using *Note gcc_jit_context_dump_reproducer_to_file(): 5d.)
and the cause should be rejected via additional checking.  The checking
ideally should be within the libgccjit API entrypoints in libgccjit.cc,
since this is as close as possible to the error; failing that, a good
place is within `recording::context::validate ()' in jit-recording.cc.


File: libgccjit.info,  Node: Submitting patches,  Prev: Design notes,  Up: Internals

4.7 Submitting patches
======================

Please read the contribution guidelines for gcc at
<https://gcc.gnu.org/contribute.html>.

Patches for the jit should be sent to both the
<gcc-patches@gcc.gnu.org> and <jit@gcc.gnu.org> mailing lists, with
“jit” and “PATCH” in the Subject line.

You don’t need to do a full bootstrap for code that just touches the
`jit' and `testsuite/jit.dg' subdirectories.  However, please run `make
check-jit' before submitting the patch, and mention the results in your
email (along with the host triple that the tests were run on).

A good patch should contain the information listed in the gcc
contribution guide linked to above; for a `jit' patch, the patch shold
contain:

        * the code itself (for example, a new API entrypoint will
          typically touch `libgccjit.h' and `.c', along with support
          code in `jit-recording.[ch]' and `jit-playback.[ch]' as
          appropriate)

        * test coverage

        * documentation for the C API

        * documentation for the C++ API

A patch that adds new API entrypoints should also contain:

        * a feature macro in `libgccjit.h' so that client code that
          doesn’t use a “configure” mechanism can still easily
          detect the presence of the entrypoint.  See e.g.
          `LIBGCCJIT_HAVE_SWITCH_STATEMENTS' (for a category of
          entrypoints) and
          `LIBGCCJIT_HAVE_gcc_jit_context_set_bool_allow_unreachable_blocks'
          (for an individual entrypoint).

        * a new ABI tag containing the new symbols (in
          `libgccjit.map'), so that we can detect client code that uses
          them

        * Support for *Note gcc_jit_context_dump_reproducer_to_file():
          5d.  Most jit testcases attempt to dump their contexts to a
          .c file; `jit.exp' then sanity-checks the generated c by
          compiling them (though not running them).   A new API
          entrypoint needs to “know” how to write itself back out
          to C (by implementing
          `gcc::jit::recording::memento::write_reproducer' for the
          appropriate `memento' subclass).

        * C++ bindings for the new entrypoints (see `libgccjit++.h');
          ideally with test coverage, though the C++ API test coverage
          is admittedly spotty at the moment

        * documentation for the new C entrypoints

        * documentation for the new C++ entrypoints

        * documentation for the new ABI tag (see
          `topics/compatibility.rst').

Depending on the patch you can either extend an existing test case, or
add a new test case.  If you add an entirely new testcase: `jit.exp'
expects jit testcases to begin with `test-', or `test-error-' (for a
testcase that generates an error on a *Note gcc_jit_context: 8.).

Every new testcase that doesn’t generate errors should also touch
`gcc/testsuite/jit.dg/all-non-failing-tests.h':

        * Testcases that don’t generate errors should ideally be
          added to the `testcases' array in that file; this means that,
          in addition to being run standalone, they also get run within
          `test-combination.c' (which runs all successful tests inside
          one big *Note gcc_jit_context: 8.), and `test-threads.c'
          (which runs all successful tests in one process, each one
          running in a different thread on a different *Note
          gcc_jit_context: 8.).

               Note: Given that exported functions within a *Note
               gcc_jit_context: 8.  must have unique names, and most
               testcases are run within `test-combination.c', this
               means that every jit-compiled test function typically
               needs a name that’s unique across the entire test
               suite.

        * Testcases that aren’t to be added to the `testcases' array
          should instead add a comment to the file clarifying why
          they’re not in that array. See the file for examples.

Typically a patch that touches the .rst documentation will also need the
texinfo to be regenerated.  You can do this with Sphinx 1.0(1) or later
by running `make texinfo' within `SRCDIR/gcc/jit/docs'.   Don’t do
this within the patch sent to the mailing list; it can often be
relatively large and inconsequential (e.g. anchor renumbering), rather
like generated “configure” changes from configure.ac.  You can
regenerate it when committing to svn.

---------- Footnotes ----------

(1) https://sphinx-doc.org/


File: libgccjit.info,  Node: Indices and tables,  Next: Index,  Prev: Internals,  Up: Top

Indices and tables
******************

   * genindex

   * modindex

   * search


File: libgccjit.info,  Node: Index,  Prev: Indices and tables,  Up: Top

Index
*****

[index]
* Menu:

* command line option; -disable-bootstrap: Working on the JIT library.
                                                              (line  46)
* command line option; -enable-checking=release: Working on the JIT library.
                                                              (line  52)
* command line option; -enable-host-shared: Working on the JIT library.
                                                              (line  30)
* command line option; -enable-languages=jit,c++: Working on the JIT library.
                                                              (line  35)
* environment variable; LD_LIBRARY_PATH: Environment variables.
                                                              (line   9)
* environment variable; LIBRARY_PATH:    Environment variables.
                                                              (line  35)
* environment variable; PATH:            Environment variables.
                                                              (line  20)
* environment variable; PRESERVE_EXECUTABLES: Running the test suite.
                                                              (line  18)
* environment variable; RUN_UNDER_VALGRIND: Running under valgrind.
                                                              (line   6)
* gcc_jit_binary_op (C type):            Binary Operations.   (line  14)
* GCC_JIT_BINARY_OP_BITWISE_AND (C macro): Binary Operations. (line  75)
* GCC_JIT_BINARY_OP_BITWISE_OR (C macro): Binary Operations.  (line  89)
* GCC_JIT_BINARY_OP_BITWISE_XOR (C macro): Binary Operations. (line  82)
* GCC_JIT_BINARY_OP_DIVIDE (C macro):    Binary Operations.   (line  57)
* GCC_JIT_BINARY_OP_LOGICAL_AND (C macro): Binary Operations. (line  96)
* GCC_JIT_BINARY_OP_LOGICAL_OR (C macro): Binary Operations.  (line 103)
* GCC_JIT_BINARY_OP_LSHIFT (C macro):    Binary Operations.   (line 110)
* GCC_JIT_BINARY_OP_MINUS (C macro):     Binary Operations.   (line  43)
* GCC_JIT_BINARY_OP_MODULO (C macro):    Binary Operations.   (line  68)
* GCC_JIT_BINARY_OP_MULT (C macro):      Binary Operations.   (line  50)
* GCC_JIT_BINARY_OP_PLUS (C macro):      Binary Operations.   (line  33)
* GCC_JIT_BINARY_OP_RSHIFT (C macro):    Binary Operations.   (line 117)
* gcc_jit_block (C type):                Blocks.              (line   6)
* gcc_jit_block_add_assignment (C function): Statements.      (line  15)
* gcc_jit_block_add_assignment_op (C function): Statements.   (line  25)
* gcc_jit_block_add_comment (C function): Statements.         (line  46)
* gcc_jit_block_add_eval (C function):   Statements.          (line   6)
* gcc_jit_block_add_extended_asm (C function): Adding assembler instructions within a function.
                                                              (line  69)
* gcc_jit_block_as_object (C function):  Blocks.              (line  37)
* gcc_jit_block_end_with_conditional (C function): Statements.
                                                              (line  64)
* gcc_jit_block_end_with_extended_asm_goto (C function): Adding assembler instructions within a function.
                                                              (line  80)
* gcc_jit_block_end_with_jump (C function): Statements.       (line  80)
* gcc_jit_block_end_with_return (C function): Statements.     (line  88)
* gcc_jit_block_end_with_switch (C function): Statements.     (line 107)
* gcc_jit_block_end_with_void_return (C function): Statements.
                                                              (line  98)
* gcc_jit_block_get_function (C function): Blocks.            (line  41)
* gcc_jit_bool_option (C type):          Boolean options.     (line  12)
* GCC_JIT_BOOL_OPTION_DEBUGINFO (C macro): Boolean options.   (line  14)
* GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING (C macro): Boolean options.
                                                              (line 102)
* GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE (C macro): Boolean options.
                                                              (line  68)
* GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE (C macro): Boolean options.
                                                              (line  54)
* GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE (C macro): Boolean options.
                                                              (line  24)
* GCC_JIT_BOOL_OPTION_DUMP_SUMMARY (C macro): Boolean options.
                                                              (line  98)
* GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES (C macro): Boolean options.
                                                              (line 117)
* GCC_JIT_BOOL_OPTION_SELFCHECK_GC (C macro): Boolean options.
                                                              (line 110)
* gcc_jit_case (C type) <1>:             Functions.           (line 115)
* gcc_jit_case (C type) <2>:             Reflection API.      (line 104)
* gcc_jit_case (C type):                 Statements.          (line 156)
* gcc_jit_case_as_object (C function):   Statements.          (line 177)
* gcc_jit_comparison (C type):           Comparisons.         (line  11)
* gcc_jit_compatible_types (C function): Reflection API.      (line 106)
* gcc_jit_context (C type):              Compilation contexts.
                                                              (line   6)
* gcc_jit_context_acquire (C function):  Lifetime-management. (line  10)
* gcc_jit_context_add_command_line_option (C function): Additional command-line options.
                                                              (line   6)
* gcc_jit_context_add_driver_option (C function): Additional command-line options.
                                                              (line  35)
* gcc_jit_context_add_top_level_asm (C function): Adding top-level assembler statements.
                                                              (line  10)
* gcc_jit_context_compile (C function):  In-memory compilation.
                                                              (line   6)
* gcc_jit_context_compile_to_file (C function): Ahead-of-time compilation.
                                                              (line  14)
* gcc_jit_context_dump_reproducer_to_file (C function): Debugging.
                                                              (line  62)
* gcc_jit_context_dump_to_file (C function): Debugging.       (line   6)
* gcc_jit_context_enable_dump (C function): Debugging.        (line  83)
* gcc_jit_context_get_builtin_function (C function): Functions.
                                                              (line  55)
* gcc_jit_context_get_first_error (C function): Error-handling<2>.
                                                              (line  26)
* gcc_jit_context_get_int_type (C function): Standard types.  (line  49)
* gcc_jit_context_get_last_error (C function): Error-handling<2>.
                                                              (line  39)
* gcc_jit_context_get_timer (C function): The timing API.     (line 156)
* gcc_jit_context_get_type (C function): Standard types.      (line   6)
* gcc_jit_context_new_array_access (C function): Working with pointers structs and unions.
                                                              (line  47)
* gcc_jit_context_new_array_constructor (C function): Constructor expressions.
                                                              (line  30)
* gcc_jit_context_new_array_type (C function): Pointers const and volatile.
                                                              (line  18)
* gcc_jit_context_new_binary_op (C function): Binary Operations.
                                                              (line   6)
* gcc_jit_context_new_bitcast (C function): Type-coercion.    (line  19)
* gcc_jit_context_new_bitfield (C function): Structures and unions.
                                                              (line  60)
* gcc_jit_context_new_call (C function): Function calls.      (line   6)
* gcc_jit_context_new_call (C++ function): Function calls<2>. (line   6)
* gcc_jit_context_new_call_through_ptr (C function): Function calls.
                                                              (line  31)
* gcc_jit_context_new_case (C function): Statements.          (line 166)
* gcc_jit_context_new_cast (C function): Type-coercion.       (line   6)
* gcc_jit_context_new_child_context (C function): Lifetime-management.
                                                              (line  26)
* gcc_jit_context_new_comparison (C function): Comparisons.   (line   6)
* gcc_jit_context_new_field (C function): Structures and unions.
                                                              (line  49)
* gcc_jit_context_new_function (C function): Functions.       (line  10)
* gcc_jit_context_new_function_ptr_type (C function): Function pointers<2>.
                                                              (line  49)
* gcc_jit_context_new_global (C function): Global variables.  (line   6)
* gcc_jit_context_new_location (C function): Source Locations.
                                                              (line  27)
* gcc_jit_context_new_opaque_struct (C function): Structures and unions.
                                                              (line  92)
* gcc_jit_context_new_param (C function): Params.             (line   9)
* gcc_jit_context_new_rvalue_from_double (C function): Simple expressions.
                                                              (line  31)
* gcc_jit_context_new_rvalue_from_int (C function): Simple expressions.
                                                              (line   6)
* gcc_jit_context_new_rvalue_from_long (C function): Simple expressions.
                                                              (line  11)
* gcc_jit_context_new_rvalue_from_ptr (C function): Simple expressions.
                                                              (line  37)
* gcc_jit_context_new_rvalue_from_vector (C function): Vector expressions.
                                                              (line   6)
* gcc_jit_context_new_string_literal (C function): Simple expressions.
                                                              (line  49)
* gcc_jit_context_new_struct_constructor (C function): Constructor expressions.
                                                              (line  60)
* gcc_jit_context_new_struct_type (C function): Structures and unions.
                                                              (line  83)
* gcc_jit_context_new_unary_op (C function): Unary Operations.
                                                              (line   6)
* gcc_jit_context_new_union_constructor (C function): Constructor expressions.
                                                              (line 103)
* gcc_jit_context_new_union_type (C function): Structures and unions.
                                                              (line 115)
* gcc_jit_context_null (C function):     Simple expressions.  (line  42)
* gcc_jit_context_one (C function):      Simple expressions.  (line  24)
* gcc_jit_context_release (C function):  Lifetime-management. (line  15)
* gcc_jit_context_set_bool_allow_unreachable_blocks (C function): Boolean options.
                                                              (line 122)
* gcc_jit_context_set_bool_option (C function): Boolean options.
                                                              (line   6)
* gcc_jit_context_set_bool_print_errors_to_stderr (C function): Boolean options.
                                                              (line 149)
* gcc_jit_context_set_bool_use_external_driver (C function): Boolean options.
                                                              (line 134)
* gcc_jit_context_set_int_option (C function): Integer options.
                                                              (line   6)
* gcc_jit_context_set_logfile (C function): Debugging.        (line  18)
* gcc_jit_context_set_str_option (C function): String Options.
                                                              (line   6)
* gcc_jit_context_set_timer (C function): The timing API.     (line 138)
* gcc_jit_context_zero (C function):     Simple expressions.  (line  17)
* gcc_jit_extended_asm (C type):         Adding assembler instructions within a function.
                                                              (line   6)
* gcc_jit_extended_asm_add_clobber (C function): Adding assembler instructions within a function.
                                                              (line 228)
* gcc_jit_extended_asm_add_input_operand (C function): Adding assembler instructions within a function.
                                                              (line 201)
* gcc_jit_extended_asm_add_output_operand (C function): Adding assembler instructions within a function.
                                                              (line 172)
* gcc_jit_extended_asm_as_object (C function): Adding assembler instructions within a function.
                                                              (line 247)
* gcc_jit_extended_asm_set_inline_flag (C function): Adding assembler instructions within a function.
                                                              (line 167)
* gcc_jit_extended_asm_set_volatile_flag (C function): Adding assembler instructions within a function.
                                                              (line 138)
* gcc_jit_field (C type):                Structures and unions.
                                                              (line  10)
* gcc_jit_field_as_object (C function):  Structures and unions.
                                                              (line  79)
* gcc_jit_function (C type):             Functions.           (line   6)
* GCC_JIT_FUNCTION_ALWAYS_INLINE (C macro): Functions.        (line  40)
* gcc_jit_function_as_object (C function): Functions.         (line  71)
* gcc_jit_function_dump_to_dot (C function): Functions.       (line  79)
* GCC_JIT_FUNCTION_EXPORTED (C macro):   Functions.           (line  22)
* gcc_jit_function_get_address (C function): Function pointers<2>.
                                                              (line  15)
* gcc_jit_function_get_param (C function): Functions.         (line  75)
* gcc_jit_function_get_param_count (C function): Functions.   (line  95)
* gcc_jit_function_get_return_type (C function): Functions.   (line  99)
* GCC_JIT_FUNCTION_IMPORTED (C macro):   Functions.           (line  35)
* GCC_JIT_FUNCTION_INTERNAL (C macro):   Functions.           (line  30)
* gcc_jit_function_kind (C type):        Functions.           (line  17)
* gcc_jit_function_new_block (C function): Blocks.            (line  21)
* gcc_jit_function_new_local (C function): Functions.         (line  83)
* gcc_jit_function_type_get_param_count (C function): Reflection API.
                                                              (line  22)
* gcc_jit_function_type_get_param_type (C function): Reflection API.
                                                              (line  26)
* gcc_jit_function_type_get_return_type (C function): Reflection API.
                                                              (line  18)
* GCC_JIT_GLOBAL_EXPORTED (C macro):     Global variables.    (line  24)
* GCC_JIT_GLOBAL_IMPORTED (C macro):     Global variables.    (line  36)
* GCC_JIT_GLOBAL_INTERNAL (C macro):     Global variables.    (line  30)
* gcc_jit_global_kind (C type):          Global variables.    (line  22)
* gcc_jit_global_set_initializer (C function): Global variables.
                                                              (line  41)
* gcc_jit_global_set_initializer_rvalue (C function): Global variables.
                                                              (line  57)
* gcc_jit_int_option (C type):           Integer options.     (line  11)
* GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL (C macro): Integer options.
                                                              (line  15)
* gcc_jit_location (C type):             Source Locations.    (line   6)
* gcc_jit_lvalue (C type):               Lvalues.             (line   6)
* gcc_jit_lvalue_access_field (C function): Working with pointers structs and unions.
                                                              (line  17)
* gcc_jit_lvalue_as_object (C function): Lvalues.             (line  13)
* gcc_jit_lvalue_as_rvalue (C function): Lvalues.             (line  17)
* gcc_jit_lvalue_get_address (C function): Lvalues.           (line  21)
* gcc_jit_lvalue_get_alignment (C function): Lvalues.         (line 101)
* gcc_jit_lvalue_set_alignment (C function): Lvalues.         (line  88)
* gcc_jit_lvalue_set_link_section (C function): Lvalues.      (line  60)
* gcc_jit_lvalue_set_tls_model (C function): Lvalues.         (line  29)
* gcc_jit_object (C type):               Objects.             (line   6)
* gcc_jit_object_get_context (C function): Objects.           (line  43)
* gcc_jit_object_get_debug_string (C function): Objects.      (line  47)
* gcc_jit_output_kind (C type):          Ahead-of-time compilation.
                                                              (line  27)
* GCC_JIT_OUTPUT_KIND_ASSEMBLER (C macro): Ahead-of-time compilation.
                                                              (line  38)
* GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY (C macro): Ahead-of-time compilation.
                                                              (line  44)
* GCC_JIT_OUTPUT_KIND_EXECUTABLE (C macro): Ahead-of-time compilation.
                                                              (line  47)
* GCC_JIT_OUTPUT_KIND_OBJECT_FILE (C macro): Ahead-of-time compilation.
                                                              (line  41)
* gcc_jit_param (C type):                Params.              (line   6)
* gcc_jit_param_as_lvalue (C function):  Params.              (line  24)
* gcc_jit_param_as_object (C function):  Params.              (line  32)
* gcc_jit_param_as_rvalue (C function):  Params.              (line  28)
* gcc_jit_result (C type):               In-memory compilation.
                                                              (line  15)
* gcc_jit_result_get_code (C function):  In-memory compilation.
                                                              (line  20)
* gcc_jit_result_get_global (C function): In-memory compilation.
                                                              (line  52)
* gcc_jit_result_release (C function):   In-memory compilation.
                                                              (line  91)
* gcc_jit_rvalue (C type):               Rvalues.             (line   6)
* gcc_jit_rvalue_access_field (C function): Working with pointers structs and unions.
                                                              (line  27)
* gcc_jit_rvalue_as_object (C function): Rvalues.             (line  36)
* gcc_jit_rvalue_dereference (C function): Working with pointers structs and unions.
                                                              (line   6)
* gcc_jit_rvalue_dereference_field (C function): Working with pointers structs and unions.
                                                              (line  37)
* gcc_jit_rvalue_get_type (C function):  Rvalues.             (line  32)
* gcc_jit_rvalue_set_bool_require_tail_call (C function): Function calls.
                                                              (line  42)
* gcc_jit_str_option (C type):           String Options.      (line  11)
* GCC_JIT_STR_OPTION_PROGNAME (C macro): String Options.      (line  19)
* gcc_jit_struct (C type):               Structures and unions.
                                                              (line   6)
* gcc_jit_struct_as_type (C function):   Structures and unions.
                                                              (line 104)
* gcc_jit_struct_get_field (C function): Reflection API.      (line  59)
* gcc_jit_struct_get_field_count (C function): Reflection API.
                                                              (line  63)
* gcc_jit_struct_set_fields (C function): Structures and unions.
                                                              (line 108)
* gcc_jit_timer (C type):                The timing API.      (line 114)
* gcc_jit_timer_new (C function):        The timing API.      (line 116)
* gcc_jit_timer_pop (C function):        The timing API.      (line 178)
* gcc_jit_timer_print (C function):      The timing API.      (line 190)
* gcc_jit_timer_push (C function):       The timing API.      (line 165)
* gcc_jit_timer_release (C function):    The timing API.      (line 126)
* gcc_jit_tls_model (C type):            Lvalues.             (line  36)
* GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC (C macro): Lvalues.        (line  41)
* GCC_JIT_TLS_MODEL_INITIAL_EXEC (C macro): Lvalues.          (line  45)
* GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC (C macro): Lvalues.         (line  43)
* GCC_JIT_TLS_MODEL_LOCAL_EXEC (C macro): Lvalues.            (line  47)
* GCC_JIT_TLS_MODEL_NONE (C macro):      Lvalues.             (line  38)
* gcc_jit_type (C type):                 Types.               (line   6)
* gcc_jit_type_as_object (C function):   Types.               (line   9)
* gcc_jit_type_dyncast_array (C function): Reflection API.    (line   6)
* gcc_jit_type_dyncast_function_ptr_type (C function): Reflection API.
                                                              (line  14)
* gcc_jit_type_dyncast_vector (C function): Reflection API.   (line  38)
* gcc_jit_type_get_aligned (C function): Pointers const and volatile.
                                                              (line  24)
* gcc_jit_type_get_const (C function):   Pointers const and volatile.
                                                              (line  10)
* gcc_jit_type_get_pointer (C function): Pointers const and volatile.
                                                              (line   6)
* gcc_jit_type_get_size (C function):    Reflection API.      (line 119)
* gcc_jit_type_get_vector (C function):  Vector types.        (line   6)
* gcc_jit_type_get_volatile (C function): Pointers const and volatile.
                                                              (line  14)
* gcc_jit_type_is_bool (C function):     Reflection API.      (line  11)
* gcc_jit_type_is_integral (C function): Reflection API.      (line  30)
* gcc_jit_type_is_pointer (C function):  Reflection API.      (line  33)
* gcc_jit_type_is_struct (C function):   Reflection API.      (line  42)
* gcc_jit_type_unqualified (C function): Reflection API.      (line  54)
* gcc_jit_unary_op (C type):             Unary Operations.    (line  14)
* GCC_JIT_UNARY_OP_ABS (C macro):        Unary Operations.    (line  47)
* GCC_JIT_UNARY_OP_BITWISE_NEGATE (C macro): Unary Operations.
                                                              (line  32)
* GCC_JIT_UNARY_OP_LOGICAL_NEGATE (C macro): Unary Operations.
                                                              (line  40)
* GCC_JIT_UNARY_OP_MINUS (C macro):      Unary Operations.    (line  25)
* gcc_jit_vector_type_get_element_type (C function): Reflection API.
                                                              (line  50)
* gcc_jit_vector_type_get_num_units (C function): Reflection API.
                                                              (line  46)
* gcc_jit_version_major (C function):    Programmatically checking version.
                                                              (line   8)
* gcc_jit_version_minor (C function):    Programmatically checking version.
                                                              (line  12)
* gcc_jit_version_patchlevel (C function): Programmatically checking version.
                                                              (line  16)
* gccjit;;block (C++ class):             Blocks<2>.           (line   6)
* gccjit;;block;;add_assignment (C++ function): Statements<2>.
                                                              (line  15)
* gccjit;;block;;add_assignment_op (C++ function): Statements<2>.
                                                              (line  25)
* gccjit;;block;;add_comment (C++ function): Statements<2>.   (line  44)
* gccjit;;block;;add_eval (C++ function): Statements<2>.      (line   6)
* gccjit;;block;;add_extended_asm (C++ function): Adding assembler instructions within a function<2>.
                                                              (line  67)
* gccjit;;block;;end_with_conditional (C++ function): Statements<2>.
                                                              (line  55)
* gccjit;;block;;end_with_extended_asm_goto (C++ function): Adding assembler instructions within a function<2>.
                                                              (line  78)
* gccjit;;block;;end_with_jump (C++ function): Statements<2>. (line  70)
* gccjit;;block;;end_with_return (C++ function): Statements<2>.
                                                              (line  78)
* gccjit;;block;;end_with_switch (C++ function): Statements<2>.
                                                              (line 102)
* gccjit;;context (C++ class):           Compilation contexts<2>.
                                                              (line   6)
* gccjit;;context;;acquire (C++ function): Lifetime-management<2>.
                                                              (line  10)
* gccjit;;context;;add_command_line_option (C++ function): Additional command-line options<2>.
                                                              (line   6)
* gccjit;;context;;add_top_level_asm (C++ function): Adding top-level assembler statements<2>.
                                                              (line  10)
* gccjit;;context;;compile (C++ function): In-memory compilation<2>.
                                                              (line   6)
* gccjit;;context;;compile_to_file (C++ function): Ahead-of-time compilation<2>.
                                                              (line  11)
* gccjit;;context;;dump_reproducer_to_file (C++ function): Debugging<2>.
                                                              (line  17)
* gccjit;;context;;dump_to_file (C++ function): Debugging<2>. (line   6)
* gccjit;;context;;get_builtin_function (C++ function): Functions<2>.
                                                              (line  21)
* gccjit;;context;;get_first_error (C++ function): Error-handling<3>.
                                                              (line  15)
* gccjit;;context;;get_int_type (C++ function): Standard types<2>.
                                                              (line  11)
* gccjit;;context;;get_int_type<T> (C++ function): Standard types<2>.
                                                              (line  15)
* gccjit;;context;;get_type (C++ function): Standard types<2>.
                                                              (line   6)
* gccjit;;context;;new_array_access (C++ function): Working with pointers structs and unions<2>.
                                                              (line  54)
* gccjit;;context;;new_array_type (C++ function): Pointers const and volatile<2>.
                                                              (line  26)
* gccjit;;context;;new_binary_op (C++ function): Binary Operations<2>.
                                                              (line   6)
* gccjit;;context;;new_bitwise_and (C++ function): Binary Operations<2>.
                                                              (line  41)
* gccjit;;context;;new_bitwise_or (C++ function): Binary Operations<2>.
                                                              (line  49)
* gccjit;;context;;new_bitwise_xor (C++ function): Binary Operations<2>.
                                                              (line  45)
* gccjit;;context;;new_cast (C++ function): Type-coercion<2>. (line   6)
* gccjit;;context;;new_child_context (C++ function): Lifetime-management<2>.
                                                              (line  27)
* gccjit;;context;;new_comparison (C++ function): Comparisons<2>.
                                                              (line   6)
* gccjit;;context;;new_divide (C++ function): Binary Operations<2>.
                                                              (line  33)
* gccjit;;context;;new_eq (C++ function): Comparisons<2>.     (line  20)
* gccjit;;context;;new_field (C++ function): Structures and unions<2>.
                                                              (line  51)
* gccjit;;context;;new_function (C++ function): Functions<2>. (line  10)
* gccjit;;context;;new_ge (C++ function): Comparisons<2>.     (line  40)
* gccjit;;context;;new_global (C++ function): Global variables<2>.
                                                              (line   6)
* gccjit;;context;;new_gt (C++ function): Comparisons<2>.     (line  36)
* gccjit;;context;;new_le (C++ function): Comparisons<2>.     (line  32)
* gccjit;;context;;new_location (C++ function): Source Locations<2>.
                                                              (line  24)
* gccjit;;context;;new_logical_and (C++ function): Binary Operations<2>.
                                                              (line  53)
* gccjit;;context;;new_logical_or (C++ function): Binary Operations<2>.
                                                              (line  57)
* gccjit;;context;;new_lt (C++ function): Comparisons<2>.     (line  28)
* gccjit;;context;;new_minus (C++ function) <1>: Binary Operations<2>.
                                                              (line  25)
* gccjit;;context;;new_minus (C++ function): Unary Operations<2>.
                                                              (line  20)
* gccjit;;context;;new_modulo (C++ function): Binary Operations<2>.
                                                              (line  37)
* gccjit;;context;;new_mult (C++ function): Binary Operations<2>.
                                                              (line  29)
* gccjit;;context;;new_ne (C++ function): Comparisons<2>.     (line  24)
* gccjit;;context;;new_opaque_struct (C++ function): Structures and unions<2>.
                                                              (line  61)
* gccjit;;context;;new_param (C++ function): Params<2>.       (line   9)
* gccjit;;context;;new_plus (C++ function): Binary Operations<2>.
                                                              (line  21)
* gccjit;;context;;new_rvalue (C++ function) <1>: Simple expressions<2>.
                                                              (line  41)
* gccjit;;context;;new_rvalue (C++ function): Vector expressions<2>.
                                                              (line   6)
* gccjit;;context;;new_struct_type (C++ function): Structures and unions<2>.
                                                              (line  56)
* gccjit;;context;;new_unary_op (C++ function): Unary Operations<2>.
                                                              (line   6)
* gccjit;;context;;one (C++ function):   Simple expressions<2>.
                                                              (line  23)
* gccjit;;context;;release (C++ function): Lifetime-management<2>.
                                                              (line  16)
* gccjit;;context;;set_bool_allow_unreachable_blocks (C++ function): Boolean options<2>.
                                                              (line  14)
* gccjit;;context;;set_bool_option (C++ function): Boolean options<2>.
                                                              (line   6)
* gccjit;;context;;set_bool_use_external_driver (C++ function): Boolean options<2>.
                                                              (line  28)
* gccjit;;context;;set_int_option (C++ function): Integer options<2>.
                                                              (line   6)
* gccjit;;context;;set_str_option (C++ function): String Options<2>.
                                                              (line   6)
* gccjit;;context;;zero (C++ function):  Simple expressions<2>.
                                                              (line  16)
* gccjit;;extended_asm (C++ class):      Adding assembler instructions within a function<2>.
                                                              (line   6)
* gccjit;;extended_asm;;add_clobber (C++ function): Adding assembler instructions within a function<2>.
                                                              (line 229)
* gccjit;;extended_asm;;add_input_operand (C++ function): Adding assembler instructions within a function<2>.
                                                              (line 220)
* gccjit;;extended_asm;;add_output_operand (C++ function): Adding assembler instructions within a function<2>.
                                                              (line 190)
* gccjit;;extended_asm;;set_inline_flag (C++ function): Adding assembler instructions within a function<2>.
                                                              (line 159)
* gccjit;;extended_asm;;set_volatile_flag (C++ function): Adding assembler instructions within a function<2>.
                                                              (line 131)
* gccjit;;field (C++ class):             Structures and unions<2>.
                                                              (line  13)
* gccjit;;function (C++ class):          Functions<2>.        (line   6)
* gccjit;;function;;dump_to_dot (C++ function): Functions<2>. (line  30)
* gccjit;;function;;get_address (C++ function): Function pointers<3>.
                                                              (line   6)
* gccjit;;function;;get_param (C++ function): Functions<2>.   (line  26)
* gccjit;;function;;new_block (C++ function): Blocks<2>.      (line  24)
* gccjit;;function;;new_local (C++ function): Functions<2>.   (line  34)
* gccjit;;location (C++ class):          Source Locations<2>. (line   6)
* gccjit;;lvalue (C++ class):            Lvalues<2>.          (line   6)
* gccjit;;lvalue;;access_field (C++ function): Working with pointers structs and unions<2>.
                                                              (line  26)
* gccjit;;lvalue;;get_address (C++ function): Lvalues<2>.     (line  15)
* gccjit;;object (C++ class):            Objects<2>.          (line   6)
* gccjit;;object;;get_context (C++ function): Objects<2>.     (line  36)
* gccjit;;object;;get_debug_string (C++ function): Objects<2>.
                                                              (line  40)
* gccjit;;param (C++ class):             Params<2>.           (line   6)
* gccjit;;rvalue (C++ class):            Rvalues<2>.          (line   6)
* gccjit;;rvalue;;access_field (C++ function): Working with pointers structs and unions<2>.
                                                              (line  35)
* gccjit;;rvalue;;dereference (C++ function): Working with pointers structs and unions<2>.
                                                              (line   6)
* gccjit;;rvalue;;dereference_field (C++ function): Working with pointers structs and unions<2>.
                                                              (line  44)
* gccjit;;rvalue;;get_type (C++ function): Rvalues<2>.        (line  34)
* gccjit;;rvalue;;operator* (C++ function): Working with pointers structs and unions<2>.
                                                              (line  20)
* gccjit;;struct_ (C++ class):           Structures and unions<2>.
                                                              (line   6)
* gccjit;;type (C++ class):              Types<2>.            (line   6)
* gccjit;;type;;get_aligned (C++ function): Pointers const and volatile<2>.
                                                              (line  18)
* gccjit;;type;;get_const (C++ function): Pointers const and volatile<2>.
                                                              (line  10)
* gccjit;;type;;get_pointer (C++ function): Pointers const and volatile<2>.
                                                              (line   6)
* gccjit;;type;;get_vector (C++ function): Vector types<2>.   (line   6)
* gccjit;;type;;get_volatile (C++ function): Pointers const and volatile<2>.
                                                              (line  14)
* LIBGCCJIT_HAVE_TIMING_API (C macro):   The timing API.      (line 103)
* new_bitwise_negate (C++ function):     Unary Operations<2>. (line  31)
* new_logical_negate (C++ function):     Unary Operations<2>. (line  43)
* operator! (C++ function):              Unary Operations<2>. (line  64)
* operator!= (C++ function):             Comparisons<2>.      (line  50)
* operator% (C++ function):              Binary Operations<2>.
                                                              (line  79)
* operator& (C++ function):              Binary Operations<2>.
                                                              (line  83)
* operator&& (C++ function):             Binary Operations<2>.
                                                              (line  95)
* operator* (C++ function):              Binary Operations<2>.
                                                              (line  71)
* operator+ (C++ function):              Binary Operations<2>.
                                                              (line  63)
* operator- (C++ function) <1>:          Binary Operations<2>.
                                                              (line  67)
* operator- (C++ function):              Unary Operations<2>. (line  56)
* operator/ (C++ function):              Binary Operations<2>.
                                                              (line  75)
* operator< (C++ function):              Comparisons<2>.      (line  54)
* operator<= (C++ function):             Comparisons<2>.      (line  58)
* operator== (C++ function):             Comparisons<2>.      (line  46)
* operator> (C++ function):              Comparisons<2>.      (line  62)
* operator>= (C++ function):             Comparisons<2>.      (line  66)
* operator^ (C++ function):              Binary Operations<2>.
                                                              (line  87)
* operator| (C++ function):              Binary Operations<2>.
                                                              (line  91)
* operator|| (C++ function):             Binary Operations<2>.
                                                              (line  99)
* operator~ (C++ function):              Unary Operations<2>. (line  60)
* PRESERVE_EXECUTABLES:                  Running the test suite.
                                                              (line  18)
* RUN_UNDER_VALGRIND:                    Running under valgrind.
                                                              (line   6)



Tag Table:
Node: Top441
Ref: index doc697
Ref: 0697
Ref: Top-Footnote-18892
Node: Tutorial8926
Ref: intro/index doc9013
Ref: 19013
Ref: intro/index libgccjit9013
Ref: 29013
Ref: intro/index tutorial9013
Ref: 39013
Node: Tutorial part 1 “Hello world”9555
Ref: intro/tutorial01 doc9701
Ref: 49701
Ref: intro/tutorial01 tutorial-part-1-hello-world9701
Ref: 59701
Node: Tutorial part 2 Creating a trivial machine code function14863
Ref: intro/tutorial02 doc15053
Ref: 615053
Ref: intro/tutorial02 tutorial-part-2-creating-a-trivial-machine-code-function15053
Ref: 715053
Node: Error-handling20448
Ref: intro/tutorial02 error-handling20574
Ref: 1820574
Node: Options21471
Ref: intro/tutorial02 options21618
Ref: 1a21618
Node: Full example24143
Ref: intro/tutorial02 full-example24267
Ref: 2024267
Node: Tutorial part 3 Loops and variables28344
Ref: intro/tutorial03 doc28560
Ref: 2128560
Ref: intro/tutorial03 tutorial-part-3-loops-and-variables28560
Ref: 2228560
Node: Expressions lvalues and rvalues30481
Ref: intro/tutorial03 expressions-lvalues-and-rvalues30608
Ref: 2330608
Node: Control flow32771
Ref: intro/tutorial03 control-flow32941
Ref: 2732941
Node: Visualizing the control flow graph37694
Ref: intro/tutorial03 visualizing-the-control-flow-graph37848
Ref: 3237848
Node: Full example<2>38423
Ref: intro/tutorial03 full-example38556
Ref: 3438556
Node: Tutorial part 4 Adding JIT-compilation to a toy interpreter44462
Ref: intro/tutorial04 doc44676
Ref: 3544676
Ref: intro/tutorial04 tutorial-part-4-adding-jit-compilation-to-a-toy-interpreter44676
Ref: 3644676
Node: Our toy interpreter45287
Ref: intro/tutorial04 our-toy-interpreter45439
Ref: 3745439
Node: Compiling to machine code51621
Ref: intro/tutorial04 compiling-to-machine-code51799
Ref: 3851799
Node: Setting things up53792
Ref: intro/tutorial04 setting-things-up53974
Ref: 3a53974
Node: Populating the function57943
Ref: intro/tutorial04 populating-the-function58132
Ref: 3c58132
Node: Verifying the control flow graph65587
Ref: intro/tutorial04 verifying-the-control-flow-graph65780
Ref: 3e65780
Node: Compiling the context66286
Ref: intro/tutorial04 compiling-the-context66498
Ref: 3f66498
Node: Single-stepping through the generated code67083
Ref: intro/tutorial04 single-stepping-through-the-generated-code67291
Ref: 4067291
Node: Examining the generated code69368
Ref: intro/tutorial04 examining-the-generated-code69578
Ref: 4369578
Node: Putting it all together74244
Ref: intro/tutorial04 putting-it-all-together74463
Ref: 4474463
Node: Behind the curtain How does our code get optimized?75285
Ref: intro/tutorial04 behind-the-curtain-how-does-our-code-get-optimized75467
Ref: 4575467
Node: Optimizing away stack manipulation81115
Ref: intro/tutorial04 optimizing-away-stack-manipulation81278
Ref: 4681278
Node: Elimination of tail recursion87197
Ref: intro/tutorial04 elimination-of-tail-recursion87360
Ref: 4787360
Node: Tutorial part 5 Implementing an Ahead-of-Time compiler88805
Ref: intro/tutorial05 doc88975
Ref: 4888975
Ref: intro/tutorial05 tutorial-part-5-implementing-an-ahead-of-time-compiler88975
Ref: 4988975
Node: The “brainf” language89828
Ref: intro/tutorial05 the-brainf-language89998
Ref: 4b89998
Node: Converting a brainf script to libgccjit IR92198
Ref: intro/tutorial05 converting-a-brainf-script-to-libgccjit-ir92406
Ref: 4c92406
Node: Compiling a context to a file103699
Ref: intro/tutorial05 compiling-a-context-to-a-file103922
Ref: 4d103922
Node: Other forms of ahead-of-time-compilation110579
Ref: intro/tutorial05 other-forms-of-ahead-of-time-compilation110751
Ref: 4e110751
Node: Topic Reference111111
Ref: topics/index doc111221
Ref: 4f111221
Ref: topics/index topic-reference111221
Ref: 50111221
Node: Compilation contexts111541
Ref: topics/contexts doc111632
Ref: 51111632
Ref: topics/contexts compilation-contexts111632
Ref: 52111632
Ref: topics/contexts c gcc_jit_context111683
Ref: 8111683
Node: Lifetime-management112138
Ref: topics/contexts lifetime-management112239
Ref: 53112239
Ref: topics/contexts c gcc_jit_context_acquire112504
Ref: 9112504
Ref: topics/contexts c gcc_jit_context_release112727
Ref: c112727
Ref: topics/contexts c gcc_jit_context_new_child_context113182
Ref: 54113182
Node: Thread-safety114586
Ref: topics/contexts thread-safety114713
Ref: 55114713
Node: Error-handling<2>115409
Ref: topics/contexts error-handling115526
Ref: 19115526
Ref: topics/contexts id1115526
Ref: 56115526
Ref: topics/contexts c gcc_jit_context_get_first_error116560
Ref: 57116560
Ref: topics/contexts c gcc_jit_context_get_last_error117071
Ref: 58117071
Node: Debugging117414
Ref: topics/contexts debugging117528
Ref: 59117528
Ref: topics/contexts c gcc_jit_context_dump_to_file117561
Ref: 5a117561
Ref: topics/contexts c gcc_jit_context_set_logfile118155
Ref: 5b118155
Ref: topics/contexts c gcc_jit_context_dump_reproducer_to_file119827
Ref: 5d119827
Ref: topics/contexts c gcc_jit_context_enable_dump120995
Ref: 5e120995
Node: Options<2>122519
Ref: topics/contexts options122607
Ref: 5f122607
Node: String Options123121
Ref: topics/contexts string-options123209
Ref: 60123209
Ref: topics/contexts c gcc_jit_context_set_str_option123256
Ref: 61123256
Ref: topics/contexts c gcc_jit_str_option123442
Ref: 62123442
Ref: topics/contexts c GCC_JIT_STR_OPTION_PROGNAME123715
Ref: 63123715
Node: Boolean options123929
Ref: topics/contexts boolean-options124041
Ref: 64124041
Ref: topics/contexts c gcc_jit_context_set_bool_option124090
Ref: 1b124090
Ref: topics/contexts c gcc_jit_bool_option124336
Ref: 65124336
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DEBUGINFO124379
Ref: 42124379
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE124861
Ref: 66124861
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE126777
Ref: 1c126777
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE127231
Ref: 1d127231
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DUMP_SUMMARY128324
Ref: 67128324
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING128508
Ref: 68128508
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_SELFCHECK_GC128971
Ref: 6a128971
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES129307
Ref: 69129307
Ref: topics/contexts c gcc_jit_context_set_bool_allow_unreachable_blocks129541
Ref: 6b129541
Ref: topics/contexts c gcc_jit_context_set_bool_use_external_driver130002
Ref: 6d130002
Ref: topics/contexts c gcc_jit_context_set_bool_print_errors_to_stderr130613
Ref: 6f130613
Node: Integer options131030
Ref: topics/contexts integer-options131159
Ref: 71131159
Ref: topics/contexts c gcc_jit_context_set_int_option131208
Ref: 1e131208
Ref: topics/contexts c gcc_jit_int_option131388
Ref: 72131388
Ref: topics/contexts c GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL131489
Ref: 1f131489
Node: Additional command-line options131742
Ref: topics/contexts additional-command-line-options131847
Ref: 73131847
Ref: topics/contexts c gcc_jit_context_add_command_line_option131928
Ref: 74131928
Ref: topics/contexts c gcc_jit_context_add_driver_option133196
Ref: 76133196
Node: Objects134585
Ref: topics/objects doc134690
Ref: 78134690
Ref: topics/objects objects134690
Ref: 79134690
Ref: topics/objects c gcc_jit_object134715
Ref: e134715
Ref: topics/objects c gcc_jit_object_get_context135833
Ref: 7a135833
Ref: topics/objects c gcc_jit_object_get_debug_string135966
Ref: f135966
Node: Types136577
Ref: topics/types doc136673
Ref: 7b136673
Ref: topics/types types136673
Ref: 7c136673
Ref: topics/types c gcc_jit_type136694
Ref: a136694
Ref: topics/types c gcc_jit_type_as_object136776
Ref: d136776
Node: Standard types137761
Ref: topics/types standard-types137856
Ref: 7f137856
Ref: topics/types c gcc_jit_context_get_type137899
Ref: b137899
Ref: topics/types c gcc_jit_context_get_int_type140762
Ref: 80140762
Node: Pointers const and volatile140935
Ref: topics/types pointers-const-and-volatile141051
Ref: 81141051
Ref: topics/types c gcc_jit_type_get_pointer141132
Ref: 7d141132
Ref: topics/types c gcc_jit_type_get_const141263
Ref: 7e141263
Ref: topics/types c gcc_jit_type_get_volatile141397
Ref: 82141397
Ref: topics/types c gcc_jit_context_new_array_type141537
Ref: 83141537
Ref: topics/types c gcc_jit_type_get_aligned141794
Ref: 84141794
Node: Vector types142219
Ref: topics/types vector-types142342
Ref: 86142342
Ref: topics/types c gcc_jit_type_get_vector142381
Ref: 87142381
Node: Structures and unions143544
Ref: topics/types structures-and-unions143662
Ref: 8a143662
Ref: topics/types c gcc_jit_struct143719
Ref: 8b143719
Ref: topics/types c gcc_jit_field143791
Ref: 8c143791
Ref: topics/types c gcc_jit_context_new_field145229
Ref: 8d145229
Ref: topics/types c gcc_jit_context_new_bitfield145661
Ref: 8e145661
Ref: topics/types c gcc_jit_field_as_object146393
Ref: 90146393
Ref: topics/types c gcc_jit_context_new_struct_type146518
Ref: 91146518
Ref: topics/types c gcc_jit_context_new_opaque_struct146957
Ref: 92146957
Ref: topics/types c gcc_jit_struct_as_type147523
Ref: 94147523
Ref: topics/types c gcc_jit_struct_set_fields147651
Ref: 93147651
Ref: topics/types c gcc_jit_context_new_union_type147930
Ref: 95147930
Node: Function pointer types150869
Ref: topics/types function-pointer-types150989
Ref: 96150989
Node: Reflection API151144
Ref: topics/types reflection-api151234
Ref: 98151234
Ref: topics/types c gcc_jit_type_dyncast_array151277
Ref: 99151277
Ref: topics/types c gcc_jit_type_is_bool151447
Ref: 9a151447
Ref: topics/types c gcc_jit_type_dyncast_function_ptr_type151554
Ref: 9b151554
Ref: topics/types c gcc_jit_function_type_get_return_type151717
Ref: 9c151717
Ref: topics/types c gcc_jit_function_type_get_param_count151888
Ref: 9d151888
Ref: topics/types c gcc_jit_function_type_get_param_type152060
Ref: 9e152060
Ref: topics/types c gcc_jit_type_is_integral152264
Ref: 9f152264
Ref: topics/types c gcc_jit_type_is_pointer152380
Ref: a0152380
Ref: topics/types c gcc_jit_type_dyncast_vector152554
Ref: a1152554
Ref: topics/types c gcc_jit_type_is_struct152719
Ref: a2152719
Ref: topics/types c gcc_jit_vector_type_get_num_units152874
Ref: a3152874
Ref: topics/types c gcc_jit_vector_type_get_element_type153043
Ref: a4153043
Ref: topics/types c gcc_jit_type_unqualified153217
Ref: a5153217
Ref: topics/types c gcc_jit_struct_get_field153421
Ref: a6153421
Ref: topics/types c gcc_jit_struct_get_field_count153567
Ref: a7153567
Ref: topics/types c gcc_jit_case154791
Ref: a9154791
Ref: topics/types c gcc_jit_compatible_types154822
Ref: aa154822
Ref: topics/types c gcc_jit_type_get_size155380
Ref: ac155380
Node: Expressions155768
Ref: topics/expressions doc155885
Ref: ad155885
Ref: topics/expressions expressions155885
Ref: ae155885
Node: Rvalues156039
Ref: topics/expressions rvalues156113
Ref: af156113
Ref: topics/expressions c gcc_jit_rvalue156142
Ref: 13156142
Ref: topics/expressions c gcc_jit_rvalue_get_type156770
Ref: b0156770
Ref: topics/expressions c gcc_jit_rvalue_as_object156894
Ref: 14156894
Node: Simple expressions157235
Ref: topics/expressions simple-expressions157332
Ref: b1157332
Ref: topics/expressions c gcc_jit_context_new_rvalue_from_int157387
Ref: 30157387
Ref: topics/expressions c gcc_jit_context_new_rvalue_from_long157642
Ref: b2157642
Ref: topics/expressions c gcc_jit_context_zero157910
Ref: 2b157910
Ref: topics/expressions c gcc_jit_context_one158223
Ref: 2f158223
Ref: topics/expressions c gcc_jit_context_new_rvalue_from_double158534
Ref: 31158534
Ref: topics/expressions c gcc_jit_context_new_rvalue_from_ptr158808
Ref: b3158808
Ref: topics/expressions c gcc_jit_context_null159029
Ref: b4159029
Ref: topics/expressions c gcc_jit_context_new_string_literal159320
Ref: b5159320
Node: Constructor expressions159711
Ref: topics/expressions constructor-expressions159835
Ref: b6159835
Ref: topics/expressions c gcc_jit_context_new_array_constructor160877
Ref: b9160877
Ref: topics/expressions c gcc_jit_context_new_struct_constructor161985
Ref: ba161985
Ref: topics/expressions c gcc_jit_context_new_union_constructor163578
Ref: bb163578
Node: Vector expressions164509
Ref: topics/expressions vector-expressions164631
Ref: bc164631
Ref: topics/expressions c gcc_jit_context_new_rvalue_from_vector164686
Ref: 89164686
Node: Unary Operations165303
Ref: topics/expressions unary-operations165419
Ref: be165419
Ref: topics/expressions c gcc_jit_context_new_unary_op165470
Ref: bf165470
Ref: topics/expressions c gcc_jit_unary_op165798
Ref: c0165798
Ref: topics/expressions c GCC_JIT_UNARY_OP_MINUS166228
Ref: c1166228
Ref: topics/expressions c GCC_JIT_UNARY_OP_BITWISE_NEGATE166342
Ref: c2166342
Ref: topics/expressions c GCC_JIT_UNARY_OP_LOGICAL_NEGATE166501
Ref: c3166501
Ref: topics/expressions c GCC_JIT_UNARY_OP_ABS166648
Ref: c4166648
Node: Binary Operations166779
Ref: topics/expressions binary-operations166888
Ref: c5166888
Ref: topics/expressions c gcc_jit_context_new_binary_op166941
Ref: 12166941
Ref: topics/expressions c gcc_jit_binary_op167293
Ref: c6167293
Ref: topics/expressions c GCC_JIT_BINARY_OP_PLUS168130
Ref: c7168130
Ref: topics/expressions c GCC_JIT_BINARY_OP_MINUS168342
Ref: c8168342
Ref: topics/expressions c GCC_JIT_BINARY_OP_MULT168475
Ref: c9168475
Ref: topics/expressions c GCC_JIT_BINARY_OP_DIVIDE168620
Ref: ca168620
Ref: topics/expressions c GCC_JIT_BINARY_OP_MODULO168977
Ref: cb168977
Ref: topics/expressions c GCC_JIT_BINARY_OP_BITWISE_AND169121
Ref: cc169121
Ref: topics/expressions c GCC_JIT_BINARY_OP_BITWISE_XOR169239
Ref: cd169239
Ref: topics/expressions c GCC_JIT_BINARY_OP_BITWISE_OR169366
Ref: ce169366
Ref: topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_AND169492
Ref: cf169492
Ref: topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_OR169611
Ref: d0169611
Ref: topics/expressions c GCC_JIT_BINARY_OP_LSHIFT169728
Ref: d1169728
Ref: topics/expressions c GCC_JIT_BINARY_OP_RSHIFT169841
Ref: d2169841
Node: Comparisons169955
Ref: topics/expressions comparisons170062
Ref: d4170062
Ref: topics/expressions c gcc_jit_context_new_comparison170103
Ref: 2c170103
Ref: topics/expressions c gcc_jit_comparison170373
Ref: d5170373
Node: Function calls170847
Ref: topics/expressions function-calls170954
Ref: d6170954
Ref: topics/expressions c gcc_jit_context_new_call171001
Ref: d7171001
Ref: topics/expressions c gcc_jit_context_new_call_through_ptr172109
Ref: d9172109
Ref: topics/expressions c gcc_jit_rvalue_set_bool_require_tail_call172642
Ref: da172642
Node: Function pointers173701
Ref: topics/expressions function-pointers173810
Ref: dc173810
Node: Type-coercion174224
Ref: topics/expressions type-coercion174310
Ref: de174310
Ref: topics/expressions c gcc_jit_context_new_cast174355
Ref: df174355
Ref: topics/expressions c gcc_jit_context_new_bitcast174771
Ref: e0174771
Node: Lvalues175351
Ref: topics/expressions lvalues175474
Ref: e2175474
Ref: topics/expressions c gcc_jit_lvalue175503
Ref: 24175503
Ref: topics/expressions c gcc_jit_lvalue_as_object175739
Ref: e3175739
Ref: topics/expressions c gcc_jit_lvalue_as_rvalue175872
Ref: e4175872
Ref: topics/expressions c gcc_jit_lvalue_get_address176005
Ref: e5176005
Ref: topics/expressions c gcc_jit_lvalue_set_tls_model176204
Ref: e6176204
Ref: topics/expressions c gcc_jit_tls_model176466
Ref: e7176466
Ref: topics/expressions c GCC_JIT_TLS_MODEL_NONE176507
Ref: e8176507
Ref: topics/expressions c GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC176586
Ref: e9176586
Ref: topics/expressions c GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC176638
Ref: ea176638
Ref: topics/expressions c GCC_JIT_TLS_MODEL_INITIAL_EXEC176689
Ref: eb176689
Ref: topics/expressions c GCC_JIT_TLS_MODEL_LOCAL_EXEC176739
Ref: ec176739
Ref: topics/expressions c gcc_jit_lvalue_set_link_section177063
Ref: ee177063
Ref: topics/expressions c gcc_jit_lvalue_set_alignment178006
Ref: f1178006
Ref: topics/expressions c gcc_jit_lvalue_get_alignment178384
Ref: f3178384
Node: Global variables178837
Ref: topics/expressions global-variables178900
Ref: f4178900
Ref: topics/expressions c gcc_jit_context_new_global178951
Ref: f5178951
Ref: topics/expressions c gcc_jit_global_kind179571
Ref: f6179571
Ref: topics/expressions c GCC_JIT_GLOBAL_EXPORTED179614
Ref: f7179614
Ref: topics/expressions c GCC_JIT_GLOBAL_INTERNAL179910
Ref: f9179910
Ref: topics/expressions c GCC_JIT_GLOBAL_IMPORTED180213
Ref: fa180213
Ref: topics/expressions c gcc_jit_global_set_initializer180423
Ref: fb180423
Ref: topics/expressions c gcc_jit_global_set_initializer_rvalue181195
Ref: b7181195
Node: Working with pointers structs and unions182484
Ref: topics/expressions working-with-pointers-structs-and-unions182591
Ref: fd182591
Ref: topics/expressions c gcc_jit_rvalue_dereference182688
Ref: fe182688
Ref: topics/expressions c gcc_jit_lvalue_access_field183026
Ref: ff183026
Ref: topics/expressions c gcc_jit_rvalue_access_field183352
Ref: 100183352
Ref: topics/expressions c gcc_jit_rvalue_dereference_field183643
Ref: 101183643
Ref: topics/expressions c gcc_jit_context_new_array_access184007
Ref: d3184007
Node: Creating and using functions184469
Ref: topics/functions doc184601
Ref: 102184601
Ref: topics/functions creating-and-using-functions184601
Ref: 103184601
Node: Params184729
Ref: topics/functions params184821
Ref: 104184821
Ref: topics/functions c gcc_jit_param184848
Ref: 25184848
Ref: topics/functions c gcc_jit_context_new_param184936
Ref: 10184936
Ref: topics/functions c gcc_jit_param_as_lvalue185517
Ref: 105185517
Ref: topics/functions c gcc_jit_param_as_rvalue185645
Ref: 106185645
Ref: topics/functions c gcc_jit_param_as_object185773
Ref: 107185773
Node: Functions185901
Ref: topics/functions functions186008
Ref: 108186008
Ref: topics/functions c gcc_jit_function186041
Ref: 29186041
Ref: topics/functions c gcc_jit_context_new_function186203
Ref: 11186203
Ref: topics/functions c gcc_jit_function_kind186557
Ref: 109186557
Ref: topics/functions c GCC_JIT_FUNCTION_EXPORTED186693
Ref: 10a186693
Ref: topics/functions c GCC_JIT_FUNCTION_INTERNAL187048
Ref: 10b187048
Ref: topics/functions c GCC_JIT_FUNCTION_IMPORTED187259
Ref: 10c187259
Ref: topics/functions c GCC_JIT_FUNCTION_ALWAYS_INLINE187495
Ref: 10d187495
Ref: topics/functions c gcc_jit_context_get_builtin_function188140
Ref: 10e188140
Ref: topics/functions c gcc_jit_function_as_object188900
Ref: 10f188900
Ref: topics/functions c gcc_jit_function_get_param189036
Ref: 110189036
Ref: topics/functions c gcc_jit_function_dump_to_dot189191
Ref: 33189191
Ref: topics/functions c gcc_jit_function_new_local189356
Ref: 26189356
Ref: topics/functions c gcc_jit_function_get_param_count189820
Ref: 111189820
Ref: topics/functions c gcc_jit_function_get_return_type189963
Ref: 112189963
Ref: topics/functions c gcc_jit_case190457
Ref: 113190457
Node: Blocks190488
Ref: topics/functions blocks190599
Ref: 114190599
Ref: topics/functions c gcc_jit_block190626
Ref: 28190626
Ref: topics/functions c gcc_jit_function_new_block191134
Ref: 115191134
Ref: topics/functions c gcc_jit_block_as_object191828
Ref: 116191828
Ref: topics/functions c gcc_jit_block_get_function191953
Ref: 117191953
Node: Statements192091
Ref: topics/functions statements192184
Ref: 118192184
Ref: topics/functions c gcc_jit_block_add_eval192219
Ref: d8192219
Ref: topics/functions c gcc_jit_block_add_assignment192522
Ref: 2a192522
Ref: topics/functions c gcc_jit_block_add_assignment_op192844
Ref: 2e192844
Ref: topics/functions c gcc_jit_block_add_comment193469
Ref: 3d193469
Ref: topics/functions c gcc_jit_block_end_with_conditional194322
Ref: 2d194322
Ref: topics/functions c gcc_jit_block_end_with_jump194851
Ref: 119194851
Ref: topics/functions c gcc_jit_block_end_with_return195119
Ref: 11a195119
Ref: topics/functions c gcc_jit_block_end_with_void_return195423
Ref: 11b195423
Ref: topics/functions c gcc_jit_block_end_with_switch195708
Ref: 11c195708
Ref: topics/functions c gcc_jit_context_new_case197522
Ref: 11e197522
Ref: topics/functions c gcc_jit_case_as_object198049
Ref: 11d198049
Node: Function pointers<2>202326
Ref: topics/function-pointers doc202463
Ref: 121202463
Ref: topics/function-pointers function-pointers202463
Ref: 122202463
Ref: topics/function-pointers c gcc_jit_function_get_address202811
Ref: dd202811
Ref: topics/function-pointers c gcc_jit_context_new_function_ptr_type204098
Ref: 97204098
Node: Source Locations204525
Ref: topics/locations doc204653
Ref: 124204653
Ref: topics/locations source-locations204653
Ref: 125204653
Ref: topics/locations c gcc_jit_location204696
Ref: 3b204696
Ref: topics/locations c gcc_jit_context_new_location205456
Ref: 41205456
Node: Faking it205887
Ref: topics/locations faking-it205952
Ref: 126205952
Node: Compiling a context206601
Ref: topics/compilation doc206734
Ref: 127206734
Ref: topics/compilation compiling-a-context206734
Ref: 128206734
Node: In-memory compilation207224
Ref: topics/compilation in-memory-compilation207338
Ref: 129207338
Ref: topics/compilation c gcc_jit_context_compile207395
Ref: 15207395
Ref: topics/compilation c gcc_jit_result207727
Ref: 16207727
Ref: topics/compilation c gcc_jit_result_get_code207934
Ref: 17207934
Ref: topics/compilation c gcc_jit_result_get_global209478
Ref: f8209478
Ref: topics/compilation c gcc_jit_result_release210898
Ref: 39210898
Node: Ahead-of-time compilation211287
Ref: topics/compilation ahead-of-time-compilation211401
Ref: 12a211401
Ref: topics/compilation c gcc_jit_context_compile_to_file211764
Ref: 4a211764
Ref: topics/compilation c gcc_jit_output_kind212305
Ref: 12b212305
Ref: topics/compilation c GCC_JIT_OUTPUT_KIND_ASSEMBLER212754
Ref: 12c212754
Ref: topics/compilation c GCC_JIT_OUTPUT_KIND_OBJECT_FILE212845
Ref: 12d212845
Ref: topics/compilation c GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY212935
Ref: 12e212935
Ref: topics/compilation c GCC_JIT_OUTPUT_KIND_EXECUTABLE213032
Ref: 12f213032
Node: ABI and API compatibility213120
Ref: topics/compatibility doc213248
Ref: 130213248
Ref: topics/compatibility abi-and-api-compatibility213248
Ref: 131213248
Node: Programmatically checking version214779
Ref: topics/compatibility programmatically-checking-version214901
Ref: 132214901
Ref: topics/compatibility c gcc_jit_version_major215047
Ref: 133215047
Ref: topics/compatibility c gcc_jit_version_minor215181
Ref: 134215181
Ref: topics/compatibility c gcc_jit_version_patchlevel215321
Ref: 135215321
Node: ABI symbol tags215564
Ref: topics/compatibility abi-symbol-tags215686
Ref: 136215686
Node: LIBGCCJIT_ABI_0216374
Ref: topics/compatibility id1216468
Ref: 137216468
Ref: topics/compatibility libgccjit-abi-0216468
Ref: 138216468
Ref: LIBGCCJIT_ABI_0-Footnote-1216841
Node: LIBGCCJIT_ABI_1216903
Ref: topics/compatibility id2217021
Ref: 139217021
Ref: topics/compatibility libgccjit-abi-1217021
Ref: 75217021
Node: LIBGCCJIT_ABI_2217169
Ref: topics/compatibility id3217287
Ref: 13a217287
Ref: topics/compatibility libgccjit-abi-2217287
Ref: 6c217287
Node: LIBGCCJIT_ABI_3217445
Ref: topics/compatibility id4217563
Ref: 13b217563
Ref: topics/compatibility libgccjit-abi-3217563
Ref: 11f217563
Node: LIBGCCJIT_ABI_4217850
Ref: topics/compatibility id5217968
Ref: 13c217968
Ref: topics/compatibility libgccjit-abi-4217968
Ref: 13d217968
Node: LIBGCCJIT_ABI_5218415
Ref: topics/compatibility id6218533
Ref: 145218533
Ref: topics/compatibility libgccjit-abi-5218533
Ref: 6e218533
Node: LIBGCCJIT_ABI_6218686
Ref: topics/compatibility id7218804
Ref: 146218804
Ref: topics/compatibility libgccjit-abi-6218804
Ref: db218804
Node: LIBGCCJIT_ABI_7218954
Ref: topics/compatibility id8219072
Ref: 147219072
Ref: topics/compatibility libgccjit-abi-7219072
Ref: 85219072
Node: LIBGCCJIT_ABI_8219205
Ref: topics/compatibility id9219323
Ref: 148219323
Ref: topics/compatibility libgccjit-abi-8219323
Ref: 88219323
Node: LIBGCCJIT_ABI_9219455
Ref: topics/compatibility id10219574
Ref: 149219574
Ref: topics/compatibility libgccjit-abi-9219574
Ref: 123219574
Node: LIBGCCJIT_ABI_10219713
Ref: topics/compatibility id11219833
Ref: 14a219833
Ref: topics/compatibility libgccjit-abi-10219833
Ref: bd219833
Node: LIBGCCJIT_ABI_11219985
Ref: topics/compatibility id12220106
Ref: 14b220106
Ref: topics/compatibility libgccjit-abi-11220106
Ref: 77220106
Node: LIBGCCJIT_ABI_12220253
Ref: topics/compatibility id13220374
Ref: 14c220374
Ref: topics/compatibility libgccjit-abi-12220374
Ref: 8f220374
Node: LIBGCCJIT_ABI_13220516
Ref: topics/compatibility id14220637
Ref: 14d220637
Ref: topics/compatibility libgccjit-abi-13220637
Ref: 14e220637
Node: LIBGCCJIT_ABI_14220922
Ref: topics/compatibility id15221043
Ref: 14f221043
Ref: topics/compatibility libgccjit-abi-14221043
Ref: fc221043
Node: LIBGCCJIT_ABI_15221187
Ref: topics/compatibility id16221308
Ref: 150221308
Ref: topics/compatibility libgccjit-abi-15221308
Ref: 151221308
Node: LIBGCCJIT_ABI_16222021
Ref: topics/compatibility id17222142
Ref: 15b222142
Ref: topics/compatibility libgccjit-abi-16222142
Ref: a8222142
Node: LIBGCCJIT_ABI_17223212
Ref: topics/compatibility id18223333
Ref: 15c223333
Ref: topics/compatibility libgccjit-abi-17223333
Ref: ed223333
Node: LIBGCCJIT_ABI_18223557
Ref: topics/compatibility id19223678
Ref: 15d223678
Ref: topics/compatibility libgccjit-abi-18223678
Ref: ef223678
Node: LIBGCCJIT_ABI_19223891
Ref: topics/compatibility id20224012
Ref: 15e224012
Ref: topics/compatibility libgccjit-abi-19224012
Ref: b8224012
Node: LIBGCCJIT_ABI_20224454
Ref: topics/compatibility id21224575
Ref: 15f224575
Ref: topics/compatibility libgccjit-abi-20224575
Ref: ab224575
Node: LIBGCCJIT_ABI_21225195
Ref: topics/compatibility id22225316
Ref: 160225316
Ref: topics/compatibility libgccjit-abi-21225316
Ref: e1225316
Node: LIBGCCJIT_ABI_22225531
Ref: topics/compatibility id23225652
Ref: 161225652
Ref: topics/compatibility libgccjit-abi-22225652
Ref: f0225652
Node: LIBGCCJIT_ABI_23225858
Ref: topics/compatibility id24225979
Ref: 162225979
Ref: topics/compatibility libgccjit-abi-23225979
Ref: 70225979
Node: LIBGCCJIT_ABI_24226190
Ref: topics/compatibility id25226286
Ref: 163226286
Ref: topics/compatibility libgccjit-abi-24226286
Ref: f2226286
Node: Performance226546
Ref: topics/performance doc226693
Ref: 164226693
Ref: topics/performance performance226693
Ref: 165226693
Node: The timing API226757
Ref: topics/performance the-timing-api226822
Ref: 166226822
Ref: topics/performance c LIBGCCJIT_HAVE_TIMING_API232107
Ref: 168232107
Ref: topics/performance c gcc_jit_timer232534
Ref: 167232534
Ref: topics/performance c gcc_jit_timer_new232561
Ref: 140232561
Ref: topics/performance c gcc_jit_timer_release232890
Ref: 141232890
Ref: topics/performance c gcc_jit_context_set_timer233250
Ref: 13f233250
Ref: topics/performance c gcc_jit_context_get_timer233921
Ref: 13e233921
Ref: topics/performance c gcc_jit_timer_push234220
Ref: 142234220
Ref: topics/performance c gcc_jit_timer_pop234656
Ref: 143234656
Ref: topics/performance c gcc_jit_timer_print235093
Ref: 144235093
Node: Using Assembly Language with libgccjit235432
Ref: topics/asm doc235545
Ref: 169235545
Ref: topics/asm using-assembly-language-with-libgccjit235545
Ref: 16a235545
Ref: Using Assembly Language with libgccjit-Footnote-1236246
Node: Adding assembler instructions within a function236322
Ref: topics/asm adding-assembler-instructions-within-a-function236493
Ref: 16b236493
Ref: topics/asm c gcc_jit_extended_asm236604
Ref: 120236604
Ref: topics/asm c gcc_jit_block_add_extended_asm239216
Ref: 152239216
Ref: topics/asm c gcc_jit_block_end_with_extended_asm_goto239776
Ref: 153239776
Ref: topics/asm c gcc_jit_extended_asm_set_volatile_flag242207
Ref: 155242207
Ref: topics/asm c gcc_jit_extended_asm_set_inline_flag243459
Ref: 156243459
Ref: topics/asm c gcc_jit_extended_asm_add_output_operand243658
Ref: 157243658
Ref: topics/asm c gcc_jit_extended_asm_add_input_operand244977
Ref: 158244977
Ref: topics/asm c gcc_jit_extended_asm_add_clobber246246
Ref: 159246246
Ref: topics/asm c gcc_jit_extended_asm_as_object247002
Ref: 154247002
Ref: Adding assembler instructions within a function-Footnote-1247185
Ref: Adding assembler instructions within a function-Footnote-2247252
Ref: Adding assembler instructions within a function-Footnote-3247327
Ref: Adding assembler instructions within a function-Footnote-4247400
Ref: Adding assembler instructions within a function-Footnote-5247469
Ref: Adding assembler instructions within a function-Footnote-6247541
Node: Adding top-level assembler statements247631
Ref: topics/asm adding-top-level-assembler-statements247802
Ref: 16c247802
Ref: topics/asm c gcc_jit_context_add_top_level_asm248058
Ref: 15a248058
Node: C++ bindings for libgccjit249406
Ref: cp/index doc249517
Ref: 16d249517
Ref: cp/index c-bindings-for-libgccjit249517
Ref: 16e249517
Ref: C++ bindings for libgccjit-Footnote-1250058
Node: Tutorial<2>250092
Ref: cp/intro/index doc250196
Ref: 16f250196
Ref: cp/intro/index tutorial250196
Ref: 170250196
Node: Tutorial part 1 “Hello world”<2>250639
Ref: cp/intro/tutorial01 doc250794
Ref: 171250794
Ref: cp/intro/tutorial01 tutorial-part-1-hello-world250794
Ref: 172250794
Node: Tutorial part 2 Creating a trivial machine code function<2>255423
Ref: cp/intro/tutorial02 doc255625
Ref: 173255625
Ref: cp/intro/tutorial02 tutorial-part-2-creating-a-trivial-machine-code-function255625
Ref: 174255625
Node: Options<3>260677
Ref: cp/intro/tutorial02 options260810
Ref: 180260810
Node: Full example<3>263205
Ref: cp/intro/tutorial02 full-example263338
Ref: 183263338
Node: Tutorial part 3 Loops and variables<2>266904
Ref: cp/intro/tutorial03 doc267132
Ref: 184267132
Ref: cp/intro/tutorial03 tutorial-part-3-loops-and-variables267132
Ref: 185267132
Node: Expressions lvalues and rvalues<2>269143
Ref: cp/intro/tutorial03 expressions-lvalues-and-rvalues269279
Ref: 186269279
Node: Control flow<2>271524
Ref: cp/intro/tutorial03 control-flow271706
Ref: 18a271706
Node: Visualizing the control flow graph<2>276320
Ref: cp/intro/tutorial03 visualizing-the-control-flow-graph276483
Ref: 193276483
Node: Full example<4>277046
Ref: cp/intro/tutorial03 full-example277185
Ref: 195277185
Node: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>282031
Ref: cp/intro/tutorial04 doc282191
Ref: 196282191
Ref: cp/intro/tutorial04 tutorial-part-4-adding-jit-compilation-to-a-toy-interpreter282191
Ref: 197282191
Node: Our toy interpreter<2>283075
Ref: cp/intro/tutorial04 our-toy-interpreter283236
Ref: 198283236
Node: Compiling to machine code<2>289310
Ref: cp/intro/tutorial04 compiling-to-machine-code289500
Ref: 199289500
Node: Setting things up<2>291097
Ref: cp/intro/tutorial04 setting-things-up291291
Ref: 19a291291
Node: Populating the function<2>294839
Ref: cp/intro/tutorial04 populating-the-function295040
Ref: 19c295040
Node: Verifying the control flow graph<2>301334
Ref: cp/intro/tutorial04 verifying-the-control-flow-graph301539
Ref: 19e301539
Node: Compiling the context<2>302027
Ref: cp/intro/tutorial04 compiling-the-context302251
Ref: 19f302251
Node: Single-stepping through the generated code<2>303301
Ref: cp/intro/tutorial04 single-stepping-through-the-generated-code303521
Ref: 1a0303521
Node: Examining the generated code<2>305542
Ref: cp/intro/tutorial04 examining-the-generated-code305764
Ref: 1a2305764
Node: Putting it all together<2>310222
Ref: cp/intro/tutorial04 putting-it-all-together310453
Ref: 1a3310453
Node: Behind the curtain How does our code get optimized?<2>311282
Ref: cp/intro/tutorial04 behind-the-curtain-how-does-our-code-get-optimized311473
Ref: 1a4311473
Node: Optimizing away stack manipulation<2>317015
Ref: cp/intro/tutorial04 optimizing-away-stack-manipulation317187
Ref: 1a5317187
Node: Elimination of tail recursion<2>323106
Ref: cp/intro/tutorial04 elimination-of-tail-recursion323278
Ref: 1a6323278
Node: Topic Reference<2>324723
Ref: cp/topics/index doc324827
Ref: 1a7324827
Ref: cp/topics/index topic-reference324827
Ref: 1a8324827
Node: Compilation contexts<2>325198
Ref: cp/topics/contexts doc325298
Ref: 1a9325298
Ref: cp/topics/contexts compilation-contexts325298
Ref: 1aa325298
Ref: cp/topics/contexts _CPPv4N6gccjit7contextE325353
Ref: 175325353
Ref: cp/topics/contexts _CPPv3N6gccjit7contextE325353
Ref: 1ab325353
Ref: cp/topics/contexts _CPPv2N6gccjit7contextE325353
Ref: 1ac325353
Ref: cp/topics/contexts gccjit context325353
Ref: 1ad325353
Node: Lifetime-management<2>325947
Ref: cp/topics/contexts lifetime-management326057
Ref: 1ae326057
Ref: cp/topics/contexts _CPPv4N6gccjit7context7acquireEv326326
Ref: 176326326
Ref: cp/topics/contexts _CPPv3N6gccjit7context7acquireEv326326
Ref: 1af326326
Ref: cp/topics/contexts _CPPv2N6gccjit7context7acquireEv326326
Ref: 1b0326326
Ref: cp/topics/contexts gccjit context acquire326326
Ref: 1b1326326
Ref: cp/topics/contexts _CPPv4N6gccjit7context7releaseEv326581
Ref: 179326581
Ref: cp/topics/contexts _CPPv3N6gccjit7context7releaseEv326581
Ref: 1b2326581
Ref: cp/topics/contexts _CPPv2N6gccjit7context7releaseEv326581
Ref: 1b3326581
Ref: cp/topics/contexts gccjit context release326581
Ref: 1b4326581
Ref: cp/topics/contexts _CPPv4N6gccjit7context17new_child_contextEv327006
Ref: 1b5327006
Ref: cp/topics/contexts _CPPv3N6gccjit7context17new_child_contextEv327006
Ref: 1b6327006
Ref: cp/topics/contexts _CPPv2N6gccjit7context17new_child_contextEv327006
Ref: 1b7327006
Ref: cp/topics/contexts gccjit context new_child_context327006
Ref: 1b8327006
Node: Thread-safety<2>328407
Ref: cp/topics/contexts thread-safety328543
Ref: 1b9328543
Node: Error-handling<3>329248
Ref: cp/topics/contexts error-handling329374
Ref: 1ba329374
Ref: cp/topics/contexts _CPPv4N6gccjit7context15get_first_errorEPN6gccjit7contextE329802
Ref: 1bb329802
Ref: cp/topics/contexts _CPPv3N6gccjit7context15get_first_errorEPN6gccjit7contextE329802
Ref: 1bc329802
Ref: cp/topics/contexts _CPPv2N6gccjit7context15get_first_errorEPN6gccjit7contextE329802
Ref: 1bd329802
Ref: cp/topics/contexts gccjit context get_first_error__gccjit contextP329802
Ref: 1be329802
Node: Debugging<2>330112
Ref: cp/topics/contexts debugging330232
Ref: 1bf330232
Ref: cp/topics/contexts _CPPv4N6gccjit7context12dump_to_fileERKNSt6stringEi330269
Ref: 1c0330269
Ref: cp/topics/contexts _CPPv3N6gccjit7context12dump_to_fileERKNSt6stringEi330269
Ref: 1c1330269
Ref: cp/topics/contexts _CPPv2N6gccjit7context12dump_to_fileERKNSt6stringEi330269
Ref: 1c2330269
Ref: cp/topics/contexts gccjit context dump_to_file__ssCR i330269
Ref: 1c3330269
Ref: cp/topics/contexts _CPPv4N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc330844
Ref: 1c4330844
Ref: cp/topics/contexts _CPPv3N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc330844
Ref: 1c5330844
Ref: cp/topics/contexts _CPPv2N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc330844
Ref: 1c6330844
Ref: cp/topics/contexts gccjit context dump_reproducer_to_file__gcc_jit_contextP cCP330844
Ref: 1c7330844
Node: Options<4>331263
Ref: cp/topics/contexts options331357
Ref: 1c8331357
Node: String Options<2>331586
Ref: cp/topics/contexts string-options331680
Ref: 1c9331680
Ref: cp/topics/contexts _CPPv4N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc331727
Ref: 1ca331727
Ref: cp/topics/contexts _CPPv3N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc331727
Ref: 1cb331727
Ref: cp/topics/contexts _CPPv2N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc331727
Ref: 1cc331727
Ref: cp/topics/contexts gccjit context set_str_option__gcc_jit_str_option cCP331727
Ref: 1cd331727
Node: Boolean options<2>332027
Ref: cp/topics/contexts boolean-options332148
Ref: 1ce332148
Ref: cp/topics/contexts _CPPv4N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni332197
Ref: 181332197
Ref: cp/topics/contexts _CPPv3N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni332197
Ref: 1cf332197
Ref: cp/topics/contexts _CPPv2N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni332197
Ref: 1d0332197
Ref: cp/topics/contexts gccjit context set_bool_option__gcc_jit_bool_option i332197
Ref: 1d1332197
Ref: cp/topics/contexts _CPPv4N6gccjit7context33set_bool_allow_unreachable_blocksEi332493
Ref: 1d2332493
Ref: cp/topics/contexts _CPPv3N6gccjit7context33set_bool_allow_unreachable_blocksEi332493
Ref: 1d3332493
Ref: cp/topics/contexts _CPPv2N6gccjit7context33set_bool_allow_unreachable_blocksEi332493
Ref: 1d4332493
Ref: cp/topics/contexts gccjit context set_bool_allow_unreachable_blocks__i332493
Ref: 1d5332493
Ref: cp/topics/contexts _CPPv4N6gccjit7context28set_bool_use_external_driverEi333057
Ref: 1d6333057
Ref: cp/topics/contexts _CPPv3N6gccjit7context28set_bool_use_external_driverEi333057
Ref: 1d7333057
Ref: cp/topics/contexts _CPPv2N6gccjit7context28set_bool_use_external_driverEi333057
Ref: 1d8333057
Ref: cp/topics/contexts gccjit context set_bool_use_external_driver__i333057
Ref: 1d9333057
Node: Integer options<2>333761
Ref: cp/topics/contexts integer-options333899
Ref: 1da333899
Ref: cp/topics/contexts _CPPv4N6gccjit7context14set_int_optionE18gcc_jit_int_optioni333948
Ref: 182333948
Ref: cp/topics/contexts _CPPv3N6gccjit7context14set_int_optionE18gcc_jit_int_optioni333948
Ref: 1db333948
Ref: cp/topics/contexts _CPPv2N6gccjit7context14set_int_optionE18gcc_jit_int_optioni333948
Ref: 1dc333948
Ref: cp/topics/contexts gccjit context set_int_option__gcc_jit_int_option i333948
Ref: 1dd333948
Node: Additional command-line options<2>334242
Ref: cp/topics/contexts additional-command-line-options334353
Ref: 1de334353
Ref: cp/topics/contexts _CPPv4N6gccjit7context23add_command_line_optionEPKc334434
Ref: 1df334434
Ref: cp/topics/contexts _CPPv3N6gccjit7context23add_command_line_optionEPKc334434
Ref: 1e0334434
Ref: cp/topics/contexts _CPPv2N6gccjit7context23add_command_line_optionEPKc334434
Ref: 1e1334434
Ref: cp/topics/contexts gccjit context add_command_line_option__cCP334434
Ref: 1e2334434
Node: Objects<2>334913
Ref: cp/topics/objects doc335030
Ref: 1e3335030
Ref: cp/topics/objects objects335030
Ref: 1e4335030
Ref: cp/topics/objects _CPPv4N6gccjit6objectE335059
Ref: 17a335059
Ref: cp/topics/objects _CPPv3N6gccjit6objectE335059
Ref: 1e5335059
Ref: cp/topics/objects _CPPv2N6gccjit6objectE335059
Ref: 1e6335059
Ref: cp/topics/objects gccjit object335059
Ref: 1e7335059
Ref: cp/topics/objects _CPPv4NK6gccjit6object11get_contextEv335870
Ref: 1e8335870
Ref: cp/topics/objects _CPPv3NK6gccjit6object11get_contextEv335870
Ref: 1e9335870
Ref: cp/topics/objects _CPPv2NK6gccjit6object11get_contextEv335870
Ref: 1ea335870
Ref: cp/topics/objects gccjit object get_contextC335870
Ref: 1eb335870
Ref: cp/topics/objects _CPPv4NK6gccjit6object16get_debug_stringEv336014
Ref: 17b336014
Ref: cp/topics/objects _CPPv3NK6gccjit6object16get_debug_stringEv336014
Ref: 1ec336014
Ref: cp/topics/objects _CPPv2NK6gccjit6object16get_debug_stringEv336014
Ref: 1ed336014
Ref: cp/topics/objects gccjit object get_debug_stringC336014
Ref: 1ee336014
Node: Types<2>336327
Ref: cp/topics/types doc336435
Ref: 1ef336435
Ref: cp/topics/types types336435
Ref: 1f0336435
Ref: cp/topics/types _CPPv4N6gccjit4typeE336460
Ref: 177336460
Ref: cp/topics/types _CPPv3N6gccjit4typeE336460
Ref: 1f1336460
Ref: cp/topics/types _CPPv2N6gccjit4typeE336460
Ref: 1f2336460
Ref: cp/topics/types gccjit type336460
Ref: 1f3336460
Node: Standard types<2>337545
Ref: cp/topics/types standard-types337649
Ref: 1f6337649
Ref: cp/topics/types _CPPv4N6gccjit7context8get_typeE13gcc_jit_types337696
Ref: 178337696
Ref: cp/topics/types _CPPv3N6gccjit7context8get_typeE13gcc_jit_types337696
Ref: 1f7337696
Ref: cp/topics/types _CPPv2N6gccjit7context8get_typeE13gcc_jit_types337696
Ref: 1f8337696
Ref: cp/topics/types gccjit context get_type__gcc_jit_types337696
Ref: 1f9337696
Ref: cp/topics/types _CPPv4N6gccjit7context12get_int_typeE6size_ti337948
Ref: 1fa337948
Ref: cp/topics/types _CPPv3N6gccjit7context12get_int_typeE6size_ti337948
Ref: 1fb337948
Ref: cp/topics/types _CPPv2N6gccjit7context12get_int_typeE6size_ti337948
Ref: 1fc337948
Ref: cp/topics/types gccjit context get_int_type__s i337948
Ref: 1fd337948
Ref: cp/topics/types _CPPv4IEN6gccjit7context12get_int_typeI1TEEN6gccjit4typeEv338126
Ref: 1fe338126
Ref: cp/topics/types _CPPv3IEN6gccjit7context12get_int_typeI1TEEv338126
Ref: 1ff338126
Ref: cp/topics/types _CPPv2IEN6gccjit7context12get_int_typeI1TEEv338126
Ref: 200338126
Node: Pointers const and volatile<2>338424
Ref: cp/topics/types pointers-const-and-volatile338552
Ref: 201338552
Ref: cp/topics/types _CPPv4N6gccjit4type11get_pointerEv338637
Ref: 1f4338637
Ref: cp/topics/types _CPPv3N6gccjit4type11get_pointerEv338637
Ref: 202338637
Ref: cp/topics/types _CPPv2N6gccjit4type11get_pointerEv338637
Ref: 203338637
Ref: cp/topics/types gccjit type get_pointer338637
Ref: 204338637
Ref: cp/topics/types _CPPv4N6gccjit4type9get_constEv338776
Ref: 1f5338776
Ref: cp/topics/types _CPPv3N6gccjit4type9get_constEv338776
Ref: 205338776
Ref: cp/topics/types _CPPv2N6gccjit4type9get_constEv338776
Ref: 206338776
Ref: cp/topics/types gccjit type get_const338776
Ref: 207338776
Ref: cp/topics/types _CPPv4N6gccjit4type12get_volatileEv338918
Ref: 208338918
Ref: cp/topics/types _CPPv3N6gccjit4type12get_volatileEv338918
Ref: 209338918
Ref: cp/topics/types _CPPv2N6gccjit4type12get_volatileEv338918
Ref: 20a338918
Ref: cp/topics/types gccjit type get_volatile338918
Ref: 20b338918
Ref: cp/topics/types _CPPv4N6gccjit4type11get_alignedE6size_t339066
Ref: 20c339066
Ref: cp/topics/types _CPPv3N6gccjit4type11get_alignedE6size_t339066
Ref: 20d339066
Ref: cp/topics/types _CPPv2N6gccjit4type11get_alignedE6size_t339066
Ref: 20e339066
Ref: cp/topics/types gccjit type get_aligned__s339066
Ref: 20f339066
Ref: cp/topics/types _CPPv4N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE339324
Ref: 210339324
Ref: cp/topics/types _CPPv3N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE339324
Ref: 211339324
Ref: cp/topics/types _CPPv2N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE339324
Ref: 212339324
Ref: cp/topics/types gccjit context new_array_type__gccjit type i gccjit location339324
Ref: 213339324
Node: Vector types<2>339600
Ref: cp/topics/types vector-types339735
Ref: 214339735
Ref: cp/topics/types _CPPv4N6gccjit4type10get_vectorE6size_t339778
Ref: 215339778
Ref: cp/topics/types _CPPv3N6gccjit4type10get_vectorE6size_t339778
Ref: 216339778
Ref: cp/topics/types _CPPv2N6gccjit4type10get_vectorE6size_t339778
Ref: 217339778
Ref: cp/topics/types gccjit type get_vector__s339778
Ref: 218339778
Node: Structures and unions<2>340072
Ref: cp/topics/types structures-and-unions340168
Ref: 219340168
Ref: cp/topics/types _CPPv4N6gccjit7struct_E340229
Ref: 21a340229
Ref: cp/topics/types _CPPv3N6gccjit7struct_E340229
Ref: 21b340229
Ref: cp/topics/types _CPPv2N6gccjit7struct_E340229
Ref: 21c340229
Ref: cp/topics/types gccjit struct_340229
Ref: 21d340229
Ref: cp/topics/types _CPPv4N6gccjit5fieldE340426
Ref: 21e340426
Ref: cp/topics/types _CPPv3N6gccjit5fieldE340426
Ref: 21f340426
Ref: cp/topics/types _CPPv2N6gccjit5fieldE340426
Ref: 220340426
Ref: cp/topics/types gccjit field340426
Ref: 221340426
Ref: cp/topics/types _CPPv4N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE341784
Ref: 222341784
Ref: cp/topics/types _CPPv3N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE341784
Ref: 223341784
Ref: cp/topics/types _CPPv2N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE341784
Ref: 224341784
Ref: cp/topics/types gccjit context new_field__gccjit type cCP gccjit location341784
Ref: 225341784
Ref: cp/topics/types _CPPv4N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE342006
Ref: 226342006
Ref: cp/topics/types _CPPv3N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE342006
Ref: 227342006
Ref: cp/topics/types _CPPv2N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE342006
Ref: 228342006
Ref: cp/topics/types gccjit context new_struct_type__ssCR std vector field R gccjit location342006
Ref: 229342006
Ref: cp/topics/types _CPPv4N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE342265
Ref: 22a342265
Ref: cp/topics/types _CPPv3N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE342265
Ref: 22b342265
Ref: cp/topics/types _CPPv2N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE342265
Ref: 22c342265
Ref: cp/topics/types gccjit context new_opaque_struct__ssCR gccjit location342265
Ref: 22d342265
Node: Expressions<2>342677
Ref: cp/topics/expressions doc342806
Ref: 22e342806
Ref: cp/topics/expressions expressions342806
Ref: 22f342806
Node: Rvalues<2>342989
Ref: cp/topics/expressions rvalues343072
Ref: 230343072
Ref: cp/topics/expressions _CPPv4N6gccjit6rvalueE343105
Ref: 17e343105
Ref: cp/topics/expressions _CPPv3N6gccjit6rvalueE343105
Ref: 231343105
Ref: cp/topics/expressions _CPPv2N6gccjit6rvalueE343105
Ref: 232343105
Ref: cp/topics/expressions gccjit rvalue343105
Ref: 233343105
Ref: cp/topics/expressions _CPPv4N6gccjit6rvalue8get_typeEv343858
Ref: 234343858
Ref: cp/topics/expressions _CPPv3N6gccjit6rvalue8get_typeEv343858
Ref: 235343858
Ref: cp/topics/expressions _CPPv2N6gccjit6rvalue8get_typeEv343858
Ref: 236343858
Ref: cp/topics/expressions gccjit rvalue get_type343858
Ref: 237343858
Node: Simple expressions<2>344316
Ref: cp/topics/expressions simple-expressions344417
Ref: 238344417
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEi344472
Ref: 192344472
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEi344472
Ref: 239344472
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEi344472
Ref: 23a344472
Ref: cp/topics/expressions gccjit context new_rvalue__gccjit type iC344472
Ref: 23b344472
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEl344725
Ref: 23c344725
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEl344725
Ref: 23d344725
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEl344725
Ref: 23e344725
Ref: cp/topics/expressions gccjit context new_rvalue__gccjit type lC344725
Ref: 23f344725
Ref: cp/topics/expressions _CPPv4NK6gccjit7context4zeroEN6gccjit4typeE344980
Ref: 18e344980
Ref: cp/topics/expressions _CPPv3NK6gccjit7context4zeroEN6gccjit4typeE344980
Ref: 240344980
Ref: cp/topics/expressions _CPPv2NK6gccjit7context4zeroEN6gccjit4typeE344980
Ref: 241344980
Ref: cp/topics/expressions gccjit context zero__gccjit typeC344980
Ref: 242344980
Ref: cp/topics/expressions _CPPv4NK6gccjit7context3oneEN6gccjit4typeE345275
Ref: 243345275
Ref: cp/topics/expressions _CPPv3NK6gccjit7context3oneEN6gccjit4typeE345275
Ref: 244345275
Ref: cp/topics/expressions _CPPv2NK6gccjit7context3oneEN6gccjit4typeE345275
Ref: 245345275
Ref: cp/topics/expressions gccjit context one__gccjit typeC345275
Ref: 246345275
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEd345568
Ref: 247345568
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEd345568
Ref: 248345568
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEd345568
Ref: 249345568
Ref: cp/topics/expressions gccjit context new_rvalue__gccjit type doubleC345568
Ref: 24a345568
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEPv345837
Ref: 24b345837
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEPv345837
Ref: 24c345837
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEPv345837
Ref: 24d345837
Ref: cp/topics/expressions gccjit context new_rvalue__gccjit type voidPC345837
Ref: 24e345837
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueERKNSt6stringE346056
Ref: 24f346056
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueERKNSt6stringE346056
Ref: 250346056
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueERKNSt6stringE346056
Ref: 251346056
Ref: cp/topics/expressions gccjit context new_rvalue__ssCRC346056
Ref: 252346056
Node: Vector expressions<2>346309
Ref: cp/topics/expressions vector-expressions346438
Ref: 253346438
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE346493
Ref: 254346493
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE346493
Ref: 255346493
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE346493
Ref: 256346493
Ref: cp/topics/expressions gccjit context new_rvalue__gccjit type std vector gccjit rvalue C346493
Ref: 257346493
Node: Unary Operations<2>346836
Ref: cp/topics/expressions unary-operations346964
Ref: 258346964
Ref: cp/topics/expressions _CPPv4N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE347015
Ref: 259347015
Ref: cp/topics/expressions _CPPv3N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE347015
Ref: 25a347015
Ref: cp/topics/expressions _CPPv2N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE347015
Ref: 25b347015
Ref: cp/topics/expressions gccjit context new_unary_op__gcc_jit_unary_op gccjit type gccjit rvalue gccjit location347015
Ref: 25c347015
Ref: cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE347545
Ref: 25d347545
Ref: cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE347545
Ref: 25e347545
Ref: cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE347545
Ref: 25f347545
Ref: cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit location347545
Ref: 260347545
Ref: cp/topics/expressions _CPPv418new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE347891
Ref: 261347891
Ref: cp/topics/expressions _CPPv318new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE347891
Ref: 262347891
Ref: cp/topics/expressions _CPPv218new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE347891
Ref: 263347891
Ref: cp/topics/expressions new_bitwise_negate__gccjit type gccjit rvalue gccjit location347891
Ref: 264347891
Ref: cp/topics/expressions _CPPv418new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE348256
Ref: 265348256
Ref: cp/topics/expressions _CPPv318new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE348256
Ref: 266348256
Ref: cp/topics/expressions _CPPv218new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE348256
Ref: 267348256
Ref: cp/topics/expressions new_logical_negate__gccjit type gccjit rvalue gccjit location348256
Ref: 268348256
Ref: cp/topics/expressions _CPPv4miN6gccjit6rvalueE348683
Ref: 269348683
Ref: cp/topics/expressions _CPPv3miN6gccjit6rvalueE348683
Ref: 26a348683
Ref: cp/topics/expressions _CPPv2miN6gccjit6rvalueE348683
Ref: 26b348683
Ref: cp/topics/expressions sub-operator__gccjit rvalue348683
Ref: 26c348683
Ref: cp/topics/expressions _CPPv4coN6gccjit6rvalueE348805
Ref: 26d348805
Ref: cp/topics/expressions _CPPv3coN6gccjit6rvalueE348805
Ref: 26e348805
Ref: cp/topics/expressions _CPPv2coN6gccjit6rvalueE348805
Ref: 26f348805
Ref: cp/topics/expressions inv-operator__gccjit rvalue348805
Ref: 270348805
Ref: cp/topics/expressions _CPPv4ntN6gccjit6rvalueE348925
Ref: 271348925
Ref: cp/topics/expressions _CPPv3ntN6gccjit6rvalueE348925
Ref: 272348925
Ref: cp/topics/expressions _CPPv2ntN6gccjit6rvalueE348925
Ref: 273348925
Ref: cp/topics/expressions not-operator__gccjit rvalue348925
Ref: 274348925
Node: Binary Operations<2>349049
Ref: cp/topics/expressions binary-operations349170
Ref: 275349170
Ref: cp/topics/expressions _CPPv4N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE349223
Ref: 17d349223
Ref: cp/topics/expressions _CPPv3N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE349223
Ref: 276349223
Ref: cp/topics/expressions _CPPv2N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE349223
Ref: 277349223
Ref: cp/topics/expressions gccjit context new_binary_op__gcc_jit_binary_op gccjit type gccjit rvalue gccjit rvalue gccjit location349223
Ref: 278349223
Ref: cp/topics/expressions _CPPv4N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE349790
Ref: 279349790
Ref: cp/topics/expressions _CPPv3N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE349790
Ref: 27a349790
Ref: cp/topics/expressions _CPPv2N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE349790
Ref: 27b349790
Ref: cp/topics/expressions gccjit context new_plus__gccjit type gccjit rvalue gccjit rvalue gccjit location349790
Ref: 27c349790
Ref: cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE349979
Ref: 27d349979
Ref: cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE349979
Ref: 27e349979
Ref: cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE349979
Ref: 27f349979
Ref: cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit rvalue gccjit location349979
Ref: 280349979
Ref: cp/topics/expressions _CPPv4N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350169
Ref: 281350169
Ref: cp/topics/expressions _CPPv3N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350169
Ref: 282350169
Ref: cp/topics/expressions _CPPv2N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350169
Ref: 283350169
Ref: cp/topics/expressions gccjit context new_mult__gccjit type gccjit rvalue gccjit rvalue gccjit location350169
Ref: 284350169
Ref: cp/topics/expressions _CPPv4N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350358
Ref: 285350358
Ref: cp/topics/expressions _CPPv3N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350358
Ref: 286350358
Ref: cp/topics/expressions _CPPv2N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350358
Ref: 287350358
Ref: cp/topics/expressions gccjit context new_divide__gccjit type gccjit rvalue gccjit rvalue gccjit location350358
Ref: 288350358
Ref: cp/topics/expressions _CPPv4N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350549
Ref: 289350549
Ref: cp/topics/expressions _CPPv3N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350549
Ref: 28a350549
Ref: cp/topics/expressions _CPPv2N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350549
Ref: 28b350549
Ref: cp/topics/expressions gccjit context new_modulo__gccjit type gccjit rvalue gccjit rvalue gccjit location350549
Ref: 28c350549
Ref: cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350740
Ref: 28d350740
Ref: cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350740
Ref: 28e350740
Ref: cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350740
Ref: 28f350740
Ref: cp/topics/expressions gccjit context new_bitwise_and__gccjit type gccjit rvalue gccjit rvalue gccjit location350740
Ref: 290350740
Ref: cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350936
Ref: 291350936
Ref: cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350936
Ref: 292350936
Ref: cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE350936
Ref: 293350936
Ref: cp/topics/expressions gccjit context new_bitwise_xor__gccjit type gccjit rvalue gccjit rvalue gccjit location350936
Ref: 294350936
Ref: cp/topics/expressions _CPPv4N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE351132
Ref: 295351132
Ref: cp/topics/expressions _CPPv3N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE351132
Ref: 296351132
Ref: cp/topics/expressions _CPPv2N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE351132
Ref: 297351132
Ref: cp/topics/expressions gccjit context new_bitwise_or__gccjit type gccjit rvalue gccjit rvalue gccjit location351132
Ref: 298351132
Ref: cp/topics/expressions _CPPv4N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE351327
Ref: 299351327
Ref: cp/topics/expressions _CPPv3N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE351327
Ref: 29a351327
Ref: cp/topics/expressions _CPPv2N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE351327
Ref: 29b351327
Ref: cp/topics/expressions gccjit context new_logical_and__gccjit type gccjit rvalue gccjit rvalue gccjit location351327
Ref: 29c351327
Ref: cp/topics/expressions _CPPv4N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE351523
Ref: 29d351523
Ref: cp/topics/expressions _CPPv3N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE351523
Ref: 29e351523
Ref: cp/topics/expressions _CPPv2N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE351523
Ref: 29f351523
Ref: cp/topics/expressions gccjit context new_logical_or__gccjit type gccjit rvalue gccjit rvalue gccjit location351523
Ref: 2a0351523
Ref: cp/topics/expressions _CPPv4plN6gccjit6rvalueEN6gccjit6rvalueE351784
Ref: 2a1351784
Ref: cp/topics/expressions _CPPv3plN6gccjit6rvalueEN6gccjit6rvalueE351784
Ref: 2a2351784
Ref: cp/topics/expressions _CPPv2plN6gccjit6rvalueEN6gccjit6rvalueE351784
Ref: 2a3351784
Ref: cp/topics/expressions add-operator__gccjit rvalue gccjit rvalue351784
Ref: 2a4351784
Ref: cp/topics/expressions _CPPv4miN6gccjit6rvalueEN6gccjit6rvalueE351924
Ref: 2a5351924
Ref: cp/topics/expressions _CPPv3miN6gccjit6rvalueEN6gccjit6rvalueE351924
Ref: 2a6351924
Ref: cp/topics/expressions _CPPv2miN6gccjit6rvalueEN6gccjit6rvalueE351924
Ref: 2a7351924
Ref: cp/topics/expressions sub-operator__gccjit rvalue gccjit rvalue351924
Ref: 2a8351924
Ref: cp/topics/expressions _CPPv4mlN6gccjit6rvalueEN6gccjit6rvalueE352065
Ref: 2a9352065
Ref: cp/topics/expressions _CPPv3mlN6gccjit6rvalueEN6gccjit6rvalueE352065
Ref: 2aa352065
Ref: cp/topics/expressions _CPPv2mlN6gccjit6rvalueEN6gccjit6rvalueE352065
Ref: 2ab352065
Ref: cp/topics/expressions mul-operator__gccjit rvalue gccjit rvalue352065
Ref: 2ac352065
Ref: cp/topics/expressions _CPPv4dvN6gccjit6rvalueEN6gccjit6rvalueE352206
Ref: 2ad352206
Ref: cp/topics/expressions _CPPv3dvN6gccjit6rvalueEN6gccjit6rvalueE352206
Ref: 2ae352206
Ref: cp/topics/expressions _CPPv2dvN6gccjit6rvalueEN6gccjit6rvalueE352206
Ref: 2af352206
Ref: cp/topics/expressions div-operator__gccjit rvalue gccjit rvalue352206
Ref: 2b0352206
Ref: cp/topics/expressions _CPPv4rmN6gccjit6rvalueEN6gccjit6rvalueE352349
Ref: 2b1352349
Ref: cp/topics/expressions _CPPv3rmN6gccjit6rvalueEN6gccjit6rvalueE352349
Ref: 2b2352349
Ref: cp/topics/expressions _CPPv2rmN6gccjit6rvalueEN6gccjit6rvalueE352349
Ref: 2b3352349
Ref: cp/topics/expressions mod-operator__gccjit rvalue gccjit rvalue352349
Ref: 2b4352349
Ref: cp/topics/expressions _CPPv4anN6gccjit6rvalueEN6gccjit6rvalueE352489
Ref: 2b5352489
Ref: cp/topics/expressions _CPPv3anN6gccjit6rvalueEN6gccjit6rvalueE352489
Ref: 2b6352489
Ref: cp/topics/expressions _CPPv2anN6gccjit6rvalueEN6gccjit6rvalueE352489
Ref: 2b7352489
Ref: cp/topics/expressions and-operator__gccjit rvalue gccjit rvalue352489
Ref: 2b8352489
Ref: cp/topics/expressions _CPPv4eoN6gccjit6rvalueEN6gccjit6rvalueE352627
Ref: 2b9352627
Ref: cp/topics/expressions _CPPv3eoN6gccjit6rvalueEN6gccjit6rvalueE352627
Ref: 2ba352627
Ref: cp/topics/expressions _CPPv2eoN6gccjit6rvalueEN6gccjit6rvalueE352627
Ref: 2bb352627
Ref: cp/topics/expressions xor-operator__gccjit rvalue gccjit rvalue352627
Ref: 2bc352627
Ref: cp/topics/expressions _CPPv4orN6gccjit6rvalueEN6gccjit6rvalueE352765
Ref: 2bd352765
Ref: cp/topics/expressions _CPPv3orN6gccjit6rvalueEN6gccjit6rvalueE352765
Ref: 2be352765
Ref: cp/topics/expressions _CPPv2orN6gccjit6rvalueEN6gccjit6rvalueE352765
Ref: 2bf352765
Ref: cp/topics/expressions or-operator__gccjit rvalue gccjit rvalue352765
Ref: 2c0352765
Ref: cp/topics/expressions _CPPv4aaN6gccjit6rvalueEN6gccjit6rvalueE352903
Ref: 2c1352903
Ref: cp/topics/expressions _CPPv3aaN6gccjit6rvalueEN6gccjit6rvalueE352903
Ref: 2c2352903
Ref: cp/topics/expressions _CPPv2aaN6gccjit6rvalueEN6gccjit6rvalueE352903
Ref: 2c3352903
Ref: cp/topics/expressions sand-operator__gccjit rvalue gccjit rvalue352903
Ref: 2c4352903
Ref: cp/topics/expressions _CPPv4ooN6gccjit6rvalueEN6gccjit6rvalueE353046
Ref: 2c5353046
Ref: cp/topics/expressions _CPPv3ooN6gccjit6rvalueEN6gccjit6rvalueE353046
Ref: 2c6353046
Ref: cp/topics/expressions _CPPv2ooN6gccjit6rvalueEN6gccjit6rvalueE353046
Ref: 2c7353046
Ref: cp/topics/expressions sor-operator__gccjit rvalue gccjit rvalue353046
Ref: 2c8353046
Node: Comparisons<2>353339
Ref: cp/topics/expressions comparisons353458
Ref: 2c9353458
Ref: cp/topics/expressions _CPPv4N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE353499
Ref: 18f353499
Ref: cp/topics/expressions _CPPv3N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE353499
Ref: 2ca353499
Ref: cp/topics/expressions _CPPv2N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE353499
Ref: 2cb353499
Ref: cp/topics/expressions gccjit context new_comparison__gcc_jit_comparison gccjit rvalue gccjit rvalue gccjit location353499
Ref: 2cc353499
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354045
Ref: 2cd354045
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354045
Ref: 2ce354045
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354045
Ref: 2cf354045
Ref: cp/topics/expressions gccjit context new_eq__gccjit rvalue gccjit rvalue gccjit location354045
Ref: 2d0354045
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354206
Ref: 2d1354206
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354206
Ref: 2d2354206
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354206
Ref: 2d3354206
Ref: cp/topics/expressions gccjit context new_ne__gccjit rvalue gccjit rvalue gccjit location354206
Ref: 2d4354206
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354367
Ref: 2d5354367
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354367
Ref: 2d6354367
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354367
Ref: 2d7354367
Ref: cp/topics/expressions gccjit context new_lt__gccjit rvalue gccjit rvalue gccjit location354367
Ref: 2d8354367
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354528
Ref: 2d9354528
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354528
Ref: 2da354528
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354528
Ref: 2db354528
Ref: cp/topics/expressions gccjit context new_le__gccjit rvalue gccjit rvalue gccjit location354528
Ref: 2dc354528
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354689
Ref: 2dd354689
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354689
Ref: 2de354689
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354689
Ref: 2df354689
Ref: cp/topics/expressions gccjit context new_gt__gccjit rvalue gccjit rvalue gccjit location354689
Ref: 2e0354689
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354850
Ref: 2e1354850
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354850
Ref: 2e2354850
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354850
Ref: 2e3354850
Ref: cp/topics/expressions gccjit context new_ge__gccjit rvalue gccjit rvalue gccjit location354850
Ref: 2e4354850
Ref: cp/topics/expressions _CPPv4eqN6gccjit6rvalueEN6gccjit6rvalueE355077
Ref: 2e5355077
Ref: cp/topics/expressions _CPPv3eqN6gccjit6rvalueEN6gccjit6rvalueE355077
Ref: 2e6355077
Ref: cp/topics/expressions _CPPv2eqN6gccjit6rvalueEN6gccjit6rvalueE355077
Ref: 2e7355077
Ref: cp/topics/expressions eq-operator__gccjit rvalue gccjit rvalue355077
Ref: 2e8355077
Ref: cp/topics/expressions _CPPv4neN6gccjit6rvalueEN6gccjit6rvalueE355238
Ref: 2e9355238
Ref: cp/topics/expressions _CPPv3neN6gccjit6rvalueEN6gccjit6rvalueE355238
Ref: 2ea355238
Ref: cp/topics/expressions _CPPv2neN6gccjit6rvalueEN6gccjit6rvalueE355238
Ref: 2eb355238
Ref: cp/topics/expressions neq-operator__gccjit rvalue gccjit rvalue355238
Ref: 2ec355238
Ref: cp/topics/expressions _CPPv4ltN6gccjit6rvalueEN6gccjit6rvalueE355383
Ref: 2ed355383
Ref: cp/topics/expressions _CPPv3ltN6gccjit6rvalueEN6gccjit6rvalueE355383
Ref: 2ee355383
Ref: cp/topics/expressions _CPPv2ltN6gccjit6rvalueEN6gccjit6rvalueE355383
Ref: 2ef355383
Ref: cp/topics/expressions lt-operator__gccjit rvalue gccjit rvalue355383
Ref: 2f0355383
Ref: cp/topics/expressions _CPPv4leN6gccjit6rvalueEN6gccjit6rvalueE355524
Ref: 2f1355524
Ref: cp/topics/expressions _CPPv3leN6gccjit6rvalueEN6gccjit6rvalueE355524
Ref: 2f2355524
Ref: cp/topics/expressions _CPPv2leN6gccjit6rvalueEN6gccjit6rvalueE355524
Ref: 2f3355524
Ref: cp/topics/expressions lte-operator__gccjit rvalue gccjit rvalue355524
Ref: 2f4355524
Ref: cp/topics/expressions _CPPv4gtN6gccjit6rvalueEN6gccjit6rvalueE355667
Ref: 2f5355667
Ref: cp/topics/expressions _CPPv3gtN6gccjit6rvalueEN6gccjit6rvalueE355667
Ref: 2f6355667
Ref: cp/topics/expressions _CPPv2gtN6gccjit6rvalueEN6gccjit6rvalueE355667
Ref: 2f7355667
Ref: cp/topics/expressions gt-operator__gccjit rvalue gccjit rvalue355667
Ref: 2f8355667
Ref: cp/topics/expressions _CPPv4geN6gccjit6rvalueEN6gccjit6rvalueE355815
Ref: 2f9355815
Ref: cp/topics/expressions _CPPv3geN6gccjit6rvalueEN6gccjit6rvalueE355815
Ref: 2fa355815
Ref: cp/topics/expressions _CPPv2geN6gccjit6rvalueEN6gccjit6rvalueE355815
Ref: 2fb355815
Ref: cp/topics/expressions gte-operator__gccjit rvalue gccjit rvalue355815
Ref: 2fc355815
Node: Function calls<2>355991
Ref: cp/topics/expressions function-calls356110
Ref: 2fd356110
Ref: cp/topics/expressions _CPPv424gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue356157
Ref: 2fe356157
Ref: cp/topics/expressions _CPPv324gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue356157
Ref: 2ff356157
Ref: cp/topics/expressions _CPPv224gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue356157
Ref: 300356157
Ref: cp/topics/expressions gcc_jit_context_new_call__gcc_jit_contextP gcc_jit_locationP gcc_jit_functionP i gcc_jit_rvaluePP356157
Ref: 301356157
Node: Function pointers<3>357115
Ref: cp/topics/expressions function-pointers357236
Ref: 303357236
Ref: cp/topics/expressions _CPPv4N6gccjit8function11get_addressEN6gccjit8locationE357289
Ref: 304357289
Ref: cp/topics/expressions _CPPv3N6gccjit8function11get_addressEN6gccjit8locationE357289
Ref: 305357289
Ref: cp/topics/expressions _CPPv2N6gccjit8function11get_addressEN6gccjit8locationE357289
Ref: 306357289
Ref: cp/topics/expressions gccjit function get_address__gccjit location357289
Ref: 307357289
Node: Type-coercion<2>357490
Ref: cp/topics/expressions type-coercion357585
Ref: 308357585
Ref: cp/topics/expressions _CPPv4N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE357630
Ref: 309357630
Ref: cp/topics/expressions _CPPv3N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE357630
Ref: 30a357630
Ref: cp/topics/expressions _CPPv2N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE357630
Ref: 30b357630
Ref: cp/topics/expressions gccjit context new_cast__gccjit rvalue gccjit type gccjit location357630
Ref: 30c357630
Node: Lvalues<2>358045
Ref: cp/topics/expressions lvalues358180
Ref: 30d358180
Ref: cp/topics/expressions _CPPv4N6gccjit6lvalueE358215
Ref: 187358215
Ref: cp/topics/expressions _CPPv3N6gccjit6lvalueE358215
Ref: 30e358215
Ref: cp/topics/expressions _CPPv2N6gccjit6lvalueE358215
Ref: 30f358215
Ref: cp/topics/expressions gccjit lvalue358215
Ref: 310358215
Ref: cp/topics/expressions _CPPv4N6gccjit6lvalue11get_addressEN6gccjit8locationE358543
Ref: 311358543
Ref: cp/topics/expressions _CPPv3N6gccjit6lvalue11get_addressEN6gccjit8locationE358543
Ref: 312358543
Ref: cp/topics/expressions _CPPv2N6gccjit6lvalue11get_addressEN6gccjit8locationE358543
Ref: 313358543
Ref: cp/topics/expressions gccjit lvalue get_address__gccjit location358543
Ref: 314358543
Node: Global variables<2>358832
Ref: cp/topics/expressions global-variables358901
Ref: 315358901
Ref: cp/topics/expressions _CPPv4N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE358954
Ref: 316358954
Ref: cp/topics/expressions _CPPv3N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE358954
Ref: 317358954
Ref: cp/topics/expressions _CPPv2N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE358954
Ref: 318358954
Ref: cp/topics/expressions gccjit context new_global__gcc_jit_global_kind gccjit type cCP gccjit location358954
Ref: 319358954
Node: Working with pointers structs and unions<2>359383
Ref: cp/topics/expressions working-with-pointers-structs-and-unions359499
Ref: 31a359499
Ref: cp/topics/expressions _CPPv4N6gccjit6rvalue11dereferenceEN6gccjit8locationE359602
Ref: 31b359602
Ref: cp/topics/expressions _CPPv3N6gccjit6rvalue11dereferenceEN6gccjit8locationE359602
Ref: 31c359602
Ref: cp/topics/expressions _CPPv2N6gccjit6rvalue11dereferenceEN6gccjit8locationE359602
Ref: 31d359602
Ref: cp/topics/expressions gccjit rvalue dereference__gccjit location359602
Ref: 31e359602
Ref: cp/topics/expressions _CPPv4N6gccjit6rvaluemlEv360015
Ref: 31f360015
Ref: cp/topics/expressions _CPPv3N6gccjit6rvaluemlEv360015
Ref: 320360015
Ref: cp/topics/expressions _CPPv2N6gccjit6rvaluemlEv360015
Ref: 321360015
Ref: cp/topics/expressions gccjit rvalue mul-operator360015
Ref: 322360015
Ref: cp/topics/expressions _CPPv4N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE360219
Ref: 323360219
Ref: cp/topics/expressions _CPPv3N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE360219
Ref: 324360219
Ref: cp/topics/expressions _CPPv2N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE360219
Ref: 325360219
Ref: cp/topics/expressions gccjit lvalue access_field__gccjit field gccjit location360219
Ref: 326360219
Ref: cp/topics/expressions _CPPv4N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE360533
Ref: 327360533
Ref: cp/topics/expressions _CPPv3N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE360533
Ref: 328360533
Ref: cp/topics/expressions _CPPv2N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE360533
Ref: 329360533
Ref: cp/topics/expressions gccjit rvalue access_field__gccjit field gccjit location360533
Ref: 32a360533
Ref: cp/topics/expressions _CPPv4N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE360812
Ref: 32b360812
Ref: cp/topics/expressions _CPPv3N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE360812
Ref: 32c360812
Ref: cp/topics/expressions _CPPv2N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE360812
Ref: 32d360812
Ref: cp/topics/expressions gccjit rvalue dereference_field__gccjit field gccjit location360812
Ref: 32e360812
Ref: cp/topics/expressions _CPPv4N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE361178
Ref: 32f361178
Ref: cp/topics/expressions _CPPv3N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE361178
Ref: 330361178
Ref: cp/topics/expressions _CPPv2N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE361178
Ref: 331361178
Ref: cp/topics/expressions gccjit context new_array_access__gccjit rvalue gccjit rvalue gccjit location361178
Ref: 332361178
Node: Creating and using functions<2>362026
Ref: cp/topics/functions doc362166
Ref: 333362166
Ref: cp/topics/functions creating-and-using-functions362166
Ref: 334362166
Node: Params<2>362345
Ref: cp/topics/functions params362446
Ref: 335362446
Ref: cp/topics/functions _CPPv4N6gccjit5paramE362477
Ref: 188362477
Ref: cp/topics/functions _CPPv3N6gccjit5paramE362477
Ref: 336362477
Ref: cp/topics/functions _CPPv2N6gccjit5paramE362477
Ref: 337362477
Ref: cp/topics/functions gccjit param362477
Ref: 338362477
Ref: cp/topics/functions _CPPv4N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE362568
Ref: 17c362568
Ref: cp/topics/functions _CPPv3N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE362568
Ref: 339362568
Ref: cp/topics/functions _CPPv2N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE362568
Ref: 33a362568
Ref: cp/topics/functions gccjit context new_param__gccjit type cCP gccjit location362568
Ref: 33b362568
Node: Functions<2>363047
Ref: cp/topics/functions functions363166
Ref: 33c363166
Ref: cp/topics/functions _CPPv4N6gccjit8functionE363203
Ref: 18c363203
Ref: cp/topics/functions _CPPv3N6gccjit8functionE363203
Ref: 33d363203
Ref: cp/topics/functions _CPPv2N6gccjit8functionE363203
Ref: 33e363203
Ref: cp/topics/functions gccjit function363203
Ref: 33f363203
Ref: cp/topics/functions _CPPv4N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE363368
Ref: 340363368
Ref: cp/topics/functions _CPPv3N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE363368
Ref: 341363368
Ref: cp/topics/functions _CPPv2N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE363368
Ref: 342363368
Ref: cp/topics/functions gccjit context new_function__gcc_jit_function_kind gccjit type cCP std vector param R i gccjit location363368
Ref: 343363368
Ref: cp/topics/functions _CPPv4N6gccjit7context20get_builtin_functionEPKc363850
Ref: 344363850
Ref: cp/topics/functions _CPPv3N6gccjit7context20get_builtin_functionEPKc363850
Ref: 345363850
Ref: cp/topics/functions _CPPv2N6gccjit7context20get_builtin_functionEPKc363850
Ref: 346363850
Ref: cp/topics/functions gccjit context get_builtin_function__cCP363850
Ref: 347363850
Ref: cp/topics/functions _CPPv4NK6gccjit8function9get_paramEi364077
Ref: 348364077
Ref: cp/topics/functions _CPPv3NK6gccjit8function9get_paramEi364077
Ref: 349364077
Ref: cp/topics/functions _CPPv2NK6gccjit8function9get_paramEi364077
Ref: 34a364077
Ref: cp/topics/functions gccjit function get_param__iC364077
Ref: 34b364077
Ref: cp/topics/functions _CPPv4N6gccjit8function11dump_to_dotEPKc364239
Ref: 194364239
Ref: cp/topics/functions _CPPv3N6gccjit8function11dump_to_dotEPKc364239
Ref: 34c364239
Ref: cp/topics/functions _CPPv2N6gccjit8function11dump_to_dotEPKc364239
Ref: 34d364239
Ref: cp/topics/functions gccjit function dump_to_dot__cCP364239
Ref: 34e364239
Ref: cp/topics/functions _CPPv4N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE364395
Ref: 189364395
Ref: cp/topics/functions _CPPv3N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE364395
Ref: 34f364395
Ref: cp/topics/functions _CPPv2N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE364395
Ref: 350364395
Ref: cp/topics/functions gccjit function new_local__gccjit type cCP gccjit location364395
Ref: 351364395
Node: Blocks<2>364648
Ref: cp/topics/functions blocks364771
Ref: 352364771
Ref: cp/topics/functions _CPPv4N6gccjit5blockE364802
Ref: 18b364802
Ref: cp/topics/functions _CPPv3N6gccjit5blockE364802
Ref: 353364802
Ref: cp/topics/functions _CPPv2N6gccjit5blockE364802
Ref: 354364802
Ref: cp/topics/functions gccjit block364802
Ref: 355364802
Ref: cp/topics/functions _CPPv4N6gccjit8function9new_blockEPKc365394
Ref: 356365394
Ref: cp/topics/functions _CPPv3N6gccjit8function9new_blockEPKc365394
Ref: 357365394
Ref: cp/topics/functions _CPPv2N6gccjit8function9new_blockEPKc365394
Ref: 358365394
Ref: cp/topics/functions gccjit function new_block__cCP365394
Ref: 359365394
Node: Statements<2>365734
Ref: cp/topics/functions statements365836
Ref: 35a365836
Ref: cp/topics/functions _CPPv4N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE365875
Ref: 302365875
Ref: cp/topics/functions _CPPv3N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE365875
Ref: 35b365875
Ref: cp/topics/functions _CPPv2N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE365875
Ref: 35c365875
Ref: cp/topics/functions gccjit block add_eval__gccjit rvalue gccjit location365875
Ref: 35d365875
Ref: cp/topics/functions _CPPv4N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE366169
Ref: 18d366169
Ref: cp/topics/functions _CPPv3N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE366169
Ref: 35e366169
Ref: cp/topics/functions _CPPv2N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE366169
Ref: 35f366169
Ref: cp/topics/functions gccjit block add_assignment__gccjit lvalue gccjit rvalue gccjit location366169
Ref: 360366169
Ref: cp/topics/functions _CPPv4N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE366481
Ref: 191366481
Ref: cp/topics/functions _CPPv3N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE366481
Ref: 361366481
Ref: cp/topics/functions _CPPv2N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE366481
Ref: 362366481
Ref: cp/topics/functions gccjit block add_assignment_op__gccjit lvalue gcc_jit_binary_op gccjit rvalue gccjit location366481
Ref: 363366481
Ref: cp/topics/functions _CPPv4N6gccjit5block11add_commentEPKcN6gccjit8locationE367034
Ref: 19d367034
Ref: cp/topics/functions _CPPv3N6gccjit5block11add_commentEPKcN6gccjit8locationE367034
Ref: 364367034
Ref: cp/topics/functions _CPPv2N6gccjit5block11add_commentEPKcN6gccjit8locationE367034
Ref: 365367034
Ref: cp/topics/functions gccjit block add_comment__cCP gccjit location367034
Ref: 366367034
Ref: cp/topics/functions _CPPv4N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE367583
Ref: 190367583
Ref: cp/topics/functions _CPPv3N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE367583
Ref: 367367583
Ref: cp/topics/functions _CPPv2N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE367583
Ref: 368367583
Ref: cp/topics/functions gccjit block end_with_conditional__gccjit rvalue gccjit block gccjit block gccjit location367583
Ref: 369367583
Ref: cp/topics/functions _CPPv4N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE368091
Ref: 36a368091
Ref: cp/topics/functions _CPPv3N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE368091
Ref: 36b368091
Ref: cp/topics/functions _CPPv2N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE368091
Ref: 36c368091
Ref: cp/topics/functions gccjit block end_with_jump__gccjit block gccjit location368091
Ref: 36d368091
Ref: cp/topics/functions _CPPv4N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE368350
Ref: 36e368350
Ref: cp/topics/functions _CPPv3N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE368350
Ref: 36f368350
Ref: cp/topics/functions _CPPv2N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE368350
Ref: 370368350
Ref: cp/topics/functions gccjit block end_with_return__gccjit rvalue gccjit location368350
Ref: 371368350
Ref: cp/topics/functions _CPPv4N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE369068
Ref: 372369068
Ref: cp/topics/functions _CPPv3N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE369068
Ref: 373369068
Ref: cp/topics/functions _CPPv2N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE369068
Ref: 374369068
Ref: cp/topics/functions gccjit block end_with_switch__gccjit rvalue gccjit block std vector gccjit case_ gccjit location369068
Ref: 375369068
Node: Source Locations<2>373955
Ref: cp/topics/locations doc374103
Ref: 376374103
Ref: cp/topics/locations source-locations374103
Ref: 377374103
Ref: cp/topics/locations _CPPv4N6gccjit8locationE374150
Ref: 19b374150
Ref: cp/topics/locations _CPPv3N6gccjit8locationE374150
Ref: 378374150
Ref: cp/topics/locations _CPPv2N6gccjit8locationE374150
Ref: 379374150
Ref: cp/topics/locations gccjit location374150
Ref: 37a374150
Ref: cp/topics/locations _CPPv4N6gccjit7context12new_locationEPKcii374872
Ref: 1a1374872
Ref: cp/topics/locations _CPPv3N6gccjit7context12new_locationEPKcii374872
Ref: 37b374872
Ref: cp/topics/locations _CPPv2N6gccjit7context12new_locationEPKcii374872
Ref: 37c374872
Ref: cp/topics/locations gccjit context new_location__cCP i i374872
Ref: 37d374872
Node: Faking it<2>375151
Ref: cp/topics/locations faking-it375222
Ref: 37e375222
Node: Compiling a context<2>375849
Ref: cp/topics/compilation doc376006
Ref: 37f376006
Ref: cp/topics/compilation compiling-a-context376006
Ref: 380376006
Node: In-memory compilation<2>376558
Ref: cp/topics/compilation in-memory-compilation376681
Ref: 382376681
Ref: cp/topics/compilation _CPPv4N6gccjit7context7compileEv376742
Ref: 17f376742
Ref: cp/topics/compilation _CPPv3N6gccjit7context7compileEv376742
Ref: 383376742
Ref: cp/topics/compilation _CPPv2N6gccjit7context7compileEv376742
Ref: 384376742
Ref: cp/topics/compilation gccjit context compile376742
Ref: 385376742
Node: Ahead-of-time compilation<2>377008
Ref: cp/topics/compilation ahead-of-time-compilation377131
Ref: 386377131
Ref: cp/topics/compilation _CPPv4N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc377410
Ref: 381377410
Ref: cp/topics/compilation _CPPv3N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc377410
Ref: 387377410
Ref: cp/topics/compilation _CPPv2N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc377410
Ref: 388377410
Ref: cp/topics/compilation gccjit context compile_to_file__gcc_jit_output_kind cCP377410
Ref: 389377410
Node: Using Assembly Language with libgccjit++377726
Ref: cp/topics/asm doc377855
Ref: 38a377855
Ref: cp/topics/asm using-assembly-language-with-libgccjit377855
Ref: 38b377855
Ref: Using Assembly Language with libgccjit++-Footnote-1378654
Node: Adding assembler instructions within a function<2>378730
Ref: cp/topics/asm adding-assembler-instructions-within-a-function378909
Ref: 38c378909
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asmE379022
Ref: 38d379022
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asmE379022
Ref: 38e379022
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asmE379022
Ref: 38f379022
Ref: cp/topics/asm gccjit extended_asm379022
Ref: 390379022
Ref: cp/topics/asm _CPPv4N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE381427
Ref: 391381427
Ref: cp/topics/asm _CPPv3N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE381427
Ref: 395381427
Ref: cp/topics/asm _CPPv2N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE381427
Ref: 396381427
Ref: cp/topics/asm gccjit block add_extended_asm__ssCR gccjit location381427
Ref: 397381427
Ref: cp/topics/asm _CPPv4N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location382001
Ref: 392382001
Ref: cp/topics/asm _CPPv3N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location382001
Ref: 398382001
Ref: cp/topics/asm _CPPv2N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location382001
Ref: 399382001
Ref: cp/topics/asm gccjit block end_with_extended_asm_goto__ssCR std vector block blockP location382001
Ref: 39a382001
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm17set_volatile_flagEb384196
Ref: 39b384196
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm17set_volatile_flagEb384196
Ref: 39c384196
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm17set_volatile_flagEb384196
Ref: 39d384196
Ref: cp/topics/asm gccjit extended_asm set_volatile_flag__b384196
Ref: 39e384196
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm15set_inline_flagEb385342
Ref: 39f385342
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm15set_inline_flagEb385342
Ref: 3a0385342
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm15set_inline_flagEb385342
Ref: 3a1385342
Ref: cp/topics/asm gccjit extended_asm set_inline_flag__b385342
Ref: 3a2385342
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE385555
Ref: 393385555
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE385555
Ref: 3a3385555
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE385555
Ref: 3a4385555
Ref: cp/topics/asm gccjit extended_asm add_output_operand__ssCR ssCR gccjit lvalue385555
Ref: 3a5385555
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE386720
Ref: 3a6386720
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE386720
Ref: 3a7386720
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE386720
Ref: 3a8386720
Ref: cp/topics/asm gccjit extended_asm add_output_operand__ssCR gccjit lvalue386720
Ref: 3a9386720
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE387107
Ref: 394387107
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE387107
Ref: 3aa387107
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE387107
Ref: 3ab387107
Ref: cp/topics/asm gccjit extended_asm add_input_operand__ssCR ssCR gccjit rvalue387107
Ref: 3ac387107
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE388019
Ref: 3ad388019
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE388019
Ref: 3ae388019
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE388019
Ref: 3af388019
Ref: cp/topics/asm gccjit extended_asm add_input_operand__ssCR gccjit rvalue388019
Ref: 3b0388019
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm11add_clobberERKNSt6stringE388401
Ref: 3b1388401
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm11add_clobberERKNSt6stringE388401
Ref: 3b2388401
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm11add_clobberERKNSt6stringE388401
Ref: 3b3388401
Ref: cp/topics/asm gccjit extended_asm add_clobber__ssCR388401
Ref: 3b4388401
Ref: Adding assembler instructions within a function<2>-Footnote-1388946
Ref: Adding assembler instructions within a function<2>-Footnote-2389013
Ref: Adding assembler instructions within a function<2>-Footnote-3389088
Ref: Adding assembler instructions within a function<2>-Footnote-4389161
Ref: Adding assembler instructions within a function<2>-Footnote-5389230
Ref: Adding assembler instructions within a function<2>-Footnote-6389302
Node: Adding top-level assembler statements<2>389392
Ref: cp/topics/asm adding-top-level-assembler-statements389571
Ref: 3b5389571
Ref: cp/topics/asm _CPPv4N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE389829
Ref: 3b6389829
Ref: cp/topics/asm _CPPv3N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE389829
Ref: 3b7389829
Ref: cp/topics/asm _CPPv2N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE389829
Ref: 3b8389829
Ref: cp/topics/asm gccjit context add_top_level_asm__cCP gccjit location389829
Ref: 3b9389829
Node: Internals391014
Ref: internals/index doc391128
Ref: 3ba391128
Ref: internals/index internals391128
Ref: 3bb391128
Node: Working on the JIT library391338
Ref: internals/index working-on-the-jit-library391444
Ref: 3bc391444
Ref: internals/index cmdoption-enable-host-shared392321
Ref: 3bd392321
Ref: internals/index cmdoption-enable-languages392540
Ref: 3be392540
Ref: internals/index cmdoption-disable-bootstrap393074
Ref: 3bf393074
Ref: internals/index cmdoption-enable-checking393372
Ref: 3c0393372
Node: Running the test suite393633
Ref: internals/index running-the-test-suite393769
Ref: 3c1393769
Node: Running under valgrind394810
Ref: internals/index running-under-valgrind394894
Ref: 3c2394894
Ref: Running under valgrind-Footnote-1396438
Ref: Running under valgrind-Footnote-2396464
Ref: Running under valgrind-Footnote-3396517
Node: Environment variables396585
Ref: internals/index environment-variables396710
Ref: 3c3396710
Ref: internals/index envvar-LD_LIBRARY_PATH396871
Ref: 3c4396871
Ref: internals/index envvar-PATH397471
Ref: 3c5397471
Ref: internals/index envvar-LIBRARY_PATH398113
Ref: 3c6398113
Node: Packaging notes399059
Ref: internals/index packaging-notes399188
Ref: 3c7399188
Node: Overview of code structure400536
Ref: internals/index overview-of-code-structure400656
Ref: 3c8400656
Ref: internals/index example-of-log-file417036
Ref: 5c417036
Node: Design notes427952
Ref: internals/index design-notes428075
Ref: 3c9428075
Node: Submitting patches428602
Ref: internals/index submitting-patches428690
Ref: 3ca428690
Ref: Submitting patches-Footnote-1433175
Node: Indices and tables433204
Ref: index indices-and-tables433297
Ref: 3cb433297
Node: Index433379

End Tag Table
