1 /* A pure C API to enable client code to embed GCC as a JIT-compiler.
2 Copyright (C) 2013-2023 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 */