Mercurial > hg > CbC > CbC_gcc

comparison gcc/jit/libgccjit.h @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children 84e7813d76e9
comparison
equal deleted inserted replaced
68:561a7518be6b 111:04ced10e8804
1 /* A pure C API to enable client code to embed GCC as a JIT-compiler.
2 Copyright (C) 2013-2017 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_field
65 +- gcc_jit_function
66 +- gcc_jit_block
67 +- gcc_jit_rvalue
68 +- gcc_jit_lvalue
69 +- gcc_jit_param
70 +- gcc_jit_case
71 */
72 typedef struct gcc_jit_object gcc_jit_object;
73
74 /* A gcc_jit_location encapsulates a source code location, so that
75 you can (optionally) associate locations in your language with
76 statements in the JIT-compiled code, allowing the debugger to
77 single-step through your language.
78
79 Note that to do so, you also need to enable
80 GCC_JIT_BOOL_OPTION_DEBUGINFO
81 on the gcc_jit_context.
82
83 gcc_jit_location instances are optional; you can always pass
84 NULL. */
85 typedef struct gcc_jit_location gcc_jit_location;
86
87 /* A gcc_jit_type encapsulates a type e.g. "int" or a "struct foo*". */
88 typedef struct gcc_jit_type gcc_jit_type;
89
90 /* A gcc_jit_field encapsulates a field within a struct; it is used
91 when creating a struct type (using gcc_jit_context_new_struct_type).
92 Fields cannot be shared between structs. */
93 typedef struct gcc_jit_field gcc_jit_field;
94
95 /* A gcc_jit_struct encapsulates a struct type, either one that we have
96 the layout for, or an opaque type. */
97 typedef struct gcc_jit_struct gcc_jit_struct;
98
99 /* A gcc_jit_function encapsulates a function: either one that you're
100 creating yourself, or a reference to one that you're dynamically
101 linking to within the rest of the process. */
102 typedef struct gcc_jit_function gcc_jit_function;
103
104 /* A gcc_jit_block encapsulates a "basic block" of statements within a
105 function (i.e. with one entry point and one exit point).
106
107 Every block within a function must be terminated with a conditional,
108 a branch, or a return.
109
110 The blocks within a function form a directed graph.
111
112 The entrypoint to the function is the first block created within
113 it.
114
115 All of the blocks in a function must be reachable via some path from
116 the first block.
117
118 It's OK to have more than one "return" from a function (i.e. multiple
119 blocks that terminate by returning). */
120 typedef struct gcc_jit_block gcc_jit_block;
121
122 /* A gcc_jit_rvalue is an expression within your code, with some type. */
123 typedef struct gcc_jit_rvalue gcc_jit_rvalue;
124
125 /* A gcc_jit_lvalue is a storage location within your code (e.g. a
126 variable, a parameter, etc). It is also a gcc_jit_rvalue; use
127 gcc_jit_lvalue_as_rvalue to cast. */
128 typedef struct gcc_jit_lvalue gcc_jit_lvalue;
129
130 /* A gcc_jit_param is a function parameter, used when creating a
131 gcc_jit_function. It is also a gcc_jit_lvalue (and thus also an
132 rvalue); use gcc_jit_param_as_lvalue to convert. */
133 typedef struct gcc_jit_param gcc_jit_param;
134
135 /* A gcc_jit_case is for use when building multiway branches via
136 gcc_jit_block_end_with_switch and represents a range of integer
137 values (or an individual integer value) together with an associated
138 destination block. */
139 typedef struct gcc_jit_case gcc_jit_case;
140
141 /* Acquire a JIT-compilation context. */
142 extern gcc_jit_context *
143 gcc_jit_context_acquire (void);
144
145 /* Release the context. After this call, it's no longer valid to use
146 the ctxt. */
147 extern void
148 gcc_jit_context_release (gcc_jit_context *ctxt);
149
150 /* Options present in the initial release of libgccjit.
151 These were handled using enums. */
152
153 /* Options taking string values. */
154 enum gcc_jit_str_option
155 {
156 /* The name of the program, for use as a prefix when printing error
157 messages to stderr. If NULL, or default, "libgccjit.so" is used. */
158 GCC_JIT_STR_OPTION_PROGNAME,
159
160 GCC_JIT_NUM_STR_OPTIONS
161 };
162
163 /* Options taking int values. */
164 enum gcc_jit_int_option
165 {
166 /* How much to optimize the code.
167 Valid values are 0-3, corresponding to GCC's command-line options
168 -O0 through -O3.
169
170 The default value is 0 (unoptimized). */
171 GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL,
172
173 GCC_JIT_NUM_INT_OPTIONS
174 };
175
176 /* Options taking boolean values.
177 These all default to "false". */
178 enum gcc_jit_bool_option
179 {
180 /* If true, gcc_jit_context_compile will attempt to do the right
181 thing so that if you attach a debugger to the process, it will
182 be able to inspect variables and step through your code.
183
184 Note that you can't step through code unless you set up source
185 location information for the code (by creating and passing in
186 gcc_jit_location instances). */
187 GCC_JIT_BOOL_OPTION_DEBUGINFO,
188
189 /* If true, gcc_jit_context_compile will dump its initial "tree"
190 representation of your code to stderr (before any
191 optimizations). */
192 GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE,
193
194 /* If true, gcc_jit_context_compile will dump the "gimple"
195 representation of your code to stderr, before any optimizations
196 are performed. The dump resembles C code. */
197 GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE,
198
199 /* If true, gcc_jit_context_compile will dump the final
200 generated code to stderr, in the form of assembly language. */
201 GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
202
203 /* If true, gcc_jit_context_compile will print information to stderr
204 on the actions it is performing, followed by a profile showing
205 the time taken and memory usage of each phase.
206 */
207 GCC_JIT_BOOL_OPTION_DUMP_SUMMARY,
208
209 /* If true, gcc_jit_context_compile will dump copious
210 amount of information on what it's doing to various
211 files within a temporary directory. Use
212 GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES (see below) to
213 see the results. The files are intended to be human-readable,
214 but the exact files and their formats are subject to change.
215 */
216 GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING,
217
218 /* If true, libgccjit will aggressively run its garbage collector, to
219 shake out bugs (greatly slowing down the compile). This is likely
220 to only be of interest to developers *of* the library. It is
221 used when running the selftest suite. */
222 GCC_JIT_BOOL_OPTION_SELFCHECK_GC,
223
224 /* If true, gcc_jit_context_release will not clean up
225 intermediate files written to the filesystem, and will display
226 their location on stderr. */
227 GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES,
228
229 GCC_JIT_NUM_BOOL_OPTIONS
230 };
231
232 /* Set a string option on the given context.
233
234 The context takes a copy of the string, so the
235 (const char *) buffer is not needed anymore after the call
236 returns. */
237 extern void
238 gcc_jit_context_set_str_option (gcc_jit_context *ctxt,
239 enum gcc_jit_str_option opt,
240 const char *value);
241
242 /* Set an int option on the given context. */
243 extern void
244 gcc_jit_context_set_int_option (gcc_jit_context *ctxt,
245 enum gcc_jit_int_option opt,
246 int value);
247
248 /* Set a boolean option on the given context.
249
250 Zero is "false" (the default), non-zero is "true". */
251 extern void
252 gcc_jit_context_set_bool_option (gcc_jit_context *ctxt,
253 enum gcc_jit_bool_option opt,
254 int value);
255
256 /* Options added after the initial release of libgccjit.
257 These are handled by providing an entrypoint per option,
258 rather than by extending the enum gcc_jit_*_option,
259 so that client code that use these new options can be identified
260 from binary metadata. */
261
262 /* By default, libgccjit will issue an error about unreachable blocks
263 within a function.
264
265 This option can be used to disable that error.
266
267 This entrypoint was added in LIBGCCJIT_ABI_2; you can test for
268 its presence using
269 #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_allow_unreachable_blocks
270 */
271
272 extern void
273 gcc_jit_context_set_bool_allow_unreachable_blocks (gcc_jit_context *ctxt,
274 int bool_value);
275
276 /* Pre-canned feature macro to indicate the presence of
277 gcc_jit_context_set_bool_allow_unreachable_blocks. This can be
278 tested for with #ifdef. */
279 #define LIBGCCJIT_HAVE_gcc_jit_context_set_bool_allow_unreachable_blocks
280
281 /* Implementation detail:
282 libgccjit internally generates assembler, and uses "driver" code
283 for converting it to other formats (e.g. shared libraries).
284
285 By default, libgccjit will use an embedded copy of the driver
286 code.
287
288 This option can be used to instead invoke an external driver executable
289 as a subprocess.
290
291 This entrypoint was added in LIBGCCJIT_ABI_5; you can test for
292 its presence using
293 #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_use_external_driver
294 */
295
296 extern void
297 gcc_jit_context_set_bool_use_external_driver (gcc_jit_context *ctxt,
298 int bool_value);
299
300 /* Pre-canned feature macro to indicate the presence of
301 gcc_jit_context_set_bool_use_external_driver. This can be
302 tested for with #ifdef. */
303 #define LIBGCCJIT_HAVE_gcc_jit_context_set_bool_use_external_driver
304
305 /* Add an arbitrary gcc command-line option to the context.
306 The context takes a copy of the string, so the
307 (const char *) optname is not needed anymore after the call
308 returns.
309
310 Note that only some options are likely to be meaningful; there is no
311 "frontend" within libgccjit, so typically only those affecting
312 optimization and code-generation are likely to be useful.
313
314 This entrypoint was added in LIBGCCJIT_ABI_1; you can test for
315 its presence using
316 #ifdef LIBGCCJIT_HAVE_gcc_jit_context_add_command_line_option
317 */
318
319 extern void
320 gcc_jit_context_add_command_line_option (gcc_jit_context *ctxt,
321 const char *optname);
322
323 /* Pre-canned feature-test macro for detecting the presence of
324 gcc_jit_context_add_command_line_option within libgccjit.h. */
325
326 #define LIBGCCJIT_HAVE_gcc_jit_context_add_command_line_option
327
328 /* Compile the context to in-memory machine code.
329
330 This can be called more that once on a given context,
331 although any errors that occur will block further compilation. */
332
333 extern gcc_jit_result *
334 gcc_jit_context_compile (gcc_jit_context *ctxt);
335
336 /* Kinds of ahead-of-time compilation, for use with
337 gcc_jit_context_compile_to_file. */
338
339 enum gcc_jit_output_kind
340 {
341 /* Compile the context to an assembler file. */
342 GCC_JIT_OUTPUT_KIND_ASSEMBLER,
343
344 /* Compile the context to an object file. */
345 GCC_JIT_OUTPUT_KIND_OBJECT_FILE,
346
347 /* Compile the context to a dynamic library. */
348 GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY,
349
350 /* Compile the context to an executable. */
351 GCC_JIT_OUTPUT_KIND_EXECUTABLE
352 };
353
354 /* Compile the context to a file of the given kind.
355
356 This can be called more that once on a given context,
357 although any errors that occur will block further compilation. */
358
359 extern void
360 gcc_jit_context_compile_to_file (gcc_jit_context *ctxt,
361 enum gcc_jit_output_kind output_kind,
362 const char *output_path);
363
364 /* To help with debugging: dump a C-like representation to the given path,
365 describing what's been set up on the context.
366
367 If "update_locations" is true, then also set up gcc_jit_location
368 information throughout the context, pointing at the dump file as if it
369 were a source file. This may be of use in conjunction with
370 GCC_JIT_BOOL_OPTION_DEBUGINFO to allow stepping through the code in a
371 debugger. */
372 extern void
373 gcc_jit_context_dump_to_file (gcc_jit_context *ctxt,
374 const char *path,
375 int update_locations);
376
377 /* To help with debugging; enable ongoing logging of the context's
378 activity to the given FILE *.
379
380 The caller remains responsible for closing "logfile".
381
382 Params "flags" and "verbosity" are reserved for future use, and
383 must both be 0 for now. */
384 extern void
385 gcc_jit_context_set_logfile (gcc_jit_context *ctxt,
386 FILE *logfile,
387 int flags,
388 int verbosity);
389
390 /* To be called after any API call, this gives the first error message
391 that occurred on the context.
392
393 The returned string is valid for the rest of the lifetime of the
394 context.
395
396 If no errors occurred, this will be NULL. */
397 extern const char *
398 gcc_jit_context_get_first_error (gcc_jit_context *ctxt);
399
400 /* To be called after any API call, this gives the last error message
401 that occurred on the context.
402
403 If no errors occurred, this will be NULL.
404
405 If non-NULL, the returned string is only guaranteed to be valid until
406 the next call to libgccjit relating to this context. */
407 extern const char *
408 gcc_jit_context_get_last_error (gcc_jit_context *ctxt);
409
410 /* Locate a given function within the built machine code.
411 This will need to be cast to a function pointer of the
412 correct type before it can be called. */
413 extern void *
414 gcc_jit_result_get_code (gcc_jit_result *result,
415 const char *funcname);
416
417 /* Locate a given global within the built machine code.
418 It must have been created using GCC_JIT_GLOBAL_EXPORTED.
419 This is a ptr to the global, so e.g. for an int this is an int *. */
420 extern void *
421 gcc_jit_result_get_global (gcc_jit_result *result,
422 const char *name);
423
424 /* Once we're done with the code, this unloads the built .so file.
425 This cleans up the result; after calling this, it's no longer
426 valid to use the result. */
427 extern void
428 gcc_jit_result_release (gcc_jit_result *result);
429
430
431 /**********************************************************************
432 Functions for creating "contextual" objects.
433
434 All objects created by these functions share the lifetime of the context
435 they are created within, and are automatically cleaned up for you when
436 you call gcc_jit_context_release on the context.
437
438 Note that this means you can't use references to them after you've
439 released their context.
440
441 All (const char *) string arguments passed to these functions are
442 copied, so you don't need to keep them around.
443
444 You create code by adding a sequence of statements to blocks.
445 **********************************************************************/
446
447 /**********************************************************************
448 The base class of "contextual" object.
449 **********************************************************************/
450 /* Which context is "obj" within? */
451 extern gcc_jit_context *
452 gcc_jit_object_get_context (gcc_jit_object *obj);
453
454 /* Get a human-readable description of this object.
455 The string buffer is created the first time this is called on a given
456 object, and persists until the object's context is released. */
457 extern const char *
458 gcc_jit_object_get_debug_string (gcc_jit_object *obj);
459
460 /**********************************************************************
461 Debugging information.
462 **********************************************************************/
463
464 /* Creating source code locations for use by the debugger.
465 Line and column numbers are 1-based. */
466 extern gcc_jit_location *
467 gcc_jit_context_new_location (gcc_jit_context *ctxt,
468 const char *filename,
469 int line,
470 int column);
471
472 /* Upcasting from location to object. */
473 extern gcc_jit_object *
474 gcc_jit_location_as_object (gcc_jit_location *loc);
475
476
477 /**********************************************************************
478 Types.
479 **********************************************************************/
480
481 /* Upcasting from type to object. */
482 extern gcc_jit_object *
483 gcc_jit_type_as_object (gcc_jit_type *type);
484
485 /* Access to specific types. */
486 enum gcc_jit_types
487 {
488 /* C's "void" type. */
489 GCC_JIT_TYPE_VOID,
490
491 /* "void *". */
492 GCC_JIT_TYPE_VOID_PTR,
493
494 /* C++'s bool type; also C99's "_Bool" type, aka "bool" if using
495 stdbool.h. */
496 GCC_JIT_TYPE_BOOL,
497
498 /* Various integer types. */
499
500 /* C's "char" (of some signedness) and the variants where the
501 signedness is specified. */
502 GCC_JIT_TYPE_CHAR,
503 GCC_JIT_TYPE_SIGNED_CHAR,
504 GCC_JIT_TYPE_UNSIGNED_CHAR,
505
506 /* C's "short" and "unsigned short". */
507 GCC_JIT_TYPE_SHORT, /* signed */
508 GCC_JIT_TYPE_UNSIGNED_SHORT,
509
510 /* C's "int" and "unsigned int". */
511 GCC_JIT_TYPE_INT, /* signed */
512 GCC_JIT_TYPE_UNSIGNED_INT,
513
514 /* C's "long" and "unsigned long". */
515 GCC_JIT_TYPE_LONG, /* signed */
516 GCC_JIT_TYPE_UNSIGNED_LONG,
517
518 /* C99's "long long" and "unsigned long long". */
519 GCC_JIT_TYPE_LONG_LONG, /* signed */
520 GCC_JIT_TYPE_UNSIGNED_LONG_LONG,
521
522 /* Floating-point types */
523
524 GCC_JIT_TYPE_FLOAT,
525 GCC_JIT_TYPE_DOUBLE,
526 GCC_JIT_TYPE_LONG_DOUBLE,
527
528 /* C type: (const char *). */
529 GCC_JIT_TYPE_CONST_CHAR_PTR,
530
531 /* The C "size_t" type. */
532 GCC_JIT_TYPE_SIZE_T,
533
534 /* C type: (FILE *) */
535 GCC_JIT_TYPE_FILE_PTR,
536
537 /* Complex numbers. */
538 GCC_JIT_TYPE_COMPLEX_FLOAT,
539 GCC_JIT_TYPE_COMPLEX_DOUBLE,
540 GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE
541
542 };
543
544 extern gcc_jit_type *
545 gcc_jit_context_get_type (gcc_jit_context *ctxt,
546 enum gcc_jit_types type_);
547
548 /* Get the integer type of the given size and signedness. */
549 extern gcc_jit_type *
550 gcc_jit_context_get_int_type (gcc_jit_context *ctxt,
551 int num_bytes, int is_signed);
552
553 /* Constructing new types. */
554
555 /* Given type "T", get type "T*". */
556 extern gcc_jit_type *
557 gcc_jit_type_get_pointer (gcc_jit_type *type);
558
559 /* Given type "T", get type "const T". */
560 extern gcc_jit_type *
561 gcc_jit_type_get_const (gcc_jit_type *type);
562
563 /* Given type "T", get type "volatile T". */
564 extern gcc_jit_type *
565 gcc_jit_type_get_volatile (gcc_jit_type *type);
566
567 /* Given type "T", get type "T[N]" (for a constant N). */
568 extern gcc_jit_type *
569 gcc_jit_context_new_array_type (gcc_jit_context *ctxt,
570 gcc_jit_location *loc,
571 gcc_jit_type *element_type,
572 int num_elements);
573
574 /* Struct-handling. */
575
576 /* Create a field, for use within a struct or union. */
577 extern gcc_jit_field *
578 gcc_jit_context_new_field (gcc_jit_context *ctxt,
579 gcc_jit_location *loc,
580 gcc_jit_type *type,
581 const char *name);
582
583 /* Upcasting from field to object. */
584 extern gcc_jit_object *
585 gcc_jit_field_as_object (gcc_jit_field *field);
586
587 /* Create a struct type from an array of fields. */
588 extern gcc_jit_struct *
589 gcc_jit_context_new_struct_type (gcc_jit_context *ctxt,
590 gcc_jit_location *loc,
591 const char *name,
592 int num_fields,
593 gcc_jit_field **fields);
594
595 /* Create an opaque struct type. */
596 extern gcc_jit_struct *
597 gcc_jit_context_new_opaque_struct (gcc_jit_context *ctxt,
598 gcc_jit_location *loc,
599 const char *name);
600
601 /* Upcast a struct to a type. */
602 extern gcc_jit_type *
603 gcc_jit_struct_as_type (gcc_jit_struct *struct_type);
604
605 /* Populating the fields of a formerly-opaque struct type.
606 This can only be called once on a given struct type. */
607 extern void
608 gcc_jit_struct_set_fields (gcc_jit_struct *struct_type,
609 gcc_jit_location *loc,
610 int num_fields,
611 gcc_jit_field **fields);
612
613 /* Unions work similarly to structs. */
614 extern gcc_jit_type *
615 gcc_jit_context_new_union_type (gcc_jit_context *ctxt,
616 gcc_jit_location *loc,
617 const char *name,
618 int num_fields,
619 gcc_jit_field **fields);
620
621 /* Function pointers. */
622
623 extern gcc_jit_type *
624 gcc_jit_context_new_function_ptr_type (gcc_jit_context *ctxt,
625 gcc_jit_location *loc,
626 gcc_jit_type *return_type,
627 int num_params,
628 gcc_jit_type **param_types,
629 int is_variadic);
630
631 /**********************************************************************
632 Constructing functions.
633 **********************************************************************/
634 /* Create a function param. */
635 extern gcc_jit_param *
636 gcc_jit_context_new_param (gcc_jit_context *ctxt,
637 gcc_jit_location *loc,
638 gcc_jit_type *type,
639 const char *name);
640
641 /* Upcasting from param to object. */
642 extern gcc_jit_object *
643 gcc_jit_param_as_object (gcc_jit_param *param);
644
645 /* Upcasting from param to lvalue. */
646 extern gcc_jit_lvalue *
647 gcc_jit_param_as_lvalue (gcc_jit_param *param);
648
649 /* Upcasting from param to rvalue. */
650 extern gcc_jit_rvalue *
651 gcc_jit_param_as_rvalue (gcc_jit_param *param);
652
653 /* Kinds of function. */
654 enum gcc_jit_function_kind
655 {
656 /* Function is defined by the client code and visible
657 by name outside of the JIT. */
658 GCC_JIT_FUNCTION_EXPORTED,
659
660 /* Function is defined by the client code, but is invisible
661 outside of the JIT. Analogous to a "static" function. */
662 GCC_JIT_FUNCTION_INTERNAL,
663
664 /* Function is not defined by the client code; we're merely
665 referring to it. Analogous to using an "extern" function from a
666 header file. */
667 GCC_JIT_FUNCTION_IMPORTED,
668
669 /* Function is only ever inlined into other functions, and is
670 invisible outside of the JIT.
671
672 Analogous to prefixing with "inline" and adding
673 __attribute__((always_inline)).
674
675 Inlining will only occur when the optimization level is
676 above 0; when optimization is off, this is essentially the
677 same as GCC_JIT_FUNCTION_INTERNAL. */
678 GCC_JIT_FUNCTION_ALWAYS_INLINE
679 };
680
681 /* Create a function. */
682 extern gcc_jit_function *
683 gcc_jit_context_new_function (gcc_jit_context *ctxt,
684 gcc_jit_location *loc,
685 enum gcc_jit_function_kind kind,
686 gcc_jit_type *return_type,
687 const char *name,
688 int num_params,
689 gcc_jit_param **params,
690 int is_variadic);
691
692 /* Create a reference to a builtin function (sometimes called
693 intrinsic functions). */
694 extern gcc_jit_function *
695 gcc_jit_context_get_builtin_function (gcc_jit_context *ctxt,
696 const char *name);
697
698 /* Upcasting from function to object. */
699 extern gcc_jit_object *
700 gcc_jit_function_as_object (gcc_jit_function *func);
701
702 /* Get a specific param of a function by index. */
703 extern gcc_jit_param *
704 gcc_jit_function_get_param (gcc_jit_function *func, int index);
705
706 /* Emit the function in graphviz format. */
707 extern void
708 gcc_jit_function_dump_to_dot (gcc_jit_function *func,
709 const char *path);
710
711 /* Create a block.
712
713 The name can be NULL, or you can give it a meaningful name, which
714 may show up in dumps of the internal representation, and in error
715 messages. */
716 extern gcc_jit_block *
717 gcc_jit_function_new_block (gcc_jit_function *func,
718 const char *name);
719
720 /* Upcasting from block to object. */
721 extern gcc_jit_object *
722 gcc_jit_block_as_object (gcc_jit_block *block);
723
724 /* Which function is this block within? */
725 extern gcc_jit_function *
726 gcc_jit_block_get_function (gcc_jit_block *block);
727
728 /**********************************************************************
729 lvalues, rvalues and expressions.
730 **********************************************************************/
731 enum gcc_jit_global_kind
732 {
733 /* Global is defined by the client code and visible
734 by name outside of this JIT context via gcc_jit_result_get_global. */
735 GCC_JIT_GLOBAL_EXPORTED,
736
737 /* Global is defined by the client code, but is invisible
738 outside of this JIT context. Analogous to a "static" global. */
739 GCC_JIT_GLOBAL_INTERNAL,
740
741 /* Global is not defined by the client code; we're merely
742 referring to it. Analogous to using an "extern" global from a
743 header file. */
744 GCC_JIT_GLOBAL_IMPORTED
745 };
746
747 extern gcc_jit_lvalue *
748 gcc_jit_context_new_global (gcc_jit_context *ctxt,
749 gcc_jit_location *loc,
750 enum gcc_jit_global_kind kind,
751 gcc_jit_type *type,
752 const char *name);
753
754 /* Upcasting. */
755 extern gcc_jit_object *
756 gcc_jit_lvalue_as_object (gcc_jit_lvalue *lvalue);
757
758 extern gcc_jit_rvalue *
759 gcc_jit_lvalue_as_rvalue (gcc_jit_lvalue *lvalue);
760
761 extern gcc_jit_object *
762 gcc_jit_rvalue_as_object (gcc_jit_rvalue *rvalue);
763
764 extern gcc_jit_type *
765 gcc_jit_rvalue_get_type (gcc_jit_rvalue *rvalue);
766
767 /* Integer constants. */
768 extern gcc_jit_rvalue *
769 gcc_jit_context_new_rvalue_from_int (gcc_jit_context *ctxt,
770 gcc_jit_type *numeric_type,
771 int value);
772
773 extern gcc_jit_rvalue *
774 gcc_jit_context_new_rvalue_from_long (gcc_jit_context *ctxt,
775 gcc_jit_type *numeric_type,
776 long value);
777
778 extern gcc_jit_rvalue *
779 gcc_jit_context_zero (gcc_jit_context *ctxt,
780 gcc_jit_type *numeric_type);
781
782 extern gcc_jit_rvalue *
783 gcc_jit_context_one (gcc_jit_context *ctxt,
784 gcc_jit_type *numeric_type);
785
786 /* Floating-point constants. */
787 extern gcc_jit_rvalue *
788 gcc_jit_context_new_rvalue_from_double (gcc_jit_context *ctxt,
789 gcc_jit_type *numeric_type,
790 double value);
791
792 /* Pointers. */
793 extern gcc_jit_rvalue *
794 gcc_jit_context_new_rvalue_from_ptr (gcc_jit_context *ctxt,
795 gcc_jit_type *pointer_type,
796 void *value);
797
798 extern gcc_jit_rvalue *
799 gcc_jit_context_null (gcc_jit_context *ctxt,
800 gcc_jit_type *pointer_type);
801
802 /* String literals. */
803 extern gcc_jit_rvalue *
804 gcc_jit_context_new_string_literal (gcc_jit_context *ctxt,
805 const char *value);
806
807 enum gcc_jit_unary_op
808 {
809 /* Negate an arithmetic value; analogous to:
810 -(EXPR)
811 in C. */
812 GCC_JIT_UNARY_OP_MINUS,
813
814 /* Bitwise negation of an integer value (one's complement); analogous
815 to:
816 ~(EXPR)
817 in C. */
818 GCC_JIT_UNARY_OP_BITWISE_NEGATE,
819
820 /* Logical negation of an arithmetic or pointer value; analogous to:
821 !(EXPR)
822 in C. */
823 GCC_JIT_UNARY_OP_LOGICAL_NEGATE,
824
825 /* Absolute value of an arithmetic expression; analogous to:
826 abs (EXPR)
827 in C. */
828 GCC_JIT_UNARY_OP_ABS
829
830 };
831
832 extern gcc_jit_rvalue *
833 gcc_jit_context_new_unary_op (gcc_jit_context *ctxt,
834 gcc_jit_location *loc,
835 enum gcc_jit_unary_op op,
836 gcc_jit_type *result_type,
837 gcc_jit_rvalue *rvalue);
838
839 enum gcc_jit_binary_op
840 {
841 /* Addition of arithmetic values; analogous to:
842 (EXPR_A) + (EXPR_B)
843 in C.
844 For pointer addition, use gcc_jit_context_new_array_access. */
845 GCC_JIT_BINARY_OP_PLUS,
846
847 /* Subtraction of arithmetic values; analogous to:
848 (EXPR_A) - (EXPR_B)
849 in C. */
850 GCC_JIT_BINARY_OP_MINUS,
851
852 /* Multiplication of a pair of arithmetic values; analogous to:
853 (EXPR_A) * (EXPR_B)
854 in C. */
855 GCC_JIT_BINARY_OP_MULT,
856
857 /* Quotient of division of arithmetic values; analogous to:
858 (EXPR_A) / (EXPR_B)
859 in C.
860 The result type affects the kind of division: if the result type is
861 integer-based, then the result is truncated towards zero, whereas
862 a floating-point result type indicates floating-point division. */
863 GCC_JIT_BINARY_OP_DIVIDE,
864
865 /* Remainder of division of arithmetic values; analogous to:
866 (EXPR_A) % (EXPR_B)
867 in C. */
868 GCC_JIT_BINARY_OP_MODULO,
869
870 /* Bitwise AND; analogous to:
871 (EXPR_A) & (EXPR_B)
872 in C. */
873 GCC_JIT_BINARY_OP_BITWISE_AND,
874
875 /* Bitwise exclusive OR; analogous to:
876 (EXPR_A) ^ (EXPR_B)
877 in C. */
878 GCC_JIT_BINARY_OP_BITWISE_XOR,
879
880 /* Bitwise inclusive OR; analogous to:
881 (EXPR_A) | (EXPR_B)
882 in C. */
883 GCC_JIT_BINARY_OP_BITWISE_OR,
884
885 /* Logical AND; analogous to:
886 (EXPR_A) && (EXPR_B)
887 in C. */
888 GCC_JIT_BINARY_OP_LOGICAL_AND,
889
890 /* Logical OR; analogous to:
891 (EXPR_A) || (EXPR_B)
892 in C. */
893 GCC_JIT_BINARY_OP_LOGICAL_OR,
894
895 /* Left shift; analogous to:
896 (EXPR_A) << (EXPR_B)
897 in C. */
898 GCC_JIT_BINARY_OP_LSHIFT,
899
900 /* Right shift; analogous to:
901 (EXPR_A) >> (EXPR_B)
902 in C. */
903 GCC_JIT_BINARY_OP_RSHIFT
904 };
905
906 extern gcc_jit_rvalue *
907 gcc_jit_context_new_binary_op (gcc_jit_context *ctxt,
908 gcc_jit_location *loc,
909 enum gcc_jit_binary_op op,
910 gcc_jit_type *result_type,
911 gcc_jit_rvalue *a, gcc_jit_rvalue *b);
912
913 /* (Comparisons are treated as separate from "binary_op" to save
914 you having to specify the result_type). */
915
916 enum gcc_jit_comparison
917 {
918 /* (EXPR_A) == (EXPR_B). */
919 GCC_JIT_COMPARISON_EQ,
920
921 /* (EXPR_A) != (EXPR_B). */
922 GCC_JIT_COMPARISON_NE,
923
924 /* (EXPR_A) < (EXPR_B). */
925 GCC_JIT_COMPARISON_LT,
926
927 /* (EXPR_A) <=(EXPR_B). */
928 GCC_JIT_COMPARISON_LE,
929
930 /* (EXPR_A) > (EXPR_B). */
931 GCC_JIT_COMPARISON_GT,
932
933 /* (EXPR_A) >= (EXPR_B). */
934 GCC_JIT_COMPARISON_GE
935 };
936
937 extern gcc_jit_rvalue *
938 gcc_jit_context_new_comparison (gcc_jit_context *ctxt,
939 gcc_jit_location *loc,
940 enum gcc_jit_comparison op,
941 gcc_jit_rvalue *a, gcc_jit_rvalue *b);
942
943 /* Function calls. */
944
945 /* Call of a specific function. */
946 extern gcc_jit_rvalue *
947 gcc_jit_context_new_call (gcc_jit_context *ctxt,
948 gcc_jit_location *loc,
949 gcc_jit_function *func,
950 int numargs , gcc_jit_rvalue **args);
951
952 /* Call through a function pointer. */
953 extern gcc_jit_rvalue *
954 gcc_jit_context_new_call_through_ptr (gcc_jit_context *ctxt,
955 gcc_jit_location *loc,
956 gcc_jit_rvalue *fn_ptr,
957 int numargs, gcc_jit_rvalue **args);
958
959 /* Type-coercion.
960
961 Currently only a limited set of conversions are possible:
962 int <-> float
963 int <-> bool */
964 extern gcc_jit_rvalue *
965 gcc_jit_context_new_cast (gcc_jit_context *ctxt,
966 gcc_jit_location *loc,
967 gcc_jit_rvalue *rvalue,
968 gcc_jit_type *type);
969
970 extern gcc_jit_lvalue *
971 gcc_jit_context_new_array_access (gcc_jit_context *ctxt,
972 gcc_jit_location *loc,
973 gcc_jit_rvalue *ptr,
974 gcc_jit_rvalue *index);
975
976 /* Field access is provided separately for both lvalues and rvalues. */
977
978 /* Accessing a field of an lvalue of struct type, analogous to:
979 (EXPR).field = ...;
980 in C. */
981 extern gcc_jit_lvalue *
982 gcc_jit_lvalue_access_field (gcc_jit_lvalue *struct_or_union,
983 gcc_jit_location *loc,
984 gcc_jit_field *field);
985
986 /* Accessing a field of an rvalue of struct type, analogous to:
987 (EXPR).field
988 in C. */
989 extern gcc_jit_rvalue *
990 gcc_jit_rvalue_access_field (gcc_jit_rvalue *struct_or_union,
991 gcc_jit_location *loc,
992 gcc_jit_field *field);
993
994 /* Accessing a field of an rvalue of pointer type, analogous to:
995 (EXPR)->field
996 in C, itself equivalent to (*EXPR).FIELD */
997 extern gcc_jit_lvalue *
998 gcc_jit_rvalue_dereference_field (gcc_jit_rvalue *ptr,
999 gcc_jit_location *loc,
1000 gcc_jit_field *field);
1001
1002 /* Dereferencing a pointer; analogous to:
1003 *(EXPR)
1004 */
1005 extern gcc_jit_lvalue *
1006 gcc_jit_rvalue_dereference (gcc_jit_rvalue *rvalue,
1007 gcc_jit_location *loc);
1008
1009 /* Taking the address of an lvalue; analogous to:
1010 &(EXPR)
1011 in C. */
1012 extern gcc_jit_rvalue *
1013 gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue,
1014 gcc_jit_location *loc);
1015
1016 extern gcc_jit_lvalue *
1017 gcc_jit_function_new_local (gcc_jit_function *func,
1018 gcc_jit_location *loc,
1019 gcc_jit_type *type,
1020 const char *name);
1021
1022 /**********************************************************************
1023 Statement-creation.
1024 **********************************************************************/
1025
1026 /* Add evaluation of an rvalue, discarding the result
1027 (e.g. a function call that "returns" void).
1028
1029 This is equivalent to this C code:
1030
1031 (void)expression;
1032 */
1033 extern void
1034 gcc_jit_block_add_eval (gcc_jit_block *block,
1035 gcc_jit_location *loc,
1036 gcc_jit_rvalue *rvalue);
1037
1038 /* Add evaluation of an rvalue, assigning the result to the given
1039 lvalue.
1040
1041 This is roughly equivalent to this C code:
1042
1043 lvalue = rvalue;
1044 */
1045 extern void
1046 gcc_jit_block_add_assignment (gcc_jit_block *block,
1047 gcc_jit_location *loc,
1048 gcc_jit_lvalue *lvalue,
1049 gcc_jit_rvalue *rvalue);
1050
1051 /* Add evaluation of an rvalue, using the result to modify an
1052 lvalue.
1053
1054 This is analogous to "+=" and friends:
1055
1056 lvalue += rvalue;
1057 lvalue *= rvalue;
1058 lvalue /= rvalue;
1059 etc */
1060 extern void
1061 gcc_jit_block_add_assignment_op (gcc_jit_block *block,
1062 gcc_jit_location *loc,
1063 gcc_jit_lvalue *lvalue,
1064 enum gcc_jit_binary_op op,
1065 gcc_jit_rvalue *rvalue);
1066
1067 /* Add a no-op textual comment to the internal representation of the
1068 code. It will be optimized away, but will be visible in the dumps
1069 seen via
1070 GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE
1071 and
1072 GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE,
1073 and thus may be of use when debugging how your project's internal
1074 representation gets converted to the libgccjit IR. */
1075 extern void
1076 gcc_jit_block_add_comment (gcc_jit_block *block,
1077 gcc_jit_location *loc,
1078 const char *text);
1079
1080 /* Terminate a block by adding evaluation of an rvalue, branching on the
1081 result to the appropriate successor block.
1082
1083 This is roughly equivalent to this C code:
1084
1085 if (boolval)
1086 goto on_true;
1087 else
1088 goto on_false;
1089
1090 block, boolval, on_true, and on_false must be non-NULL. */
1091 extern void
1092 gcc_jit_block_end_with_conditional (gcc_jit_block *block,
1093 gcc_jit_location *loc,
1094 gcc_jit_rvalue *boolval,
1095 gcc_jit_block *on_true,
1096 gcc_jit_block *on_false);
1097
1098 /* Terminate a block by adding a jump to the given target block.
1099
1100 This is roughly equivalent to this C code:
1101
1102 goto target;
1103 */
1104 extern void
1105 gcc_jit_block_end_with_jump (gcc_jit_block *block,
1106 gcc_jit_location *loc,
1107 gcc_jit_block *target);
1108
1109 /* Terminate a block by adding evaluation of an rvalue, returning the value.
1110
1111 This is roughly equivalent to this C code:
1112
1113 return expression;
1114 */
1115 extern void
1116 gcc_jit_block_end_with_return (gcc_jit_block *block,
1117 gcc_jit_location *loc,
1118 gcc_jit_rvalue *rvalue);
1119
1120 /* Terminate a block by adding a valueless return, for use within a function
1121 with "void" return type.
1122
1123 This is equivalent to this C code:
1124
1125 return;
1126 */
1127 extern void
1128 gcc_jit_block_end_with_void_return (gcc_jit_block *block,
1129 gcc_jit_location *loc);
1130
1131 /* Create a new gcc_jit_case instance for use in a switch statement.
1132 min_value and max_value must be constants of integer type.
1133
1134 This API entrypoint was added in LIBGCCJIT_ABI_3; you can test for its
1135 presence using
1136 #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1137 */
1138 extern gcc_jit_case *
1139 gcc_jit_context_new_case (gcc_jit_context *ctxt,
1140 gcc_jit_rvalue *min_value,
1141 gcc_jit_rvalue *max_value,
1142 gcc_jit_block *dest_block);
1143
1144 /* Upcasting from case to object.
1145
1146 This API entrypoint was added in LIBGCCJIT_ABI_3; you can test for its
1147 presence using
1148 #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1149 */
1150
1151 extern gcc_jit_object *
1152 gcc_jit_case_as_object (gcc_jit_case *case_);
1153
1154 /* Terminate a block by adding evalation of an rvalue, then performing
1155 a multiway branch.
1156
1157 This is roughly equivalent to this C code:
1158
1159 switch (expr)
1160 {
1161 default:
1162 goto default_block;
1163
1164 case C0.min_value ... C0.max_value:
1165 goto C0.dest_block;
1166
1167 case C1.min_value ... C1.max_value:
1168 goto C1.dest_block;
1169
1170 ...etc...
1171
1172 case C[N - 1].min_value ... C[N - 1].max_value:
1173 goto C[N - 1].dest_block;
1174 }
1175
1176 block, expr, default_block and cases must all be non-NULL.
1177
1178 expr must be of the same integer type as all of the min_value
1179 and max_value within the cases.
1180
1181 num_cases must be >= 0.
1182
1183 The ranges of the cases must not overlap (or have duplicate
1184 values).
1185
1186 This API entrypoint was added in LIBGCCJIT_ABI_3; you can test for its
1187 presence using
1188 #ifdef LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1189 */
1190
1191 extern void
1192 gcc_jit_block_end_with_switch (gcc_jit_block *block,
1193 gcc_jit_location *loc,
1194 gcc_jit_rvalue *expr,
1195 gcc_jit_block *default_block,
1196 int num_cases,
1197 gcc_jit_case **cases);
1198
1199 /* Pre-canned feature macro to indicate the presence of
1200 gcc_jit_block_end_with_switch, gcc_jit_case_as_object, and
1201 gcc_jit_context_new_case.
1202
1203 This can be tested for with #ifdef. */
1204 #define LIBGCCJIT_HAVE_SWITCH_STATEMENTS
1205
1206 /**********************************************************************
1207 Nested contexts.
1208 **********************************************************************/
1209
1210 /* Given an existing JIT context, create a child context.
1211
1212 The child inherits a copy of all option-settings from the parent.
1213
1214 The child can reference objects created within the parent, but not
1215 vice-versa.
1216
1217 The lifetime of the child context must be bounded by that of the
1218 parent: you should release a child context before releasing the parent
1219 context.
1220
1221 If you use a function from a parent context within a child context,
1222 you have to compile the parent context before you can compile the
1223 child context, and the gcc_jit_result of the parent context must
1224 outlive the gcc_jit_result of the child context.
1225
1226 This allows caching of shared initializations. For example, you could
1227 create types and declarations of global functions in a parent context
1228 once within a process, and then create child contexts whenever a
1229 function or loop becomes hot. Each such child context can be used for
1230 JIT-compiling just one function or loop, but can reference types
1231 and helper functions created within the parent context.
1232
1233 Contexts can be arbitrarily nested, provided the above rules are
1234 followed, but it's probably not worth going above 2 or 3 levels, and
1235 there will likely be a performance hit for such nesting. */
1236
1237 extern gcc_jit_context *
1238 gcc_jit_context_new_child_context (gcc_jit_context *parent_ctxt);
1239
1240 /**********************************************************************
1241 Implementation support.
1242 **********************************************************************/
1243
1244 /* Write C source code into "path" that can be compiled into a
1245 self-contained executable (i.e. with libgccjit as the only dependency).
1246 The generated code will attempt to replay the API calls that have been
1247 made into the given context.
1248
1249 This may be useful when debugging the library or client code, for
1250 reducing a complicated recipe for reproducing a bug into a simpler
1251 form.
1252
1253 Typically you need to supply the option "-Wno-unused-variable" when
1254 compiling the generated file (since the result of each API call is
1255 assigned to a unique variable within the generated C source, and not
1256 all are necessarily then used). */
1257
1258 extern void
1259 gcc_jit_context_dump_reproducer_to_file (gcc_jit_context *ctxt,
1260 const char *path);
1261
1262 /* Enable the dumping of a specific set of internal state from the
1263 compilation, capturing the result in-memory as a buffer.
1264
1265 Parameter "dumpname" corresponds to the equivalent gcc command-line
1266 option, without the "-fdump-" prefix.
1267 For example, to get the equivalent of "-fdump-tree-vrp1", supply
1268 "tree-vrp1".
1269 The context directly stores the dumpname as a (const char *), so the
1270 passed string must outlive the context.
1271
1272 gcc_jit_context_compile and gcc_jit_context_to_file
1273 will capture the dump as a dynamically-allocated buffer, writing
1274 it to ``*out_ptr``.
1275
1276 The caller becomes responsible for calling
1277 free (*out_ptr)
1278 each time that gcc_jit_context_compile or gcc_jit_context_to_file
1279 are called. *out_ptr will be written to, either with the address of a
1280 buffer, or with NULL if an error occurred.
1281
1282 This API entrypoint is likely to be less stable than the others.
1283 In particular, both the precise dumpnames, and the format and content
1284 of the dumps are subject to change.
1285
1286 It exists primarily for writing the library's own test suite. */
1287
1288 extern void
1289 gcc_jit_context_enable_dump (gcc_jit_context *ctxt,
1290 const char *dumpname,
1291 char **out_ptr);
1292
1293 /**********************************************************************
1294 Timing support.
1295 **********************************************************************/
1296
1297 /* The timing API was added in LIBGCCJIT_ABI_4; you can test for its
1298 presence using
1299 #ifdef LIBGCCJIT_HAVE_TIMING_API
1300 */
1301 #define LIBGCCJIT_HAVE_TIMING_API
1302
1303 typedef struct gcc_jit_timer gcc_jit_timer;
1304
1305 /* Create a gcc_jit_timer instance, and start timing.
1306
1307 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1308 presence using
1309 #ifdef LIBGCCJIT_HAVE_TIMING_API
1310 */
1311 extern gcc_jit_timer *
1312 gcc_jit_timer_new (void);
1313
1314 /* Release a gcc_jit_timer instance.
1315
1316 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1317 presence using
1318 #ifdef LIBGCCJIT_HAVE_TIMING_API
1319 */
1320 extern void
1321 gcc_jit_timer_release (gcc_jit_timer *timer);
1322
1323 /* Associate a gcc_jit_timer instance with a context.
1324
1325 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1326 presence using
1327 #ifdef LIBGCCJIT_HAVE_TIMING_API
1328 */
1329 extern void
1330 gcc_jit_context_set_timer (gcc_jit_context *ctxt,
1331 gcc_jit_timer *timer);
1332
1333 /* Get the timer associated with a context (if any).
1334
1335 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1336 presence using
1337 #ifdef LIBGCCJIT_HAVE_TIMING_API
1338 */
1339
1340 extern gcc_jit_timer *
1341 gcc_jit_context_get_timer (gcc_jit_context *ctxt);
1342
1343 /* Push the given item onto the timing stack.
1344
1345 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1346 presence using
1347 #ifdef LIBGCCJIT_HAVE_TIMING_API
1348 */
1349
1350 extern void
1351 gcc_jit_timer_push (gcc_jit_timer *timer,
1352 const char *item_name);
1353
1354 /* Pop the top item from the timing stack.
1355
1356 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1357 presence using
1358 #ifdef LIBGCCJIT_HAVE_TIMING_API
1359 */
1360
1361 extern void
1362 gcc_jit_timer_pop (gcc_jit_timer *timer,
1363 const char *item_name);
1364
1365 /* Print timing information to the given stream about activity since
1366 the timer was started.
1367
1368 This API entrypoint was added in LIBGCCJIT_ABI_4; you can test for its
1369 presence using
1370 #ifdef LIBGCCJIT_HAVE_TIMING_API
1371 */
1372
1373 extern void
1374 gcc_jit_timer_print (gcc_jit_timer *timer,
1375 FILE *f_out);
1376
1377
1378 #define LIBGCCJIT_HAVE_gcc_jit_rvalue_set_bool_require_tail_call
1379
1380 /* Mark/clear a call as needing tail-call optimization.
1381
1382 This API entrypoint was added in LIBGCCJIT_ABI_6; you can test for its
1383 presence using
1384 #ifdef LIBGCCJIT_HAVE_gcc_jit_rvalue_set_bool_require_tail_call
1385 */
1386 extern void
1387 gcc_jit_rvalue_set_bool_require_tail_call (gcc_jit_rvalue *call,
1388 int require_tail_call);
1389
1390 #define LIBGCCJIT_HAVE_gcc_jit_type_get_aligned
1391
1392 /* Given type "T", get type:
1393
1394 T __attribute__ ((aligned (ALIGNMENT_IN_BYTES)))
1395
1396 The alignment must be a power of two.
1397
1398 This API entrypoint was added in LIBGCCJIT_ABI_7; you can test for its
1399 presence using
1400 #ifdef LIBGCCJIT_HAVE_gcc_jit_type_get_aligned
1401 */
1402 extern gcc_jit_type *
1403 gcc_jit_type_get_aligned (gcc_jit_type *type,
1404 size_t alignment_in_bytes);
1405
1406 #define LIBGCCJIT_HAVE_gcc_jit_type_get_vector
1407
1408 /* Given type "T", get type:
1409
1410 T __attribute__ ((vector_size (sizeof(T) * num_units))
1411
1412 T must be integral/floating point; num_units must be a power of two.
1413
1414 This API entrypoint was added in LIBGCCJIT_ABI_8; you can test for its
1415 presence using
1416 #ifdef LIBGCCJIT_HAVE_gcc_jit_type_get_vector
1417 */
1418 extern gcc_jit_type *
1419 gcc_jit_type_get_vector (gcc_jit_type *type, size_t num_units);
1420
1421
1422 #define LIBGCCJIT_HAVE_gcc_jit_function_get_address
1423
1424 /* Get the address of a function as an rvalue, of function pointer
1425 type.
1426
1427 This API entrypoint was added in LIBGCCJIT_ABI_9; you can test for its
1428 presence using
1429 #ifdef LIBGCCJIT_HAVE_gcc_jit_function_get_address
1430 */
1431 extern gcc_jit_rvalue *
1432 gcc_jit_function_get_address (gcc_jit_function *fn,
1433 gcc_jit_location *loc);
1434
1435
1436 #define LIBGCCJIT_HAVE_gcc_jit_context_new_rvalue_from_vector
1437
1438 /* Build a vector rvalue from an array of elements.
1439
1440 "vec_type" should be a vector type, created using gcc_jit_type_get_vector.
1441
1442 This API entrypoint was added in LIBGCCJIT_ABI_10; you can test for its
1443 presence using
1444 #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_rvalue_from_vector
1445 */
1446 extern gcc_jit_rvalue *
1447 gcc_jit_context_new_rvalue_from_vector (gcc_jit_context *ctxt,
1448 gcc_jit_location *loc,
1449 gcc_jit_type *vec_type,
1450 size_t num_elements,
1451 gcc_jit_rvalue **elements);
1452
1453 #ifdef __cplusplus
1454 }
1455 #endif /* __cplusplus */
1456
1457 #endif /* LIBGCCJIT_H */