1 /* A pure C API to enable client code to embed GCC as a JIT-compiler.
2 Copyright (C) 2013-2021 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
27 #endif /* __cplusplus */
29 /**********************************************************************
31 **********************************************************************/
32 /* All structs within the API are opaque. */
34 /* A gcc_jit_context encapsulates the state of a compilation.
35 You can set up options on it, and add types, functions and code, using
38 Invoking gcc_jit_context_compile on it gives you a gcc_jit_result *
39 (or NULL), representing in-memory machine code.
41 You can call gcc_jit_context_compile repeatedly on one context, giving
42 multiple independent results.
44 Similarly, you can call gcc_jit_context_compile_to_file on a context
47 Eventually you can call gcc_jit_context_release to clean up the
48 context; any in-memory results created from it are still usable, and
49 should be cleaned up via gcc_jit_result_release. */
50 typedef struct gcc_jit_context gcc_jit_context
;
52 /* A gcc_jit_result encapsulates the result of an in-memory compilation. */
53 typedef struct gcc_jit_result gcc_jit_result
;
55 /* An object created within a context. Such objects are automatically
56 cleaned up when the context is released.
58 The class hierarchy looks like this:
64 +- gcc_jit_function_type
65 +- gcc_jit_vector_type
73 +- gcc_jit_extended_asm
75 typedef struct gcc_jit_object gcc_jit_object
;
77 /* A gcc_jit_location encapsulates a source code location, so that
78 you can (optionally) associate locations in your language with
79 statements in the JIT-compiled code, allowing the debugger to
80 single-step through your language.
82 Note that to do so, you also need to enable
83 GCC_JIT_BOOL_OPTION_DEBUGINFO
84 on the gcc_jit_context.
86 gcc_jit_location instances are optional; you can always pass
88 typedef struct gcc_jit_location gcc_jit_location
;
90 /* A gcc_jit_type encapsulates a type e.g. "int" or a "struct foo*". */
91 typedef struct gcc_jit_type gcc_jit_type
;
93 /* A gcc_jit_field encapsulates a field within a struct; it is used
94 when creating a struct type (using gcc_jit_context_new_struct_type).
95 Fields cannot be shared between structs. */
96 typedef struct gcc_jit_field gcc_jit_field
;
98 /* A gcc_jit_struct encapsulates a struct type, either one that we have
99 the layout for, or an opaque type. */
100 typedef struct gcc_jit_struct gcc_jit_struct
;
102 /* A gcc_jit_function_type encapsulates a function type. */
103 typedef struct gcc_jit_function_type gcc_jit_function_type
;
105 /* A gcc_jit_vector_type encapsulates a vector type. */
106 typedef struct gcc_jit_vector_type gcc_jit_vector_type
;
108 /* A gcc_jit_function encapsulates a function: either one that you're
109 creating yourself, or a reference to one that you're dynamically
110 linking to within the rest of the process. */
111 typedef struct gcc_jit_function gcc_jit_function
;
113 /* A gcc_jit_block encapsulates a "basic block" of statements within a
114 function (i.e. with one entry point and one exit point).
116 Every block within a function must be terminated with a conditional,
117 a branch, or a return.
119 The blocks within a function form a directed graph.
121 The entrypoint to the function is the first block created within
124 All of the blocks in a function must be reachable via some path from
127 It's OK to have more than one "return" from a function (i.e. multiple
128 blocks that terminate by returning). */
129 typedef struct gcc_jit_block gcc_jit_block
;
131 /* A gcc_jit_rvalue is an expression within your code, with some type. */
132 typedef struct gcc_jit_rvalue gcc_jit_rvalue
;
134 /* A gcc_jit_lvalue is a storage location within your code (e.g. a
135 variable, a parameter, etc). It is also a gcc_jit_rvalue; use
136 gcc_jit_lvalue_as_rvalue to cast. */
137 typedef struct gcc_jit_lvalue gcc_jit_lvalue
;
139 /* A gcc_jit_param is a function parameter, used when creating a
140 gcc_jit_function. It is also a gcc_jit_lvalue (and thus also an
141 rvalue); use gcc_jit_param_as_lvalue to convert. */
142 typedef struct gcc_jit_param gcc_jit_param
;
144 /* A gcc_jit_case is for use when building multiway branches via
145 gcc_jit_block_end_with_switch and represents a range of integer
146 values (or an individual integer value) together with an associated
147 destination block. */
148 typedef struct gcc_jit_case gcc_jit_case
;
150 /* A gcc_jit_extended_asm represents an assembly language statement,
151 analogous to an extended "asm" statement in GCC's C front-end: a series
152 of low-level instructions inside a function that convert inputs to
154 typedef struct gcc_jit_extended_asm gcc_jit_extended_asm
;
156 /* Acquire a JIT-compilation context. */
157 extern gcc_jit_context
*
158 gcc_jit_context_acquire (void);
160 /* Release the context. After this call, it's no longer valid to use
163 gcc_jit_context_release (gcc_jit_context
*ctxt
);
165 /* Options present in the initial release of libgccjit.
166 These were handled using enums. */
168 /* Options taking string values. */
169 enum gcc_jit_str_option
171 /* The name of the program, for use as a prefix when printing error
172 messages to stderr. If NULL, or default, "libgccjit.so" is used. */
173 GCC_JIT_STR_OPTION_PROGNAME
,
175 GCC_JIT_NUM_STR_OPTIONS
178 /* Options taking int values. */
179 enum gcc_jit_int_option
181 /* How much to optimize the code.
182 Valid values are 0-3, corresponding to GCC's command-line options
185 The default value is 0 (unoptimized). */
186 GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL
,
188 GCC_JIT_NUM_INT_OPTIONS
191 /* Options taking boolean values.
192 These all default to "false". */
193 enum gcc_jit_bool_option
195 /* If true, gcc_jit_context_compile will attempt to do the right
196 thing so that if you attach a debugger to the process, it will
197 be able to inspect variables and step through your code.
199 Note that you can't step through code unless you set up source
200 location information for the code (by creating and passing in
201 gcc_jit_location instances). */
202 GCC_JIT_BOOL_OPTION_DEBUGINFO
,
204 /* If true, gcc_jit_context_compile will dump its initial "tree"
205 representation of your code to stderr (before any
207 GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE
,
209 /* If true, gcc_jit_context_compile will dump the "gimple"
210 representation of your code to stderr, before any optimizations
211 are performed. The dump resembles C code. */
212 GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE
,
214 /* If true, gcc_jit_context_compile will dump the final
215 generated code to stderr, in the form of assembly language. */
216 GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE
,
218 /* If true, gcc_jit_context_compile will print information to stderr
219 on the actions it is performing, followed by a profile showing
220 the time taken and memory usage of each phase.
222 GCC_JIT_BOOL_OPTION_DUMP_SUMMARY
,
224 /* If true, gcc_jit_context_compile will dump copious
225 amount of information on what it's doing to various
226 files within a temporary directory. Use
227 GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES (see below) to
228 see the results. The files are intended to be human-readable,
229 but the exact files and their formats are subject to change.
231 GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING
,
233 /* If true, libgccjit will aggressively run its garbage collector, to
234 shake out bugs (greatly slowing down the compile). This is likely
235 to only be of interest to developers *of* the library. It is
236 used when running the selftest suite. */
237 GCC_JIT_BOOL_OPTION_SELFCHECK_GC
,
239 /* If true, gcc_jit_context_release will not clean up
240 intermediate files written to the filesystem, and will display
241 their location on stderr. */
242 GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES
,
244 GCC_JIT_NUM_BOOL_OPTIONS
247 /* Set a string option on the given context.
249 The context takes a copy of the string, so the
250 (const char *) buffer is not needed anymore after the call
253 gcc_jit_context_set_str_option (gcc_jit_context
*ctxt
,
254 enum gcc_jit_str_option opt
,
257 /* Set an int option on the given context. */
259 gcc_jit_context_set_int_option (gcc_jit_context
*ctxt
,
260 enum gcc_jit_int_option opt
,
263 /* Set a boolean option on the given context.
265 Zero is "false" (the default), non-zero is "true". */
267 gcc_jit_context_set_bool_option (gcc_jit_context
*ctxt
,
268 enum gcc_jit_bool_option opt
,
271 /* Options added after the initial release of libgccjit.
272 These are handled by providing an entrypoint per option,
273 rather than by extending the enum gcc_jit_*_option,
274 so that client code that use these new options can be identified
275 from binary metadata. */
277 /* By default, libgccjit will issue an error about unreachable blocks
280 This option can be used to disable that error.
282 This entrypoint was added in LIBGCCJIT_ABI_2; you can test for
284 #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_allow_unreachable_blocks
288 gcc_jit_context_set_bool_allow_unreachable_blocks (gcc_jit_context
*ctxt
,
291 /* Pre-canned feature macro to indicate the presence of
292 gcc_jit_context_set_bool_allow_unreachable_blocks. This can be
293 tested for with #ifdef. */
294 #define LIBGCCJIT_HAVE_gcc_jit_context_set_bool_allow_unreachable_blocks
296 /* Implementation detail:
297 libgccjit internally generates assembler, and uses "driver" code
298 for converting it to other formats (e.g. shared libraries).
300 By default, libgccjit will use an embedded copy of the driver
303 This option can be used to instead invoke an external driver executable
306 This entrypoint was added in LIBGCCJIT_ABI_5; you can test for
308 #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_use_external_driver
312 gcc_jit_context_set_bool_use_external_driver (gcc_jit_context
*ctxt
,
315 /* Pre-canned feature macro to indicate the presence of
316 gcc_jit_context_set_bool_use_external_driver. This can be
317 tested for with #ifdef. */
318 #define LIBGCCJIT_HAVE_gcc_jit_context_set_bool_use_external_driver
320 /* Add an arbitrary gcc command-line option to the context.
321 The context takes a copy of the string, so the
322 (const char *) optname is not needed anymore after the call
325 Note that only some options are likely to be meaningful; there is no
326 "frontend" within libgccjit, so typically only those affecting
327 optimization and code-generation are likely to be useful.
329 This entrypoint was added in LIBGCCJIT_ABI_1; you can test for
331 #ifdef LIBGCCJIT_HAVE_gcc_jit_context_add_command_line_option
335 gcc_jit_context_add_command_line_option (gcc_jit_context
*ctxt
,
336 const char *optname
);
338 /* Pre-canned feature-test macro for detecting the presence of
339 gcc_jit_context_add_command_line_option within libgccjit.h. */
341 #define LIBGCCJIT_HAVE_gcc_jit_context_add_command_line_option
343 /* Add an arbitrary gcc driver option to the context.
344 The context takes a copy of the string, so the
345 (const char *) optname is not needed anymore after the call
348 Note that only some options are likely to be meaningful; there is no
349 "frontend" within libgccjit, so typically only those affecting
350 assembler and linker are likely to be useful.
352 This entrypoint was added in LIBGCCJIT_ABI_11; you can test for
354 #ifdef LIBGCCJIT_HAVE_gcc_jit_context_add_driver_option
357 gcc_jit_context_add_driver_option (gcc_jit_context
*ctxt
,
358 const char *optname
);
360 /* Pre-canned feature-test macro for detecting the presence of
361 gcc_jit_context_add_driver_option within libgccjit.h. */
363 #define LIBGCCJIT_HAVE_gcc_jit_context_add_driver_option
365 /* Compile the context to in-memory machine code.
367 This can be called more that once on a given context,
368 although any errors that occur will block further compilation. */
370 extern gcc_jit_result
*
371 gcc_jit_context_compile (gcc_jit_context
*ctxt
);
373 /* Kinds of ahead-of-time compilation, for use with
374 gcc_jit_context_compile_to_file. */
376 enum gcc_jit_output_kind
378 /* Compile the context to an assembler file. */
379 GCC_JIT_OUTPUT_KIND_ASSEMBLER
,
381 /* Compile the context to an object file. */
382 GCC_JIT_OUTPUT_KIND_OBJECT_FILE
,
384 /* Compile the context to a dynamic library. */
385 GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY
,
387 /* Compile the context to an executable. */
388 GCC_JIT_OUTPUT_KIND_EXECUTABLE
391 /* Compile the context to a file of the given kind.
393 This can be called more that once on a given context,
394 although any errors that occur will block further compilation. */
397 gcc_jit_context_compile_to_file (gcc_jit_context
*ctxt
,
398 enum gcc_jit_output_kind output_kind
,
399 const char *output_path
);
401 /* To help with debugging: dump a C-like representation to the given path,
402 describing what's been set up on the context.
404 If "update_locations" is true, then also set up gcc_jit_location
405 information throughout the context, pointing at the dump file as if it
406 were a source file. This may be of use in conjunction with
407 GCC_JIT_BOOL_OPTION_DEBUGINFO to allow stepping through the code in a
410 gcc_jit_context_dump_to_file (gcc_jit_context
*ctxt
,
412 int update_locations
);
414 /* To help with debugging; enable ongoing logging of the context's
415 activity to the given FILE *.
417 The caller remains responsible for closing "logfile".
419 Params "flags" and "verbosity" are reserved for future use, and
420 must both be 0 for now. */
422 gcc_jit_context_set_logfile (gcc_jit_context
*ctxt
,
427 /* To be called after any API call, this gives the first error message
428 that occurred on the context.
430 The returned string is valid for the rest of the lifetime of the
433 If no errors occurred, this will be NULL. */
435 gcc_jit_context_get_first_error (gcc_jit_context
*ctxt
);
437 /* To be called after any API call, this gives the last error message
438 that occurred on the context.
440 If no errors occurred, this will be NULL.
442 If non-NULL, the returned string is only guaranteed to be valid until
443 the next call to libgccjit relating to this context. */
445 gcc_jit_context_get_last_error (gcc_jit_context
*ctxt
);
447 /* Locate a given function within the built machine code.
448 This will need to be cast to a function pointer of the
449 correct type before it can be called. */
451 gcc_jit_result_get_code (gcc_jit_result
*result
,
452 const char *funcname
);
454 /* Locate a given global within the built machine code.
455 It must have been created using GCC_JIT_GLOBAL_EXPORTED.
456 This is a ptr to the global, so e.g. for an int this is an int *. */
458 gcc_jit_result_get_global (gcc_jit_result
*result
,
461 /* Once we're done with the code, this unloads the built .so file.
462 This cleans up the result; after calling this, it's no longer
463 valid to use the result. */
465 gcc_jit_result_release (gcc_jit_result
*result
);
468 /**********************************************************************
469 Functions for creating "contextual" objects.
471 All objects created by these functions share the lifetime of the context
472 they are created within, and are automatically cleaned up for you when
473 you call gcc_jit_context_release on the context.
475 Note that this means you can't use references to them after you've
476 released their context.
478 All (const char *) string arguments passed to these functions are
479 copied, so you don't need to keep them around.
481 You create code by adding a sequence of statements to blocks.
482 **********************************************************************/
484 /**********************************************************************
485 The base class of "contextual" object.
486 **********************************************************************/
487 /* Which context is "obj" within? */
488 extern gcc_jit_context
*
489 gcc_jit_object_get_context (gcc_jit_object
*obj
);
491 /* Get a human-readable description of this object.
492 The string buffer is created the first time this is called on a given
493 object, and persists until the object's context is released. */
495 gcc_jit_object_get_debug_string (gcc_jit_object
*obj
);
497 /**********************************************************************
498 Debugging information.
499 **********************************************************************/
501 /* Creating source code locations for use by the debugger.
502 Line and column numbers are 1-based. */
503 extern gcc_jit_location
*
504 gcc_jit_context_new_location (gcc_jit_context
*ctxt
,
505 const char *filename
,
509 /* Upcasting from location to object. */
510 extern gcc_jit_object
*
511 gcc_jit_location_as_object (gcc_jit_location
*loc
);
514 /**********************************************************************
516 **********************************************************************/
518 /* Upcasting from type to object. */
519 extern gcc_jit_object
*
520 gcc_jit_type_as_object (gcc_jit_type
*type
);
522 /* Access to specific types. */
525 /* C's "void" type. */
529 GCC_JIT_TYPE_VOID_PTR
,
531 /* C++'s bool type; also C99's "_Bool" type, aka "bool" if using
535 /* Various integer types. */
537 /* C's "char" (of some signedness) and the variants where the
538 signedness is specified. */
540 GCC_JIT_TYPE_SIGNED_CHAR
,
541 GCC_JIT_TYPE_UNSIGNED_CHAR
,
543 /* C's "short" and "unsigned short". */
544 GCC_JIT_TYPE_SHORT
, /* signed */
545 GCC_JIT_TYPE_UNSIGNED_SHORT
,
547 /* C's "int" and "unsigned int". */
548 GCC_JIT_TYPE_INT
, /* signed */
549 GCC_JIT_TYPE_UNSIGNED_INT
,
551 /* C's "long" and "unsigned long". */
552 GCC_JIT_TYPE_LONG
, /* signed */
553 GCC_JIT_TYPE_UNSIGNED_LONG
,
555 /* C99's "long long" and "unsigned long long". */
556 GCC_JIT_TYPE_LONG_LONG
, /* signed */
557 GCC_JIT_TYPE_UNSIGNED_LONG_LONG
,
559 /* Floating-point types */
563 GCC_JIT_TYPE_LONG_DOUBLE
,
565 /* C type: (const char *). */
566 GCC_JIT_TYPE_CONST_CHAR_PTR
,
568 /* The C "size_t" type. */
571 /* C type: (FILE *) */
572 GCC_JIT_TYPE_FILE_PTR
,
574 /* Complex numbers. */
575 GCC_JIT_TYPE_COMPLEX_FLOAT
,
576 GCC_JIT_TYPE_COMPLEX_DOUBLE
,
577 GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE
581 extern gcc_jit_type
*
582 gcc_jit_context_get_type (gcc_jit_context
*ctxt
,
583 enum gcc_jit_types type_
);
585 /* Get the integer type of the given size and signedness. */
586 extern gcc_jit_type
*
587 gcc_jit_context_get_int_type (gcc_jit_context
*ctxt
,
588 int num_bytes
, int is_signed
);
590 /* Constructing new types. */
592 /* Given type "T", get type "T*". */
593 extern gcc_jit_type
*
594 gcc_jit_type_get_pointer (gcc_jit_type
*type
);
596 /* Given type "T", get type "const T". */
597 extern gcc_jit_type
*
598 gcc_jit_type_get_const (gcc_jit_type
*type
);
600 /* Given type "T", get type "volatile T". */
601 extern gcc_jit_type
*
602 gcc_jit_type_get_volatile (gcc_jit_type
*type
);
604 /* Given type "T", get type "T[N]" (for a constant N). */
605 extern gcc_jit_type
*
606 gcc_jit_context_new_array_type (gcc_jit_context
*ctxt
,
607 gcc_jit_location
*loc
,
608 gcc_jit_type
*element_type
,
611 /* Struct-handling. */
613 /* Create a field, for use within a struct or union. */
614 extern gcc_jit_field
*
615 gcc_jit_context_new_field (gcc_jit_context
*ctxt
,
616 gcc_jit_location
*loc
,
620 #define LIBGCCJIT_HAVE_gcc_jit_context_new_bitfield
622 /* Create a bit field, for use within a struct or union.
624 This API entrypoint was added in LIBGCCJIT_ABI_12; you can test for its
626 #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_bitfield
628 extern gcc_jit_field
*
629 gcc_jit_context_new_bitfield (gcc_jit_context
*ctxt
,
630 gcc_jit_location
*loc
,
635 /* Upcasting from field to object. */
636 extern gcc_jit_object
*
637 gcc_jit_field_as_object (gcc_jit_field
*field
);
639 /* Create a struct type from an array of fields. */
640 extern gcc_jit_struct
*
641 gcc_jit_context_new_struct_type (gcc_jit_context
*ctxt
,
642 gcc_jit_location
*loc
,
645 gcc_jit_field
**fields
);
647 /* Create an opaque struct type. */
648 extern gcc_jit_struct
*
649 gcc_jit_context_new_opaque_struct (gcc_jit_context
*ctxt
,
650 gcc_jit_location
*loc
,
653 /* Upcast a struct to a type. */
654 extern gcc_jit_type
*
655 gcc_jit_struct_as_type (gcc_jit_struct
*struct_type
);
657 /* Populating the fields of a formerly-opaque struct type.
658 This can only be called once on a given struct type. */
660 gcc_jit_struct_set_fields (gcc_jit_struct
*struct_type
,
661 gcc_jit_location
*loc
,
663 gcc_jit_field
**fields
);
665 /* Get a field by index. */
666 extern gcc_jit_field
*
667 gcc_jit_struct_get_field (gcc_jit_struct
*struct_type
,
670 /* Get the number of fields. */
672 gcc_jit_struct_get_field_count (gcc_jit_struct
*struct_type
);
674 /* Unions work similarly to structs. */
675 extern gcc_jit_type
*
676 gcc_jit_context_new_union_type (gcc_jit_context
*ctxt
,
677 gcc_jit_location
*loc
,
680 gcc_jit_field
**fields
);
682 /* Function pointers. */
684 extern gcc_jit_type
*
685 gcc_jit_context_new_function_ptr_type (gcc_jit_context
*ctxt
,
686 gcc_jit_location
*loc
,
687 gcc_jit_type
*return_type
,
689 gcc_jit_type
**param_types
,
692 /**********************************************************************
693 Constructing functions.
694 **********************************************************************/
695 /* Create a function param. */
696 extern gcc_jit_param
*
697 gcc_jit_context_new_param (gcc_jit_context
*ctxt
,
698 gcc_jit_location
*loc
,
702 /* Upcasting from param to object. */
703 extern gcc_jit_object
*
704 gcc_jit_param_as_object (gcc_jit_param
*param
);
706 /* Upcasting from param to lvalue. */
707 extern gcc_jit_lvalue
*
708 gcc_jit_param_as_lvalue (gcc_jit_param
*param
);
710 /* Upcasting from param to rvalue. */
711 extern gcc_jit_rvalue
*
712 gcc_jit_param_as_rvalue (gcc_jit_param
*param
);
714 /* Kinds of function. */
715 enum gcc_jit_function_kind
717 /* Function is defined by the client code and visible
718 by name outside of the JIT. */
719 GCC_JIT_FUNCTION_EXPORTED
,
721 /* Function is defined by the client code, but is invisible
722 outside of the JIT. Analogous to a "static" function. */
723 GCC_JIT_FUNCTION_INTERNAL
,
725 /* Function is not defined by the client code; we're merely
726 referring to it. Analogous to using an "extern" function from a
728 GCC_JIT_FUNCTION_IMPORTED
,
730 /* Function is only ever inlined into other functions, and is
731 invisible outside of the JIT.
733 Analogous to prefixing with "inline" and adding
734 __attribute__((always_inline)).
736 Inlining will only occur when the optimization level is
737 above 0; when optimization is off, this is essentially the
738 same as GCC_JIT_FUNCTION_INTERNAL. */
739 GCC_JIT_FUNCTION_ALWAYS_INLINE
742 /* Thread local storage model. */
743 enum gcc_jit_tls_model
745 GCC_JIT_TLS_MODEL_NONE
,
746 GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC
,
747 GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC
,
748 GCC_JIT_TLS_MODEL_INITIAL_EXEC
,
749 GCC_JIT_TLS_MODEL_LOCAL_EXEC
,
752 /* Create a function. */
753 extern gcc_jit_function
*
754 gcc_jit_context_new_function (gcc_jit_context
*ctxt
,
755 gcc_jit_location
*loc
,
756 enum gcc_jit_function_kind kind
,
757 gcc_jit_type
*return_type
,
760 gcc_jit_param
**params
,
763 /* Create a reference to a builtin function (sometimes called
764 intrinsic functions). */
765 extern gcc_jit_function
*
766 gcc_jit_context_get_builtin_function (gcc_jit_context
*ctxt
,
769 /* Upcasting from function to object. */
770 extern gcc_jit_object
*
771 gcc_jit_function_as_object (gcc_jit_function
*func
);
773 /* Get a specific param of a function by index. */
774 extern gcc_jit_param
*
775 gcc_jit_function_get_param (gcc_jit_function
*func
, int index
);
777 /* Emit the function in graphviz format. */
779 gcc_jit_function_dump_to_dot (gcc_jit_function
*func
,
784 The name can be NULL, or you can give it a meaningful name, which
785 may show up in dumps of the internal representation, and in error
787 extern gcc_jit_block
*
788 gcc_jit_function_new_block (gcc_jit_function
*func
,
791 /* Upcasting from block to object. */
792 extern gcc_jit_object
*
793 gcc_jit_block_as_object (gcc_jit_block
*block
);
795 /* Which function is this block within? */
796 extern gcc_jit_function
*
797 gcc_jit_block_get_function (gcc_jit_block
*block
);
799 /**********************************************************************
800 lvalues, rvalues and expressions.
801 **********************************************************************/
802 enum gcc_jit_global_kind
804 /* Global is defined by the client code and visible
805 by name outside of this JIT context via gcc_jit_result_get_global. */
806 GCC_JIT_GLOBAL_EXPORTED
,
808 /* Global is defined by the client code, but is invisible
809 outside of this JIT context. Analogous to a "static" global. */
810 GCC_JIT_GLOBAL_INTERNAL
,
812 /* Global is not defined by the client code; we're merely
813 referring to it. Analogous to using an "extern" global from a
815 GCC_JIT_GLOBAL_IMPORTED
818 extern gcc_jit_lvalue
*
819 gcc_jit_context_new_global (gcc_jit_context
*ctxt
,
820 gcc_jit_location
*loc
,
821 enum gcc_jit_global_kind kind
,
825 #define LIBGCCJIT_HAVE_gcc_jit_global_set_initializer
827 /* Set an initial value for a global, which must be an array of
828 integral type. Return the global itself.
830 This API entrypoint was added in LIBGCCJIT_ABI_14; you can test for its
832 #ifdef LIBGCCJIT_HAVE_gcc_jit_global_set_initializer
835 extern gcc_jit_lvalue
*
836 gcc_jit_global_set_initializer (gcc_jit_lvalue
*global
,
841 extern gcc_jit_object
*
842 gcc_jit_lvalue_as_object (gcc_jit_lvalue
*lvalue
);
844 extern gcc_jit_rvalue
*
845 gcc_jit_lvalue_as_rvalue (gcc_jit_lvalue
*lvalue
);
847 extern gcc_jit_object
*
848 gcc_jit_rvalue_as_object (gcc_jit_rvalue
*rvalue
);
850 extern gcc_jit_type
*
851 gcc_jit_rvalue_get_type (gcc_jit_rvalue
*rvalue
);
853 /* Integer constants. */
854 extern gcc_jit_rvalue
*
855 gcc_jit_context_new_rvalue_from_int (gcc_jit_context
*ctxt
,
856 gcc_jit_type
*numeric_type
,
859 extern gcc_jit_rvalue
*
860 gcc_jit_context_new_rvalue_from_long (gcc_jit_context
*ctxt
,
861 gcc_jit_type
*numeric_type
,
864 extern gcc_jit_rvalue
*
865 gcc_jit_context_zero (gcc_jit_context
*ctxt
,
866 gcc_jit_type
*numeric_type
);
868 extern gcc_jit_rvalue
*
869 gcc_jit_context_one (gcc_jit_context
*ctxt
,
870 gcc_jit_type
*numeric_type
);
872 /* Floating-point constants. */
873 extern gcc_jit_rvalue
*
874 gcc_jit_context_new_rvalue_from_double (gcc_jit_context
*ctxt
,
875 gcc_jit_type
*numeric_type
,
879 extern gcc_jit_rvalue
*
880 gcc_jit_context_new_rvalue_from_ptr (gcc_jit_context
*ctxt
,
881 gcc_jit_type
*pointer_type
,
884 extern gcc_jit_rvalue
*
885 gcc_jit_context_null (gcc_jit_context
*ctxt
,
886 gcc_jit_type
*pointer_type
);
888 /* String literals. */
889 extern gcc_jit_rvalue
*
890 gcc_jit_context_new_string_literal (gcc_jit_context
*ctxt
,
893 enum gcc_jit_unary_op
895 /* Negate an arithmetic value; analogous to:
898 GCC_JIT_UNARY_OP_MINUS
,
900 /* Bitwise negation of an integer value (one's complement); analogous
904 GCC_JIT_UNARY_OP_BITWISE_NEGATE
,
906 /* Logical negation of an arithmetic or pointer value; analogous to:
909 GCC_JIT_UNARY_OP_LOGICAL_NEGATE
,
911 /* Absolute value of an arithmetic expression; analogous to:
918 extern gcc_jit_rvalue
*
919 gcc_jit_context_new_unary_op (gcc_jit_context
*ctxt
,
920 gcc_jit_location
*loc
,
921 enum gcc_jit_unary_op op
,
922 gcc_jit_type
*result_type
,
923 gcc_jit_rvalue
*rvalue
);
925 enum gcc_jit_binary_op
927 /* Addition of arithmetic values; analogous to:
930 For pointer addition, use gcc_jit_context_new_array_access. */
931 GCC_JIT_BINARY_OP_PLUS
,
933 /* Subtraction of arithmetic values; analogous to:
936 GCC_JIT_BINARY_OP_MINUS
,
938 /* Multiplication of a pair of arithmetic values; analogous to:
941 GCC_JIT_BINARY_OP_MULT
,
943 /* Quotient of division of arithmetic values; analogous to:
946 The result type affects the kind of division: if the result type is
947 integer-based, then the result is truncated towards zero, whereas
948 a floating-point result type indicates floating-point division. */
949 GCC_JIT_BINARY_OP_DIVIDE
,
951 /* Remainder of division of arithmetic values; analogous to:
954 GCC_JIT_BINARY_OP_MODULO
,
956 /* Bitwise AND; analogous to:
959 GCC_JIT_BINARY_OP_BITWISE_AND
,
961 /* Bitwise exclusive OR; analogous to:
964 GCC_JIT_BINARY_OP_BITWISE_XOR
,
966 /* Bitwise inclusive OR; analogous to:
969 GCC_JIT_BINARY_OP_BITWISE_OR
,
971 /* Logical AND; analogous to:
974 GCC_JIT_BINARY_OP_LOGICAL_AND
,
976 /* Logical OR; analogous to:
979 GCC_JIT_BINARY_OP_LOGICAL_OR
,
981 /* Left shift; analogous to:
984 GCC_JIT_BINARY_OP_LSHIFT
,
986 /* Right shift; analogous to:
989 GCC_JIT_BINARY_OP_RSHIFT
992 extern gcc_jit_rvalue
*
993 gcc_jit_context_new_binary_op (gcc_jit_context
*ctxt
,
994 gcc_jit_location
*loc
,
995 enum gcc_jit_binary_op op
,
996 gcc_jit_type
*result_type
,
997 gcc_jit_rvalue
*a
, gcc_jit_rvalue
*b
);
999 /* (Comparisons are treated as separate from "binary_op" to save
1000 you having to specify the result_type). */
1002 enum gcc_jit_comparison
1004 /* (EXPR_A) == (EXPR_B). */
1005 GCC_JIT_COMPARISON_EQ
,
1007 /* (EXPR_A) != (EXPR_B). */
1008 GCC_JIT_COMPARISON_NE
,
1010 /* (EXPR_A) < (EXPR_B). */
1011 GCC_JIT_COMPARISON_LT
,
1013 /* (EXPR_A) <=(EXPR_B). */
1014 GCC_JIT_COMPARISON_LE
,
1016 /* (EXPR_A) > (EXPR_B). */
1017 GCC_JIT_COMPARISON_GT
,
1019 /* (EXPR_A) >= (EXPR_B). */
1020 GCC_JIT_COMPARISON_GE
1023 extern gcc_jit_rvalue
*
1024 gcc_jit_context_new_comparison (gcc_jit_context
*ctxt
,
1025 gcc_jit_location
*loc
,
1026 enum gcc_jit_comparison op
,
1027 gcc_jit_rvalue
*a
, gcc_jit_rvalue
*b
);
1029 /* Function calls. */
1031 /* Call of a specific function. */
1032 extern gcc_jit_rvalue
*
1033 gcc_jit_context_new_call (gcc_jit_context
*ctxt
,
1034 gcc_jit_location
*loc
,
1035 gcc_jit_function
*func
,
1036 int numargs
, gcc_jit_rvalue
**args
);
1038 /* Call through a function pointer. */
1039 extern gcc_jit_rvalue
*
1040 gcc_jit_context_new_call_through_ptr (gcc_jit_context
*ctxt
,
1041 gcc_jit_location
*loc
,
1042 gcc_jit_rvalue
*fn_ptr
,
1043 int numargs
, gcc_jit_rvalue
**args
);
1047 Currently only a limited set of conversions are possible:
1050 extern gcc_jit_rvalue
*
1051 gcc_jit_context_new_cast (gcc_jit_context
*ctxt
,
1052 gcc_jit_location
*loc
,
1053 gcc_jit_rvalue
*rvalue
,
1054 gcc_jit_type
*type
);
1056 extern gcc_jit_lvalue
*
1057 gcc_jit_context_new_array_access (gcc_jit_context
*ctxt
,
1058 gcc_jit_location
*loc
,
1059 gcc_jit_rvalue
*ptr
,
1060 gcc_jit_rvalue
*index
);
1062 /* Field access is provided separately for both lvalues and rvalues. */
1064 /* Accessing a field of an lvalue of struct type, analogous to:
1067 extern gcc_jit_lvalue
*
1068 gcc_jit_lvalue_access_field (gcc_jit_lvalue
*struct_or_union
,
1069 gcc_jit_location
*loc
,
1070 gcc_jit_field
*field
);
1072 /* Accessing a field of an rvalue of struct type, analogous to:
1075 extern gcc_jit_rvalue
*
1076 gcc_jit_rvalue_access_field (gcc_jit_rvalue
*struct_or_union
,
1077 gcc_jit_location
*loc
,
1078 gcc_jit_field
*field
);
1080 /* Accessing a field of an rvalue of pointer type, analogous to:
1082 in C, itself equivalent to (*EXPR).FIELD */
1083 extern gcc_jit_lvalue
*
1084 gcc_jit_rvalue_dereference_field (gcc_jit_rvalue
*ptr
,
1085 gcc_jit_location
*loc
,
1086 gcc_jit_field
*field
);
1088 /* Dereferencing a pointer; analogous to:
1091 extern gcc_jit_lvalue
*
1092 gcc_jit_rvalue_dereference (gcc_jit_rvalue
*rvalue
,
1093 gcc_jit_location
*loc
);
1095 /* Taking the address of an lvalue; analogous to:
1098 extern gcc_jit_rvalue
*
1099 gcc_jit_lvalue_get_address (gcc_jit_lvalue
*lvalue
,
1100 gcc_jit_location
*loc
);
1102 #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model
1104 /* Set the thread-local storage model of a global variable
1106 This API entrypoint was added in LIBGCCJIT_ABI_17; you can test for its
1108 #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model */
1110 gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue
*lvalue
,
1111 enum gcc_jit_tls_model model
);
1113 #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section
1115 /* Set the link section of a global variable; analogous to:
1116 __attribute__((section(".section_name")))
1119 This API entrypoint was added in LIBGCCJIT_ABI_18; you can test for its
1121 #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section
1124 gcc_jit_lvalue_set_link_section (gcc_jit_lvalue
*lvalue
,
1125 const char *section_name
);
1127 extern gcc_jit_lvalue
*
1128 gcc_jit_function_new_local (gcc_jit_function
*func
,
1129 gcc_jit_location
*loc
,
1133 /**********************************************************************
1135 **********************************************************************/
1137 /* Add evaluation of an rvalue, discarding the result
1138 (e.g. a function call that "returns" void).
1140 This is equivalent to this C code:
1145 gcc_jit_block_add_eval (gcc_jit_block
*block
,
1146 gcc_jit_location
*loc
,
1147 gcc_jit_rvalue
*rvalue
);
1149 /* Add evaluation of an rvalue, assigning the result to the given
1152 This is roughly equivalent to this C code:
1157 gcc_jit_block_add_assignment (gcc_jit_block
*block
,
1158 gcc_jit_location
*loc
,
1159 gcc_jit_lvalue
*lvalue
,
1160 gcc_jit_rvalue
*rvalue
);
1162 /* Add evaluation of an rvalue, using the result to modify an
1165 This is analogous to "+=" and friends:
1172 gcc_jit_block_add_assignment_op (gcc_jit_block
*block
,
1173 gcc_jit_location
*loc
,
1174 gcc_jit_lvalue
*lvalue
,
1175 enum gcc_jit_binary_op op
,
1176 gcc_jit_rvalue
*rvalue
);
1178 /* Add a no-op textual comment to the internal representation of the
1179 code. It will be optimized away, but will be visible in the dumps
1181 GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE
1183 GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE,
1184 and thus may be of use when debugging how your project's internal
1185 representation gets converted to the libgccjit IR. */
1187 gcc_jit_block_add_comment (gcc_jit_block
*block
,
1188 gcc_jit_location
*loc
,
1191 /* Terminate a block by adding evaluation of an rvalue, branching on the
1192 result to the appropriate successor block.
1194 This is roughly equivalent to this C code:
1201 block, boolval, on_true, and on_false must be non-NULL. */
1203 gcc_jit_block_end_with_conditional (gcc_jit_block
*block
,
1204 gcc_jit_location
*loc
,
1205 gcc_jit_rvalue
*boolval
,
1206 gcc_jit_block
*on_true
,
1207 gcc_jit_block
*on_false
);
1209 /* Terminate a block by adding a jump to the given target block.
1211 This is roughly equivalent to this C code:
1216 gcc_jit_block_end_with_jump (gcc_jit_block
*block
,
1217 gcc_jit_location
*loc
,
1218 gcc_jit_block
*target
);
1220 /* Terminate a block by adding evaluation of an rvalue, returning the value.
1222 This is roughly equivalent to this C code:
1227 gcc_jit_block_end_with_return (gcc_jit_block
*block
,
1228 gcc_jit_location
*loc
,
1229 gcc_jit_rvalue
*rvalue
);
1231 /* Terminate a block by adding a valueless return, for use within a function
1232 with "void" return type.
1234 This is equivalent to this C code:
1239 gcc_jit_block_end_with_void_return (gcc_jit_block
*block
,
1240 gcc_jit_location
*loc
);
1242 /* Create a new gcc_jit_case instance for use in a switch statement.
1243 min_value and max_value must be constants of integer type.
1245 This API entrypoint was added in LIBGCCJIT_ABI_3; you can test for its
1247 #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1249 extern gcc_jit_case
*
1250 gcc_jit_context_new_case (gcc_jit_context
*ctxt
,
1251 gcc_jit_rvalue
*min_value
,
1252 gcc_jit_rvalue
*max_value
,
1253 gcc_jit_block
*dest_block
);
1255 /* Upcasting from case to object.
1257 This API entrypoint was added in LIBGCCJIT_ABI_3; you can test for its
1259 #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1262 extern gcc_jit_object
*
1263 gcc_jit_case_as_object (gcc_jit_case
*case_
);
1265 /* Terminate a block by adding evalation of an rvalue, then performing
1268 This is roughly equivalent to this C code:
1275 case C0.min_value ... C0.max_value:
1278 case C1.min_value ... C1.max_value:
1283 case C[N - 1].min_value ... C[N - 1].max_value:
1284 goto C[N - 1].dest_block;
1287 block, expr, default_block and cases must all be non-NULL.
1289 expr must be of the same integer type as all of the min_value
1290 and max_value within the cases.
1292 num_cases must be >= 0.
1294 The ranges of the cases must not overlap (or have duplicate
1297 This API entrypoint was added in LIBGCCJIT_ABI_3; you can test for its
1299 #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1303 gcc_jit_block_end_with_switch (gcc_jit_block
*block
,
1304 gcc_jit_location
*loc
,
1305 gcc_jit_rvalue
*expr
,
1306 gcc_jit_block
*default_block
,
1308 gcc_jit_case
**cases
);
1310 /* Pre-canned feature macro to indicate the presence of
1311 gcc_jit_block_end_with_switch, gcc_jit_case_as_object, and
1312 gcc_jit_context_new_case.
1314 This can be tested for with #ifdef. */
1315 #define LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1317 /**********************************************************************
1319 **********************************************************************/
1321 /* Given an existing JIT context, create a child context.
1323 The child inherits a copy of all option-settings from the parent.
1325 The child can reference objects created within the parent, but not
1328 The lifetime of the child context must be bounded by that of the
1329 parent: you should release a child context before releasing the parent
1332 If you use a function from a parent context within a child context,
1333 you have to compile the parent context before you can compile the
1334 child context, and the gcc_jit_result of the parent context must
1335 outlive the gcc_jit_result of the child context.
1337 This allows caching of shared initializations. For example, you could
1338 create types and declarations of global functions in a parent context
1339 once within a process, and then create child contexts whenever a
1340 function or loop becomes hot. Each such child context can be used for
1341 JIT-compiling just one function or loop, but can reference types
1342 and helper functions created within the parent context.
1344 Contexts can be arbitrarily nested, provided the above rules are
1345 followed, but it's probably not worth going above 2 or 3 levels, and
1346 there will likely be a performance hit for such nesting. */
1348 extern gcc_jit_context
*
1349 gcc_jit_context_new_child_context (gcc_jit_context
*parent_ctxt
);
1351 /**********************************************************************
1352 Implementation support.
1353 **********************************************************************/
1355 /* Write C source code into "path" that can be compiled into a
1356 self-contained executable (i.e. with libgccjit as the only dependency).
1357 The generated code will attempt to replay the API calls that have been
1358 made into the given context.
1360 This may be useful when debugging the library or client code, for
1361 reducing a complicated recipe for reproducing a bug into a simpler
1364 Typically you need to supply the option "-Wno-unused-variable" when
1365 compiling the generated file (since the result of each API call is
1366 assigned to a unique variable within the generated C source, and not
1367 all are necessarily then used). */
1370 gcc_jit_context_dump_reproducer_to_file (gcc_jit_context
*ctxt
,
1373 /* Enable the dumping of a specific set of internal state from the
1374 compilation, capturing the result in-memory as a buffer.
1376 Parameter "dumpname" corresponds to the equivalent gcc command-line
1377 option, without the "-fdump-" prefix.
1378 For example, to get the equivalent of "-fdump-tree-vrp1", supply
1380 The context directly stores the dumpname as a (const char *), so the
1381 passed string must outlive the context.
1383 gcc_jit_context_compile and gcc_jit_context_to_file
1384 will capture the dump as a dynamically-allocated buffer, writing
1387 The caller becomes responsible for calling
1389 each time that gcc_jit_context_compile or gcc_jit_context_to_file
1390 are called. *out_ptr will be written to, either with the address of a
1391 buffer, or with NULL if an error occurred.
1393 This API entrypoint is likely to be less stable than the others.
1394 In particular, both the precise dumpnames, and the format and content
1395 of the dumps are subject to change.
1397 It exists primarily for writing the library's own test suite. */
1400 gcc_jit_context_enable_dump (gcc_jit_context
*ctxt
,
1401 const char *dumpname
,
1404 /**********************************************************************
1406 **********************************************************************/
1408 /* The timing API was added in LIBGCCJIT_ABI_4; you can test for its
1410 #ifdef LIBGCCJIT_HAVE_TIMING_API
1412 #define LIBGCCJIT_HAVE_TIMING_API
1414 typedef struct gcc_jit_timer gcc_jit_timer
;
1416 /* Create a gcc_jit_timer instance, and start timing.
1418 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1420 #ifdef LIBGCCJIT_HAVE_TIMING_API
1422 extern gcc_jit_timer
*
1423 gcc_jit_timer_new (void);
1425 /* Release a gcc_jit_timer instance.
1427 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1429 #ifdef LIBGCCJIT_HAVE_TIMING_API
1432 gcc_jit_timer_release (gcc_jit_timer
*timer
);
1434 /* Associate a gcc_jit_timer instance with a context.
1436 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1438 #ifdef LIBGCCJIT_HAVE_TIMING_API
1441 gcc_jit_context_set_timer (gcc_jit_context
*ctxt
,
1442 gcc_jit_timer
*timer
);
1444 /* Get the timer associated with a context (if any).
1446 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1448 #ifdef LIBGCCJIT_HAVE_TIMING_API
1451 extern gcc_jit_timer
*
1452 gcc_jit_context_get_timer (gcc_jit_context
*ctxt
);
1454 /* Push the given item onto the timing stack.
1456 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1458 #ifdef LIBGCCJIT_HAVE_TIMING_API
1462 gcc_jit_timer_push (gcc_jit_timer
*timer
,
1463 const char *item_name
);
1465 /* Pop the top item from the timing stack.
1467 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1469 #ifdef LIBGCCJIT_HAVE_TIMING_API
1473 gcc_jit_timer_pop (gcc_jit_timer
*timer
,
1474 const char *item_name
);
1476 /* Print timing information to the given stream about activity since
1477 the timer was started.
1479 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1481 #ifdef LIBGCCJIT_HAVE_TIMING_API
1485 gcc_jit_timer_print (gcc_jit_timer
*timer
,
1489 #define LIBGCCJIT_HAVE_gcc_jit_rvalue_set_bool_require_tail_call
1491 /* Mark/clear a call as needing tail-call optimization.
1493 This API entrypoint was added in LIBGCCJIT_ABI_6; you can test for its
1495 #ifdef LIBGCCJIT_HAVE_gcc_jit_rvalue_set_bool_require_tail_call
1498 gcc_jit_rvalue_set_bool_require_tail_call (gcc_jit_rvalue
*call
,
1499 int require_tail_call
);
1501 #define LIBGCCJIT_HAVE_gcc_jit_type_get_aligned
1503 /* Given type "T", get type:
1505 T __attribute__ ((aligned (ALIGNMENT_IN_BYTES)))
1507 The alignment must be a power of two.
1509 This API entrypoint was added in LIBGCCJIT_ABI_7; you can test for its
1511 #ifdef LIBGCCJIT_HAVE_gcc_jit_type_get_aligned
1513 extern gcc_jit_type
*
1514 gcc_jit_type_get_aligned (gcc_jit_type
*type
,
1515 size_t alignment_in_bytes
);
1517 #define LIBGCCJIT_HAVE_gcc_jit_type_get_vector
1519 /* Given type "T", get type:
1521 T __attribute__ ((vector_size (sizeof(T) * num_units))
1523 T must be integral/floating point; num_units must be a power of two.
1525 This API entrypoint was added in LIBGCCJIT_ABI_8; you can test for its
1527 #ifdef LIBGCCJIT_HAVE_gcc_jit_type_get_vector
1529 extern gcc_jit_type
*
1530 gcc_jit_type_get_vector (gcc_jit_type
*type
, size_t num_units
);
1533 #define LIBGCCJIT_HAVE_gcc_jit_function_get_address
1535 /* Get the address of a function as an rvalue, of function pointer
1538 This API entrypoint was added in LIBGCCJIT_ABI_9; you can test for its
1540 #ifdef LIBGCCJIT_HAVE_gcc_jit_function_get_address
1542 extern gcc_jit_rvalue
*
1543 gcc_jit_function_get_address (gcc_jit_function
*fn
,
1544 gcc_jit_location
*loc
);
1547 #define LIBGCCJIT_HAVE_gcc_jit_context_new_rvalue_from_vector
1549 /* Build a vector rvalue from an array of elements.
1551 "vec_type" should be a vector type, created using gcc_jit_type_get_vector.
1553 This API entrypoint was added in LIBGCCJIT_ABI_10; you can test for its
1555 #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_rvalue_from_vector
1557 extern gcc_jit_rvalue
*
1558 gcc_jit_context_new_rvalue_from_vector (gcc_jit_context
*ctxt
,
1559 gcc_jit_location
*loc
,
1560 gcc_jit_type
*vec_type
,
1561 size_t num_elements
,
1562 gcc_jit_rvalue
**elements
);
1564 #define LIBGCCJIT_HAVE_gcc_jit_version
1566 /* Functions to retrieve libgccjit version.
1567 Analogous to __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__ in C code.
1569 These API entrypoints were added in LIBGCCJIT_ABI_13; you can test for their
1571 #ifdef LIBGCCJIT_HAVE_gcc_jit_version
1574 gcc_jit_version_major (void);
1576 gcc_jit_version_minor (void);
1578 gcc_jit_version_patchlevel (void);
1580 /**********************************************************************
1582 **********************************************************************/
1584 /* Functions for adding inline assembler code, analogous to GCC's
1585 "extended asm" syntax.
1587 See https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-with-C.html
1589 These API entrypoints were added in LIBGCCJIT_ABI_15; you can test for their
1591 #ifdef LIBGCCJIT_HAVE_ASM_STATEMENTS
1594 #define LIBGCCJIT_HAVE_ASM_STATEMENTS
1596 /* Create a gcc_jit_extended_asm for an extended asm statement
1597 with no control flow (i.e. without the goto qualifier).
1599 The asm_template parameter corresponds to the AssemblerTemplate
1600 within C's extended asm syntax. It must be non-NULL. */
1602 extern gcc_jit_extended_asm
*
1603 gcc_jit_block_add_extended_asm (gcc_jit_block
*block
,
1604 gcc_jit_location
*loc
,
1605 const char *asm_template
);
1607 /* Create a gcc_jit_extended_asm for an extended asm statement
1608 that may perform jumps, and use it to terminate the given block.
1609 This is equivalent to the "goto" qualifier in C's extended asm
1612 extern gcc_jit_extended_asm
*
1613 gcc_jit_block_end_with_extended_asm_goto (gcc_jit_block
*block
,
1614 gcc_jit_location
*loc
,
1615 const char *asm_template
,
1616 int num_goto_blocks
,
1617 gcc_jit_block
**goto_blocks
,
1618 gcc_jit_block
*fallthrough_block
);
1620 /* Upcasting from extended asm to object. */
1622 extern gcc_jit_object
*
1623 gcc_jit_extended_asm_as_object (gcc_jit_extended_asm
*ext_asm
);
1625 /* Set whether the gcc_jit_extended_asm has side-effects, equivalent to
1626 the "volatile" qualifier in C's extended asm syntax. */
1629 gcc_jit_extended_asm_set_volatile_flag (gcc_jit_extended_asm
*ext_asm
,
1632 /* Set the equivalent of the "inline" qualifier in C's extended asm
1636 gcc_jit_extended_asm_set_inline_flag (gcc_jit_extended_asm
*ext_asm
,
1639 /* Add an output operand to the extended asm statement.
1640 "asm_symbolic_name" can be NULL.
1641 "constraint" and "dest" must be non-NULL.
1642 This function can't be called on an "asm goto" as such instructions
1643 can't have outputs */
1646 gcc_jit_extended_asm_add_output_operand (gcc_jit_extended_asm
*ext_asm
,
1647 const char *asm_symbolic_name
,
1648 const char *constraint
,
1649 gcc_jit_lvalue
*dest
);
1651 /* Add an input operand to the extended asm statement.
1652 "asm_symbolic_name" can be NULL.
1653 "constraint" and "src" must be non-NULL. */
1656 gcc_jit_extended_asm_add_input_operand (gcc_jit_extended_asm
*ext_asm
,
1657 const char *asm_symbolic_name
,
1658 const char *constraint
,
1659 gcc_jit_rvalue
*src
);
1661 /* Add "victim" to the list of registers clobbered by the extended
1662 asm statement. It must be non-NULL. */
1665 gcc_jit_extended_asm_add_clobber (gcc_jit_extended_asm
*ext_asm
,
1666 const char *victim
);
1668 /* Add "asm_stmts", a set of top-level asm statements, analogous to
1669 those created by GCC's "basic" asm syntax in C at file scope. */
1672 gcc_jit_context_add_top_level_asm (gcc_jit_context
*ctxt
,
1673 gcc_jit_location
*loc
,
1674 const char *asm_stmts
);
1676 #define LIBGCCJIT_HAVE_REFLECTION
1678 /* Reflection functions to get the number of parameters, return type of
1679 a function and whether a type is a bool from the C API.
1681 This API entrypoint was added in LIBGCCJIT_ABI_16; you can test for its
1683 #ifdef LIBGCCJIT_HAVE_REFLECTION
1685 /* Get the return type of a function. */
1686 extern gcc_jit_type
*
1687 gcc_jit_function_get_return_type (gcc_jit_function
*func
);
1689 /* Get the number of params of a function. */
1691 gcc_jit_function_get_param_count (gcc_jit_function
*func
);
1693 /* Get the element type of an array type or NULL if it's not an array. */
1694 extern gcc_jit_type
*
1695 gcc_jit_type_dyncast_array (gcc_jit_type
*type
);
1697 /* Return non-zero if the type is a bool. */
1699 gcc_jit_type_is_bool (gcc_jit_type
*type
);
1701 /* Return the function type if it is one or NULL. */
1702 extern gcc_jit_function_type
*
1703 gcc_jit_type_dyncast_function_ptr_type (gcc_jit_type
*type
);
1705 /* Given a function type, return its return type. */
1706 extern gcc_jit_type
*
1707 gcc_jit_function_type_get_return_type (gcc_jit_function_type
*function_type
);
1709 /* Given a function type, return its number of parameters. */
1711 gcc_jit_function_type_get_param_count (gcc_jit_function_type
*function_type
);
1713 /* Given a function type, return the type of the specified parameter. */
1714 extern gcc_jit_type
*
1715 gcc_jit_function_type_get_param_type (gcc_jit_function_type
*function_type
,
1718 /* Return non-zero if the type is an integral. */
1720 gcc_jit_type_is_integral (gcc_jit_type
*type
);
1722 /* Return the type pointed by the pointer type or NULL if it's not a
1724 extern gcc_jit_type
*
1725 gcc_jit_type_is_pointer (gcc_jit_type
*type
);
1727 /* Given a type, return a dynamic cast to a vector type or NULL. */
1728 extern gcc_jit_vector_type
*
1729 gcc_jit_type_dyncast_vector (gcc_jit_type
*type
);
1731 /* Given a type, return a dynamic cast to a struct type or NULL. */
1732 extern gcc_jit_struct
*
1733 gcc_jit_type_is_struct (gcc_jit_type
*type
);
1735 /* Given a vector type, return the number of units it contains. */
1737 gcc_jit_vector_type_get_num_units (gcc_jit_vector_type
*vector_type
);
1739 /* Given a vector type, return the type of its elements. */
1740 extern gcc_jit_type
*
1741 gcc_jit_vector_type_get_element_type (gcc_jit_vector_type
*vector_type
);
1743 /* Given a type, return the unqualified type, removing "const", "volatile"
1744 * and alignment qualifiers. */
1745 extern gcc_jit_type
*
1746 gcc_jit_type_unqualified (gcc_jit_type
*type
);
1750 #endif /* __cplusplus */
1752 #endif /* LIBGCCJIT_H */