xref: /netbsd-src/external/gpl3/gcc/dist/gcc/jit/libgccjit.h (revision b1e838363e3c6fc78a55519254d99869742dd33c)
1 /* A pure C API to enable client code to embed GCC as a JIT-compiler.
2    Copyright (C) 2013-2022 Free Software Foundation, Inc.
3 
4 This file is part of GCC.
5 
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)
9 any later version.
10 
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.
15 
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/>.  */
19 
20 #ifndef LIBGCCJIT_H
21 #define LIBGCCJIT_H
22 
23 #include <stdio.h>
24 
25 #ifdef __cplusplus
26 extern "C" {
27 #endif /* __cplusplus */
28 
29 /**********************************************************************
30  Data structures.
31  **********************************************************************/
32 /* All structs within the API are opaque. */
33 
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
36    the API below.
37 
38    Invoking gcc_jit_context_compile on it gives you a gcc_jit_result *
39    (or NULL), representing in-memory machine code.
40 
41    You can call gcc_jit_context_compile repeatedly on one context, giving
42    multiple independent results.
43 
44    Similarly, you can call gcc_jit_context_compile_to_file on a context
45    to compile to disk.
46 
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;
51 
52 /* A gcc_jit_result encapsulates the result of an in-memory compilation.  */
53 typedef struct gcc_jit_result gcc_jit_result;
54 
55 /* An object created within a context.  Such objects are automatically
56    cleaned up when the context is released.
57 
58    The class hierarchy looks like this:
59 
60      +- gcc_jit_object
61 	 +- gcc_jit_location
62 	 +- gcc_jit_type
63 	    +- gcc_jit_struct
64 	    +- gcc_jit_function_type
65 	    +- gcc_jit_vector_type
66 	 +- gcc_jit_field
67 	 +- gcc_jit_function
68 	 +- gcc_jit_block
69 	 +- gcc_jit_rvalue
70 	     +- gcc_jit_lvalue
71 		 +- gcc_jit_param
72 	 +- gcc_jit_case
73 	 +- gcc_jit_extended_asm
74 */
75 typedef struct gcc_jit_object gcc_jit_object;
76 
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.
81 
82    Note that to do so, you also need to enable
83      GCC_JIT_BOOL_OPTION_DEBUGINFO
84    on the gcc_jit_context.
85 
86    gcc_jit_location instances are optional; you can always pass
87    NULL.  */
88 typedef struct gcc_jit_location gcc_jit_location;
89 
90 /* A gcc_jit_type encapsulates a type e.g. "int" or a "struct foo*".  */
91 typedef struct gcc_jit_type gcc_jit_type;
92 
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;
97 
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;
101 
102 /* A gcc_jit_function_type encapsulates a function type.  */
103 typedef struct gcc_jit_function_type gcc_jit_function_type;
104 
105 /* A gcc_jit_vector_type encapsulates a vector type.  */
106 typedef struct gcc_jit_vector_type gcc_jit_vector_type;
107 
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;
112 
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).
115 
116    Every block within a function must be terminated with a conditional,
117    a branch, or a return.
118 
119    The blocks within a function form a directed graph.
120 
121    The entrypoint to the function is the first block created within
122    it.
123 
124    All of the blocks in a function must be reachable via some path from
125    the first block.
126 
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;
130 
131 /* A gcc_jit_rvalue is an expression within your code, with some type.  */
132 typedef struct gcc_jit_rvalue gcc_jit_rvalue;
133 
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;
138 
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;
143 
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;
149 
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
153    outputs.  */
154 typedef struct gcc_jit_extended_asm gcc_jit_extended_asm;
155 
156 /* Acquire a JIT-compilation context.  */
157 extern gcc_jit_context *
158 gcc_jit_context_acquire (void);
159 
160 /* Release the context.  After this call, it's no longer valid to use
161    the ctxt.  */
162 extern void
163 gcc_jit_context_release (gcc_jit_context *ctxt);
164 
165 /* Options present in the initial release of libgccjit.
166    These were handled using enums.  */
167 
168 /* Options taking string values. */
169 enum gcc_jit_str_option
170 {
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,
174 
175   GCC_JIT_NUM_STR_OPTIONS
176 };
177 
178 /* Options taking int values. */
179 enum gcc_jit_int_option
180 {
181   /* How much to optimize the code.
182      Valid values are 0-3, corresponding to GCC's command-line options
183      -O0 through -O3.
184 
185      The default value is 0 (unoptimized).  */
186   GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL,
187 
188   GCC_JIT_NUM_INT_OPTIONS
189 };
190 
191 /* Options taking boolean values.
192    These all default to "false".  */
193 enum gcc_jit_bool_option
194 {
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.
198 
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,
203 
204   /* If true, gcc_jit_context_compile will dump its initial "tree"
205      representation of your code to stderr (before any
206      optimizations).  */
207   GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE,
208 
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,
213 
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,
217 
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.
221    */
222   GCC_JIT_BOOL_OPTION_DUMP_SUMMARY,
223 
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.
230   */
231   GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING,
232 
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,
238 
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,
243 
244   GCC_JIT_NUM_BOOL_OPTIONS
245 };
246 
247 /* Set a string option on the given context.
248 
249    The context takes a copy of the string, so the
250    (const char *) buffer is not needed anymore after the call
251    returns.  */
252 extern void
253 gcc_jit_context_set_str_option (gcc_jit_context *ctxt,
254 				enum gcc_jit_str_option opt,
255 				const char *value);
256 
257 /* Set an int option on the given context.  */
258 extern void
259 gcc_jit_context_set_int_option (gcc_jit_context *ctxt,
260 				enum gcc_jit_int_option opt,
261 				int value);
262 
263 /* Set a boolean option on the given context.
264 
265    Zero is "false" (the default), non-zero is "true".  */
266 extern void
267 gcc_jit_context_set_bool_option (gcc_jit_context *ctxt,
268 				 enum gcc_jit_bool_option opt,
269 				 int value);
270 
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.  */
276 
277 /* By default, libgccjit will issue an error about unreachable blocks
278    within a function.
279 
280    This option can be used to disable that error.
281 
282    This entrypoint was added in LIBGCCJIT_ABI_2; you can test for
283    its presence using
284      #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_allow_unreachable_blocks
285 */
286 
287 extern void
288 gcc_jit_context_set_bool_allow_unreachable_blocks (gcc_jit_context *ctxt,
289 						   int bool_value);
290 
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
295 
296 /* By default, libgccjit will print errors to stderr.
297 
298    This option can be used to disable the printing.
299 
300    This entrypoint was added in LIBGCCJIT_ABI_23; you can test for
301    its presence using
302      #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_print_errors_to_stderr
303 */
304 
305 extern void
306 gcc_jit_context_set_bool_print_errors_to_stderr (gcc_jit_context *ctxt,
307 						 int enabled);
308 
309 /* Pre-canned feature macro to indicate the presence of
310    gcc_jit_context_set_bool_print_errors_to_stderr.  This can be
311    tested for with #ifdef.  */
312 #define LIBGCCJIT_HAVE_gcc_jit_context_set_bool_print_errors_to_stderr
313 
314 /* Implementation detail:
315    libgccjit internally generates assembler, and uses "driver" code
316    for converting it to other formats (e.g. shared libraries).
317 
318    By default, libgccjit will use an embedded copy of the driver
319    code.
320 
321    This option can be used to instead invoke an external driver executable
322    as a subprocess.
323 
324    This entrypoint was added in LIBGCCJIT_ABI_5; you can test for
325    its presence using
326      #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_use_external_driver
327 */
328 
329 extern void
330 gcc_jit_context_set_bool_use_external_driver (gcc_jit_context *ctxt,
331 					      int bool_value);
332 
333 /* Pre-canned feature macro to indicate the presence of
334    gcc_jit_context_set_bool_use_external_driver.  This can be
335    tested for with #ifdef.  */
336 #define LIBGCCJIT_HAVE_gcc_jit_context_set_bool_use_external_driver
337 
338 /* Add an arbitrary gcc command-line option to the context.
339    The context takes a copy of the string, so the
340    (const char *) optname is not needed anymore after the call
341    returns.
342 
343    Note that only some options are likely to be meaningful; there is no
344    "frontend" within libgccjit, so typically only those affecting
345    optimization and code-generation are likely to be useful.
346 
347    This entrypoint was added in LIBGCCJIT_ABI_1; you can test for
348    its presence using
349    #ifdef LIBGCCJIT_HAVE_gcc_jit_context_add_command_line_option
350 */
351 
352 extern void
353 gcc_jit_context_add_command_line_option (gcc_jit_context *ctxt,
354 					 const char *optname);
355 
356 /* Pre-canned feature-test macro for detecting the presence of
357    gcc_jit_context_add_command_line_option within libgccjit.h.  */
358 
359 #define LIBGCCJIT_HAVE_gcc_jit_context_add_command_line_option
360 
361 /* Add an arbitrary gcc driver option to the context.
362    The context takes a copy of the string, so the
363    (const char *) optname is not needed anymore after the call
364    returns.
365 
366    Note that only some options are likely to be meaningful; there is no
367    "frontend" within libgccjit, so typically only those affecting
368    assembler and linker are likely to be useful.
369 
370    This entrypoint was added in LIBGCCJIT_ABI_11; you can test for
371    its presence using
372    #ifdef LIBGCCJIT_HAVE_gcc_jit_context_add_driver_option
373 */
374 extern void
375 gcc_jit_context_add_driver_option (gcc_jit_context *ctxt,
376 				   const char *optname);
377 
378 /* Pre-canned feature-test macro for detecting the presence of
379    gcc_jit_context_add_driver_option within libgccjit.h.  */
380 
381 #define LIBGCCJIT_HAVE_gcc_jit_context_add_driver_option
382 
383 /* Compile the context to in-memory machine code.
384 
385    This can be called more that once on a given context,
386    although any errors that occur will block further compilation.  */
387 
388 extern gcc_jit_result *
389 gcc_jit_context_compile (gcc_jit_context *ctxt);
390 
391 /* Kinds of ahead-of-time compilation, for use with
392    gcc_jit_context_compile_to_file.  */
393 
394 enum gcc_jit_output_kind
395 {
396   /* Compile the context to an assembler file.  */
397   GCC_JIT_OUTPUT_KIND_ASSEMBLER,
398 
399   /* Compile the context to an object file.  */
400   GCC_JIT_OUTPUT_KIND_OBJECT_FILE,
401 
402   /* Compile the context to a dynamic library.  */
403   GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY,
404 
405   /* Compile the context to an executable.  */
406   GCC_JIT_OUTPUT_KIND_EXECUTABLE
407 };
408 
409 /* Compile the context to a file of the given kind.
410 
411    This can be called more that once on a given context,
412    although any errors that occur will block further compilation.  */
413 
414 extern void
415 gcc_jit_context_compile_to_file (gcc_jit_context *ctxt,
416 				 enum gcc_jit_output_kind output_kind,
417 				 const char *output_path);
418 
419 /* To help with debugging: dump a C-like representation to the given path,
420    describing what's been set up on the context.
421 
422    If "update_locations" is true, then also set up gcc_jit_location
423    information throughout the context, pointing at the dump file as if it
424    were a source file.  This may be of use in conjunction with
425    GCC_JIT_BOOL_OPTION_DEBUGINFO to allow stepping through the code in a
426    debugger.  */
427 extern void
428 gcc_jit_context_dump_to_file (gcc_jit_context *ctxt,
429 			      const char *path,
430 			      int update_locations);
431 
432 /* To help with debugging; enable ongoing logging of the context's
433    activity to the given FILE *.
434 
435    The caller remains responsible for closing "logfile".
436 
437    Params "flags" and "verbosity" are reserved for future use, and
438    must both be 0 for now.  */
439 extern void
440 gcc_jit_context_set_logfile (gcc_jit_context *ctxt,
441 			     FILE *logfile,
442 			     int flags,
443 			     int verbosity);
444 
445 /* To be called after any API call, this gives the first error message
446    that occurred on the context.
447 
448    The returned string is valid for the rest of the lifetime of the
449    context.
450 
451    If no errors occurred, this will be NULL.  */
452 extern const char *
453 gcc_jit_context_get_first_error (gcc_jit_context *ctxt);
454 
455 /* To be called after any API call, this gives the last error message
456    that occurred on the context.
457 
458    If no errors occurred, this will be NULL.
459 
460    If non-NULL, the returned string is only guaranteed to be valid until
461    the next call to libgccjit relating to this context. */
462 extern const char *
463 gcc_jit_context_get_last_error (gcc_jit_context *ctxt);
464 
465 /* Locate a given function within the built machine code.
466    This will need to be cast to a function pointer of the
467    correct type before it can be called. */
468 extern void *
469 gcc_jit_result_get_code (gcc_jit_result *result,
470 			 const char *funcname);
471 
472 /* Locate a given global within the built machine code.
473    It must have been created using GCC_JIT_GLOBAL_EXPORTED.
474    This is a ptr to the global, so e.g. for an int this is an int *.  */
475 extern void *
476 gcc_jit_result_get_global (gcc_jit_result *result,
477 			   const char *name);
478 
479 /* Once we're done with the code, this unloads the built .so file.
480    This cleans up the result; after calling this, it's no longer
481    valid to use the result.  */
482 extern void
483 gcc_jit_result_release (gcc_jit_result *result);
484 
485 
486 /**********************************************************************
487  Functions for creating "contextual" objects.
488 
489  All objects created by these functions share the lifetime of the context
490  they are created within, and are automatically cleaned up for you when
491  you call gcc_jit_context_release on the context.
492 
493  Note that this means you can't use references to them after you've
494  released their context.
495 
496  All (const char *) string arguments passed to these functions are
497  copied, so you don't need to keep them around.
498 
499  You create code by adding a sequence of statements to blocks.
500 **********************************************************************/
501 
502 /**********************************************************************
503  The base class of "contextual" object.
504  **********************************************************************/
505 /* Which context is "obj" within?  */
506 extern gcc_jit_context *
507 gcc_jit_object_get_context (gcc_jit_object *obj);
508 
509 /* Get a human-readable description of this object.
510    The string buffer is created the first time this is called on a given
511    object, and persists until the object's context is released.  */
512 extern const char *
513 gcc_jit_object_get_debug_string (gcc_jit_object *obj);
514 
515 /**********************************************************************
516  Debugging information.
517  **********************************************************************/
518 
519 /* Creating source code locations for use by the debugger.
520    Line and column numbers are 1-based.  */
521 extern gcc_jit_location *
522 gcc_jit_context_new_location (gcc_jit_context *ctxt,
523 			      const char *filename,
524 			      int line,
525 			      int column);
526 
527 /* Upcasting from location to object.  */
528 extern gcc_jit_object *
529 gcc_jit_location_as_object (gcc_jit_location *loc);
530 
531 
532 /**********************************************************************
533  Types.
534  **********************************************************************/
535 
536 /* Upcasting from type to object.  */
537 extern gcc_jit_object *
538 gcc_jit_type_as_object (gcc_jit_type *type);
539 
540 /* Access to specific types.  */
541 enum gcc_jit_types
542 {
543   /* C's "void" type.  */
544   GCC_JIT_TYPE_VOID,
545 
546   /* "void *".  */
547   GCC_JIT_TYPE_VOID_PTR,
548 
549   /* C++'s bool type; also C99's "_Bool" type, aka "bool" if using
550      stdbool.h.  */
551   GCC_JIT_TYPE_BOOL,
552 
553   /* Various integer types.  */
554 
555   /* C's "char" (of some signedness) and the variants where the
556      signedness is specified.  */
557   GCC_JIT_TYPE_CHAR,
558   GCC_JIT_TYPE_SIGNED_CHAR,
559   GCC_JIT_TYPE_UNSIGNED_CHAR,
560 
561   /* C's "short" and "unsigned short".  */
562   GCC_JIT_TYPE_SHORT, /* signed */
563   GCC_JIT_TYPE_UNSIGNED_SHORT,
564 
565   /* C's "int" and "unsigned int".  */
566   GCC_JIT_TYPE_INT, /* signed */
567   GCC_JIT_TYPE_UNSIGNED_INT,
568 
569   /* C's "long" and "unsigned long".  */
570   GCC_JIT_TYPE_LONG, /* signed */
571   GCC_JIT_TYPE_UNSIGNED_LONG,
572 
573   /* C99's "long long" and "unsigned long long".  */
574   GCC_JIT_TYPE_LONG_LONG, /* signed */
575   GCC_JIT_TYPE_UNSIGNED_LONG_LONG,
576 
577   /* Floating-point types  */
578 
579   GCC_JIT_TYPE_FLOAT,
580   GCC_JIT_TYPE_DOUBLE,
581   GCC_JIT_TYPE_LONG_DOUBLE,
582 
583   /* C type: (const char *).  */
584   GCC_JIT_TYPE_CONST_CHAR_PTR,
585 
586  /* The C "size_t" type.  */
587   GCC_JIT_TYPE_SIZE_T,
588 
589  /* C type: (FILE *)  */
590   GCC_JIT_TYPE_FILE_PTR,
591 
592   /* Complex numbers.  */
593   GCC_JIT_TYPE_COMPLEX_FLOAT,
594   GCC_JIT_TYPE_COMPLEX_DOUBLE,
595   GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE,
596 
597   /* Sized integer types.  */
598   GCC_JIT_TYPE_UINT8_T,
599   GCC_JIT_TYPE_UINT16_T,
600   GCC_JIT_TYPE_UINT32_T,
601   GCC_JIT_TYPE_UINT64_T,
602   GCC_JIT_TYPE_UINT128_T,
603   GCC_JIT_TYPE_INT8_T,
604   GCC_JIT_TYPE_INT16_T,
605   GCC_JIT_TYPE_INT32_T,
606   GCC_JIT_TYPE_INT64_T,
607   GCC_JIT_TYPE_INT128_T
608 };
609 
610 extern gcc_jit_type *
611 gcc_jit_context_get_type (gcc_jit_context *ctxt,
612 			  enum gcc_jit_types type_);
613 
614 /* Get the integer type of the given size and signedness.  */
615 extern gcc_jit_type *
616 gcc_jit_context_get_int_type (gcc_jit_context *ctxt,
617 			      int num_bytes, int is_signed);
618 
619 /* Constructing new types. */
620 
621 /* Given type "T", get type "T*".  */
622 extern gcc_jit_type *
623 gcc_jit_type_get_pointer (gcc_jit_type *type);
624 
625 /* Given type "T", get type "const T".  */
626 extern gcc_jit_type *
627 gcc_jit_type_get_const (gcc_jit_type *type);
628 
629 /* Given type "T", get type "volatile T".  */
630 extern gcc_jit_type *
631 gcc_jit_type_get_volatile (gcc_jit_type *type);
632 
633 #define LIBGCCJIT_HAVE_SIZED_INTEGERS
634 
635 /* Given types LTYPE and RTYPE, return non-zero if they are compatible.
636    This API entrypoint was added in LIBGCCJIT_ABI_20; you can test for its
637    presence using
638      #ifdef LIBGCCJIT_HAVE_SIZED_INTEGERS  */
639 extern int
640 gcc_jit_compatible_types (gcc_jit_type *ltype,
641 			  gcc_jit_type *rtype);
642 
643 /* Given type "T", get its size.
644    This API entrypoint was added in LIBGCCJIT_ABI_20; you can test for its
645    presence using
646      #ifdef LIBGCCJIT_HAVE_SIZED_INTEGERS  */
647 extern ssize_t
648 gcc_jit_type_get_size (gcc_jit_type *type);
649 
650 /* Given type "T", get type "T[N]" (for a constant N).  */
651 extern gcc_jit_type *
652 gcc_jit_context_new_array_type (gcc_jit_context *ctxt,
653 				gcc_jit_location *loc,
654 				gcc_jit_type *element_type,
655 				int num_elements);
656 
657 /* Struct-handling.  */
658 
659 /* Create a field, for use within a struct or union.  */
660 extern gcc_jit_field *
661 gcc_jit_context_new_field (gcc_jit_context *ctxt,
662 			   gcc_jit_location *loc,
663 			   gcc_jit_type *type,
664 			   const char *name);
665 
666 #define LIBGCCJIT_HAVE_gcc_jit_context_new_bitfield
667 
668 /* Create a bit field, for use within a struct or union.
669 
670    This API entrypoint was added in LIBGCCJIT_ABI_12; you can test for its
671    presence using
672      #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_bitfield
673 */
674 extern gcc_jit_field *
675 gcc_jit_context_new_bitfield (gcc_jit_context *ctxt,
676 			      gcc_jit_location *loc,
677 			      gcc_jit_type *type,
678 			      int width,
679 			      const char *name);
680 
681 /* Upcasting from field to object.  */
682 extern gcc_jit_object *
683 gcc_jit_field_as_object (gcc_jit_field *field);
684 
685 /* Create a struct type from an array of fields.  */
686 extern gcc_jit_struct *
687 gcc_jit_context_new_struct_type (gcc_jit_context *ctxt,
688 				 gcc_jit_location *loc,
689 				 const char *name,
690 				 int num_fields,
691 				 gcc_jit_field **fields);
692 
693 /* Create an opaque struct type.  */
694 extern gcc_jit_struct *
695 gcc_jit_context_new_opaque_struct (gcc_jit_context *ctxt,
696 				   gcc_jit_location *loc,
697 				   const char *name);
698 
699 /* Upcast a struct to a type.  */
700 extern gcc_jit_type *
701 gcc_jit_struct_as_type (gcc_jit_struct *struct_type);
702 
703 /* Populating the fields of a formerly-opaque struct type.
704    This can only be called once on a given struct type.  */
705 extern void
706 gcc_jit_struct_set_fields (gcc_jit_struct *struct_type,
707 			   gcc_jit_location *loc,
708 			   int num_fields,
709 			   gcc_jit_field **fields);
710 
711 /* Get a field by index.  */
712 extern gcc_jit_field *
713 gcc_jit_struct_get_field (gcc_jit_struct *struct_type,
714 			   size_t index);
715 
716 /* Get the number of fields.  */
717 extern size_t
718 gcc_jit_struct_get_field_count (gcc_jit_struct *struct_type);
719 
720 /* Unions work similarly to structs.  */
721 extern gcc_jit_type *
722 gcc_jit_context_new_union_type (gcc_jit_context *ctxt,
723 				gcc_jit_location *loc,
724 				const char *name,
725 				int num_fields,
726 				gcc_jit_field **fields);
727 
728 /* Function pointers. */
729 
730 extern gcc_jit_type *
731 gcc_jit_context_new_function_ptr_type (gcc_jit_context *ctxt,
732 				       gcc_jit_location *loc,
733 				       gcc_jit_type *return_type,
734 				       int num_params,
735 				       gcc_jit_type **param_types,
736 				       int is_variadic);
737 
738 /**********************************************************************
739  Constructing functions.
740  **********************************************************************/
741 /* Create a function param.  */
742 extern gcc_jit_param *
743 gcc_jit_context_new_param (gcc_jit_context *ctxt,
744 			   gcc_jit_location *loc,
745 			   gcc_jit_type *type,
746 			   const char *name);
747 
748 /* Upcasting from param to object.  */
749 extern gcc_jit_object *
750 gcc_jit_param_as_object (gcc_jit_param *param);
751 
752 /* Upcasting from param to lvalue.  */
753 extern gcc_jit_lvalue *
754 gcc_jit_param_as_lvalue (gcc_jit_param *param);
755 
756 /* Upcasting from param to rvalue.  */
757 extern gcc_jit_rvalue *
758 gcc_jit_param_as_rvalue (gcc_jit_param *param);
759 
760 /* Kinds of function.  */
761 enum gcc_jit_function_kind
762 {
763   /* Function is defined by the client code and visible
764      by name outside of the JIT.  */
765   GCC_JIT_FUNCTION_EXPORTED,
766 
767   /* Function is defined by the client code, but is invisible
768      outside of the JIT.  Analogous to a "static" function.  */
769   GCC_JIT_FUNCTION_INTERNAL,
770 
771   /* Function is not defined by the client code; we're merely
772      referring to it.  Analogous to using an "extern" function from a
773      header file.  */
774   GCC_JIT_FUNCTION_IMPORTED,
775 
776   /* Function is only ever inlined into other functions, and is
777      invisible outside of the JIT.
778 
779      Analogous to prefixing with "inline" and adding
780      __attribute__((always_inline)).
781 
782      Inlining will only occur when the optimization level is
783      above 0; when optimization is off, this is essentially the
784      same as GCC_JIT_FUNCTION_INTERNAL.  */
785   GCC_JIT_FUNCTION_ALWAYS_INLINE
786 };
787 
788 /* Thread local storage model.  */
789 enum gcc_jit_tls_model
790 {
791   GCC_JIT_TLS_MODEL_NONE,
792   GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC,
793   GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC,
794   GCC_JIT_TLS_MODEL_INITIAL_EXEC,
795   GCC_JIT_TLS_MODEL_LOCAL_EXEC,
796 };
797 
798 /* Create a function.  */
799 extern gcc_jit_function *
800 gcc_jit_context_new_function (gcc_jit_context *ctxt,
801 			      gcc_jit_location *loc,
802 			      enum gcc_jit_function_kind kind,
803 			      gcc_jit_type *return_type,
804 			      const char *name,
805 			      int num_params,
806 			      gcc_jit_param **params,
807 			      int is_variadic);
808 
809 /* Create a reference to a builtin function (sometimes called
810    intrinsic functions).  */
811 extern gcc_jit_function *
812 gcc_jit_context_get_builtin_function (gcc_jit_context *ctxt,
813 				      const char *name);
814 
815 /* Upcasting from function to object.  */
816 extern gcc_jit_object *
817 gcc_jit_function_as_object (gcc_jit_function *func);
818 
819 /* Get a specific param of a function by index.  */
820 extern gcc_jit_param *
821 gcc_jit_function_get_param (gcc_jit_function *func, int index);
822 
823 /* Emit the function in graphviz format.  */
824 extern void
825 gcc_jit_function_dump_to_dot (gcc_jit_function *func,
826 			      const char *path);
827 
828 /* Create a block.
829 
830    The name can be NULL, or you can give it a meaningful name, which
831    may show up in dumps of the internal representation, and in error
832    messages.  */
833 extern gcc_jit_block *
834 gcc_jit_function_new_block (gcc_jit_function *func,
835 			    const char *name);
836 
837 /* Upcasting from block to object.  */
838 extern gcc_jit_object *
839 gcc_jit_block_as_object (gcc_jit_block *block);
840 
841 /* Which function is this block within?  */
842 extern gcc_jit_function *
843 gcc_jit_block_get_function (gcc_jit_block *block);
844 
845 /**********************************************************************
846  lvalues, rvalues and expressions.
847  **********************************************************************/
848 enum gcc_jit_global_kind
849 {
850   /* Global is defined by the client code and visible
851      by name outside of this JIT context via gcc_jit_result_get_global.  */
852   GCC_JIT_GLOBAL_EXPORTED,
853 
854   /* Global is defined by the client code, but is invisible
855      outside of this JIT context.  Analogous to a "static" global.  */
856   GCC_JIT_GLOBAL_INTERNAL,
857 
858   /* Global is not defined by the client code; we're merely
859      referring to it.  Analogous to using an "extern" global from a
860      header file.  */
861   GCC_JIT_GLOBAL_IMPORTED
862 };
863 
864 extern gcc_jit_lvalue *
865 gcc_jit_context_new_global (gcc_jit_context *ctxt,
866 			    gcc_jit_location *loc,
867 			    enum gcc_jit_global_kind kind,
868 			    gcc_jit_type *type,
869 			    const char *name);
870 
871 #define LIBGCCJIT_HAVE_CTORS
872 
873 /* Create a constructor for a struct as an rvalue.
874 
875    Returns NULL on error.  The two parameter arrays are copied and
876    do not have to outlive the context.
877 
878    `type` specifies what the constructor will build and has to be
879    a struct.
880 
881    `num_values` specifies the number of elements in `values`.
882 
883    `fields` need to have the same length as `values`, or be NULL.
884 
885    If `fields` is null, the values are applied in definition order.
886 
887    Otherwise, each field in `fields` specifies which field in the struct to
888    set to the corresponding value in `values`.  `fields` and `values`
889    are paired by index.
890 
891    Each value has to have the same unqualified type as the field
892    it is applied to.
893 
894    A NULL value element  in `values` is a shorthand for zero initialization
895    of the corresponding field.
896 
897    The fields in `fields` have to be in definition order, but there
898    can be gaps.  Any field in the struct that is not specified in
899    `fields` will be zeroed.
900 
901    The fields in `fields` need to be the same objects that were used
902    to create the struct.
903 
904    If `num_values` is 0, the array parameters will be
905    ignored and zero initialization will be used.
906 
907    The constructor rvalue can be used for assignment to locals.
908    It can be used to initialize global variables with
909    gcc_jit_global_set_initializer_rvalue.  It can also be used as a
910    temporary value for function calls and return values.
911 
912    The constructor can contain nested constructors.
913 
914    This entrypoint was added in LIBGCCJIT_ABI_19; you can test for its
915    presence using:
916    #ifdef LIBGCCJIT_HAVE_CTORS
917 */
918 
919 extern gcc_jit_rvalue *
920 gcc_jit_context_new_struct_constructor (gcc_jit_context *ctxt,
921 					gcc_jit_location *loc,
922 					gcc_jit_type *type,
923 					size_t num_values,
924 					gcc_jit_field **fields,
925 					gcc_jit_rvalue **values);
926 
927 /* Create a constructor for a union as an rvalue.
928 
929    Returns NULL on error.
930 
931    `type` specifies what the constructor will build and has to be
932    an union.
933 
934    `field` specifies which field to set.  If it is NULL, the first
935    field in the union will be set.  `field` need to be the same
936    object that were used to create the union.
937 
938    `value` specifies what value to set the corresponding field to.
939    If `value` is NULL, zero initialization will be used.
940 
941    Each value has to have the same unqualified type as the field
942    it is applied to.
943 
944    `field` need to be the same objects that were used
945    to create the union.
946 
947    The constructor rvalue can be used for assignment to locals.
948    It can be used to initialize global variables with
949    gcc_jit_global_set_initializer_rvalue.  It can also be used as a
950    temporary value for function calls and return values.
951 
952    The constructor can contain nested constructors.
953 
954    This entrypoint was added in LIBGCCJIT_ABI_19; you can test for its
955    presence using:
956    #ifdef LIBGCCJIT_HAVE_CTORS
957 */
958 
959 extern gcc_jit_rvalue *
960 gcc_jit_context_new_union_constructor (gcc_jit_context *ctxt,
961 				       gcc_jit_location *loc,
962 				       gcc_jit_type *type,
963 				       gcc_jit_field *field,
964 				       gcc_jit_rvalue *value);
965 
966 /* Create a constructor for an array as an rvalue.
967 
968    Returns NULL on error.  `values` are copied and
969    do not have to outlive the context.
970 
971    `type` specifies what the constructor will build and has to be
972    an array.
973 
974    `num_values` specifies the number of elements in `values` and
975    it can't have more elements than the array type.
976 
977    Each value in `values` sets the corresponding value in the array.
978    If the array type itself has more elements than `values`, the
979    left-over elements will be zeroed.
980 
981    Each value in `values` need to be the same unqualified type as the
982    array type's element type.
983 
984    If `num_values` is 0, the `values` parameter will be
985    ignored and zero initialization will be used.
986 
987    Note that a string literal rvalue can't be used to construct a char
988    array.  It needs one rvalue for each char.
989 
990    This entrypoint was added in LIBGCCJIT_ABI_19; you can test for its
991    presence using:
992    #ifdef LIBGCCJIT_HAVE_CTORS
993 */
994 
995 extern gcc_jit_rvalue *
996 gcc_jit_context_new_array_constructor (gcc_jit_context *ctxt,
997 				       gcc_jit_location *loc,
998 				       gcc_jit_type *type,
999 				       size_t num_values,
1000 				       gcc_jit_rvalue **values);
1001 
1002 /* Set the initial value of a global of any type with an rvalue.
1003 
1004    The rvalue needs to be a constant expression, e.g. no function calls.
1005 
1006    The global can't have the 'kind' GCC_JIT_GLOBAL_IMPORTED.
1007 
1008    Use together with gcc_jit_context_new_constructor () to
1009    initialize structs, unions and arrays.
1010 
1011    On success, returns the 'global' parameter unchanged.  Otherwise, NULL.
1012 
1013    'values' is copied and does not have to outlive the context.
1014 
1015    This entrypoint was added in LIBGCCJIT_ABI_19; you can test for its
1016    presence using:
1017      #ifdef LIBGCCJIT_HAVE_CTORS
1018 */
1019 
1020 extern gcc_jit_lvalue *
1021 gcc_jit_global_set_initializer_rvalue (gcc_jit_lvalue *global,
1022 				       gcc_jit_rvalue *init_value);
1023 
1024 #define LIBGCCJIT_HAVE_gcc_jit_global_set_initializer
1025 
1026 /* Set an initial value for a global, which must be an array of
1027    integral type.  Return the global itself.
1028 
1029    This API entrypoint was added in LIBGCCJIT_ABI_14; you can test for its
1030    presence using
1031      #ifdef LIBGCCJIT_HAVE_gcc_jit_global_set_initializer
1032 */
1033 
1034 extern gcc_jit_lvalue *
1035 gcc_jit_global_set_initializer (gcc_jit_lvalue *global,
1036 				const void *blob,
1037 				size_t num_bytes);
1038 
1039 /* Upcasting.  */
1040 extern gcc_jit_object *
1041 gcc_jit_lvalue_as_object (gcc_jit_lvalue *lvalue);
1042 
1043 extern gcc_jit_rvalue *
1044 gcc_jit_lvalue_as_rvalue (gcc_jit_lvalue *lvalue);
1045 
1046 extern gcc_jit_object *
1047 gcc_jit_rvalue_as_object (gcc_jit_rvalue *rvalue);
1048 
1049 extern gcc_jit_type *
1050 gcc_jit_rvalue_get_type (gcc_jit_rvalue *rvalue);
1051 
1052 /* Integer constants. */
1053 extern gcc_jit_rvalue *
1054 gcc_jit_context_new_rvalue_from_int (gcc_jit_context *ctxt,
1055 				     gcc_jit_type *numeric_type,
1056 				     int value);
1057 
1058 extern gcc_jit_rvalue *
1059 gcc_jit_context_new_rvalue_from_long (gcc_jit_context *ctxt,
1060 				      gcc_jit_type *numeric_type,
1061 				      long value);
1062 
1063 extern gcc_jit_rvalue *
1064 gcc_jit_context_zero (gcc_jit_context *ctxt,
1065 		      gcc_jit_type *numeric_type);
1066 
1067 extern gcc_jit_rvalue *
1068 gcc_jit_context_one (gcc_jit_context *ctxt,
1069 		     gcc_jit_type *numeric_type);
1070 
1071 /* Floating-point constants.  */
1072 extern gcc_jit_rvalue *
1073 gcc_jit_context_new_rvalue_from_double (gcc_jit_context *ctxt,
1074 					gcc_jit_type *numeric_type,
1075 					double value);
1076 
1077 /* Pointers.  */
1078 extern gcc_jit_rvalue *
1079 gcc_jit_context_new_rvalue_from_ptr (gcc_jit_context *ctxt,
1080 				     gcc_jit_type *pointer_type,
1081 				     void *value);
1082 
1083 extern gcc_jit_rvalue *
1084 gcc_jit_context_null (gcc_jit_context *ctxt,
1085 		      gcc_jit_type *pointer_type);
1086 
1087 /* String literals. */
1088 extern gcc_jit_rvalue *
1089 gcc_jit_context_new_string_literal (gcc_jit_context *ctxt,
1090 				    const char *value);
1091 
1092 enum gcc_jit_unary_op
1093 {
1094   /* Negate an arithmetic value; analogous to:
1095        -(EXPR)
1096      in C.  */
1097   GCC_JIT_UNARY_OP_MINUS,
1098 
1099   /* Bitwise negation of an integer value (one's complement); analogous
1100      to:
1101        ~(EXPR)
1102      in C.  */
1103   GCC_JIT_UNARY_OP_BITWISE_NEGATE,
1104 
1105   /* Logical negation of an arithmetic or pointer value; analogous to:
1106        !(EXPR)
1107      in C.  */
1108   GCC_JIT_UNARY_OP_LOGICAL_NEGATE,
1109 
1110   /* Absolute value of an arithmetic expression; analogous to:
1111        abs (EXPR)
1112      in C.  */
1113   GCC_JIT_UNARY_OP_ABS
1114 
1115 };
1116 
1117 extern gcc_jit_rvalue *
1118 gcc_jit_context_new_unary_op (gcc_jit_context *ctxt,
1119 			      gcc_jit_location *loc,
1120 			      enum gcc_jit_unary_op op,
1121 			      gcc_jit_type *result_type,
1122 			      gcc_jit_rvalue *rvalue);
1123 
1124 enum gcc_jit_binary_op
1125 {
1126   /* Addition of arithmetic values; analogous to:
1127        (EXPR_A) + (EXPR_B)
1128      in C.
1129      For pointer addition, use gcc_jit_context_new_array_access.  */
1130   GCC_JIT_BINARY_OP_PLUS,
1131 
1132   /* Subtraction of arithmetic values; analogous to:
1133        (EXPR_A) - (EXPR_B)
1134      in C.  */
1135   GCC_JIT_BINARY_OP_MINUS,
1136 
1137   /* Multiplication of a pair of arithmetic values; analogous to:
1138        (EXPR_A) * (EXPR_B)
1139      in C.  */
1140   GCC_JIT_BINARY_OP_MULT,
1141 
1142   /* Quotient of division of arithmetic values; analogous to:
1143        (EXPR_A) / (EXPR_B)
1144      in C.
1145      The result type affects the kind of division: if the result type is
1146      integer-based, then the result is truncated towards zero, whereas
1147      a floating-point result type indicates floating-point division.  */
1148   GCC_JIT_BINARY_OP_DIVIDE,
1149 
1150   /* Remainder of division of arithmetic values; analogous to:
1151        (EXPR_A) % (EXPR_B)
1152      in C.  */
1153   GCC_JIT_BINARY_OP_MODULO,
1154 
1155   /* Bitwise AND; analogous to:
1156        (EXPR_A) & (EXPR_B)
1157      in C.  */
1158   GCC_JIT_BINARY_OP_BITWISE_AND,
1159 
1160   /* Bitwise exclusive OR; analogous to:
1161        (EXPR_A) ^ (EXPR_B)
1162      in C.  */
1163   GCC_JIT_BINARY_OP_BITWISE_XOR,
1164 
1165   /* Bitwise inclusive OR; analogous to:
1166        (EXPR_A) | (EXPR_B)
1167      in C.  */
1168   GCC_JIT_BINARY_OP_BITWISE_OR,
1169 
1170   /* Logical AND; analogous to:
1171        (EXPR_A) && (EXPR_B)
1172      in C.  */
1173   GCC_JIT_BINARY_OP_LOGICAL_AND,
1174 
1175   /* Logical OR; analogous to:
1176        (EXPR_A) || (EXPR_B)
1177      in C.  */
1178   GCC_JIT_BINARY_OP_LOGICAL_OR,
1179 
1180   /* Left shift; analogous to:
1181        (EXPR_A) << (EXPR_B)
1182      in C.  */
1183   GCC_JIT_BINARY_OP_LSHIFT,
1184 
1185   /* Right shift; analogous to:
1186        (EXPR_A) >> (EXPR_B)
1187      in C.  */
1188   GCC_JIT_BINARY_OP_RSHIFT
1189 };
1190 
1191 extern gcc_jit_rvalue *
1192 gcc_jit_context_new_binary_op (gcc_jit_context *ctxt,
1193 			       gcc_jit_location *loc,
1194 			       enum gcc_jit_binary_op op,
1195 			       gcc_jit_type *result_type,
1196 			       gcc_jit_rvalue *a, gcc_jit_rvalue *b);
1197 
1198 /* (Comparisons are treated as separate from "binary_op" to save
1199    you having to specify the result_type).  */
1200 
1201 enum gcc_jit_comparison
1202 {
1203   /* (EXPR_A) == (EXPR_B).  */
1204   GCC_JIT_COMPARISON_EQ,
1205 
1206   /* (EXPR_A) != (EXPR_B).  */
1207   GCC_JIT_COMPARISON_NE,
1208 
1209   /* (EXPR_A) < (EXPR_B).  */
1210   GCC_JIT_COMPARISON_LT,
1211 
1212   /* (EXPR_A) <=(EXPR_B).  */
1213   GCC_JIT_COMPARISON_LE,
1214 
1215   /* (EXPR_A) > (EXPR_B).  */
1216   GCC_JIT_COMPARISON_GT,
1217 
1218   /* (EXPR_A) >= (EXPR_B).  */
1219   GCC_JIT_COMPARISON_GE
1220 };
1221 
1222 extern gcc_jit_rvalue *
1223 gcc_jit_context_new_comparison (gcc_jit_context *ctxt,
1224 				gcc_jit_location *loc,
1225 				enum gcc_jit_comparison op,
1226 				gcc_jit_rvalue *a, gcc_jit_rvalue *b);
1227 
1228 /* Function calls.  */
1229 
1230 /* Call of a specific function.  */
1231 extern gcc_jit_rvalue *
1232 gcc_jit_context_new_call (gcc_jit_context *ctxt,
1233 			  gcc_jit_location *loc,
1234 			  gcc_jit_function *func,
1235 			  int numargs , gcc_jit_rvalue **args);
1236 
1237 /* Call through a function pointer.  */
1238 extern gcc_jit_rvalue *
1239 gcc_jit_context_new_call_through_ptr (gcc_jit_context *ctxt,
1240 				      gcc_jit_location *loc,
1241 				      gcc_jit_rvalue *fn_ptr,
1242 				      int numargs, gcc_jit_rvalue **args);
1243 
1244 /* Type-coercion.
1245 
1246    Currently only a limited set of conversions are possible:
1247      int <-> float
1248      int <-> bool  */
1249 extern gcc_jit_rvalue *
1250 gcc_jit_context_new_cast (gcc_jit_context *ctxt,
1251 			  gcc_jit_location *loc,
1252 			  gcc_jit_rvalue *rvalue,
1253 			  gcc_jit_type *type);
1254 
1255 #define LIBGCCJIT_HAVE_gcc_jit_context_new_bitcast
1256 
1257 /* Reinterpret a value as another type.
1258 
1259    The types must be of the same size.
1260 
1261    This API entrypoint was added in LIBGCCJIT_ABI_21; you can test for its
1262    presence using
1263      #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_bitcast  */
1264 extern gcc_jit_rvalue *
1265 gcc_jit_context_new_bitcast (gcc_jit_context *ctxt,
1266 			     gcc_jit_location *loc,
1267 			     gcc_jit_rvalue *rvalue,
1268 			     gcc_jit_type *type);
1269 
1270 #define LIBGCCJIT_HAVE_ALIGNMENT
1271 
1272 /* Set the alignment of a variable.
1273 
1274    This API entrypoint was added in LIBGCCJIT_ABI_24; you can test for its
1275    presence using
1276      #ifdef LIBGCCJIT_HAVE_ALIGNMENT  */
1277 extern void
1278 gcc_jit_lvalue_set_alignment (gcc_jit_lvalue *lvalue,
1279 			      unsigned bytes);
1280 
1281 /* Get the alignment of a variable.
1282 
1283    This API entrypoint was added in LIBGCCJIT_ABI_24; you can test for its
1284    presence using
1285      #ifdef LIBGCCJIT_HAVE_ALIGNMENT  */
1286 extern unsigned
1287 gcc_jit_lvalue_get_alignment (gcc_jit_lvalue *lvalue);
1288 
1289 extern gcc_jit_lvalue *
1290 gcc_jit_context_new_array_access (gcc_jit_context *ctxt,
1291 				  gcc_jit_location *loc,
1292 				  gcc_jit_rvalue *ptr,
1293 				  gcc_jit_rvalue *index);
1294 
1295 /* Field access is provided separately for both lvalues and rvalues.  */
1296 
1297 /* Accessing a field of an lvalue of struct type, analogous to:
1298       (EXPR).field = ...;
1299    in C.  */
1300 extern gcc_jit_lvalue *
1301 gcc_jit_lvalue_access_field (gcc_jit_lvalue *struct_or_union,
1302 			     gcc_jit_location *loc,
1303 			     gcc_jit_field *field);
1304 
1305 /* Accessing a field of an rvalue of struct type, analogous to:
1306       (EXPR).field
1307    in C.  */
1308 extern gcc_jit_rvalue *
1309 gcc_jit_rvalue_access_field (gcc_jit_rvalue *struct_or_union,
1310 			     gcc_jit_location *loc,
1311 			     gcc_jit_field *field);
1312 
1313 /* Accessing a field of an rvalue of pointer type, analogous to:
1314       (EXPR)->field
1315    in C, itself equivalent to (*EXPR).FIELD  */
1316 extern gcc_jit_lvalue *
1317 gcc_jit_rvalue_dereference_field (gcc_jit_rvalue *ptr,
1318 				  gcc_jit_location *loc,
1319 				  gcc_jit_field *field);
1320 
1321 /* Dereferencing a pointer; analogous to:
1322      *(EXPR)
1323 */
1324 extern gcc_jit_lvalue *
1325 gcc_jit_rvalue_dereference (gcc_jit_rvalue *rvalue,
1326 			    gcc_jit_location *loc);
1327 
1328 /* Taking the address of an lvalue; analogous to:
1329      &(EXPR)
1330    in C.  */
1331 extern gcc_jit_rvalue *
1332 gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue,
1333 			    gcc_jit_location *loc);
1334 
1335 #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model
1336 
1337 /* Set the thread-local storage model of a global variable
1338 
1339    This API entrypoint was added in LIBGCCJIT_ABI_17; you can test for its
1340    presence using
1341      #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_tls_model  */
1342 extern void
1343 gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue *lvalue,
1344 			    enum gcc_jit_tls_model model);
1345 
1346 #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section
1347 
1348 /* Set the link section of a global variable; analogous to:
1349      __attribute__((section(".section_name")))
1350    in C.
1351 
1352    This API entrypoint was added in LIBGCCJIT_ABI_18; you can test for its
1353    presence using
1354      #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section
1355 */
1356 extern void
1357 gcc_jit_lvalue_set_link_section (gcc_jit_lvalue *lvalue,
1358 			    const char *section_name);
1359 
1360 #define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_register_name
1361 
1362 /* Make this variable a register variable and set its register name.
1363 
1364    This API entrypoint was added in LIBGCCJIT_ABI_22; you can test for its
1365    presence using
1366      #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_register_name
1367 */
1368 void
1369 gcc_jit_lvalue_set_register_name (gcc_jit_lvalue *lvalue,
1370 				  const char *reg_name);
1371 
1372 extern gcc_jit_lvalue *
1373 gcc_jit_function_new_local (gcc_jit_function *func,
1374 			    gcc_jit_location *loc,
1375 			    gcc_jit_type *type,
1376 			    const char *name);
1377 
1378 /**********************************************************************
1379  Statement-creation.
1380  **********************************************************************/
1381 
1382 /* Add evaluation of an rvalue, discarding the result
1383    (e.g. a function call that "returns" void).
1384 
1385    This is equivalent to this C code:
1386 
1387      (void)expression;
1388 */
1389 extern void
1390 gcc_jit_block_add_eval (gcc_jit_block *block,
1391 			gcc_jit_location *loc,
1392 			gcc_jit_rvalue *rvalue);
1393 
1394 /* Add evaluation of an rvalue, assigning the result to the given
1395    lvalue.
1396 
1397    This is roughly equivalent to this C code:
1398 
1399      lvalue = rvalue;
1400 */
1401 extern void
1402 gcc_jit_block_add_assignment (gcc_jit_block *block,
1403 			      gcc_jit_location *loc,
1404 			      gcc_jit_lvalue *lvalue,
1405 			      gcc_jit_rvalue *rvalue);
1406 
1407 /* Add evaluation of an rvalue, using the result to modify an
1408    lvalue.
1409 
1410    This is analogous to "+=" and friends:
1411 
1412      lvalue += rvalue;
1413      lvalue *= rvalue;
1414      lvalue /= rvalue;
1415    etc  */
1416 extern void
1417 gcc_jit_block_add_assignment_op (gcc_jit_block *block,
1418 				 gcc_jit_location *loc,
1419 				 gcc_jit_lvalue *lvalue,
1420 				 enum gcc_jit_binary_op op,
1421 				 gcc_jit_rvalue *rvalue);
1422 
1423 /* Add a no-op textual comment to the internal representation of the
1424    code.  It will be optimized away, but will be visible in the dumps
1425    seen via
1426      GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE
1427    and
1428      GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE,
1429    and thus may be of use when debugging how your project's internal
1430    representation gets converted to the libgccjit IR.  */
1431 extern void
1432 gcc_jit_block_add_comment (gcc_jit_block *block,
1433 			   gcc_jit_location *loc,
1434 			   const char *text);
1435 
1436 /* Terminate a block by adding evaluation of an rvalue, branching on the
1437    result to the appropriate successor block.
1438 
1439    This is roughly equivalent to this C code:
1440 
1441      if (boolval)
1442        goto on_true;
1443      else
1444        goto on_false;
1445 
1446    block, boolval, on_true, and on_false must be non-NULL.  */
1447 extern void
1448 gcc_jit_block_end_with_conditional (gcc_jit_block *block,
1449 				    gcc_jit_location *loc,
1450 				    gcc_jit_rvalue *boolval,
1451 				    gcc_jit_block *on_true,
1452 				    gcc_jit_block *on_false);
1453 
1454 /* Terminate a block by adding a jump to the given target block.
1455 
1456    This is roughly equivalent to this C code:
1457 
1458       goto target;
1459 */
1460 extern void
1461 gcc_jit_block_end_with_jump (gcc_jit_block *block,
1462 			     gcc_jit_location *loc,
1463 			     gcc_jit_block *target);
1464 
1465 /* Terminate a block by adding evaluation of an rvalue, returning the value.
1466 
1467    This is roughly equivalent to this C code:
1468 
1469       return expression;
1470 */
1471 extern void
1472 gcc_jit_block_end_with_return (gcc_jit_block *block,
1473 			       gcc_jit_location *loc,
1474 			       gcc_jit_rvalue *rvalue);
1475 
1476 /* Terminate a block by adding a valueless return, for use within a function
1477    with "void" return type.
1478 
1479    This is equivalent to this C code:
1480 
1481       return;
1482 */
1483 extern void
1484 gcc_jit_block_end_with_void_return (gcc_jit_block *block,
1485 				    gcc_jit_location *loc);
1486 
1487 /* Create a new gcc_jit_case instance for use in a switch statement.
1488    min_value and max_value must be constants of integer type.
1489 
1490    This API entrypoint was added in LIBGCCJIT_ABI_3; you can test for its
1491    presence using
1492      #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1493 */
1494 extern gcc_jit_case *
1495 gcc_jit_context_new_case (gcc_jit_context *ctxt,
1496 			  gcc_jit_rvalue *min_value,
1497 			  gcc_jit_rvalue *max_value,
1498 			  gcc_jit_block *dest_block);
1499 
1500 /* Upcasting from case to object.
1501 
1502    This API entrypoint was added in LIBGCCJIT_ABI_3; you can test for its
1503    presence using
1504      #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1505 */
1506 
1507 extern gcc_jit_object *
1508 gcc_jit_case_as_object (gcc_jit_case *case_);
1509 
1510 /* Terminate a block by adding evalation of an rvalue, then performing
1511    a multiway branch.
1512 
1513    This is roughly equivalent to this C code:
1514 
1515      switch (expr)
1516        {
1517        default:
1518 	 goto default_block;
1519 
1520        case C0.min_value ... C0.max_value:
1521 	 goto C0.dest_block;
1522 
1523        case C1.min_value ... C1.max_value:
1524 	 goto C1.dest_block;
1525 
1526        ...etc...
1527 
1528        case C[N - 1].min_value ... C[N - 1].max_value:
1529 	 goto C[N - 1].dest_block;
1530      }
1531 
1532    block, expr, default_block and cases must all be non-NULL.
1533 
1534    expr must be of the same integer type as all of the min_value
1535    and max_value within the cases.
1536 
1537    num_cases must be >= 0.
1538 
1539    The ranges of the cases must not overlap (or have duplicate
1540    values).
1541 
1542    This API entrypoint was added in LIBGCCJIT_ABI_3; you can test for its
1543    presence using
1544      #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1545 */
1546 
1547 extern void
1548 gcc_jit_block_end_with_switch (gcc_jit_block *block,
1549 			       gcc_jit_location *loc,
1550 			       gcc_jit_rvalue *expr,
1551 			       gcc_jit_block *default_block,
1552 			       int num_cases,
1553 			       gcc_jit_case **cases);
1554 
1555 /* Pre-canned feature macro to indicate the presence of
1556    gcc_jit_block_end_with_switch, gcc_jit_case_as_object, and
1557    gcc_jit_context_new_case.
1558 
1559    This can be tested for with #ifdef.  */
1560 #define LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1561 
1562 /**********************************************************************
1563  Nested contexts.
1564  **********************************************************************/
1565 
1566 /* Given an existing JIT context, create a child context.
1567 
1568    The child inherits a copy of all option-settings from the parent.
1569 
1570    The child can reference objects created within the parent, but not
1571    vice-versa.
1572 
1573    The lifetime of the child context must be bounded by that of the
1574    parent: you should release a child context before releasing the parent
1575    context.
1576 
1577    If you use a function from a parent context within a child context,
1578    you have to compile the parent context before you can compile the
1579    child context, and the gcc_jit_result of the parent context must
1580    outlive the gcc_jit_result of the child context.
1581 
1582    This allows caching of shared initializations.  For example, you could
1583    create types and declarations of global functions in a parent context
1584    once within a process, and then create child contexts whenever a
1585    function or loop becomes hot. Each such child context can be used for
1586    JIT-compiling just one function or loop, but can reference types
1587    and helper functions created within the parent context.
1588 
1589    Contexts can be arbitrarily nested, provided the above rules are
1590    followed, but it's probably not worth going above 2 or 3 levels, and
1591    there will likely be a performance hit for such nesting.  */
1592 
1593 extern gcc_jit_context *
1594 gcc_jit_context_new_child_context (gcc_jit_context *parent_ctxt);
1595 
1596 /**********************************************************************
1597  Implementation support.
1598  **********************************************************************/
1599 
1600 /* Write C source code into "path" that can be compiled into a
1601    self-contained executable (i.e. with libgccjit as the only dependency).
1602    The generated code will attempt to replay the API calls that have been
1603    made into the given context.
1604 
1605    This may be useful when debugging the library or client code, for
1606    reducing a complicated recipe for reproducing a bug into a simpler
1607    form.
1608 
1609    Typically you need to supply the option "-Wno-unused-variable" when
1610    compiling the generated file (since the result of each API call is
1611    assigned to a unique variable within the generated C source, and not
1612    all are necessarily then used).  */
1613 
1614 extern void
1615 gcc_jit_context_dump_reproducer_to_file (gcc_jit_context *ctxt,
1616 					 const char *path);
1617 
1618 /* Enable the dumping of a specific set of internal state from the
1619    compilation, capturing the result in-memory as a buffer.
1620 
1621    Parameter "dumpname" corresponds to the equivalent gcc command-line
1622    option, without the "-fdump-" prefix.
1623    For example, to get the equivalent of "-fdump-tree-vrp1", supply
1624    "tree-vrp1".
1625    The context directly stores the dumpname as a (const char *), so the
1626    passed string must outlive the context.
1627 
1628    gcc_jit_context_compile and gcc_jit_context_to_file
1629    will capture the dump as a dynamically-allocated buffer, writing
1630    it to ``*out_ptr``.
1631 
1632    The caller becomes responsible for calling
1633       free (*out_ptr)
1634    each time that gcc_jit_context_compile or gcc_jit_context_to_file
1635    are called.  *out_ptr will be written to, either with the address of a
1636    buffer, or with NULL if an error occurred.
1637 
1638    This API entrypoint is likely to be less stable than the others.
1639    In particular, both the precise dumpnames, and the format and content
1640    of the dumps are subject to change.
1641 
1642    It exists primarily for writing the library's own test suite.  */
1643 
1644 extern void
1645 gcc_jit_context_enable_dump (gcc_jit_context *ctxt,
1646 			     const char *dumpname,
1647 			     char **out_ptr);
1648 
1649 /**********************************************************************
1650  Timing support.
1651  **********************************************************************/
1652 
1653 /* The timing API was added in LIBGCCJIT_ABI_4; you can test for its
1654    presence using
1655      #ifdef LIBGCCJIT_HAVE_TIMING_API
1656 */
1657 #define LIBGCCJIT_HAVE_TIMING_API
1658 
1659 typedef struct gcc_jit_timer gcc_jit_timer;
1660 
1661 /* Create a gcc_jit_timer instance, and start timing.
1662 
1663    This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1664    presence using
1665      #ifdef LIBGCCJIT_HAVE_TIMING_API
1666 */
1667 extern gcc_jit_timer *
1668 gcc_jit_timer_new (void);
1669 
1670 /* Release a gcc_jit_timer instance.
1671 
1672    This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1673    presence using
1674      #ifdef LIBGCCJIT_HAVE_TIMING_API
1675 */
1676 extern void
1677 gcc_jit_timer_release (gcc_jit_timer *timer);
1678 
1679 /* Associate a gcc_jit_timer instance with a context.
1680 
1681    This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1682    presence using
1683      #ifdef LIBGCCJIT_HAVE_TIMING_API
1684 */
1685 extern void
1686 gcc_jit_context_set_timer (gcc_jit_context *ctxt,
1687 			   gcc_jit_timer *timer);
1688 
1689 /* Get the timer associated with a context (if any).
1690 
1691    This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1692    presence using
1693      #ifdef LIBGCCJIT_HAVE_TIMING_API
1694 */
1695 
1696 extern gcc_jit_timer *
1697 gcc_jit_context_get_timer (gcc_jit_context *ctxt);
1698 
1699 /* Push the given item onto the timing stack.
1700 
1701    This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1702    presence using
1703      #ifdef LIBGCCJIT_HAVE_TIMING_API
1704 */
1705 
1706 extern void
1707 gcc_jit_timer_push (gcc_jit_timer *timer,
1708 		    const char *item_name);
1709 
1710 /* Pop the top item from the timing stack.
1711 
1712    This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1713    presence using
1714      #ifdef LIBGCCJIT_HAVE_TIMING_API
1715 */
1716 
1717 extern void
1718 gcc_jit_timer_pop (gcc_jit_timer *timer,
1719 		   const char *item_name);
1720 
1721 /* Print timing information to the given stream about activity since
1722    the timer was started.
1723 
1724    This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1725    presence using
1726      #ifdef LIBGCCJIT_HAVE_TIMING_API
1727 */
1728 
1729 extern void
1730 gcc_jit_timer_print (gcc_jit_timer *timer,
1731 		     FILE *f_out);
1732 
1733 
1734 #define LIBGCCJIT_HAVE_gcc_jit_rvalue_set_bool_require_tail_call
1735 
1736 /* Mark/clear a call as needing tail-call optimization.
1737 
1738    This API entrypoint was added in LIBGCCJIT_ABI_6; you can test for its
1739    presence using
1740      #ifdef LIBGCCJIT_HAVE_gcc_jit_rvalue_set_bool_require_tail_call
1741 */
1742 extern void
1743 gcc_jit_rvalue_set_bool_require_tail_call (gcc_jit_rvalue *call,
1744 					   int require_tail_call);
1745 
1746 #define LIBGCCJIT_HAVE_gcc_jit_type_get_aligned
1747 
1748 /* Given type "T", get type:
1749 
1750      T __attribute__ ((aligned (ALIGNMENT_IN_BYTES)))
1751 
1752    The alignment must be a power of two.
1753 
1754    This API entrypoint was added in LIBGCCJIT_ABI_7; you can test for its
1755    presence using
1756      #ifdef LIBGCCJIT_HAVE_gcc_jit_type_get_aligned
1757 */
1758 extern gcc_jit_type *
1759 gcc_jit_type_get_aligned (gcc_jit_type *type,
1760 			  size_t alignment_in_bytes);
1761 
1762 #define LIBGCCJIT_HAVE_gcc_jit_type_get_vector
1763 
1764 /* Given type "T", get type:
1765 
1766      T  __attribute__ ((vector_size (sizeof(T) * num_units))
1767 
1768    T must be integral/floating point; num_units must be a power of two.
1769 
1770    This API entrypoint was added in LIBGCCJIT_ABI_8; you can test for its
1771    presence using
1772      #ifdef LIBGCCJIT_HAVE_gcc_jit_type_get_vector
1773 */
1774 extern gcc_jit_type *
1775 gcc_jit_type_get_vector (gcc_jit_type *type, size_t num_units);
1776 
1777 
1778 #define LIBGCCJIT_HAVE_gcc_jit_function_get_address
1779 
1780 /* Get the address of a function as an rvalue, of function pointer
1781    type.
1782 
1783    This API entrypoint was added in LIBGCCJIT_ABI_9; you can test for its
1784    presence using
1785      #ifdef LIBGCCJIT_HAVE_gcc_jit_function_get_address
1786 */
1787 extern gcc_jit_rvalue *
1788 gcc_jit_function_get_address (gcc_jit_function *fn,
1789 			      gcc_jit_location *loc);
1790 
1791 
1792 #define LIBGCCJIT_HAVE_gcc_jit_context_new_rvalue_from_vector
1793 
1794 /* Build a vector rvalue from an array of elements.
1795 
1796    "vec_type" should be a vector type, created using gcc_jit_type_get_vector.
1797 
1798    This API entrypoint was added in LIBGCCJIT_ABI_10; you can test for its
1799    presence using
1800      #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_rvalue_from_vector
1801 */
1802 extern gcc_jit_rvalue *
1803 gcc_jit_context_new_rvalue_from_vector (gcc_jit_context *ctxt,
1804 					gcc_jit_location *loc,
1805 					gcc_jit_type *vec_type,
1806 					size_t num_elements,
1807 					gcc_jit_rvalue **elements);
1808 
1809 #define LIBGCCJIT_HAVE_gcc_jit_version
1810 
1811 /* Functions to retrieve libgccjit version.
1812    Analogous to __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__ in C code.
1813 
1814    These API entrypoints were added in LIBGCCJIT_ABI_13; you can test for their
1815    presence using
1816      #ifdef LIBGCCJIT_HAVE_gcc_jit_version
1817  */
1818 extern int
1819 gcc_jit_version_major (void);
1820 extern int
1821 gcc_jit_version_minor (void);
1822 extern int
1823 gcc_jit_version_patchlevel (void);
1824 
1825 /**********************************************************************
1826  Asm support.
1827  **********************************************************************/
1828 
1829 /* Functions for adding inline assembler code, analogous to GCC's
1830    "extended asm" syntax.
1831 
1832    See https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-with-C.html
1833 
1834    These API entrypoints were added in LIBGCCJIT_ABI_15; you can test for their
1835    presence using
1836      #ifdef LIBGCCJIT_HAVE_ASM_STATEMENTS
1837 */
1838 
1839 #define LIBGCCJIT_HAVE_ASM_STATEMENTS
1840 
1841 /* Create a gcc_jit_extended_asm for an extended asm statement
1842    with no control flow (i.e. without the goto qualifier).
1843 
1844    The asm_template parameter  corresponds to the AssemblerTemplate
1845    within C's extended asm syntax.  It must be non-NULL.  */
1846 
1847 extern gcc_jit_extended_asm *
1848 gcc_jit_block_add_extended_asm (gcc_jit_block *block,
1849 				gcc_jit_location *loc,
1850 				const char *asm_template);
1851 
1852 /* Create a gcc_jit_extended_asm for an extended asm statement
1853    that may perform jumps, and use it to terminate the given block.
1854    This is equivalent to the "goto" qualifier in C's extended asm
1855    syntax.  */
1856 
1857 extern gcc_jit_extended_asm *
1858 gcc_jit_block_end_with_extended_asm_goto (gcc_jit_block *block,
1859 					  gcc_jit_location *loc,
1860 					  const char *asm_template,
1861 					  int num_goto_blocks,
1862 					  gcc_jit_block **goto_blocks,
1863 					  gcc_jit_block *fallthrough_block);
1864 
1865 /* Upcasting from extended asm to object.  */
1866 
1867 extern gcc_jit_object *
1868 gcc_jit_extended_asm_as_object (gcc_jit_extended_asm *ext_asm);
1869 
1870 /* Set whether the gcc_jit_extended_asm has side-effects, equivalent to
1871    the "volatile" qualifier in C's extended asm syntax.  */
1872 
1873 extern void
1874 gcc_jit_extended_asm_set_volatile_flag (gcc_jit_extended_asm *ext_asm,
1875 					int flag);
1876 
1877 /* Set the equivalent of the "inline" qualifier in C's extended asm
1878    syntax.  */
1879 
1880 extern void
1881 gcc_jit_extended_asm_set_inline_flag (gcc_jit_extended_asm *ext_asm,
1882 				      int flag);
1883 
1884 /* Add an output operand to the extended asm statement.
1885    "asm_symbolic_name" can be NULL.
1886    "constraint" and "dest" must be non-NULL.
1887    This function can't be called on an "asm goto" as such instructions
1888    can't have outputs  */
1889 
1890 extern void
1891 gcc_jit_extended_asm_add_output_operand (gcc_jit_extended_asm *ext_asm,
1892 					 const char *asm_symbolic_name,
1893 					 const char *constraint,
1894 					 gcc_jit_lvalue *dest);
1895 
1896 /* Add an input operand to the extended asm statement.
1897    "asm_symbolic_name" can be NULL.
1898    "constraint" and "src" must be non-NULL.  */
1899 
1900 extern void
1901 gcc_jit_extended_asm_add_input_operand (gcc_jit_extended_asm *ext_asm,
1902 					const char *asm_symbolic_name,
1903 					const char *constraint,
1904 					gcc_jit_rvalue *src);
1905 
1906 /* Add "victim" to the list of registers clobbered by the extended
1907    asm statement.  It must be non-NULL.  */
1908 
1909 extern void
1910 gcc_jit_extended_asm_add_clobber (gcc_jit_extended_asm *ext_asm,
1911 				  const char *victim);
1912 
1913 /* Add "asm_stmts", a set of top-level asm statements, analogous to
1914    those created by GCC's "basic" asm syntax in C at file scope.  */
1915 
1916 extern void
1917 gcc_jit_context_add_top_level_asm (gcc_jit_context *ctxt,
1918 				   gcc_jit_location *loc,
1919 				   const char *asm_stmts);
1920 
1921 #define LIBGCCJIT_HAVE_REFLECTION
1922 
1923 /* Reflection functions to get the number of parameters, return type of
1924    a function and whether a type is a bool from the C API.
1925 
1926    This API entrypoint was added in LIBGCCJIT_ABI_16; you can test for its
1927    presence using
1928      #ifdef LIBGCCJIT_HAVE_REFLECTION
1929 */
1930 /* Get the return type of a function.  */
1931 extern gcc_jit_type *
1932 gcc_jit_function_get_return_type (gcc_jit_function *func);
1933 
1934 /* Get the number of params of a function.  */
1935 extern size_t
1936 gcc_jit_function_get_param_count (gcc_jit_function *func);
1937 
1938 /* Get the element type of an array type or NULL if it's not an array.  */
1939 extern gcc_jit_type *
1940 gcc_jit_type_dyncast_array (gcc_jit_type *type);
1941 
1942 /* Return non-zero if the type is a bool.  */
1943 extern int
1944 gcc_jit_type_is_bool (gcc_jit_type *type);
1945 
1946 /* Return the function type if it is one or NULL.  */
1947 extern gcc_jit_function_type *
1948 gcc_jit_type_dyncast_function_ptr_type (gcc_jit_type *type);
1949 
1950 /* Given a function type, return its return type.  */
1951 extern gcc_jit_type *
1952 gcc_jit_function_type_get_return_type (gcc_jit_function_type *function_type);
1953 
1954 /* Given a function type, return its number of parameters.  */
1955 extern size_t
1956 gcc_jit_function_type_get_param_count (gcc_jit_function_type *function_type);
1957 
1958 /* Given a function type, return the type of the specified parameter.  */
1959 extern gcc_jit_type *
1960 gcc_jit_function_type_get_param_type (gcc_jit_function_type *function_type,
1961 				size_t index);
1962 
1963 /* Return non-zero if the type is an integral.  */
1964 extern int
1965 gcc_jit_type_is_integral (gcc_jit_type *type);
1966 
1967 /* Return the type pointed by the pointer type or NULL if it's not a
1968  * pointer.  */
1969 extern gcc_jit_type *
1970 gcc_jit_type_is_pointer (gcc_jit_type *type);
1971 
1972 /* Given a type, return a dynamic cast to a vector type or NULL.  */
1973 extern gcc_jit_vector_type *
1974 gcc_jit_type_dyncast_vector (gcc_jit_type *type);
1975 
1976 /* Given a type, return a dynamic cast to a struct type or NULL.  */
1977 extern gcc_jit_struct *
1978 gcc_jit_type_is_struct (gcc_jit_type *type);
1979 
1980 /* Given a vector type, return the number of units it contains.  */
1981 extern size_t
1982 gcc_jit_vector_type_get_num_units (gcc_jit_vector_type *vector_type);
1983 
1984 /* Given a vector type, return the type of its elements.  */
1985 extern gcc_jit_type *
1986 gcc_jit_vector_type_get_element_type (gcc_jit_vector_type *vector_type);
1987 
1988 /* Given a type, return the unqualified type, removing "const", "volatile"
1989  * and alignment qualifiers.  */
1990 extern gcc_jit_type *
1991 gcc_jit_type_unqualified (gcc_jit_type *type);
1992 
1993 #ifdef __cplusplus
1994 }
1995 #endif /* __cplusplus */
1996 
1997 #endif  /* LIBGCCJIT_H  */
1998