This is libgccjit.info, produced by makeinfo version 6.8 from
libgccjit.texi.

     libgccjit 11.0.0 (experimental 20210114), Jan 14, 2021

     David Malcolm

     Copyright © 2014-2021 Free Software Foundation, Inc.

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


   Generated by Sphinx 2.2.2.


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

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

     libgccjit 11.0.0 (experimental 20210114), Jan 14, 2021

     David Malcolm

     Copyright © 2014-2021 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::

Expressions

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

Rvalues

* Simple 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::

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) http://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-2021 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-2021 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:

[image of a control flow graph]

     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’):

[image of a control flow graph]

     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-2021 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     ‘[..., x, y]’       ‘[..., (x+y)]’
                           on 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     ‘[..., x]’          ‘[..., fn(x)]’
                           of the stack, and popping                        
                           the result.
                           
                                                                            
RETURN                     Return the top of the        ‘[x]’               ‘[]’
                           stack.                                           
                           
                                                                            
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[16];
                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.

[image of a control flow graph]

     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


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: 73.; 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");

     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: 75.; 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(): 7b. and *note gcc_jit_type_get_const():
     7c.:

          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::


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_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: 83.; 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: 86.; 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(): 87.


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: 89.

You can model C ‘struct’ types by creating *note gcc_jit_struct *: 89.
and *note gcc_jit_field: 8a. 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: 8d.; 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(): 91.

     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,  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(): 95.


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::
* Vector expressions::
* Unary Operations::
* Binary Operations::
* Comparisons::
* Function calls::
* Function pointers::
* Type-coercion::


File: libgccjit.info,  Node: Simple expressions,  Next: Vector 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: Vector expressions,  Next: Unary Operations,  Prev: Simple expressions,  Up: Rvalues

2.4.1.2 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(): 85.

     “num_elements” should match that of the vector type.

     This entrypoint was added in *note LIBGCCJIT_ABI_10: a0.; 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.3 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: a4.              ‘-(EXPR)’
                                               
                                               
*note GCC_JIT_UNARY_OP_BITWISE_NEGATE: a5.     ‘~(EXPR)’
                                               
                                               
*note GCC_JIT_UNARY_OP_LOGICAL_NEGATE: a6.     ‘!(EXPR)’
                                               
                                               
*note GCC_JIT_UNARY_OP_ABS: a7.                ‘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.4 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: aa.            ‘x + y’
                                             
                                             
*note GCC_JIT_BINARY_OP_MINUS: ab.           ‘x - y’
                                             
                                             
*note GCC_JIT_BINARY_OP_MULT: ac.            ‘x * y’
                                             
                                             
*note GCC_JIT_BINARY_OP_DIVIDE: ad.          ‘x / y’
                                             
                                             
*note GCC_JIT_BINARY_OP_MODULO: ae.          ‘x % y’
                                             
                                             
*note GCC_JIT_BINARY_OP_BITWISE_AND: af.     ‘x & y’
                                             
                                             
*note GCC_JIT_BINARY_OP_BITWISE_XOR: b0.     ‘x ^ y’
                                             
                                             
*note GCC_JIT_BINARY_OP_BITWISE_OR: b1.      ‘x | y’
                                             
                                             
*note GCC_JIT_BINARY_OP_LOGICAL_AND: b2.     ‘x && y’
                                             
                                             
*note GCC_JIT_BINARY_OP_LOGICAL_OR: b3.      ‘x || y’
                                             
                                             
*note GCC_JIT_BINARY_OP_LSHIFT: b4.          ‘x << y’
                                             
                                             
*note GCC_JIT_BINARY_OP_RSHIFT: b5.          ‘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():
     b6.

 -- 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.5 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.6 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(): ba. 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(): bb.:

               /* 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(): 95.), 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():
          ba. 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(): ba. or *note
     gcc_jit_context_new_call_through_ptr(): bc, 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: be.; 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.7 Function pointers
.........................

Function pointers can be obtained:

        * from a *note gcc_jit_function: 29. using *note
          gcc_jit_function_get_address(): c0, or

        * from an existing function using *note
          gcc_jit_context_new_rvalue_from_ptr(): 9c, using a function
          pointer type obtained using *note
          gcc_jit_context_new_function_ptr_type(): 95.


File: libgccjit.info,  Node: Type-coercion,  Prev: Function pointers,  Up: Rvalues

2.4.1.8 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


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.

* 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(): cb. (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: cf.; you can
     test for its presence using

          #ifdef LIBGCCJIT_HAVE_gcc_jit_global_set_initializer


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.


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(): ec.

             * *note gcc_jit_case_as_object(): ed.

             * *note gcc_jit_context_new_case(): ee.

     were added in *note LIBGCCJIT_ABI_3: ef.; 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(): ee.

     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: f1. 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(): bc.

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(): c0.

 -- 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: f4.; 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(): 9c, using a function pointer type
obtained using *note gcc_jit_context_new_function_ptr_type(): 95.

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: dd.:

          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(): c8. with ‘kind’ *note
     GCC_JIT_GLOBAL_EXPORTED: ca.

     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(): cb. 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.

 -- 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: fd.           .s
                                                   
                                                   
*note GCC_JIT_OUTPUT_KIND_OBJECT_FILE: fe.         .o
                                                   
                                                   
*note GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY: ff.     .so or .dll
                                                   
                                                   
*note GCC_JIT_OUTPUT_KIND_EXECUTABLE: 100.         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.

     There is currently no support for specifying other libraries to
     link against.

 -- C Macro: GCC_JIT_OUTPUT_KIND_EXECUTABLE

     Compile the context to an executable.

     There is currently no support for specifying libraries to link
     against.


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(): 72. 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::


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(): 72.


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(): ec.

        * *note gcc_jit_case_as_object(): ed.

        * *note gcc_jit_context_new_case(): ee.


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(): 10f.

        * *note gcc_jit_context_set_timer(): 110.

        * *note gcc_jit_timer_new(): 111.

        * *note gcc_jit_timer_release(): 112.

        * *note gcc_jit_timer_push(): 113.

        * *note gcc_jit_timer_pop(): 114.

        * *note gcc_jit_timer_print(): 115.


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(): bd.


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(): 82.


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(): 85.


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(): c0.


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(): 87.


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(): 74.


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(): 8c.


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(): 104.

        * *note gcc_jit_version_minor(): 105.

        * *note gcc_jit_version_patchlevel(): 106.


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(): ce.


File: libgccjit.info,  Node: LIBGCCJIT_ABI_15,  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(): 123.

        * *note gcc_jit_block_end_with_extended_asm_goto(): 124.

        * *note gcc_jit_extended_asm_as_object(): 125.

        * *note gcc_jit_extended_asm_set_volatile_flag(): 126.

        * *note gcc_jit_extended_asm_set_inline_flag(): 127.

        * *note gcc_jit_extended_asm_add_output_operand(): 128.

        * *note gcc_jit_extended_asm_add_input_operand(): 129.

        * *note gcc_jit_extended_asm_add_clobber(): 12a.

        * *note gcc_jit_context_add_top_level_asm(): 12b.


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: 12f. 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: 12f. instance, and start timing:

          gcc_jit_timer *t = gcc_jit_timer_new ();

     This API entrypoint was added in *note LIBGCCJIT_ABI_4: 10e.; 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: 12f. 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: 10e.; 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: 12f. 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: 10e.; 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: 10e.; 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: 10e.; 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: 10e.; 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: 10e.; 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: 122.; 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: f1, 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: f1.:

        * *note gcc_jit_block_add_extended_asm(): 123. for an ‘asm’
          statement with no control flow, and

        * *note gcc_jit_block_end_with_extended_asm_goto(): 124. 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():
          128. and *note gcc_jit_extended_asm_add_input_operand(): 129.
          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: f1. 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: f1. 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: f1. 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: f1. 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: f1. 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) http://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-2021 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: 13d, which is a thin C++ wrapper around the C API’s
*note gcc_jit_context *: 8.

Create one using *note gccjit;;context;;acquire(): 13e.:

     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: 13f, using *note
gccjit;;context;;get_type(): 140.:

     gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT);

*note gccjit;;type: 13f. is an example of a “contextual” object: every
entity in the API is associated with a *note gccjit;;context: 13d.

Memory management is easy: all such “contextual” objects are
automatically cleaned up for you when the context is released, using
*note gccjit;;context;;release(): 141.:

     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: 142. is to ask it for
a human-readable description as a ‘std::string’, using *note
gccjit;;object;;get_debug_string(): 143.:

     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(): 144.:

     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(): 145.:

     gccjit::rvalue expr =
       ctxt.new_binary_op (
         GCC_JIT_BINARY_OP_MULT, int_type,
         param_i, param_i);

A *note gccjit;;rvalue: 146. is another example of a *note
gccjit;;object: 142. subclass.  As before, we can print it with *note
gccjit;;object;;get_debug_string(): 143.

     printf ("expr: %s\n", expr.get_debug_string ().c_str ());

giving this output:

     expr: i * i

Note that *note gccjit;;rvalue: 146. 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(): 147.:

     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(): 149.

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(): 14a. 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-2021 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:

[image of a control flow graph]

     Figure
     
As before, we include the libgccjit++ header and make a *note
gccjit;;context: 13d.

     #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: 146,
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: 13f.

Anothe important class is *note gccjit;;lvalue: 14f.  A *note
gccjit;;lvalue: 14f.  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: 14f. is a subclass of *note
gccjit;;rvalue: 146, 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: 146, and

  2. the various function parameters: ‘param_i’ and ‘param_n’, instances
     of *note gccjit;;param: 150, which is a subclass of *note
     gccjit;;lvalue: 14f. (and, in turn, of *note gccjit;;rvalue: 146.):
     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(): 151, 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: 14f. - 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: 153. instances within the
*note gccjit;;function: 154.:

     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(): 155. to add an assignment statement,
and using *note gccjit;;context;;zero(): 156. 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: 146, in this case the comparison of ‘i’ and ‘n’.

We could build the comparison using *note
gccjit;;context;;new_comparison(): 157.:

     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(): 158.:

     b_loop_cond.end_with_conditional (guard,
                                       b_after_loop, // on_true
                                       b_loop_body); // on_false

However *note gccjit;;rvalue: 146. 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(): 159. 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(): 15a, 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(): 15c.:

     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’):

[image of a control flow graph]

     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-2021 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     ‘[..., x, y]’       ‘[..., (x+y)]’
                           on 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     ‘[..., x]’          ‘[..., fn(x)]’
                           of the stack, and popping                        
                           the result.
                           
                                                                            
RETURN                     Return the top of the        ‘[x]’               ‘[]’
                           stack.                                           
                           
                                                                            
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: 163. 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[16];
                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(): 165. 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(): 15c.:

     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.

[image of a control flow graph]

     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(): 169. and using
          the results.

        * Enable the generation of debugging information, by setting
          *note GCC_JIT_BOOL_OPTION_DEBUGINFO: 42. on the *note
          gccjit;;context: 13d. via *note
          gccjit;;context;;set_bool_option(): 149.:

               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(): 14a. 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: 153. 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: 13d. type.

A *note gccjit;;context: 13d. 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(): 147. 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: 13d. gccjit::*note context:
          13d.::acquire ()

     This function acquires a new *note gccjit;;context: 13d. instance,
     which is independent of any others that may be present within this
     process.

 -- C++ Function: void gccjit::*note context: 13d.::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: 13d. gccjit::*note context:
          13d.::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: 13d. created via *note
gccjit;;context;;acquire(): 13e. 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(): 17d.
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(): 183.

 -- C++ Function: const char *gccjit::*note context:
          13d.::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: 13d.::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: 163. 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:
          13d.::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: 13d.::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: 13d.::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:
          13d.::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:
          13d.::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: 13d.::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:
          13d.::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(): 72.

     This entrypoint was added in *note LIBGCCJIT_ABI_1: 73.; 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: 13d. and *note gcc_jit_result *: 16.) is a “contextual”
object, a *note gccjit;;object: 142.

A JIT object:

        * is associated with a *note gccjit;;context: 13d.

        * 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: 142. base class has the following operations:

 -- C++ Function: gccjit::*note context: 13d. gccjit::*note object:
          142.::get_context () const

     Which context is the obj within?

 -- C++ Function: std::string gccjit::*note object:
          142.::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: 142.

Types can be created in several ways:

   * fundamental types can be accessed using *note
     gccjit;;context;;get_type(): 140.:

          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(): 1bc. and *note
     gccjit;;type;;get_const(): 1bd.:

          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: 13f. gccjit::*note context:
          13d.::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: 13f. gccjit::*note context:
          13d.::get_int_type (size_t num_bytes, int is_signed)

     Access the integer type of the given size.

 -- C++ Function: template<>gccjit::*note type: 13f. gccjit::*note
          context: 13d.::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: 13f. gccjit::*note type:
          13f.::get_pointer ()

     Given type “T”, get type “T*”.

 -- C++ Function: gccjit::*note type: 13f. gccjit::*note type:
          13f.::get_const ()

     Given type “T”, get type “const T”.

 -- C++ Function: gccjit::*note type: 13f. gccjit::*note type:
          13f.::get_volatile ()

     Given type “T”, get type “volatile T”.

 -- C++ Function: gccjit::*note type: 13f. gccjit::*note type:
          13f.::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: 13f. gccjit::*note context:
          13d.::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: 13f. gccjit::*note type:
          13f.::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_: 1e2. is a subclass of *note gccjit;;type: 13f.
(and thus of *note gccjit;;object: 142. in turn).

 -- C++ Class: gccjit::field

A field within a *note gccjit;;struct_: 1e2.

*note gccjit;;field: 1e6. is a subclass of *note gccjit;;object: 142.

You can model C ‘struct’ types by creating *note gccjit;;struct_: 1e2.
and *note gccjit;;field: 1e6. 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: 1e6. gccjit::*note context:
          13d.::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_: 1e2. gccjit::*note context:
          13d.::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_: 1e2. gccjit::*note context:
          13d.::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(): 91.


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: 146. is an expression that can be computed.  It
is a subclass of *note gccjit;;object: 142, 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: 13f. gccjit::*note rvalue:
          146.::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: 146. gccjit::*note context:
          13d.::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: 146. gccjit::*note context:
          13d.::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: 146. gccjit::*note context:
          13d.::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: 146. gccjit::*note context:
          13d.::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: 146. gccjit::*note context:
          13d.::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: 146. gccjit::*note context:
          13d.::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: 146. gccjit::*note context:
          13d.::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: 146. gccjit::*note context:
          13d.::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: 146. gccjit::*note context:
          13d.::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(): a2. 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: 146. gccjit::*note context:
          13d.::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: 146. 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: 146. 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: 146. operator- (gccjit::rvalue
          a)

          gccjit::rvalue negpi = -pi;

 -- C++ Function: gccjit::*note rvalue: 146. operator~ (gccjit::rvalue
          a)

          gccjit::rvalue mask = ~a;

 -- C++ Function: gccjit::*note rvalue: 146. 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: 146. gccjit::*note context:
          13d.::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: 146. gccjit::*note context:
          13d.::new_plus (gccjit::type result_type, gccjit::rvalue a,
          gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_minus (gccjit::type result_type, gccjit::rvalue a,
          gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_mult (gccjit::type result_type, gccjit::rvalue a,
          gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_divide (gccjit::type result_type, gccjit::rvalue a,
          gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_modulo (gccjit::type result_type, gccjit::rvalue a,
          gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_bitwise_and (gccjit::type result_type,
          gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_bitwise_xor (gccjit::type result_type,
          gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_bitwise_or (gccjit::type result_type, gccjit::rvalue
          a, gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_logical_and (gccjit::type result_type,
          gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::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: 146. operator+ (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue sum = a + b;

 -- C++ Function: gccjit::*note rvalue: 146. operator- (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue diff = a - b;

 -- C++ Function: gccjit::*note rvalue: 146. operator* (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue prod = a * b;

 -- C++ Function: gccjit::*note rvalue: 146. operator/ (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue result = a / b;

 -- C++ Function: gccjit::*note rvalue: 146. operator% (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue mod = a % b;

 -- C++ Function: gccjit::*note rvalue: 146. operator& (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue x = a & b;

 -- C++ Function: gccjit::*note rvalue: 146. operator^ (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue x = a ^ b;

 -- C++ Function: gccjit::*note rvalue: 146. operator| (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue x = a | b;

 -- C++ Function: gccjit::*note rvalue: 146. operator&& (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue cond = a && b;

 -- C++ Function: gccjit::*note rvalue: 146. 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: 146. gccjit::*note context:
          13d.::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: 146. gccjit::*note context:
          13d.::new_eq (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_ne (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_lt (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_le (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::new_gt (gccjit::rvalue a, gccjit::rvalue b,
          gccjit::location loc)

 -- C++ Function: gccjit::*note rvalue: 146. gccjit::*note context:
          13d.::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: 146. operator== (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue cond = (a == ctxt.zero (t_int));

 -- C++ Function: gccjit::*note rvalue: 146. operator!= (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue cond = (i != j);

 -- C++ Function: gccjit::*note rvalue: 146. operator< (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue cond = i < n;

 -- C++ Function: gccjit::*note rvalue: 146. operator<= (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue cond = i <= n;

 -- C++ Function: gccjit::*note rvalue: 146. operator> (gccjit::rvalue
          a, gccjit::rvalue b)

          gccjit::rvalue cond = (ch > limit);

 -- C++ Function: gccjit::*note rvalue: 146. 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: 146. 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(): 2ca.:

               /* 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: 146. gccjit::*note function:
          154.::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: 146. gccjit::*note context:
          13d.::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: 146, 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: 146. gccjit::*note lvalue:
          14f.::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: 14f. gccjit::*note context:
          13d.::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():
     c8. 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: 14f. gccjit::*note rvalue:
          146.::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: 14f. gccjit::*note rvalue:
          146.::operator* ()

          gccjit::lvalue content = *ptr;

Field access is provided separately for both lvalues and rvalues:

 -- C++ Function: gccjit::*note lvalue: 14f. gccjit::*note lvalue:
          14f.::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: 146. gccjit::*note rvalue:
          146.::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: 14f. gccjit::*note rvalue:
          146.::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: 14f. gccjit::*note context:
          13d.::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: 163, 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: 150. gccjit::*note context:
          13d.::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: 150. is a subclass of *note gccjit;;lvalue: 14f.
(and thus of *note gccjit;;rvalue: 146. and *note gccjit;;object: 142.).
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: 154. gccjit::*note context:
          13d.::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: 154. gccjit::*note context:
          13d.::get_builtin_function (const char *name)

     This is a wrapper around the C API’s *note
     gcc_jit_context_get_builtin_function(): e1.

 -- C++ Function: gccjit::*note param: 150. gccjit::*note function:
          154.::get_param (int index) const

     Get the param of the given index (0-based).

 -- C++ Function: void gccjit::*note function: 154.::dump_to_dot (const
          char *path)

     Emit the function in graphviz format to the given path.

 -- C++ Function: gccjit::*note lvalue: 14f. gccjit::*note function:
          154.::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: 153. is a subclass of *note gccjit;;object:
     142.

     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: 153. gccjit::*note function:
          154.::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: 153.::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: 153.::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: 153.::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: 153.::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: 153.::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: 153.::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: 153.::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: 153.::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(): 33a.

             * ‘gccjit::context::new_case()’

     were added in *note LIBGCCJIT_ABI_3: ef.; 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: 13d. using
     ‘gccjit::context::new_case()’.  It is a subclass of *note
     gccjit;;object: 142.

     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():
     169.

     You need to enable *note GCC_JIT_BOOL_OPTION_DEBUGINFO: 42. on the
     *note gccjit;;context: 13d. 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: 163. gccjit::*note context:
          13d.::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(): 188.:

     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: 13d. can be compiled to machine
code, either in-memory via *note gccjit;;context;;compile(): 147. or to
disk via *note gccjit;;context;;compile_to_file(): 349.

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: 13d.::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(): 349.
method.

 -- C++ Function: void gccjit::*note context: 13d.::compile_to_file
          (enum gcc_jit_output_kind, const char *output_path)

     Compile the *note gccjit;;context: 13d. 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: 122.; 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: 355. is a subclass of *note
     gccjit;;object: 142.  It is a thin wrapper around the C API’s *note
     gcc_jit_extended_asm *: f1.

     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: 355,
     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: 355.:

        * *note gccjit;;block;;add_extended_asm(): 359. for an ‘asm’
          statement with no control flow, and

        * *note gccjit;;block;;end_with_extended_asm_goto(): 35a. 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():
          35b. and *note gccjit;;extended_asm;;add_input_operand(): 35c.
          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: 355. gccjit::*note block:
          153.::add_extended_asm (const std::string &asm_template,
          gccjit::location loc = location())

     Create a *note gccjit;;extended_asm: 355. 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: 355. gccjit::*note block:
          153.::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: 355. 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: 153. 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: 355. &gccjit::*note
          extended_asm: 355.::set_volatile_flag (bool flag)

     Set whether the *note gccjit;;extended_asm: 355. 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: 355. is flagged as volatile.

 -- C++ Function: gccjit::*note extended_asm: 355. &gccjit::*note
          extended_asm: 355.::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: 355. &gccjit::*note
          extended_asm: 355.::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: 355. &gccjit::*note
          extended_asm: 355.::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: 355. &gccjit::*note
          extended_asm: 355.::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: 355. &gccjit::*note
          extended_asm: 355.::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: 355. &gccjit::*note
          extended_asm: 355.::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: 13d.::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) http://valgrind.org

   (2) http://valgrind.org/docs/manual/mc-manual.html

   (3) http://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: 385. 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: 385. for most
          languages, and

        * once with *note –enable-host-shared: 385. 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.c’ implements the API entrypoints.  It performs error
     checking, then calls into classes of the gcc::jit::recording
     namespace within ‘jit-recording.c’ and ‘jit-recording.h’.

   * The gcc::jit::recording classes (within ‘jit-recording.c’ 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.c’ 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.c       .
                             .           .        │ (error-checking).
                             .           .        │                 .
                             .           .        ──> jit-recording.c
                             .           .              (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.c
                             .           .          .    │   (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.c,
since this is as close as possible to the error; failing that, a good
place is within ‘recording::context::validate ()’ in jit-recording.c.


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) http://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  48)
* command line option; –enable-checking=release: Working on the JIT library.
                                                              (line  55)
* 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  36)
* environment variable; LD_LIBRARY_PATH: Environment variables.
                                                              (line   9)
* environment variable; LIBRARY_PATH:    Environment variables.
                                                              (line  37)
* environment variable; PATH:            Environment variables.
                                                              (line  21)
* environment variable; PRESERVE_EXECUTABLES: Running the test suite.
                                                              (line  18)
* environment variable; RUN_UNDER_VALGRIND: Running under valgrind.
                                                              (line   6)
* gccjit;;block (C++ class):             Blocks<2>.           (line   6)
* gccjit;;block;;add_assignment (C++ function): Statements<2>.
                                                              (line  16)
* gccjit;;block;;add_assignment_op (C++ function): Statements<2>.
                                                              (line  27)
* gccjit;;block;;add_comment (C++ function): Statements<2>.   (line  47)
* 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  68)
* gccjit;;block;;end_with_conditional (C++ function): Statements<2>.
                                                              (line  59)
* gccjit;;block;;end_with_extended_asm_goto (C++ function): Adding assembler instructions within a function<2>.
                                                              (line  81)
* gccjit;;block;;end_with_jump (C++ function): Statements<2>. (line  75)
* gccjit;;block;;end_with_return (C++ function): Statements<2>.
                                                              (line  84)
* gccjit;;block;;end_with_switch (C++ function): Statements<2>.
                                                              (line 109)
* 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  18)
* gccjit;;context;;dump_to_file (C++ function): Debugging<2>. (line   6)
* gccjit;;context;;get_builtin_function (C++ function): Functions<2>.
                                                              (line  23)
* gccjit;;context;;get_first_error (C++ function): Error-handling<3>.
                                                              (line  15)
* gccjit;;context;;get_int_type (C++ function): Standard types<2>.
                                                              (line  12)
* gccjit;;context;;get_int_type<T> (C++ function): Standard types<2>.
                                                              (line  17)
* 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  59)
* gccjit;;context;;new_array_type (C++ function): Pointers const and volatile<2>.
                                                              (line  30)
* gccjit;;context;;new_binary_op (C++ function): Binary Operations<2>.
                                                              (line   6)
* gccjit;;context;;new_bitwise_and (C++ function): Binary Operations<2>.
                                                              (line  42)
* gccjit;;context;;new_bitwise_or (C++ function): Binary Operations<2>.
                                                              (line  50)
* gccjit;;context;;new_bitwise_xor (C++ function): Binary Operations<2>.
                                                              (line  46)
* gccjit;;context;;new_cast (C++ function): Type-coercion<2>. (line   6)
* gccjit;;context;;new_child_context (C++ function): Lifetime-management<2>.
                                                              (line  29)
* gccjit;;context;;new_comparison (C++ function): Comparisons<2>.
                                                              (line   6)
* gccjit;;context;;new_divide (C++ function): Binary Operations<2>.
                                                              (line  34)
* gccjit;;context;;new_eq (C++ function): Comparisons<2>.     (line  21)
* gccjit;;context;;new_field (C++ function): Structures and unions<2>.
                                                              (line  51)
* gccjit;;context;;new_function (C++ function): Functions<2>. (line  11)
* gccjit;;context;;new_ge (C++ function): Comparisons<2>.     (line  41)
* gccjit;;context;;new_global (C++ function): Global variables<2>.
                                                              (line   6)
* gccjit;;context;;new_gt (C++ function): Comparisons<2>.     (line  37)
* gccjit;;context;;new_le (C++ function): Comparisons<2>.     (line  33)
* gccjit;;context;;new_location (C++ function): Source Locations<2>.
                                                              (line  25)
* gccjit;;context;;new_logical_and (C++ function): Binary Operations<2>.
                                                              (line  54)
* gccjit;;context;;new_logical_or (C++ function): Binary Operations<2>.
                                                              (line  58)
* gccjit;;context;;new_lt (C++ function): Comparisons<2>.     (line  29)
* gccjit;;context;;new_minus (C++ function): Unary Operations<2>.
                                                              (line  21)
* gccjit;;context;;new_minus (C++ function) <1>: Binary Operations<2>.
                                                              (line  26)
* gccjit;;context;;new_modulo (C++ function): Binary Operations<2>.
                                                              (line  38)
* gccjit;;context;;new_mult (C++ function): Binary Operations<2>.
                                                              (line  30)
* gccjit;;context;;new_ne (C++ function): Comparisons<2>.     (line  25)
* gccjit;;context;;new_opaque_struct (C++ function): Structures and unions<2>.
                                                              (line  63)
* gccjit;;context;;new_param (C++ function): Params<2>.       (line  10)
* gccjit;;context;;new_plus (C++ function): Binary Operations<2>.
                                                              (line  22)
* gccjit;;context;;new_rvalue (C++ function): Simple expressions<2>.
                                                              (line   6)
* gccjit;;context;;new_rvalue (C++ function) <1>: Simple expressions<2>.
                                                              (line  12)
* gccjit;;context;;new_rvalue (C++ function) <2>: Simple expressions<2>.
                                                              (line  34)
* gccjit;;context;;new_rvalue (C++ function) <3>: Simple expressions<2>.
                                                              (line  41)
* gccjit;;context;;new_rvalue (C++ function) <4>: Simple expressions<2>.
                                                              (line  47)
* gccjit;;context;;new_rvalue (C++ function) <5>: Vector expressions<2>.
                                                              (line   6)
* gccjit;;context;;new_struct_type (C++ function): Structures and unions<2>.
                                                              (line  57)
* gccjit;;context;;new_unary_op (C++ function): Unary Operations<2>.
                                                              (line   6)
* gccjit;;context;;one (C++ function):   Simple expressions<2>.
                                                              (line  26)
* gccjit;;context;;release (C++ function): Lifetime-management<2>.
                                                              (line  17)
* gccjit;;context;;set_bool_allow_unreachable_blocks (C++ function): Boolean options<2>.
                                                              (line  15)
* 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  30)
* 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  18)
* 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 238)
* gccjit;;extended_asm;;add_input_operand (C++ function): Adding assembler instructions within a function<2>.
                                                              (line 206)
* gccjit;;extended_asm;;add_input_operand (C++ function) <1>: Adding assembler instructions within a function<2>.
                                                              (line 228)
* gccjit;;extended_asm;;add_output_operand (C++ function): Adding assembler instructions within a function<2>.
                                                              (line 169)
* gccjit;;extended_asm;;add_output_operand (C++ function) <1>: Adding assembler instructions within a function<2>.
                                                              (line 196)
* gccjit;;extended_asm;;set_inline_flag (C++ function): Adding assembler instructions within a function<2>.
                                                              (line 163)
* gccjit;;extended_asm;;set_volatile_flag (C++ function): Adding assembler instructions within a function<2>.
                                                              (line 135)
* 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  34)
* gccjit;;function;;get_address (C++ function): Function pointers<3>.
                                                              (line   6)
* gccjit;;function;;get_param (C++ function): Functions<2>.   (line  29)
* gccjit;;function;;new_block (C++ function): Blocks<2>.      (line  25)
* gccjit;;function;;new_local (C++ function): Functions<2>.   (line  39)
* 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  28)
* 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  41)
* 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  38)
* 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  48)
* gccjit;;rvalue;;get_type (C++ function): Rvalues<2>.        (line  34)
* gccjit;;rvalue;;operator* (C++ function): Working with pointers structs and unions<2>.
                                                              (line  21)
* 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  21)
* gccjit;;type;;get_const (C++ function): Pointers const and volatile<2>.
                                                              (line  11)
* 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  16)
* gcc_jit_binary_op (C type):            Binary Operations.   (line  15)
* GCC_JIT_BINARY_OP_BITWISE_AND (C macro): Binary Operations. (line 106)
* GCC_JIT_BINARY_OP_BITWISE_OR (C macro): Binary Operations.  (line 122)
* GCC_JIT_BINARY_OP_BITWISE_XOR (C macro): Binary Operations. (line 114)
* GCC_JIT_BINARY_OP_DIVIDE (C macro):    Binary Operations.   (line  86)
* GCC_JIT_BINARY_OP_LOGICAL_AND (C macro): Binary Operations. (line 130)
* GCC_JIT_BINARY_OP_LOGICAL_OR (C macro): Binary Operations.  (line 138)
* GCC_JIT_BINARY_OP_LSHIFT (C macro):    Binary Operations.   (line 146)
* GCC_JIT_BINARY_OP_MINUS (C macro):     Binary Operations.   (line  70)
* GCC_JIT_BINARY_OP_MODULO (C macro):    Binary Operations.   (line  98)
* GCC_JIT_BINARY_OP_MULT (C macro):      Binary Operations.   (line  78)
* GCC_JIT_BINARY_OP_PLUS (C macro):      Binary Operations.   (line  59)
* GCC_JIT_BINARY_OP_RSHIFT (C macro):    Binary Operations.   (line 154)
* gcc_jit_block (C type):                Blocks.              (line   6)
* gcc_jit_block_add_assignment (C function): Statements.      (line  16)
* gcc_jit_block_add_assignment_op (C function): Statements.   (line  27)
* gcc_jit_block_add_comment (C function): Statements.         (line  49)
* 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  39)
* gcc_jit_block_end_with_conditional (C function): Statements.
                                                              (line  68)
* gcc_jit_block_end_with_extended_asm_goto (C function): Adding assembler instructions within a function.
                                                              (line  82)
* gcc_jit_block_end_with_jump (C function): Statements.       (line  85)
* gcc_jit_block_end_with_return (C function): Statements.     (line  94)
* gcc_jit_block_end_with_switch (C function): Statements.     (line 115)
* gcc_jit_block_end_with_void_return (C function): Statements.
                                                              (line 105)
* gcc_jit_block_get_function (C function): Blocks.            (line  44)
* gcc_jit_bool_option (C type):          Boolean options.     (line  13)
* GCC_JIT_BOOL_OPTION_DEBUGINFO (C macro): Boolean options.   (line  15)
* GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING (C macro): Boolean options.
                                                              (line 108)
* GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE (C macro): Boolean options.
                                                              (line  72)
* GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE (C macro): Boolean options.
                                                              (line  57)
* GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE (C macro): Boolean options.
                                                              (line  26)
* GCC_JIT_BOOL_OPTION_DUMP_SUMMARY (C macro): Boolean options.
                                                              (line 103)
* GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES (C macro): Boolean options.
                                                              (line 124)
* GCC_JIT_BOOL_OPTION_SELFCHECK_GC (C macro): Boolean options.
                                                              (line 117)
* gcc_jit_case (C type):                 Statements.          (line 165)
* gcc_jit_case_as_object (C function):   Statements.          (line 187)
* gcc_jit_comparison (C type):           Comparisons.         (line  12)
* 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  36)
* 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  11)
* gcc_jit_context_dump_reproducer_to_file (C function): Debugging.
                                                              (line  63)
* gcc_jit_context_dump_to_file (C function): Debugging.       (line   6)
* gcc_jit_context_enable_dump (C function): Debugging.        (line  85)
* gcc_jit_context_get_builtin_function (C function): Functions.
                                                              (line  60)
* gcc_jit_context_get_first_error (C function): Error-handling<2>.
                                                              (line  26)
* gcc_jit_context_get_int_type (C function): Standard types.  (line  83)
* gcc_jit_context_get_last_error (C function): Error-handling<2>.
                                                              (line  40)
* gcc_jit_context_get_timer (C function): The timing API.     (line 160)
* 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  51)
* gcc_jit_context_new_array_type (C function): Pointers const and volatile.
                                                              (line  21)
* gcc_jit_context_new_binary_op (C function): Binary Operations.
                                                              (line   6)
* gcc_jit_context_new_bitfield (C function): Structures and unions.
                                                              (line  61)
* 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  32)
* gcc_jit_context_new_case (C function): Statements.          (line 175)
* gcc_jit_context_new_cast (C function): Type-coercion.       (line   6)
* gcc_jit_context_new_child_context (C function): Lifetime-management.
                                                              (line  28)
* 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  11)
* gcc_jit_context_new_function_ptr_type (C function): Function pointers<2>.
                                                              (line  50)
* gcc_jit_context_new_global (C function): Global variables.  (line   6)
* gcc_jit_context_new_location (C function): Source Locations.
                                                              (line  28)
* gcc_jit_context_new_opaque_struct (C function): Structures and unions.
                                                              (line  96)
* gcc_jit_context_new_param (C function): Params.             (line  10)
* gcc_jit_context_new_rvalue_from_double (C function): Simple expressions.
                                                              (line  35)
* 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  12)
* gcc_jit_context_new_rvalue_from_ptr (C function): Simple expressions.
                                                              (line  42)
* gcc_jit_context_new_rvalue_from_vector (C function): Vector expressions.
                                                              (line   6)
* gcc_jit_context_new_string_literal (C function): Simple expressions.
                                                              (line  56)
* gcc_jit_context_new_struct_type (C function): Structures and unions.
                                                              (line  86)
* gcc_jit_context_new_unary_op (C function): Unary Operations.
                                                              (line   6)
* gcc_jit_context_new_union_type (C function): Structures and unions.
                                                              (line 122)
* gcc_jit_context_null (C function):     Simple expressions.  (line  48)
* gcc_jit_context_one (C function):      Simple expressions.  (line  27)
* gcc_jit_context_release (C function):  Lifetime-management. (line  16)
* gcc_jit_context_set_bool_allow_unreachable_blocks (C function): Boolean options.
                                                              (line 130)
* gcc_jit_context_set_bool_option (C function): Boolean options.
                                                              (line   6)
* gcc_jit_context_set_bool_use_external_driver (C function): Boolean options.
                                                              (line 143)
* gcc_jit_context_set_int_option (C function): Integer options.
                                                              (line   6)
* gcc_jit_context_set_logfile (C function): Debugging.        (line  19)
* gcc_jit_context_set_str_option (C function): String Options.
                                                              (line   6)
* gcc_jit_context_set_timer (C function): The timing API.     (line 141)
* gcc_jit_context_zero (C function):     Simple expressions.  (line  19)
* 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 232)
* gcc_jit_extended_asm_add_input_operand (C function): Adding assembler instructions within a function.
                                                              (line 205)
* gcc_jit_extended_asm_add_output_operand (C function): Adding assembler instructions within a function.
                                                              (line 176)
* gcc_jit_extended_asm_as_object (C function): Adding assembler instructions within a function.
                                                              (line 251)
* gcc_jit_extended_asm_set_inline_flag (C function): Adding assembler instructions within a function.
                                                              (line 170)
* gcc_jit_extended_asm_set_volatile_flag (C function): Adding assembler instructions within a function.
                                                              (line 141)
* gcc_jit_field (C type):                Structures and unions.
                                                              (line  10)
* gcc_jit_field_as_object (C function):  Structures and unions.
                                                              (line  81)
* gcc_jit_function (C type):             Functions.           (line   6)
* GCC_JIT_FUNCTION_ALWAYS_INLINE (C macro): Functions.        (line  44)
* gcc_jit_function_as_object (C function): Functions.         (line  76)
* gcc_jit_function_dump_to_dot (C function): Functions.       (line  86)
* GCC_JIT_FUNCTION_EXPORTED (C macro):   Functions.           (line  24)
* gcc_jit_function_get_address (C function): Function pointers<2>.
                                                              (line  15)
* gcc_jit_function_get_param (C function): Functions.         (line  81)
* GCC_JIT_FUNCTION_IMPORTED (C macro):   Functions.           (line  38)
* GCC_JIT_FUNCTION_INTERNAL (C macro):   Functions.           (line  33)
* gcc_jit_function_kind (C type):        Functions.           (line  19)
* gcc_jit_function_new_block (C function): Blocks.            (line  22)
* gcc_jit_function_new_local (C function): Functions.         (line  91)
* GCC_JIT_GLOBAL_EXPORTED (C macro):     Global variables.    (line  25)
* GCC_JIT_GLOBAL_IMPORTED (C macro):     Global variables.    (line  39)
* GCC_JIT_GLOBAL_INTERNAL (C macro):     Global variables.    (line  32)
* gcc_jit_global_kind (C type):          Global variables.    (line  23)
* gcc_jit_global_set_initializer (C function): Global variables.
                                                              (line  45)
* gcc_jit_int_option (C type):           Integer options.     (line  12)
* GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL (C macro): Integer options.
                                                              (line  16)
* 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  18)
* gcc_jit_lvalue_as_object (C function): Lvalues.             (line  13)
* gcc_jit_lvalue_as_rvalue (C function): Lvalues.             (line  18)
* gcc_jit_lvalue_get_address (C function): Lvalues.           (line  23)
* 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  48)
* gcc_jit_output_kind (C type):          Ahead-of-time compilation.
                                                              (line  25)
* GCC_JIT_OUTPUT_KIND_ASSEMBLER (C macro): Ahead-of-time compilation.
                                                              (line  45)
* GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY (C macro): Ahead-of-time compilation.
                                                              (line  53)
* GCC_JIT_OUTPUT_KIND_EXECUTABLE (C macro): Ahead-of-time compilation.
                                                              (line  60)
* GCC_JIT_OUTPUT_KIND_OBJECT_FILE (C macro): Ahead-of-time compilation.
                                                              (line  49)
* gcc_jit_param (C type):                Params.              (line   6)
* gcc_jit_param_as_lvalue (C function):  Params.              (line  26)
* gcc_jit_param_as_object (C function):  Params.              (line  36)
* gcc_jit_param_as_rvalue (C function):  Params.              (line  31)
* gcc_jit_result (C type):               In-memory compilation.
                                                              (line  16)
* gcc_jit_result_get_code (C function):  In-memory compilation.
                                                              (line  22)
* gcc_jit_result_get_global (C function): In-memory compilation.
                                                              (line  55)
* gcc_jit_result_release (C function):   In-memory compilation.
                                                              (line  95)
* gcc_jit_rvalue (C type):               Rvalues.             (line   6)
* gcc_jit_rvalue_access_field (C function): Working with pointers structs and unions.
                                                              (line  29)
* gcc_jit_rvalue_as_object (C function): Rvalues.             (line  37)
* 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  40)
* gcc_jit_rvalue_get_type (C function):  Rvalues.             (line  32)
* gcc_jit_rvalue_set_bool_require_tail_call (C function): Function calls.
                                                              (line  44)
* gcc_jit_struct (C type):               Structures and unions.
                                                              (line   6)
* gcc_jit_struct_as_type (C function):   Structures and unions.
                                                              (line 109)
* gcc_jit_struct_set_fields (C function): Structures and unions.
                                                              (line 114)
* gcc_jit_str_option (C type):           String Options.      (line  12)
* GCC_JIT_STR_OPTION_PROGNAME (C macro): String Options.      (line  20)
* gcc_jit_timer (C type):                The timing API.      (line 115)
* gcc_jit_timer_new (C function):        The timing API.      (line 117)
* gcc_jit_timer_pop (C function):        The timing API.      (line 184)
* gcc_jit_timer_print (C function):      The timing API.      (line 197)
* gcc_jit_timer_push (C function):       The timing API.      (line 170)
* gcc_jit_timer_release (C function):    The timing API.      (line 128)
* gcc_jit_type (C type):                 Types.               (line   6)
* gcc_jit_type_as_object (C function):   Types.               (line  10)
* gcc_jit_type_get_aligned (C function): Pointers const and volatile.
                                                              (line  27)
* gcc_jit_type_get_const (C function):   Pointers const and volatile.
                                                              (line  11)
* gcc_jit_type_get_pointer (C function): Pointers const and volatile.
                                                              (line   6)
* gcc_jit_type_get_vector (C function):  Vector types.        (line   6)
* gcc_jit_type_get_volatile (C function): Pointers const and volatile.
                                                              (line  16)
* gcc_jit_unary_op (C type):             Unary Operations.    (line  15)
* GCC_JIT_UNARY_OP_ABS (C macro):        Unary Operations.    (line  60)
* GCC_JIT_UNARY_OP_BITWISE_NEGATE (C macro): Unary Operations.
                                                              (line  43)
* GCC_JIT_UNARY_OP_LOGICAL_NEGATE (C macro): Unary Operations.
                                                              (line  52)
* GCC_JIT_UNARY_OP_MINUS (C macro):      Unary Operations.    (line  35)
* gcc_jit_version_major (C function):    Programmatically checking version.
                                                              (line   8)
* gcc_jit_version_minor (C function):    Programmatically checking version.
                                                              (line  13)
* gcc_jit_version_patchlevel (C function): Programmatically checking version.
                                                              (line  18)
* LIBGCCJIT_HAVE_TIMING_API (C macro):   The timing API.      (line 103)
* new_bitwise_negate (C++ function):     Unary Operations<2>. (line  33)
* new_logical_negate (C++ function):     Unary Operations<2>. (line  46)
* operator! (C++ function):              Unary Operations<2>. (line  70)
* operator!= (C++ function):             Comparisons<2>.      (line  52)
* operator% (C++ function):              Binary Operations<2>.
                                                              (line  84)
* operator& (C++ function):              Binary Operations<2>.
                                                              (line  89)
* operator&& (C++ function):             Binary Operations<2>.
                                                              (line 104)
* operator* (C++ function):              Binary Operations<2>.
                                                              (line  74)
* operator+ (C++ function):              Binary Operations<2>.
                                                              (line  64)
* operator- (C++ function):              Unary Operations<2>. (line  60)
* operator- (C++ function) <1>:          Binary Operations<2>.
                                                              (line  69)
* operator/ (C++ function):              Binary Operations<2>.
                                                              (line  79)
* operator< (C++ function):              Comparisons<2>.      (line  57)
* operator<= (C++ function):             Comparisons<2>.      (line  62)
* operator== (C++ function):             Comparisons<2>.      (line  47)
* operator> (C++ function):              Comparisons<2>.      (line  67)
* operator>= (C++ function):             Comparisons<2>.      (line  72)
* operator^ (C++ function):              Binary Operations<2>.
                                                              (line  94)
* operator| (C++ function):              Binary Operations<2>.
                                                              (line  99)
* operator|| (C++ function):             Binary Operations<2>.
                                                              (line 109)
* operator~ (C++ function):              Unary Operations<2>. (line  65)
* PRESERVE_EXECUTABLES:                  Running the test suite.
                                                              (line  18)
* RUN_UNDER_VALGRIND:                    Running under valgrind.
                                                              (line   6)



Tag Table:
Node: Top396
Ref: index doc651
Ref: 0651
Ref: Top-Footnote-18622
Node: Tutorial8658
Ref: intro/index doc8745
Ref: 18745
Ref: intro/index libgccjit8745
Ref: 28745
Ref: intro/index tutorial8745
Ref: 38745
Node: Tutorial part 1 “Hello world”9287
Ref: intro/tutorial01 doc9433
Ref: 49433
Ref: intro/tutorial01 tutorial-part-1-hello-world9433
Ref: 59433
Node: Tutorial part 2 Creating a trivial machine code function14710
Ref: intro/tutorial02 doc14900
Ref: 614900
Ref: intro/tutorial02 tutorial-part-2-creating-a-trivial-machine-code-function14900
Ref: 714900
Node: Error-handling20365
Ref: intro/tutorial02 error-handling20491
Ref: 1820491
Node: Options21394
Ref: intro/tutorial02 options21541
Ref: 1a21541
Node: Full example24137
Ref: intro/tutorial02 full-example24261
Ref: 2024261
Node: Tutorial part 3 Loops and variables28438
Ref: intro/tutorial03 doc28654
Ref: 2128654
Ref: intro/tutorial03 tutorial-part-3-loops-and-variables28654
Ref: 2228654
Node: Expressions lvalues and rvalues30663
Ref: intro/tutorial03 expressions-lvalues-and-rvalues30790
Ref: 2330790
Node: Control flow32996
Ref: intro/tutorial03 control-flow33166
Ref: 2733166
Node: Visualizing the control flow graph38052
Ref: intro/tutorial03 visualizing-the-control-flow-graph38206
Ref: 3238206
Node: Full example<2>38830
Ref: intro/tutorial03 full-example38963
Ref: 3438963
Node: Tutorial part 4 Adding JIT-compilation to a toy interpreter45021
Ref: intro/tutorial04 doc45235
Ref: 3545235
Ref: intro/tutorial04 tutorial-part-4-adding-jit-compilation-to-a-toy-interpreter45235
Ref: 3645235
Node: Our toy interpreter45846
Ref: intro/tutorial04 our-toy-interpreter45998
Ref: 3745998
Node: Compiling to machine code53705
Ref: intro/tutorial04 compiling-to-machine-code53883
Ref: 3853883
Node: Setting things up55922
Ref: intro/tutorial04 setting-things-up56104
Ref: 3a56104
Node: Populating the function60185
Ref: intro/tutorial04 populating-the-function60374
Ref: 3c60374
Node: Verifying the control flow graph68033
Ref: intro/tutorial04 verifying-the-control-flow-graph68226
Ref: 3e68226
Node: Compiling the context68768
Ref: intro/tutorial04 compiling-the-context68980
Ref: 3f68980
Node: Single-stepping through the generated code69572
Ref: intro/tutorial04 single-stepping-through-the-generated-code69780
Ref: 4069780
Node: Examining the generated code71901
Ref: intro/tutorial04 examining-the-generated-code72111
Ref: 4372111
Node: Putting it all together76909
Ref: intro/tutorial04 putting-it-all-together77128
Ref: 4477128
Node: Behind the curtain How does our code get optimized?77969
Ref: intro/tutorial04 behind-the-curtain-how-does-our-code-get-optimized78151
Ref: 4578151
Node: Optimizing away stack manipulation83952
Ref: intro/tutorial04 optimizing-away-stack-manipulation84115
Ref: 4684115
Node: Elimination of tail recursion90238
Ref: intro/tutorial04 elimination-of-tail-recursion90401
Ref: 4790401
Node: Tutorial part 5 Implementing an Ahead-of-Time compiler91893
Ref: intro/tutorial05 doc92063
Ref: 4892063
Ref: intro/tutorial05 tutorial-part-5-implementing-an-ahead-of-time-compiler92063
Ref: 4992063
Node: The “brainf” language92916
Ref: intro/tutorial05 the-brainf-language93086
Ref: 4b93086
Node: Converting a brainf script to libgccjit IR95897
Ref: intro/tutorial05 converting-a-brainf-script-to-libgccjit-ir96105
Ref: 4c96105
Node: Compiling a context to a file107713
Ref: intro/tutorial05 compiling-a-context-to-a-file107936
Ref: 4d107936
Node: Other forms of ahead-of-time-compilation114772
Ref: intro/tutorial05 other-forms-of-ahead-of-time-compilation114944
Ref: 4e114944
Node: Topic Reference115304
Ref: topics/index doc115414
Ref: 4f115414
Ref: topics/index topic-reference115414
Ref: 50115414
Node: Compilation contexts115734
Ref: topics/contexts doc115825
Ref: 51115825
Ref: topics/contexts compilation-contexts115825
Ref: 52115825
Ref: topics/contexts c gcc_jit_context115876
Ref: 8115876
Node: Lifetime-management116331
Ref: topics/contexts lifetime-management116432
Ref: 53116432
Ref: topics/contexts c gcc_jit_context_acquire116697
Ref: 9116697
Ref: topics/contexts c gcc_jit_context_release116921
Ref: c116921
Ref: topics/contexts c gcc_jit_context_new_child_context117377
Ref: 54117377
Node: Thread-safety118783
Ref: topics/contexts thread-safety118910
Ref: 55118910
Node: Error-handling<2>119605
Ref: topics/contexts error-handling119722
Ref: 19119722
Ref: topics/contexts id1119722
Ref: 56119722
Ref: topics/contexts c gcc_jit_context_get_first_error120756
Ref: 57120756
Ref: topics/contexts c gcc_jit_context_get_last_error121268
Ref: 58121268
Node: Debugging121612
Ref: topics/contexts debugging121726
Ref: 59121726
Ref: topics/contexts c gcc_jit_context_dump_to_file121759
Ref: 5a121759
Ref: topics/contexts c gcc_jit_context_set_logfile122353
Ref: 5b122353
Ref: topics/contexts c gcc_jit_context_dump_reproducer_to_file124037
Ref: 5d124037
Ref: topics/contexts c gcc_jit_context_enable_dump125219
Ref: 5e125219
Node: Options<2>126761
Ref: topics/contexts options126849
Ref: 5f126849
Node: String Options127367
Ref: topics/contexts string-options127455
Ref: 60127455
Ref: topics/contexts c gcc_jit_context_set_str_option127502
Ref: 61127502
Ref: topics/contexts c gcc_jit_str_option127689
Ref: 62127689
Ref: topics/contexts c GCC_JIT_STR_OPTION_PROGNAME127964
Ref: 63127964
Node: Boolean options128183
Ref: topics/contexts boolean-options128295
Ref: 64128295
Ref: topics/contexts c gcc_jit_context_set_bool_option128344
Ref: 1b128344
Ref: topics/contexts c gcc_jit_bool_option128591
Ref: 65128591
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DEBUGINFO128634
Ref: 42128634
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE129117
Ref: 66129117
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE131059
Ref: 1c131059
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE131521
Ref: 1d131521
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DUMP_SUMMARY132639
Ref: 67132639
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING132824
Ref: 68132824
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_SELFCHECK_GC133288
Ref: 6a133288
Ref: topics/contexts c GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES133615
Ref: 69133615
Ref: topics/contexts c gcc_jit_context_set_bool_allow_unreachable_blocks133850
Ref: 6b133850
Ref: topics/contexts c gcc_jit_context_set_bool_use_external_driver134313
Ref: 6d134313
Node: Integer options134927
Ref: topics/contexts integer-options135056
Ref: 6f135056
Ref: topics/contexts c gcc_jit_context_set_int_option135105
Ref: 1e135105
Ref: topics/contexts c gcc_jit_int_option135286
Ref: 70135286
Ref: topics/contexts c GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL135387
Ref: 1f135387
Node: Additional command-line options135641
Ref: topics/contexts additional-command-line-options135746
Ref: 71135746
Ref: topics/contexts c gcc_jit_context_add_command_line_option135827
Ref: 72135827
Ref: topics/contexts c gcc_jit_context_add_driver_option137106
Ref: 74137106
Node: Objects138321
Ref: topics/objects doc138426
Ref: 76138426
Ref: topics/objects objects138426
Ref: 77138426
Ref: topics/objects c gcc_jit_object138451
Ref: e138451
Ref: topics/objects c gcc_jit_object_get_context139582
Ref: 78139582
Ref: topics/objects c gcc_jit_object_get_debug_string139716
Ref: f139716
Node: Types140323
Ref: topics/types doc140419
Ref: 79140419
Ref: topics/types types140419
Ref: 7a140419
Ref: topics/types c gcc_jit_type140440
Ref: a140440
Ref: topics/types c gcc_jit_type_as_object140523
Ref: d140523
Node: Standard types141493
Ref: topics/types standard-types141588
Ref: 7d141588
Ref: topics/types c gcc_jit_context_get_type141631
Ref: b141631
Ref: topics/types c gcc_jit_context_get_int_type146070
Ref: 7e146070
Node: Pointers const and volatile146244
Ref: topics/types pointers-const-and-volatile146360
Ref: 7f146360
Ref: topics/types c gcc_jit_type_get_pointer146449
Ref: 7b146449
Ref: topics/types c gcc_jit_type_get_const146581
Ref: 7c146581
Ref: topics/types c gcc_jit_type_get_volatile146716
Ref: 80146716
Ref: topics/types c gcc_jit_context_new_array_type146857
Ref: 81146857
Ref: topics/types c gcc_jit_type_get_aligned147114
Ref: 82147114
Node: Vector types147546
Ref: topics/types vector-types147669
Ref: 84147669
Ref: topics/types c gcc_jit_type_get_vector147708
Ref: 85147708
Node: Structures and unions148886
Ref: topics/types structures-and-unions149004
Ref: 88149004
Ref: topics/types c gcc_jit_struct149061
Ref: 89149061
Ref: topics/types c gcc_jit_field149137
Ref: 8a149137
Ref: topics/types c gcc_jit_context_new_field150600
Ref: 8b150600
Ref: topics/types c gcc_jit_context_new_bitfield151044
Ref: 8c151044
Ref: topics/types c gcc_jit_field_as_object151793
Ref: 8e151793
Ref: topics/types c gcc_jit_context_new_struct_type151919
Ref: 8f151919
Ref: topics/types c gcc_jit_context_new_opaque_struct152362
Ref: 90152362
Ref: topics/types c gcc_jit_struct_as_type152931
Ref: 92152931
Ref: topics/types c gcc_jit_struct_set_fields153060
Ref: 91153060
Ref: topics/types c gcc_jit_context_new_union_type153340
Ref: 93153340
Node: Function pointer types156349
Ref: topics/types function-pointer-types156446
Ref: 94156446
Node: Expressions156601
Ref: topics/expressions doc156718
Ref: 96156718
Ref: topics/expressions expressions156718
Ref: 97156718
Node: Rvalues156872
Ref: topics/expressions rvalues156946
Ref: 98156946
Ref: topics/expressions c gcc_jit_rvalue156975
Ref: 13156975
Ref: topics/expressions c gcc_jit_rvalue_get_type157639
Ref: 99157639
Ref: topics/expressions c gcc_jit_rvalue_as_object157764
Ref: 14157764
Node: Simple expressions158078
Ref: topics/expressions simple-expressions158170
Ref: 9a158170
Ref: topics/expressions c gcc_jit_context_new_rvalue_from_int158225
Ref: 30158225
Ref: topics/expressions c gcc_jit_context_new_rvalue_from_long158485
Ref: 9b158485
Ref: topics/expressions c gcc_jit_context_zero158758
Ref: 2b158758
Ref: topics/expressions c gcc_jit_context_one159073
Ref: 2f159073
Ref: topics/expressions c gcc_jit_context_new_rvalue_from_double159386
Ref: 31159386
Ref: topics/expressions c gcc_jit_context_new_rvalue_from_ptr159665
Ref: 9c159665
Ref: topics/expressions c gcc_jit_context_null159887
Ref: 9d159887
Ref: topics/expressions c gcc_jit_context_new_string_literal160184
Ref: 9e160184
Node: Vector expressions160583
Ref: topics/expressions vector-expressions160700
Ref: 9f160700
Ref: topics/expressions c gcc_jit_context_new_rvalue_from_vector160755
Ref: 87160755
Node: Unary Operations161374
Ref: topics/expressions unary-operations161490
Ref: a1161490
Ref: topics/expressions c gcc_jit_context_new_unary_op161541
Ref: a2161541
Ref: topics/expressions c gcc_jit_unary_op161874
Ref: a3161874
Ref: topics/expressions c GCC_JIT_UNARY_OP_MINUS162751
Ref: a4162751
Ref: topics/expressions c GCC_JIT_UNARY_OP_BITWISE_NEGATE162867
Ref: a5162867
Ref: topics/expressions c GCC_JIT_UNARY_OP_LOGICAL_NEGATE163028
Ref: a6163028
Ref: topics/expressions c GCC_JIT_UNARY_OP_ABS163177
Ref: a7163177
Node: Binary Operations163310
Ref: topics/expressions binary-operations163419
Ref: a8163419
Ref: topics/expressions c gcc_jit_context_new_binary_op163472
Ref: 12163472
Ref: topics/expressions c gcc_jit_binary_op163829
Ref: a9163829
Ref: topics/expressions c GCC_JIT_BINARY_OP_PLUS165863
Ref: aa165863
Ref: topics/expressions c GCC_JIT_BINARY_OP_MINUS166077
Ref: ab166077
Ref: topics/expressions c GCC_JIT_BINARY_OP_MULT166212
Ref: ac166212
Ref: topics/expressions c GCC_JIT_BINARY_OP_DIVIDE166359
Ref: ad166359
Ref: topics/expressions c GCC_JIT_BINARY_OP_MODULO166718
Ref: ae166718
Ref: topics/expressions c GCC_JIT_BINARY_OP_BITWISE_AND166864
Ref: af166864
Ref: topics/expressions c GCC_JIT_BINARY_OP_BITWISE_XOR166984
Ref: b0166984
Ref: topics/expressions c GCC_JIT_BINARY_OP_BITWISE_OR167113
Ref: b1167113
Ref: topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_AND167241
Ref: b2167241
Ref: topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_OR167362
Ref: b3167362
Ref: topics/expressions c GCC_JIT_BINARY_OP_LSHIFT167481
Ref: b4167481
Ref: topics/expressions c GCC_JIT_BINARY_OP_RSHIFT167596
Ref: b5167596
Node: Comparisons167712
Ref: topics/expressions comparisons167819
Ref: b7167819
Ref: topics/expressions c gcc_jit_context_new_comparison167860
Ref: 2c167860
Ref: topics/expressions c gcc_jit_comparison168131
Ref: b8168131
Node: Function calls169237
Ref: topics/expressions function-calls169344
Ref: b9169344
Ref: topics/expressions c gcc_jit_context_new_call169391
Ref: ba169391
Ref: topics/expressions c gcc_jit_context_new_call_through_ptr170513
Ref: bc170513
Ref: topics/expressions c gcc_jit_rvalue_set_bool_require_tail_call171048
Ref: bd171048
Node: Function pointers172112
Ref: topics/expressions function-pointers172221
Ref: bf172221
Node: Type-coercion172635
Ref: topics/expressions type-coercion172721
Ref: c1172721
Ref: topics/expressions c gcc_jit_context_new_cast172766
Ref: c2172766
Node: Lvalues173182
Ref: topics/expressions lvalues173305
Ref: c3173305
Ref: topics/expressions c gcc_jit_lvalue173334
Ref: 24173334
Ref: topics/expressions c gcc_jit_lvalue_as_object173570
Ref: c4173570
Ref: topics/expressions c gcc_jit_lvalue_as_rvalue173704
Ref: c5173704
Ref: topics/expressions c gcc_jit_lvalue_get_address173838
Ref: c6173838
Node: Global variables174070
Ref: topics/expressions global-variables174133
Ref: c7174133
Ref: topics/expressions c gcc_jit_context_new_global174184
Ref: c8174184
Ref: topics/expressions c gcc_jit_global_kind174816
Ref: c9174816
Ref: topics/expressions c GCC_JIT_GLOBAL_EXPORTED174859
Ref: ca174859
Ref: topics/expressions c GCC_JIT_GLOBAL_INTERNAL175156
Ref: cc175156
Ref: topics/expressions c GCC_JIT_GLOBAL_IMPORTED175459
Ref: cd175459
Ref: topics/expressions c gcc_jit_global_set_initializer175670
Ref: ce175670
Node: Working with pointers structs and unions176472
Ref: topics/expressions working-with-pointers-structs-and-unions176579
Ref: d0176579
Ref: topics/expressions c gcc_jit_rvalue_dereference176676
Ref: d1176676
Ref: topics/expressions c gcc_jit_lvalue_access_field177024
Ref: d2177024
Ref: topics/expressions c gcc_jit_rvalue_access_field177352
Ref: d3177352
Ref: topics/expressions c gcc_jit_rvalue_dereference_field177645
Ref: d4177645
Ref: topics/expressions c gcc_jit_context_new_array_access178019
Ref: b6178019
Node: Creating and using functions178504
Ref: topics/functions doc178636
Ref: d5178636
Ref: topics/functions creating-and-using-functions178636
Ref: d6178636
Node: Params178764
Ref: topics/functions params178856
Ref: d7178856
Ref: topics/functions c gcc_jit_param178883
Ref: 25178883
Ref: topics/functions c gcc_jit_context_new_param178976
Ref: 10178976
Ref: topics/functions c gcc_jit_param_as_lvalue179569
Ref: d8179569
Ref: topics/functions c gcc_jit_param_as_rvalue179698
Ref: d9179698
Ref: topics/functions c gcc_jit_param_as_object179827
Ref: da179827
Node: Functions179956
Ref: topics/functions functions180063
Ref: db180063
Ref: topics/functions c gcc_jit_function180096
Ref: 29180096
Ref: topics/functions c gcc_jit_context_new_function180263
Ref: 11180263
Ref: topics/functions c gcc_jit_function_kind180618
Ref: dc180618
Ref: topics/functions c GCC_JIT_FUNCTION_EXPORTED180753
Ref: dd180753
Ref: topics/functions c GCC_JIT_FUNCTION_INTERNAL181110
Ref: de181110
Ref: topics/functions c GCC_JIT_FUNCTION_IMPORTED181306
Ref: df181306
Ref: topics/functions c GCC_JIT_FUNCTION_ALWAYS_INLINE181543
Ref: e0181543
Ref: topics/functions c gcc_jit_context_get_builtin_function182200
Ref: e1182200
Ref: topics/functions c gcc_jit_function_as_object182954
Ref: e2182954
Ref: topics/functions c gcc_jit_function_get_param183091
Ref: e3183091
Ref: topics/functions c gcc_jit_function_dump_to_dot183247
Ref: 33183247
Ref: topics/functions c gcc_jit_function_new_local183413
Ref: 26183413
Node: Blocks183889
Ref: topics/functions blocks184000
Ref: e4184000
Ref: topics/functions c gcc_jit_block184027
Ref: 28184027
Ref: topics/functions c gcc_jit_function_new_block184539
Ref: e5184539
Ref: topics/functions c gcc_jit_block_as_object185240
Ref: e6185240
Ref: topics/functions c gcc_jit_block_get_function185366
Ref: e7185366
Node: Statements185505
Ref: topics/functions statements185598
Ref: e8185598
Ref: topics/functions c gcc_jit_block_add_eval185633
Ref: bb185633
Ref: topics/functions c gcc_jit_block_add_assignment185939
Ref: 2a185939
Ref: topics/functions c gcc_jit_block_add_assignment_op186263
Ref: 2e186263
Ref: topics/functions c gcc_jit_block_add_comment186898
Ref: 3d186898
Ref: topics/functions c gcc_jit_block_end_with_conditional187759
Ref: 2d187759
Ref: topics/functions c gcc_jit_block_end_with_jump188293
Ref: e9188293
Ref: topics/functions c gcc_jit_block_end_with_return188563
Ref: ea188563
Ref: topics/functions c gcc_jit_block_end_with_void_return188869
Ref: eb188869
Ref: topics/functions c gcc_jit_block_end_with_switch189156
Ref: ec189156
Ref: topics/functions c gcc_jit_case190618
Ref: f0190618
Ref: topics/functions c gcc_jit_context_new_case191023
Ref: ee191023
Ref: topics/functions c gcc_jit_case_as_object191563
Ref: ed191563
Node: Function pointers<2>195930
Ref: topics/function-pointers doc196067
Ref: f2196067
Ref: topics/function-pointers function-pointers196067
Ref: f3196067
Ref: topics/function-pointers c gcc_jit_function_get_address196415
Ref: c0196415
Ref: topics/function-pointers c gcc_jit_context_new_function_ptr_type197720
Ref: 95197720
Node: Source Locations198164
Ref: topics/locations doc198292
Ref: f5198292
Ref: topics/locations source-locations198292
Ref: f6198292
Ref: topics/locations c gcc_jit_location198335
Ref: 3b198335
Ref: topics/locations c gcc_jit_context_new_location199108
Ref: 41199108
Node: Faking it199547
Ref: topics/locations faking-it199612
Ref: f7199612
Node: Compiling a context200271
Ref: topics/compilation doc200404
Ref: f8200404
Ref: topics/compilation compiling-a-context200404
Ref: f9200404
Node: In-memory compilation200894
Ref: topics/compilation in-memory-compilation201008
Ref: fa201008
Ref: topics/compilation c gcc_jit_context_compile201065
Ref: 15201065
Ref: topics/compilation c gcc_jit_result201402
Ref: 16201402
Ref: topics/compilation c gcc_jit_result_get_code201614
Ref: 17201614
Ref: topics/compilation c gcc_jit_result_get_global203195
Ref: cb203195
Ref: topics/compilation c gcc_jit_result_release204665
Ref: 39204665
Node: Ahead-of-time compilation205055
Ref: topics/compilation ahead-of-time-compilation205169
Ref: fb205169
Ref: topics/compilation c gcc_jit_context_compile_to_file205450
Ref: 4a205450
Ref: topics/compilation c gcc_jit_output_kind206004
Ref: fc206004
Ref: topics/compilation c GCC_JIT_OUTPUT_KIND_ASSEMBLER206920
Ref: fd206920
Ref: topics/compilation c GCC_JIT_OUTPUT_KIND_OBJECT_FILE207012
Ref: fe207012
Ref: topics/compilation c GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY207103
Ref: ff207103
Ref: topics/compilation c GCC_JIT_OUTPUT_KIND_EXECUTABLE207290
Ref: 100207290
Node: ABI and API compatibility207462
Ref: topics/compatibility doc207590
Ref: 101207590
Ref: topics/compatibility abi-and-api-compatibility207590
Ref: 102207590
Node: Programmatically checking version209147
Ref: topics/compatibility programmatically-checking-version209269
Ref: 103209269
Ref: topics/compatibility c gcc_jit_version_major209415
Ref: 104209415
Ref: topics/compatibility c gcc_jit_version_minor209550
Ref: 105209550
Ref: topics/compatibility c gcc_jit_version_patchlevel209691
Ref: 106209691
Node: ABI symbol tags209939
Ref: topics/compatibility abi-symbol-tags210061
Ref: 107210061
Node: LIBGCCJIT_ABI_0210560
Ref: topics/compatibility id1210654
Ref: 108210654
Ref: topics/compatibility libgccjit-abi-0210654
Ref: 109210654
Ref: LIBGCCJIT_ABI_0-Footnote-1211042
Node: LIBGCCJIT_ABI_1211107
Ref: topics/compatibility id2211225
Ref: 10a211225
Ref: topics/compatibility libgccjit-abi-1211225
Ref: 73211225
Node: LIBGCCJIT_ABI_2211381
Ref: topics/compatibility id3211499
Ref: 10b211499
Ref: topics/compatibility libgccjit-abi-2211499
Ref: 6c211499
Node: LIBGCCJIT_ABI_3211665
Ref: topics/compatibility id4211783
Ref: 10c211783
Ref: topics/compatibility libgccjit-abi-3211783
Ref: ef211783
Node: LIBGCCJIT_ABI_4212075
Ref: topics/compatibility id5212193
Ref: 10d212193
Ref: topics/compatibility libgccjit-abi-4212193
Ref: 10e212193
Node: LIBGCCJIT_ABI_5212648
Ref: topics/compatibility id6212766
Ref: 116212766
Ref: topics/compatibility libgccjit-abi-5212766
Ref: 6e212766
Node: LIBGCCJIT_ABI_6212927
Ref: topics/compatibility id7213045
Ref: 117213045
Ref: topics/compatibility libgccjit-abi-6213045
Ref: be213045
Node: LIBGCCJIT_ABI_7213203
Ref: topics/compatibility id8213321
Ref: 118213321
Ref: topics/compatibility libgccjit-abi-7213321
Ref: 83213321
Node: LIBGCCJIT_ABI_8213462
Ref: topics/compatibility id9213580
Ref: 119213580
Ref: topics/compatibility libgccjit-abi-8213580
Ref: 86213580
Node: LIBGCCJIT_ABI_9213720
Ref: topics/compatibility id10213839
Ref: 11a213839
Ref: topics/compatibility libgccjit-abi-9213839
Ref: f4213839
Node: LIBGCCJIT_ABI_10213986
Ref: topics/compatibility id11214106
Ref: 11b214106
Ref: topics/compatibility libgccjit-abi-10214106
Ref: a0214106
Node: LIBGCCJIT_ABI_11214266
Ref: topics/compatibility id12214387
Ref: 11c214387
Ref: topics/compatibility libgccjit-abi-11214387
Ref: 75214387
Node: LIBGCCJIT_ABI_12214542
Ref: topics/compatibility id13214663
Ref: 11d214663
Ref: topics/compatibility libgccjit-abi-12214663
Ref: 8d214663
Node: LIBGCCJIT_ABI_13214813
Ref: topics/compatibility id14214934
Ref: 11e214934
Ref: topics/compatibility libgccjit-abi-13214934
Ref: 11f214934
Node: LIBGCCJIT_ABI_14215227
Ref: topics/compatibility id15215348
Ref: 120215348
Ref: topics/compatibility libgccjit-abi-14215348
Ref: cf215348
Node: LIBGCCJIT_ABI_15215500
Ref: topics/compatibility id16215596
Ref: 121215596
Ref: topics/compatibility libgccjit-abi-15215596
Ref: 122215596
Node: Performance216317
Ref: topics/performance doc216464
Ref: 12c216464
Ref: topics/performance performance216464
Ref: 12d216464
Node: The timing API216528
Ref: topics/performance the-timing-api216593
Ref: 12e216593
Ref: topics/performance c LIBGCCJIT_HAVE_TIMING_API221946
Ref: 130221946
Ref: topics/performance c gcc_jit_timer222378
Ref: 12f222378
Ref: topics/performance c gcc_jit_timer_new222405
Ref: 111222405
Ref: topics/performance c gcc_jit_timer_release222737
Ref: 112222737
Ref: topics/performance c gcc_jit_context_set_timer223100
Ref: 110223100
Ref: topics/performance c gcc_jit_context_get_timer223774
Ref: 10f223774
Ref: topics/performance c gcc_jit_timer_push224075
Ref: 113224075
Ref: topics/performance c gcc_jit_timer_pop224516
Ref: 114224516
Ref: topics/performance c gcc_jit_timer_print224959
Ref: 115224959
Node: Using Assembly Language with libgccjit225300
Ref: topics/asm doc225413
Ref: 131225413
Ref: topics/asm using-assembly-language-with-libgccjit225413
Ref: 132225413
Ref: Using Assembly Language with libgccjit-Footnote-1226122
Node: Adding assembler instructions within a function226202
Ref: topics/asm adding-assembler-instructions-within-a-function226373
Ref: 133226373
Ref: topics/asm c gcc_jit_extended_asm226484
Ref: f1226484
Ref: topics/asm c gcc_jit_block_add_extended_asm229146
Ref: 123229146
Ref: topics/asm c gcc_jit_block_end_with_extended_asm_goto229731
Ref: 124229731
Ref: topics/asm c gcc_jit_extended_asm_set_volatile_flag232216
Ref: 126232216
Ref: topics/asm c gcc_jit_extended_asm_set_inline_flag233477
Ref: 127233477
Ref: topics/asm c gcc_jit_extended_asm_add_output_operand233681
Ref: 128233681
Ref: topics/asm c gcc_jit_extended_asm_add_input_operand235040
Ref: 129235040
Ref: topics/asm c gcc_jit_extended_asm_add_clobber236347
Ref: 12a236347
Ref: topics/asm c gcc_jit_extended_asm_as_object237113
Ref: 125237113
Ref: Adding assembler instructions within a function-Footnote-1237304
Ref: Adding assembler instructions within a function-Footnote-2237374
Ref: Adding assembler instructions within a function-Footnote-3237453
Ref: Adding assembler instructions within a function-Footnote-4237530
Ref: Adding assembler instructions within a function-Footnote-5237602
Ref: Adding assembler instructions within a function-Footnote-6237678
Node: Adding top-level assembler statements237772
Ref: topics/asm adding-top-level-assembler-statements237943
Ref: 134237943
Ref: topics/asm c gcc_jit_context_add_top_level_asm238203
Ref: 12b238203
Node: C++ bindings for libgccjit239574
Ref: cp/index doc239685
Ref: 135239685
Ref: cp/index c-bindings-for-libgccjit239685
Ref: 136239685
Ref: C++ bindings for libgccjit-Footnote-1240233
Node: Tutorial<2>240269
Ref: cp/intro/index doc240373
Ref: 137240373
Ref: cp/intro/index tutorial240373
Ref: 138240373
Node: Tutorial part 1 “Hello world”<2>240816
Ref: cp/intro/tutorial01 doc240971
Ref: 139240971
Ref: cp/intro/tutorial01 tutorial-part-1-hello-world240971
Ref: 13a240971
Node: Tutorial part 2 Creating a trivial machine code function<2>245699
Ref: cp/intro/tutorial02 doc245901
Ref: 13b245901
Ref: cp/intro/tutorial02 tutorial-part-2-creating-a-trivial-machine-code-function245901
Ref: 13c245901
Node: Options<3>251020
Ref: cp/intro/tutorial02 options251153
Ref: 148251153
Node: Full example<3>253610
Ref: cp/intro/tutorial02 full-example253743
Ref: 14b253743
Node: Tutorial part 3 Loops and variables<2>257391
Ref: cp/intro/tutorial03 doc257619
Ref: 14c257619
Ref: cp/intro/tutorial03 tutorial-part-3-loops-and-variables257619
Ref: 14d257619
Node: Expressions lvalues and rvalues<2>259719
Ref: cp/intro/tutorial03 expressions-lvalues-and-rvalues259855
Ref: 14e259855
Node: Control flow<2>262140
Ref: cp/intro/tutorial03 control-flow262322
Ref: 152262322
Node: Visualizing the control flow graph<2>267060
Ref: cp/intro/tutorial03 visualizing-the-control-flow-graph267223
Ref: 15b267223
Node: Full example<4>267835
Ref: cp/intro/tutorial03 full-example267974
Ref: 15d267974
Node: Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>272935
Ref: cp/intro/tutorial04 doc273095
Ref: 15e273095
Ref: cp/intro/tutorial04 tutorial-part-4-adding-jit-compilation-to-a-toy-interpreter273095
Ref: 15f273095
Node: Our toy interpreter<2>273979
Ref: cp/intro/tutorial04 our-toy-interpreter274140
Ref: 160274140
Node: Compiling to machine code<2>281739
Ref: cp/intro/tutorial04 compiling-to-machine-code281929
Ref: 161281929
Node: Setting things up<2>283564
Ref: cp/intro/tutorial04 setting-things-up283758
Ref: 162283758
Node: Populating the function<2>287405
Ref: cp/intro/tutorial04 populating-the-function287606
Ref: 164287606
Node: Verifying the control flow graph<2>294075
Ref: cp/intro/tutorial04 verifying-the-control-flow-graph294280
Ref: 166294280
Node: Compiling the context<2>294804
Ref: cp/intro/tutorial04 compiling-the-context295028
Ref: 167295028
Node: Single-stepping through the generated code<2>296104
Ref: cp/intro/tutorial04 single-stepping-through-the-generated-code296324
Ref: 168296324
Node: Examining the generated code<2>298386
Ref: cp/intro/tutorial04 examining-the-generated-code298608
Ref: 16a298608
Node: Putting it all together<2>303187
Ref: cp/intro/tutorial04 putting-it-all-together303418
Ref: 16b303418
Node: Behind the curtain How does our code get optimized?<2>304266
Ref: cp/intro/tutorial04 behind-the-curtain-how-does-our-code-get-optimized304457
Ref: 16c304457
Node: Optimizing away stack manipulation<2>310148
Ref: cp/intro/tutorial04 optimizing-away-stack-manipulation310320
Ref: 16d310320
Node: Elimination of tail recursion<2>316443
Ref: cp/intro/tutorial04 elimination-of-tail-recursion316615
Ref: 16e316615
Node: Topic Reference<2>318107
Ref: cp/topics/index doc318211
Ref: 16f318211
Ref: cp/topics/index topic-reference318211
Ref: 170318211
Node: Compilation contexts<2>318582
Ref: cp/topics/contexts doc318682
Ref: 171318682
Ref: cp/topics/contexts compilation-contexts318682
Ref: 172318682
Ref: cp/topics/contexts _CPPv4N6gccjit7contextE318737
Ref: 13d318737
Ref: cp/topics/contexts _CPPv3N6gccjit7contextE318737
Ref: 173318737
Ref: cp/topics/contexts _CPPv2N6gccjit7contextE318737
Ref: 174318737
Ref: cp/topics/contexts gccjit context318737
Ref: 175318737
Node: Lifetime-management<2>319331
Ref: cp/topics/contexts lifetime-management319441
Ref: 176319441
Ref: cp/topics/contexts _CPPv4N6gccjit7context7acquireEv319710
Ref: 13e319710
Ref: cp/topics/contexts _CPPv3N6gccjit7context7acquireEv319710
Ref: 177319710
Ref: cp/topics/contexts _CPPv2N6gccjit7context7acquireEv319710
Ref: 178319710
Ref: cp/topics/contexts gccjit context acquire319710
Ref: 179319710
Ref: cp/topics/contexts _CPPv4N6gccjit7context7releaseEv319966
Ref: 141319966
Ref: cp/topics/contexts _CPPv3N6gccjit7context7releaseEv319966
Ref: 17a319966
Ref: cp/topics/contexts _CPPv2N6gccjit7context7releaseEv319966
Ref: 17b319966
Ref: cp/topics/contexts gccjit context release319966
Ref: 17c319966
Ref: cp/topics/contexts _CPPv4N6gccjit7context17new_child_contextEv320397
Ref: 17d320397
Ref: cp/topics/contexts _CPPv3N6gccjit7context17new_child_contextEv320397
Ref: 17e320397
Ref: cp/topics/contexts _CPPv2N6gccjit7context17new_child_contextEv320397
Ref: 17f320397
Ref: cp/topics/contexts gccjit context new_child_context320397
Ref: 180320397
Node: Thread-safety<2>321800
Ref: cp/topics/contexts thread-safety321936
Ref: 181321936
Node: Error-handling<3>322640
Ref: cp/topics/contexts error-handling322766
Ref: 182322766
Ref: cp/topics/contexts _CPPv4N6gccjit7context15get_first_errorEPN6gccjit7contextE323193
Ref: 183323193
Ref: cp/topics/contexts _CPPv3N6gccjit7context15get_first_errorEPN6gccjit7contextE323193
Ref: 184323193
Ref: cp/topics/contexts _CPPv2N6gccjit7context15get_first_errorEPN6gccjit7contextE323193
Ref: 185323193
Ref: cp/topics/contexts gccjit context get_first_error__gccjit contextP323193
Ref: 186323193
Node: Debugging<2>323504
Ref: cp/topics/contexts debugging323624
Ref: 187323624
Ref: cp/topics/contexts _CPPv4N6gccjit7context12dump_to_fileERKNSt6stringEi323661
Ref: 188323661
Ref: cp/topics/contexts _CPPv3N6gccjit7context12dump_to_fileERKNSt6stringEi323661
Ref: 189323661
Ref: cp/topics/contexts _CPPv2N6gccjit7context12dump_to_fileERKNSt6stringEi323661
Ref: 18a323661
Ref: cp/topics/contexts gccjit context dump_to_file__ssCR i323661
Ref: 18b323661
Ref: cp/topics/contexts _CPPv4N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc324240
Ref: 18c324240
Ref: cp/topics/contexts _CPPv3N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc324240
Ref: 18d324240
Ref: cp/topics/contexts _CPPv2N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc324240
Ref: 18e324240
Ref: cp/topics/contexts gccjit context dump_reproducer_to_file__gcc_jit_contextP cCP324240
Ref: 18f324240
Node: Options<4>324660
Ref: cp/topics/contexts options324754
Ref: 190324754
Node: String Options<2>324983
Ref: cp/topics/contexts string-options325077
Ref: 191325077
Ref: cp/topics/contexts _CPPv4N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc325124
Ref: 192325124
Ref: cp/topics/contexts _CPPv3N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc325124
Ref: 193325124
Ref: cp/topics/contexts _CPPv2N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc325124
Ref: 194325124
Ref: cp/topics/contexts gccjit context set_str_option__gcc_jit_str_option cCP325124
Ref: 195325124
Node: Boolean options<2>325425
Ref: cp/topics/contexts boolean-options325546
Ref: 196325546
Ref: cp/topics/contexts _CPPv4N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni325595
Ref: 149325595
Ref: cp/topics/contexts _CPPv3N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni325595
Ref: 197325595
Ref: cp/topics/contexts _CPPv2N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni325595
Ref: 198325595
Ref: cp/topics/contexts gccjit context set_bool_option__gcc_jit_bool_option i325595
Ref: 199325595
Ref: cp/topics/contexts _CPPv4N6gccjit7context33set_bool_allow_unreachable_blocksEi325892
Ref: 19a325892
Ref: cp/topics/contexts _CPPv3N6gccjit7context33set_bool_allow_unreachable_blocksEi325892
Ref: 19b325892
Ref: cp/topics/contexts _CPPv2N6gccjit7context33set_bool_allow_unreachable_blocksEi325892
Ref: 19c325892
Ref: cp/topics/contexts gccjit context set_bool_allow_unreachable_blocks__i325892
Ref: 19d325892
Ref: cp/topics/contexts _CPPv4N6gccjit7context28set_bool_use_external_driverEi326458
Ref: 19e326458
Ref: cp/topics/contexts _CPPv3N6gccjit7context28set_bool_use_external_driverEi326458
Ref: 19f326458
Ref: cp/topics/contexts _CPPv2N6gccjit7context28set_bool_use_external_driverEi326458
Ref: 1a0326458
Ref: cp/topics/contexts gccjit context set_bool_use_external_driver__i326458
Ref: 1a1326458
Node: Integer options<2>327165
Ref: cp/topics/contexts integer-options327303
Ref: 1a2327303
Ref: cp/topics/contexts _CPPv4N6gccjit7context14set_int_optionE18gcc_jit_int_optioni327352
Ref: 14a327352
Ref: cp/topics/contexts _CPPv3N6gccjit7context14set_int_optionE18gcc_jit_int_optioni327352
Ref: 1a3327352
Ref: cp/topics/contexts _CPPv2N6gccjit7context14set_int_optionE18gcc_jit_int_optioni327352
Ref: 1a4327352
Ref: cp/topics/contexts gccjit context set_int_option__gcc_jit_int_option i327352
Ref: 1a5327352
Node: Additional command-line options<2>327647
Ref: cp/topics/contexts additional-command-line-options327758
Ref: 1a6327758
Ref: cp/topics/contexts _CPPv4N6gccjit7context23add_command_line_optionEPKc327839
Ref: 1a7327839
Ref: cp/topics/contexts _CPPv3N6gccjit7context23add_command_line_optionEPKc327839
Ref: 1a8327839
Ref: cp/topics/contexts _CPPv2N6gccjit7context23add_command_line_optionEPKc327839
Ref: 1a9327839
Ref: cp/topics/contexts gccjit context add_command_line_option__cCP327839
Ref: 1aa327839
Node: Objects<2>328320
Ref: cp/topics/objects doc328437
Ref: 1ab328437
Ref: cp/topics/objects objects328437
Ref: 1ac328437
Ref: cp/topics/objects _CPPv4N6gccjit6objectE328466
Ref: 142328466
Ref: cp/topics/objects _CPPv3N6gccjit6objectE328466
Ref: 1ad328466
Ref: cp/topics/objects _CPPv2N6gccjit6objectE328466
Ref: 1ae328466
Ref: cp/topics/objects gccjit object328466
Ref: 1af328466
Ref: cp/topics/objects _CPPv4NK6gccjit6object11get_contextEv329292
Ref: 1b0329292
Ref: cp/topics/objects _CPPv3NK6gccjit6object11get_contextEv329292
Ref: 1b1329292
Ref: cp/topics/objects _CPPv2NK6gccjit6object11get_contextEv329292
Ref: 1b2329292
Ref: cp/topics/objects gccjit object get_contextC329292
Ref: 1b3329292
Ref: cp/topics/objects _CPPv4NK6gccjit6object16get_debug_stringEv329437
Ref: 143329437
Ref: cp/topics/objects _CPPv3NK6gccjit6object16get_debug_stringEv329437
Ref: 1b4329437
Ref: cp/topics/objects _CPPv2NK6gccjit6object16get_debug_stringEv329437
Ref: 1b5329437
Ref: cp/topics/objects gccjit object get_debug_stringC329437
Ref: 1b6329437
Node: Types<2>329753
Ref: cp/topics/types doc329861
Ref: 1b7329861
Ref: cp/topics/types types329861
Ref: 1b8329861
Ref: cp/topics/types _CPPv4N6gccjit4typeE329886
Ref: 13f329886
Ref: cp/topics/types _CPPv3N6gccjit4typeE329886
Ref: 1b9329886
Ref: cp/topics/types _CPPv2N6gccjit4typeE329886
Ref: 1ba329886
Ref: cp/topics/types gccjit type329886
Ref: 1bb329886
Node: Standard types<2>330980
Ref: cp/topics/types standard-types331084
Ref: 1be331084
Ref: cp/topics/types _CPPv4N6gccjit7context8get_typeE13gcc_jit_types331131
Ref: 140331131
Ref: cp/topics/types _CPPv3N6gccjit7context8get_typeE13gcc_jit_types331131
Ref: 1bf331131
Ref: cp/topics/types _CPPv2N6gccjit7context8get_typeE13gcc_jit_types331131
Ref: 1c0331131
Ref: cp/topics/types gccjit context get_type__gcc_jit_types331131
Ref: 1c1331131
Ref: cp/topics/types _CPPv4N6gccjit7context12get_int_typeE6size_ti331384
Ref: 1c2331384
Ref: cp/topics/types _CPPv3N6gccjit7context12get_int_typeE6size_ti331384
Ref: 1c3331384
Ref: cp/topics/types _CPPv2N6gccjit7context12get_int_typeE6size_ti331384
Ref: 1c4331384
Ref: cp/topics/types gccjit context get_int_type__s i331384
Ref: 1c5331384
Ref: cp/topics/types _CPPv4IEN6gccjit7context12get_int_typeI1TEEN6gccjit4typeEv331563
Ref: 1c6331563
Ref: cp/topics/types _CPPv3IEN6gccjit7context12get_int_typeI1TEEv331563
Ref: 1c7331563
Ref: cp/topics/types _CPPv2IEN6gccjit7context12get_int_typeI1TEEv331563
Ref: 1c8331563
Node: Pointers const and volatile<2>331867
Ref: cp/topics/types pointers-const-and-volatile331995
Ref: 1c9331995
Ref: cp/topics/types _CPPv4N6gccjit4type11get_pointerEv332088
Ref: 1bc332088
Ref: cp/topics/types _CPPv3N6gccjit4type11get_pointerEv332088
Ref: 1ca332088
Ref: cp/topics/types _CPPv2N6gccjit4type11get_pointerEv332088
Ref: 1cb332088
Ref: cp/topics/types gccjit type get_pointer332088
Ref: 1cc332088
Ref: cp/topics/types _CPPv4N6gccjit4type9get_constEv332228
Ref: 1bd332228
Ref: cp/topics/types _CPPv3N6gccjit4type9get_constEv332228
Ref: 1cd332228
Ref: cp/topics/types _CPPv2N6gccjit4type9get_constEv332228
Ref: 1ce332228
Ref: cp/topics/types gccjit type get_const332228
Ref: 1cf332228
Ref: cp/topics/types _CPPv4N6gccjit4type12get_volatileEv332371
Ref: 1d0332371
Ref: cp/topics/types _CPPv3N6gccjit4type12get_volatileEv332371
Ref: 1d1332371
Ref: cp/topics/types _CPPv2N6gccjit4type12get_volatileEv332371
Ref: 1d2332371
Ref: cp/topics/types gccjit type get_volatile332371
Ref: 1d3332371
Ref: cp/topics/types _CPPv4N6gccjit4type11get_alignedE6size_t332520
Ref: 1d4332520
Ref: cp/topics/types _CPPv3N6gccjit4type11get_alignedE6size_t332520
Ref: 1d5332520
Ref: cp/topics/types _CPPv2N6gccjit4type11get_alignedE6size_t332520
Ref: 1d6332520
Ref: cp/topics/types gccjit type get_aligned__s332520
Ref: 1d7332520
Ref: cp/topics/types _CPPv4N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE332780
Ref: 1d8332780
Ref: cp/topics/types _CPPv3N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE332780
Ref: 1d9332780
Ref: cp/topics/types _CPPv2N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE332780
Ref: 1da332780
Ref: cp/topics/types gccjit context new_array_type__gccjit type i gccjit location332780
Ref: 1db332780
Node: Vector types<2>333056
Ref: cp/topics/types vector-types333191
Ref: 1dc333191
Ref: cp/topics/types _CPPv4N6gccjit4type10get_vectorE6size_t333234
Ref: 1dd333234
Ref: cp/topics/types _CPPv3N6gccjit4type10get_vectorE6size_t333234
Ref: 1de333234
Ref: cp/topics/types _CPPv2N6gccjit4type10get_vectorE6size_t333234
Ref: 1df333234
Ref: cp/topics/types gccjit type get_vector__s333234
Ref: 1e0333234
Node: Structures and unions<2>333530
Ref: cp/topics/types structures-and-unions333626
Ref: 1e1333626
Ref: cp/topics/types _CPPv4N6gccjit7struct_E333687
Ref: 1e2333687
Ref: cp/topics/types _CPPv3N6gccjit7struct_E333687
Ref: 1e3333687
Ref: cp/topics/types _CPPv2N6gccjit7struct_E333687
Ref: 1e4333687
Ref: cp/topics/types gccjit struct_333687
Ref: 1e5333687
Ref: cp/topics/types _CPPv4N6gccjit5fieldE333888
Ref: 1e6333888
Ref: cp/topics/types _CPPv3N6gccjit5fieldE333888
Ref: 1e7333888
Ref: cp/topics/types _CPPv2N6gccjit5fieldE333888
Ref: 1e8333888
Ref: cp/topics/types gccjit field333888
Ref: 1e9333888
Ref: cp/topics/types _CPPv4N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE335266
Ref: 1ea335266
Ref: cp/topics/types _CPPv3N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE335266
Ref: 1eb335266
Ref: cp/topics/types _CPPv2N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE335266
Ref: 1ec335266
Ref: cp/topics/types gccjit context new_field__gccjit type cCP gccjit location335266
Ref: 1ed335266
Ref: cp/topics/types _CPPv4N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE335489
Ref: 1ee335489
Ref: cp/topics/types _CPPv3N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE335489
Ref: 1ef335489
Ref: cp/topics/types _CPPv2N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE335489
Ref: 1f0335489
Ref: cp/topics/types gccjit context new_struct_type__ssCR std vector field R gccjit location335489
Ref: 1f1335489
Ref: cp/topics/types _CPPv4N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE335749
Ref: 1f2335749
Ref: cp/topics/types _CPPv3N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE335749
Ref: 1f3335749
Ref: cp/topics/types _CPPv2N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE335749
Ref: 1f4335749
Ref: cp/topics/types gccjit context new_opaque_struct__ssCR gccjit location335749
Ref: 1f5335749
Node: Expressions<2>336161
Ref: cp/topics/expressions doc336290
Ref: 1f6336290
Ref: cp/topics/expressions expressions336290
Ref: 1f7336290
Node: Rvalues<2>336473
Ref: cp/topics/expressions rvalues336556
Ref: 1f8336556
Ref: cp/topics/expressions _CPPv4N6gccjit6rvalueE336589
Ref: 146336589
Ref: cp/topics/expressions _CPPv3N6gccjit6rvalueE336589
Ref: 1f9336589
Ref: cp/topics/expressions _CPPv2N6gccjit6rvalueE336589
Ref: 1fa336589
Ref: cp/topics/expressions gccjit rvalue336589
Ref: 1fb336589
Ref: cp/topics/expressions _CPPv4N6gccjit6rvalue8get_typeEv337376
Ref: 1fc337376
Ref: cp/topics/expressions _CPPv3N6gccjit6rvalue8get_typeEv337376
Ref: 1fd337376
Ref: cp/topics/expressions _CPPv2N6gccjit6rvalue8get_typeEv337376
Ref: 1fe337376
Ref: cp/topics/expressions gccjit rvalue get_type337376
Ref: 1ff337376
Node: Simple expressions<2>337835
Ref: cp/topics/expressions simple-expressions337936
Ref: 200337936
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEi337991
Ref: 15a337991
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEi337991
Ref: 201337991
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEi337991
Ref: 202337991
Ref: cp/topics/expressions gccjit context new_rvalue__gccjit type iC337991
Ref: 203337991
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEl338249
Ref: 204338249
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEl338249
Ref: 205338249
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEl338249
Ref: 206338249
Ref: cp/topics/expressions gccjit context new_rvalue__gccjit type lC338249
Ref: 207338249
Ref: cp/topics/expressions _CPPv4NK6gccjit7context4zeroEN6gccjit4typeE338509
Ref: 156338509
Ref: cp/topics/expressions _CPPv3NK6gccjit7context4zeroEN6gccjit4typeE338509
Ref: 208338509
Ref: cp/topics/expressions _CPPv2NK6gccjit7context4zeroEN6gccjit4typeE338509
Ref: 209338509
Ref: cp/topics/expressions gccjit context zero__gccjit typeC338509
Ref: 20a338509
Ref: cp/topics/expressions _CPPv4NK6gccjit7context3oneEN6gccjit4typeE338806
Ref: 20b338806
Ref: cp/topics/expressions _CPPv3NK6gccjit7context3oneEN6gccjit4typeE338806
Ref: 20c338806
Ref: cp/topics/expressions _CPPv2NK6gccjit7context3oneEN6gccjit4typeE338806
Ref: 20d338806
Ref: cp/topics/expressions gccjit context one__gccjit typeC338806
Ref: 20e338806
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEd339101
Ref: 20f339101
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEd339101
Ref: 210339101
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEd339101
Ref: 211339101
Ref: cp/topics/expressions gccjit context new_rvalue__gccjit type doubleC339101
Ref: 212339101
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEPv339375
Ref: 213339375
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEPv339375
Ref: 214339375
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEPv339375
Ref: 215339375
Ref: cp/topics/expressions gccjit context new_rvalue__gccjit type voidPC339375
Ref: 216339375
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueERKNSt6stringE339595
Ref: 217339595
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueERKNSt6stringE339595
Ref: 218339595
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueERKNSt6stringE339595
Ref: 219339595
Ref: cp/topics/expressions gccjit context new_rvalue__ssCRC339595
Ref: 21a339595
Node: Vector expressions<2>339853
Ref: cp/topics/expressions vector-expressions339982
Ref: 21b339982
Ref: cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE340037
Ref: 21c340037
Ref: cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE340037
Ref: 21d340037
Ref: cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE340037
Ref: 21e340037
Ref: cp/topics/expressions gccjit context new_rvalue__gccjit type std vector gccjit rvalue C340037
Ref: 21f340037
Node: Unary Operations<2>340381
Ref: cp/topics/expressions unary-operations340509
Ref: 220340509
Ref: cp/topics/expressions _CPPv4N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE340560
Ref: 221340560
Ref: cp/topics/expressions _CPPv3N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE340560
Ref: 222340560
Ref: cp/topics/expressions _CPPv2N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE340560
Ref: 223340560
Ref: cp/topics/expressions gccjit context new_unary_op__gcc_jit_unary_op gccjit type gccjit rvalue gccjit location340560
Ref: 224340560
Ref: cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE341095
Ref: 225341095
Ref: cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE341095
Ref: 226341095
Ref: cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE341095
Ref: 227341095
Ref: cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit location341095
Ref: 228341095
Ref: cp/topics/expressions _CPPv418new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE341444
Ref: 229341444
Ref: cp/topics/expressions _CPPv318new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE341444
Ref: 22a341444
Ref: cp/topics/expressions _CPPv218new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE341444
Ref: 22b341444
Ref: cp/topics/expressions new_bitwise_negate__gccjit type gccjit rvalue gccjit location341444
Ref: 22c341444
Ref: cp/topics/expressions _CPPv418new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE341812
Ref: 22d341812
Ref: cp/topics/expressions _CPPv318new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE341812
Ref: 22e341812
Ref: cp/topics/expressions _CPPv218new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE341812
Ref: 22f341812
Ref: cp/topics/expressions new_logical_negate__gccjit type gccjit rvalue gccjit location341812
Ref: 230341812
Ref: cp/topics/expressions _CPPv4miN6gccjit6rvalueE342242
Ref: 231342242
Ref: cp/topics/expressions _CPPv3miN6gccjit6rvalueE342242
Ref: 232342242
Ref: cp/topics/expressions _CPPv2miN6gccjit6rvalueE342242
Ref: 233342242
Ref: cp/topics/expressions sub-operator__gccjit rvalue342242
Ref: 234342242
Ref: cp/topics/expressions _CPPv4coN6gccjit6rvalueE342366
Ref: 235342366
Ref: cp/topics/expressions _CPPv3coN6gccjit6rvalueE342366
Ref: 236342366
Ref: cp/topics/expressions _CPPv2coN6gccjit6rvalueE342366
Ref: 237342366
Ref: cp/topics/expressions inv-operator__gccjit rvalue342366
Ref: 238342366
Ref: cp/topics/expressions _CPPv4ntN6gccjit6rvalueE342488
Ref: 239342488
Ref: cp/topics/expressions _CPPv3ntN6gccjit6rvalueE342488
Ref: 23a342488
Ref: cp/topics/expressions _CPPv2ntN6gccjit6rvalueE342488
Ref: 23b342488
Ref: cp/topics/expressions not-operator__gccjit rvalue342488
Ref: 23c342488
Node: Binary Operations<2>342614
Ref: cp/topics/expressions binary-operations342735
Ref: 23d342735
Ref: cp/topics/expressions _CPPv4N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE342788
Ref: 145342788
Ref: cp/topics/expressions _CPPv3N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE342788
Ref: 23e342788
Ref: cp/topics/expressions _CPPv2N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE342788
Ref: 23f342788
Ref: cp/topics/expressions gccjit context new_binary_op__gcc_jit_binary_op gccjit type gccjit rvalue gccjit rvalue gccjit location342788
Ref: 240342788
Ref: cp/topics/expressions _CPPv4N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343360
Ref: 241343360
Ref: cp/topics/expressions _CPPv3N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343360
Ref: 242343360
Ref: cp/topics/expressions _CPPv2N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343360
Ref: 243343360
Ref: cp/topics/expressions gccjit context new_plus__gccjit type gccjit rvalue gccjit rvalue gccjit location343360
Ref: 244343360
Ref: cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343549
Ref: 245343549
Ref: cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343549
Ref: 246343549
Ref: cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343549
Ref: 247343549
Ref: cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit rvalue gccjit location343549
Ref: 248343549
Ref: cp/topics/expressions _CPPv4N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343739
Ref: 249343739
Ref: cp/topics/expressions _CPPv3N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343739
Ref: 24a343739
Ref: cp/topics/expressions _CPPv2N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343739
Ref: 24b343739
Ref: cp/topics/expressions gccjit context new_mult__gccjit type gccjit rvalue gccjit rvalue gccjit location343739
Ref: 24c343739
Ref: cp/topics/expressions _CPPv4N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343928
Ref: 24d343928
Ref: cp/topics/expressions _CPPv3N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343928
Ref: 24e343928
Ref: cp/topics/expressions _CPPv2N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE343928
Ref: 24f343928
Ref: cp/topics/expressions gccjit context new_divide__gccjit type gccjit rvalue gccjit rvalue gccjit location343928
Ref: 250343928
Ref: cp/topics/expressions _CPPv4N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344119
Ref: 251344119
Ref: cp/topics/expressions _CPPv3N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344119
Ref: 252344119
Ref: cp/topics/expressions _CPPv2N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344119
Ref: 253344119
Ref: cp/topics/expressions gccjit context new_modulo__gccjit type gccjit rvalue gccjit rvalue gccjit location344119
Ref: 254344119
Ref: cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344310
Ref: 255344310
Ref: cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344310
Ref: 256344310
Ref: cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344310
Ref: 257344310
Ref: cp/topics/expressions gccjit context new_bitwise_and__gccjit type gccjit rvalue gccjit rvalue gccjit location344310
Ref: 258344310
Ref: cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344506
Ref: 259344506
Ref: cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344506
Ref: 25a344506
Ref: cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344506
Ref: 25b344506
Ref: cp/topics/expressions gccjit context new_bitwise_xor__gccjit type gccjit rvalue gccjit rvalue gccjit location344506
Ref: 25c344506
Ref: cp/topics/expressions _CPPv4N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344702
Ref: 25d344702
Ref: cp/topics/expressions _CPPv3N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344702
Ref: 25e344702
Ref: cp/topics/expressions _CPPv2N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344702
Ref: 25f344702
Ref: cp/topics/expressions gccjit context new_bitwise_or__gccjit type gccjit rvalue gccjit rvalue gccjit location344702
Ref: 260344702
Ref: cp/topics/expressions _CPPv4N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344897
Ref: 261344897
Ref: cp/topics/expressions _CPPv3N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344897
Ref: 262344897
Ref: cp/topics/expressions _CPPv2N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE344897
Ref: 263344897
Ref: cp/topics/expressions gccjit context new_logical_and__gccjit type gccjit rvalue gccjit rvalue gccjit location344897
Ref: 264344897
Ref: cp/topics/expressions _CPPv4N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE345093
Ref: 265345093
Ref: cp/topics/expressions _CPPv3N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE345093
Ref: 266345093
Ref: cp/topics/expressions _CPPv2N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE345093
Ref: 267345093
Ref: cp/topics/expressions gccjit context new_logical_or__gccjit type gccjit rvalue gccjit rvalue gccjit location345093
Ref: 268345093
Ref: cp/topics/expressions _CPPv4plN6gccjit6rvalueEN6gccjit6rvalueE345354
Ref: 269345354
Ref: cp/topics/expressions _CPPv3plN6gccjit6rvalueEN6gccjit6rvalueE345354
Ref: 26a345354
Ref: cp/topics/expressions _CPPv2plN6gccjit6rvalueEN6gccjit6rvalueE345354
Ref: 26b345354
Ref: cp/topics/expressions add-operator__gccjit rvalue gccjit rvalue345354
Ref: 26c345354
Ref: cp/topics/expressions _CPPv4miN6gccjit6rvalueEN6gccjit6rvalueE345496
Ref: 26d345496
Ref: cp/topics/expressions _CPPv3miN6gccjit6rvalueEN6gccjit6rvalueE345496
Ref: 26e345496
Ref: cp/topics/expressions _CPPv2miN6gccjit6rvalueEN6gccjit6rvalueE345496
Ref: 26f345496
Ref: cp/topics/expressions sub-operator__gccjit rvalue gccjit rvalue345496
Ref: 270345496
Ref: cp/topics/expressions _CPPv4mlN6gccjit6rvalueEN6gccjit6rvalueE345639
Ref: 271345639
Ref: cp/topics/expressions _CPPv3mlN6gccjit6rvalueEN6gccjit6rvalueE345639
Ref: 272345639
Ref: cp/topics/expressions _CPPv2mlN6gccjit6rvalueEN6gccjit6rvalueE345639
Ref: 273345639
Ref: cp/topics/expressions mul-operator__gccjit rvalue gccjit rvalue345639
Ref: 274345639
Ref: cp/topics/expressions _CPPv4dvN6gccjit6rvalueEN6gccjit6rvalueE345782
Ref: 275345782
Ref: cp/topics/expressions _CPPv3dvN6gccjit6rvalueEN6gccjit6rvalueE345782
Ref: 276345782
Ref: cp/topics/expressions _CPPv2dvN6gccjit6rvalueEN6gccjit6rvalueE345782
Ref: 277345782
Ref: cp/topics/expressions div-operator__gccjit rvalue gccjit rvalue345782
Ref: 278345782
Ref: cp/topics/expressions _CPPv4rmN6gccjit6rvalueEN6gccjit6rvalueE345927
Ref: 279345927
Ref: cp/topics/expressions _CPPv3rmN6gccjit6rvalueEN6gccjit6rvalueE345927
Ref: 27a345927
Ref: cp/topics/expressions _CPPv2rmN6gccjit6rvalueEN6gccjit6rvalueE345927
Ref: 27b345927
Ref: cp/topics/expressions mod-operator__gccjit rvalue gccjit rvalue345927
Ref: 27c345927
Ref: cp/topics/expressions _CPPv4anN6gccjit6rvalueEN6gccjit6rvalueE346069
Ref: 27d346069
Ref: cp/topics/expressions _CPPv3anN6gccjit6rvalueEN6gccjit6rvalueE346069
Ref: 27e346069
Ref: cp/topics/expressions _CPPv2anN6gccjit6rvalueEN6gccjit6rvalueE346069
Ref: 27f346069
Ref: cp/topics/expressions and-operator__gccjit rvalue gccjit rvalue346069
Ref: 280346069
Ref: cp/topics/expressions _CPPv4eoN6gccjit6rvalueEN6gccjit6rvalueE346209
Ref: 281346209
Ref: cp/topics/expressions _CPPv3eoN6gccjit6rvalueEN6gccjit6rvalueE346209
Ref: 282346209
Ref: cp/topics/expressions _CPPv2eoN6gccjit6rvalueEN6gccjit6rvalueE346209
Ref: 283346209
Ref: cp/topics/expressions xor-operator__gccjit rvalue gccjit rvalue346209
Ref: 284346209
Ref: cp/topics/expressions _CPPv4orN6gccjit6rvalueEN6gccjit6rvalueE346349
Ref: 285346349
Ref: cp/topics/expressions _CPPv3orN6gccjit6rvalueEN6gccjit6rvalueE346349
Ref: 286346349
Ref: cp/topics/expressions _CPPv2orN6gccjit6rvalueEN6gccjit6rvalueE346349
Ref: 287346349
Ref: cp/topics/expressions or-operator__gccjit rvalue gccjit rvalue346349
Ref: 288346349
Ref: cp/topics/expressions _CPPv4aaN6gccjit6rvalueEN6gccjit6rvalueE346489
Ref: 289346489
Ref: cp/topics/expressions _CPPv3aaN6gccjit6rvalueEN6gccjit6rvalueE346489
Ref: 28a346489
Ref: cp/topics/expressions _CPPv2aaN6gccjit6rvalueEN6gccjit6rvalueE346489
Ref: 28b346489
Ref: cp/topics/expressions sand-operator__gccjit rvalue gccjit rvalue346489
Ref: 28c346489
Ref: cp/topics/expressions _CPPv4ooN6gccjit6rvalueEN6gccjit6rvalueE346634
Ref: 28d346634
Ref: cp/topics/expressions _CPPv3ooN6gccjit6rvalueEN6gccjit6rvalueE346634
Ref: 28e346634
Ref: cp/topics/expressions _CPPv2ooN6gccjit6rvalueEN6gccjit6rvalueE346634
Ref: 28f346634
Ref: cp/topics/expressions sor-operator__gccjit rvalue gccjit rvalue346634
Ref: 290346634
Node: Comparisons<2>346930
Ref: cp/topics/expressions comparisons347049
Ref: 291347049
Ref: cp/topics/expressions _CPPv4N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347090
Ref: 157347090
Ref: cp/topics/expressions _CPPv3N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347090
Ref: 292347090
Ref: cp/topics/expressions _CPPv2N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347090
Ref: 293347090
Ref: cp/topics/expressions gccjit context new_comparison__gcc_jit_comparison gccjit rvalue gccjit rvalue gccjit location347090
Ref: 294347090
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347641
Ref: 295347641
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347641
Ref: 296347641
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347641
Ref: 297347641
Ref: cp/topics/expressions gccjit context new_eq__gccjit rvalue gccjit rvalue gccjit location347641
Ref: 298347641
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347802
Ref: 299347802
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347802
Ref: 29a347802
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347802
Ref: 29b347802
Ref: cp/topics/expressions gccjit context new_ne__gccjit rvalue gccjit rvalue gccjit location347802
Ref: 29c347802
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347963
Ref: 29d347963
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347963
Ref: 29e347963
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE347963
Ref: 29f347963
Ref: cp/topics/expressions gccjit context new_lt__gccjit rvalue gccjit rvalue gccjit location347963
Ref: 2a0347963
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE348124
Ref: 2a1348124
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE348124
Ref: 2a2348124
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE348124
Ref: 2a3348124
Ref: cp/topics/expressions gccjit context new_le__gccjit rvalue gccjit rvalue gccjit location348124
Ref: 2a4348124
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE348285
Ref: 2a5348285
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE348285
Ref: 2a6348285
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE348285
Ref: 2a7348285
Ref: cp/topics/expressions gccjit context new_gt__gccjit rvalue gccjit rvalue gccjit location348285
Ref: 2a8348285
Ref: cp/topics/expressions _CPPv4N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE348446
Ref: 2a9348446
Ref: cp/topics/expressions _CPPv3N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE348446
Ref: 2aa348446
Ref: cp/topics/expressions _CPPv2N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE348446
Ref: 2ab348446
Ref: cp/topics/expressions gccjit context new_ge__gccjit rvalue gccjit rvalue gccjit location348446
Ref: 2ac348446
Ref: cp/topics/expressions _CPPv4eqN6gccjit6rvalueEN6gccjit6rvalueE348673
Ref: 2ad348673
Ref: cp/topics/expressions _CPPv3eqN6gccjit6rvalueEN6gccjit6rvalueE348673
Ref: 2ae348673
Ref: cp/topics/expressions _CPPv2eqN6gccjit6rvalueEN6gccjit6rvalueE348673
Ref: 2af348673
Ref: cp/topics/expressions eq-operator__gccjit rvalue gccjit rvalue348673
Ref: 2b0348673
Ref: cp/topics/expressions _CPPv4neN6gccjit6rvalueEN6gccjit6rvalueE348836
Ref: 2b1348836
Ref: cp/topics/expressions _CPPv3neN6gccjit6rvalueEN6gccjit6rvalueE348836
Ref: 2b2348836
Ref: cp/topics/expressions _CPPv2neN6gccjit6rvalueEN6gccjit6rvalueE348836
Ref: 2b3348836
Ref: cp/topics/expressions neq-operator__gccjit rvalue gccjit rvalue348836
Ref: 2b4348836
Ref: cp/topics/expressions _CPPv4ltN6gccjit6rvalueEN6gccjit6rvalueE348983
Ref: 2b5348983
Ref: cp/topics/expressions _CPPv3ltN6gccjit6rvalueEN6gccjit6rvalueE348983
Ref: 2b6348983
Ref: cp/topics/expressions _CPPv2ltN6gccjit6rvalueEN6gccjit6rvalueE348983
Ref: 2b7348983
Ref: cp/topics/expressions lt-operator__gccjit rvalue gccjit rvalue348983
Ref: 2b8348983
Ref: cp/topics/expressions _CPPv4leN6gccjit6rvalueEN6gccjit6rvalueE349126
Ref: 2b9349126
Ref: cp/topics/expressions _CPPv3leN6gccjit6rvalueEN6gccjit6rvalueE349126
Ref: 2ba349126
Ref: cp/topics/expressions _CPPv2leN6gccjit6rvalueEN6gccjit6rvalueE349126
Ref: 2bb349126
Ref: cp/topics/expressions lte-operator__gccjit rvalue gccjit rvalue349126
Ref: 2bc349126
Ref: cp/topics/expressions _CPPv4gtN6gccjit6rvalueEN6gccjit6rvalueE349271
Ref: 2bd349271
Ref: cp/topics/expressions _CPPv3gtN6gccjit6rvalueEN6gccjit6rvalueE349271
Ref: 2be349271
Ref: cp/topics/expressions _CPPv2gtN6gccjit6rvalueEN6gccjit6rvalueE349271
Ref: 2bf349271
Ref: cp/topics/expressions gt-operator__gccjit rvalue gccjit rvalue349271
Ref: 2c0349271
Ref: cp/topics/expressions _CPPv4geN6gccjit6rvalueEN6gccjit6rvalueE349421
Ref: 2c1349421
Ref: cp/topics/expressions _CPPv3geN6gccjit6rvalueEN6gccjit6rvalueE349421
Ref: 2c2349421
Ref: cp/topics/expressions _CPPv2geN6gccjit6rvalueEN6gccjit6rvalueE349421
Ref: 2c3349421
Ref: cp/topics/expressions gte-operator__gccjit rvalue gccjit rvalue349421
Ref: 2c4349421
Node: Function calls<2>349599
Ref: cp/topics/expressions function-calls349718
Ref: 2c5349718
Ref: cp/topics/expressions _CPPv424gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue349765
Ref: 2c6349765
Ref: cp/topics/expressions _CPPv324gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue349765
Ref: 2c7349765
Ref: cp/topics/expressions _CPPv224gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue349765
Ref: 2c8349765
Ref: cp/topics/expressions gcc_jit_context_new_call__gcc_jit_contextP gcc_jit_locationP gcc_jit_functionP i gcc_jit_rvaluePP349765
Ref: 2c9349765
Node: Function pointers<3>350734
Ref: cp/topics/expressions function-pointers350855
Ref: 2cb350855
Ref: cp/topics/expressions _CPPv4N6gccjit8function11get_addressEN6gccjit8locationE350908
Ref: 2cc350908
Ref: cp/topics/expressions _CPPv3N6gccjit8function11get_addressEN6gccjit8locationE350908
Ref: 2cd350908
Ref: cp/topics/expressions _CPPv2N6gccjit8function11get_addressEN6gccjit8locationE350908
Ref: 2ce350908
Ref: cp/topics/expressions gccjit function get_address__gccjit location350908
Ref: 2cf350908
Node: Type-coercion<2>351110
Ref: cp/topics/expressions type-coercion351205
Ref: 2d0351205
Ref: cp/topics/expressions _CPPv4N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE351250
Ref: 2d1351250
Ref: cp/topics/expressions _CPPv3N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE351250
Ref: 2d2351250
Ref: cp/topics/expressions _CPPv2N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE351250
Ref: 2d3351250
Ref: cp/topics/expressions gccjit context new_cast__gccjit rvalue gccjit type gccjit location351250
Ref: 2d4351250
Node: Lvalues<2>351665
Ref: cp/topics/expressions lvalues351800
Ref: 2d5351800
Ref: cp/topics/expressions _CPPv4N6gccjit6lvalueE351835
Ref: 14f351835
Ref: cp/topics/expressions _CPPv3N6gccjit6lvalueE351835
Ref: 2d6351835
Ref: cp/topics/expressions _CPPv2N6gccjit6lvalueE351835
Ref: 2d7351835
Ref: cp/topics/expressions gccjit lvalue351835
Ref: 2d8351835
Ref: cp/topics/expressions _CPPv4N6gccjit6lvalue11get_addressEN6gccjit8locationE352163
Ref: 2d9352163
Ref: cp/topics/expressions _CPPv3N6gccjit6lvalue11get_addressEN6gccjit8locationE352163
Ref: 2da352163
Ref: cp/topics/expressions _CPPv2N6gccjit6lvalue11get_addressEN6gccjit8locationE352163
Ref: 2db352163
Ref: cp/topics/expressions gccjit lvalue get_address__gccjit location352163
Ref: 2dc352163
Node: Global variables<2>352454
Ref: cp/topics/expressions global-variables352523
Ref: 2dd352523
Ref: cp/topics/expressions _CPPv4N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE352576
Ref: 2de352576
Ref: cp/topics/expressions _CPPv3N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE352576
Ref: 2df352576
Ref: cp/topics/expressions _CPPv2N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE352576
Ref: 2e0352576
Ref: cp/topics/expressions gccjit context new_global__gcc_jit_global_kind gccjit type cCP gccjit location352576
Ref: 2e1352576
Node: Working with pointers structs and unions<2>353006
Ref: cp/topics/expressions working-with-pointers-structs-and-unions353122
Ref: 2e2353122
Ref: cp/topics/expressions _CPPv4N6gccjit6rvalue11dereferenceEN6gccjit8locationE353225
Ref: 2e3353225
Ref: cp/topics/expressions _CPPv3N6gccjit6rvalue11dereferenceEN6gccjit8locationE353225
Ref: 2e4353225
Ref: cp/topics/expressions _CPPv2N6gccjit6rvalue11dereferenceEN6gccjit8locationE353225
Ref: 2e5353225
Ref: cp/topics/expressions gccjit rvalue dereference__gccjit location353225
Ref: 2e6353225
Ref: cp/topics/expressions _CPPv4N6gccjit6rvaluemlEv353648
Ref: 2e7353648
Ref: cp/topics/expressions _CPPv3N6gccjit6rvaluemlEv353648
Ref: 2e8353648
Ref: cp/topics/expressions _CPPv2N6gccjit6rvaluemlEv353648
Ref: 2e9353648
Ref: cp/topics/expressions gccjit rvalue mul-operator353648
Ref: 2ea353648
Ref: cp/topics/expressions _CPPv4N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE353854
Ref: 2eb353854
Ref: cp/topics/expressions _CPPv3N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE353854
Ref: 2ec353854
Ref: cp/topics/expressions _CPPv2N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE353854
Ref: 2ed353854
Ref: cp/topics/expressions gccjit lvalue access_field__gccjit field gccjit location353854
Ref: 2ee353854
Ref: cp/topics/expressions _CPPv4N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE354170
Ref: 2ef354170
Ref: cp/topics/expressions _CPPv3N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE354170
Ref: 2f0354170
Ref: cp/topics/expressions _CPPv2N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE354170
Ref: 2f1354170
Ref: cp/topics/expressions gccjit rvalue access_field__gccjit field gccjit location354170
Ref: 2f2354170
Ref: cp/topics/expressions _CPPv4N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE354451
Ref: 2f3354451
Ref: cp/topics/expressions _CPPv3N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE354451
Ref: 2f4354451
Ref: cp/topics/expressions _CPPv2N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE354451
Ref: 2f5354451
Ref: cp/topics/expressions gccjit rvalue dereference_field__gccjit field gccjit location354451
Ref: 2f6354451
Ref: cp/topics/expressions _CPPv4N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354827
Ref: 2f7354827
Ref: cp/topics/expressions _CPPv3N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354827
Ref: 2f8354827
Ref: cp/topics/expressions _CPPv2N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE354827
Ref: 2f9354827
Ref: cp/topics/expressions gccjit context new_array_access__gccjit rvalue gccjit rvalue gccjit location354827
Ref: 2fa354827
Node: Creating and using functions<2>355700
Ref: cp/topics/functions doc355840
Ref: 2fb355840
Ref: cp/topics/functions creating-and-using-functions355840
Ref: 2fc355840
Node: Params<2>356019
Ref: cp/topics/functions params356120
Ref: 2fd356120
Ref: cp/topics/functions _CPPv4N6gccjit5paramE356151
Ref: 150356151
Ref: cp/topics/functions _CPPv3N6gccjit5paramE356151
Ref: 2fe356151
Ref: cp/topics/functions _CPPv2N6gccjit5paramE356151
Ref: 2ff356151
Ref: cp/topics/functions gccjit param356151
Ref: 300356151
Ref: cp/topics/functions _CPPv4N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE356247
Ref: 144356247
Ref: cp/topics/functions _CPPv3N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE356247
Ref: 301356247
Ref: cp/topics/functions _CPPv2N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE356247
Ref: 302356247
Ref: cp/topics/functions gccjit context new_param__gccjit type cCP gccjit location356247
Ref: 303356247
Node: Functions<2>356726
Ref: cp/topics/functions functions356845
Ref: 304356845
Ref: cp/topics/functions _CPPv4N6gccjit8functionE356882
Ref: 154356882
Ref: cp/topics/functions _CPPv3N6gccjit8functionE356882
Ref: 305356882
Ref: cp/topics/functions _CPPv2N6gccjit8functionE356882
Ref: 306356882
Ref: cp/topics/functions gccjit function356882
Ref: 307356882
Ref: cp/topics/functions _CPPv4N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE357052
Ref: 308357052
Ref: cp/topics/functions _CPPv3N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE357052
Ref: 309357052
Ref: cp/topics/functions _CPPv2N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE357052
Ref: 30a357052
Ref: cp/topics/functions gccjit context new_function__gcc_jit_function_kind gccjit type cCP std vector param R i gccjit location357052
Ref: 30b357052
Ref: cp/topics/functions _CPPv4N6gccjit7context20get_builtin_functionEPKc357535
Ref: 30c357535
Ref: cp/topics/functions _CPPv3N6gccjit7context20get_builtin_functionEPKc357535
Ref: 30d357535
Ref: cp/topics/functions _CPPv2N6gccjit7context20get_builtin_functionEPKc357535
Ref: 30e357535
Ref: cp/topics/functions gccjit context get_builtin_function__cCP357535
Ref: 30f357535
Ref: cp/topics/functions _CPPv4NK6gccjit8function9get_paramEi357762
Ref: 310357762
Ref: cp/topics/functions _CPPv3NK6gccjit8function9get_paramEi357762
Ref: 311357762
Ref: cp/topics/functions _CPPv2NK6gccjit8function9get_paramEi357762
Ref: 312357762
Ref: cp/topics/functions gccjit function get_param__iC357762
Ref: 313357762
Ref: cp/topics/functions _CPPv4N6gccjit8function11dump_to_dotEPKc357925
Ref: 15c357925
Ref: cp/topics/functions _CPPv3N6gccjit8function11dump_to_dotEPKc357925
Ref: 314357925
Ref: cp/topics/functions _CPPv2N6gccjit8function11dump_to_dotEPKc357925
Ref: 315357925
Ref: cp/topics/functions gccjit function dump_to_dot__cCP357925
Ref: 316357925
Ref: cp/topics/functions _CPPv4N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE358082
Ref: 151358082
Ref: cp/topics/functions _CPPv3N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE358082
Ref: 317358082
Ref: cp/topics/functions _CPPv2N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE358082
Ref: 318358082
Ref: cp/topics/functions gccjit function new_local__gccjit type cCP gccjit location358082
Ref: 319358082
Node: Blocks<2>358336
Ref: cp/topics/functions blocks358459
Ref: 31a358459
Ref: cp/topics/functions _CPPv4N6gccjit5blockE358490
Ref: 153358490
Ref: cp/topics/functions _CPPv3N6gccjit5blockE358490
Ref: 31b358490
Ref: cp/topics/functions _CPPv2N6gccjit5blockE358490
Ref: 31c358490
Ref: cp/topics/functions gccjit block358490
Ref: 31d358490
Ref: cp/topics/functions _CPPv4N6gccjit8function9new_blockEPKc359086
Ref: 31e359086
Ref: cp/topics/functions _CPPv3N6gccjit8function9new_blockEPKc359086
Ref: 31f359086
Ref: cp/topics/functions _CPPv2N6gccjit8function9new_blockEPKc359086
Ref: 320359086
Ref: cp/topics/functions gccjit function new_block__cCP359086
Ref: 321359086
Node: Statements<2>359427
Ref: cp/topics/functions statements359529
Ref: 322359529
Ref: cp/topics/functions _CPPv4N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE359568
Ref: 2ca359568
Ref: cp/topics/functions _CPPv3N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE359568
Ref: 323359568
Ref: cp/topics/functions _CPPv2N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE359568
Ref: 324359568
Ref: cp/topics/functions gccjit block add_eval__gccjit rvalue gccjit location359568
Ref: 325359568
Ref: cp/topics/functions _CPPv4N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE359865
Ref: 155359865
Ref: cp/topics/functions _CPPv3N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE359865
Ref: 326359865
Ref: cp/topics/functions _CPPv2N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE359865
Ref: 327359865
Ref: cp/topics/functions gccjit block add_assignment__gccjit lvalue gccjit rvalue gccjit location359865
Ref: 328359865
Ref: cp/topics/functions _CPPv4N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE360179
Ref: 159360179
Ref: cp/topics/functions _CPPv3N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE360179
Ref: 329360179
Ref: cp/topics/functions _CPPv2N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE360179
Ref: 32a360179
Ref: cp/topics/functions gccjit block add_assignment_op__gccjit lvalue gcc_jit_binary_op gccjit rvalue gccjit location360179
Ref: 32b360179
Ref: cp/topics/functions _CPPv4N6gccjit5block11add_commentEPKcN6gccjit8locationE360741
Ref: 165360741
Ref: cp/topics/functions _CPPv3N6gccjit5block11add_commentEPKcN6gccjit8locationE360741
Ref: 32c360741
Ref: cp/topics/functions _CPPv2N6gccjit5block11add_commentEPKcN6gccjit8locationE360741
Ref: 32d360741
Ref: cp/topics/functions gccjit block add_comment__cCP gccjit location360741
Ref: 32e360741
Ref: cp/topics/functions _CPPv4N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE361290
Ref: 158361290
Ref: cp/topics/functions _CPPv3N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE361290
Ref: 32f361290
Ref: cp/topics/functions _CPPv2N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE361290
Ref: 330361290
Ref: cp/topics/functions gccjit block end_with_conditional__gccjit rvalue gccjit block gccjit block gccjit location361290
Ref: 331361290
Ref: cp/topics/functions _CPPv4N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE361803
Ref: 332361803
Ref: cp/topics/functions _CPPv3N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE361803
Ref: 333361803
Ref: cp/topics/functions _CPPv2N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE361803
Ref: 334361803
Ref: cp/topics/functions gccjit block end_with_jump__gccjit block gccjit location361803
Ref: 335361803
Ref: cp/topics/functions _CPPv4N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE362064
Ref: 336362064
Ref: cp/topics/functions _CPPv3N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE362064
Ref: 337362064
Ref: cp/topics/functions _CPPv2N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE362064
Ref: 338362064
Ref: cp/topics/functions gccjit block end_with_return__gccjit rvalue gccjit location362064
Ref: 339362064
Ref: cp/topics/functions _CPPv4N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE362789
Ref: 33a362789
Ref: cp/topics/functions _CPPv3N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE362789
Ref: 33b362789
Ref: cp/topics/functions _CPPv2N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE362789
Ref: 33c362789
Ref: cp/topics/functions gccjit block end_with_switch__gccjit rvalue gccjit block std vector gccjit case_ gccjit location362789
Ref: 33d362789
Node: Source Locations<2>367782
Ref: cp/topics/locations doc367930
Ref: 33e367930
Ref: cp/topics/locations source-locations367930
Ref: 33f367930
Ref: cp/topics/locations _CPPv4N6gccjit8locationE367977
Ref: 163367977
Ref: cp/topics/locations _CPPv3N6gccjit8locationE367977
Ref: 340367977
Ref: cp/topics/locations _CPPv2N6gccjit8locationE367977
Ref: 341367977
Ref: cp/topics/locations gccjit location367977
Ref: 342367977
Ref: cp/topics/locations _CPPv4N6gccjit7context12new_locationEPKcii368709
Ref: 169368709
Ref: cp/topics/locations _CPPv3N6gccjit7context12new_locationEPKcii368709
Ref: 343368709
Ref: cp/topics/locations _CPPv2N6gccjit7context12new_locationEPKcii368709
Ref: 344368709
Ref: cp/topics/locations gccjit context new_location__cCP i i368709
Ref: 345368709
Node: Faking it<2>368993
Ref: cp/topics/locations faking-it369064
Ref: 346369064
Node: Compiling a context<2>369701
Ref: cp/topics/compilation doc369858
Ref: 347369858
Ref: cp/topics/compilation compiling-a-context369858
Ref: 348369858
Node: In-memory compilation<2>370410
Ref: cp/topics/compilation in-memory-compilation370533
Ref: 34a370533
Ref: cp/topics/compilation _CPPv4N6gccjit7context7compileEv370594
Ref: 147370594
Ref: cp/topics/compilation _CPPv3N6gccjit7context7compileEv370594
Ref: 34b370594
Ref: cp/topics/compilation _CPPv2N6gccjit7context7compileEv370594
Ref: 34c370594
Ref: cp/topics/compilation gccjit context compile370594
Ref: 34d370594
Node: Ahead-of-time compilation<2>370865
Ref: cp/topics/compilation ahead-of-time-compilation370988
Ref: 34e370988
Ref: cp/topics/compilation _CPPv4N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc371267
Ref: 349371267
Ref: cp/topics/compilation _CPPv3N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc371267
Ref: 34f371267
Ref: cp/topics/compilation _CPPv2N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc371267
Ref: 350371267
Ref: cp/topics/compilation gccjit context compile_to_file__gcc_jit_output_kind cCP371267
Ref: 351371267
Node: Using Assembly Language with libgccjit++371584
Ref: cp/topics/asm doc371713
Ref: 352371713
Ref: cp/topics/asm using-assembly-language-with-libgccjit371713
Ref: 353371713
Ref: Using Assembly Language with libgccjit++-Footnote-1372520
Node: Adding assembler instructions within a function<2>372600
Ref: cp/topics/asm adding-assembler-instructions-within-a-function372779
Ref: 354372779
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asmE372892
Ref: 355372892
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asmE372892
Ref: 356372892
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asmE372892
Ref: 357372892
Ref: cp/topics/asm gccjit extended_asm372892
Ref: 358372892
Ref: cp/topics/asm _CPPv4N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE375347
Ref: 359375347
Ref: cp/topics/asm _CPPv3N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE375347
Ref: 35d375347
Ref: cp/topics/asm _CPPv2N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE375347
Ref: 35e375347
Ref: cp/topics/asm gccjit block add_extended_asm__ssCR gccjit location375347
Ref: 35f375347
Ref: cp/topics/asm _CPPv4N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location375947
Ref: 35a375947
Ref: cp/topics/asm _CPPv3N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location375947
Ref: 360375947
Ref: cp/topics/asm _CPPv2N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location375947
Ref: 361375947
Ref: cp/topics/asm gccjit block end_with_extended_asm_goto__ssCR std vector block blockP location375947
Ref: 362375947
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm17set_volatile_flagEb378196
Ref: 363378196
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm17set_volatile_flagEb378196
Ref: 364378196
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm17set_volatile_flagEb378196
Ref: 365378196
Ref: cp/topics/asm gccjit extended_asm set_volatile_flag__b378196
Ref: 366378196
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm15set_inline_flagEb379352
Ref: 367379352
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm15set_inline_flagEb379352
Ref: 368379352
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm15set_inline_flagEb379352
Ref: 369379352
Ref: cp/topics/asm gccjit extended_asm set_inline_flag__b379352
Ref: 36a379352
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE379570
Ref: 35b379570
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE379570
Ref: 36b379570
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE379570
Ref: 36c379570
Ref: cp/topics/asm gccjit extended_asm add_output_operand__ssCR ssCR gccjit lvalue379570
Ref: 36d379570
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE380783
Ref: 36e380783
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE380783
Ref: 36f380783
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE380783
Ref: 370380783
Ref: cp/topics/asm gccjit extended_asm add_output_operand__ssCR gccjit lvalue380783
Ref: 371380783
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE381174
Ref: 35c381174
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE381174
Ref: 372381174
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE381174
Ref: 373381174
Ref: cp/topics/asm gccjit extended_asm add_input_operand__ssCR ssCR gccjit rvalue381174
Ref: 374381174
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE382130
Ref: 375382130
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE382130
Ref: 376382130
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE382130
Ref: 377382130
Ref: cp/topics/asm gccjit extended_asm add_input_operand__ssCR gccjit rvalue382130
Ref: 378382130
Ref: cp/topics/asm _CPPv4N6gccjit12extended_asm11add_clobberERKNSt6stringE382516
Ref: 379382516
Ref: cp/topics/asm _CPPv3N6gccjit12extended_asm11add_clobberERKNSt6stringE382516
Ref: 37a382516
Ref: cp/topics/asm _CPPv2N6gccjit12extended_asm11add_clobberERKNSt6stringE382516
Ref: 37b382516
Ref: cp/topics/asm gccjit extended_asm add_clobber__ssCR382516
Ref: 37c382516
Ref: Adding assembler instructions within a function<2>-Footnote-1383074
Ref: Adding assembler instructions within a function<2>-Footnote-2383144
Ref: Adding assembler instructions within a function<2>-Footnote-3383223
Ref: Adding assembler instructions within a function<2>-Footnote-4383300
Ref: Adding assembler instructions within a function<2>-Footnote-5383372
Ref: Adding assembler instructions within a function<2>-Footnote-6383448
Node: Adding top-level assembler statements<2>383542
Ref: cp/topics/asm adding-top-level-assembler-statements383721
Ref: 37d383721
Ref: cp/topics/asm _CPPv4N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE383983
Ref: 37e383983
Ref: cp/topics/asm _CPPv3N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE383983
Ref: 37f383983
Ref: cp/topics/asm _CPPv2N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE383983
Ref: 380383983
Ref: cp/topics/asm gccjit context add_top_level_asm__cCP gccjit location383983
Ref: 381383983
Node: Internals385190
Ref: internals/index doc385304
Ref: 382385304
Ref: internals/index internals385304
Ref: 383385304
Node: Working on the JIT library385514
Ref: internals/index working-on-the-jit-library385620
Ref: 384385620
Ref: internals/index cmdoption-enable-host-shared386512
Ref: 385386512
Ref: internals/index cmdoption-enable-languages386732
Ref: 386386732
Ref: internals/index cmdoption-disable-bootstrap387269
Ref: 387387269
Ref: internals/index cmdoption-enable-checking387569
Ref: 388387569
Node: Running the test suite387835
Ref: internals/index running-the-test-suite387971
Ref: 389387971
Node: Running under valgrind389029
Ref: internals/index running-under-valgrind389113
Ref: 38a389113
Ref: Running under valgrind-Footnote-1390691
Ref: Running under valgrind-Footnote-2390719
Ref: Running under valgrind-Footnote-3390774
Node: Environment variables390844
Ref: internals/index environment-variables390969
Ref: 38b390969
Ref: internals/index envvar-LD_LIBRARY_PATH391130
Ref: 38c391130
Ref: internals/index envvar-PATH391743
Ref: 38d391743
Ref: internals/index envvar-LIBRARY_PATH392399
Ref: 38e392399
Node: Packaging notes393358
Ref: internals/index packaging-notes393487
Ref: 38f393487
Node: Overview of code structure394870
Ref: internals/index overview-of-code-structure394990
Ref: 390394990
Ref: internals/index example-of-log-file411580
Ref: 5c411580
Node: Design notes422671
Ref: internals/index design-notes422794
Ref: 391422794
Node: Submitting patches423323
Ref: internals/index submitting-patches423411
Ref: 392423411
Ref: Submitting patches-Footnote-1427989
Node: Indices and tables428020
Ref: index indices-and-tables428113
Ref: 393428113
Node: Index428195

End Tag Table


Local Variables:
coding: utf-8
End:
