Branch data Line data Source code
1 : : /* Core of implementation of libgccjit.so
2 : : Copyright (C) 2013-2025 Free Software Foundation, Inc.
3 : : Contributed by David Malcolm <dmalcolm@redhat.com>.
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify it
8 : : under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful, but
13 : : WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : : General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : : #ifndef JIT_COMMON_H
22 : : #define JIT_COMMON_H
23 : :
24 : : #include "libgccjit.h"
25 : :
26 : : #include "vec.h"
27 : : #include "tree.h"
28 : : #include "inchash.h"
29 : : #include "tree-iterator.h"
30 : :
31 : : #ifdef GCC_VERSION
32 : : #if GCC_VERSION >= 4001
33 : : #define GNU_PRINTF(M, N) __attribute__ ((format (gnu_printf, (M), (N))))
34 : : #else
35 : : #define GNU_PRINTF(M, N)
36 : : #endif
37 : : #endif
38 : :
39 : : const int NUM_GCC_JIT_TYPES = GCC_JIT_TYPE_FLOAT128 + 1;
40 : :
41 : : /* This comment is included by the docs.
42 : :
43 : : In order to allow jit objects to be usable outside of a compile
44 : : whilst working with the existing structure of GCC's code the
45 : : C API is implemented in terms of a gcc::jit::recording::context,
46 : : which records the calls made to it.
47 : :
48 : : When a gcc_jit_context is compiled, the recording context creates a
49 : : playback context. The playback context invokes the bulk of the GCC
50 : : code, and within the "frontend" parsing hook, plays back the recorded
51 : : API calls, creating GCC tree objects.
52 : :
53 : : So there are two parallel families of classes: those relating to
54 : : recording, and those relating to playback:
55 : :
56 : : * Visibility: recording objects are exposed back to client code,
57 : : whereas playback objects are internal to the library.
58 : :
59 : : * Lifetime: recording objects have a lifetime equal to that of the
60 : : recording context that created them, whereas playback objects only
61 : : exist within the frontend hook.
62 : :
63 : : * Memory allocation: recording objects are allocated by the recording
64 : : context, and automatically freed by it when the context is released,
65 : : whereas playback objects are allocated within the GC heap, and
66 : : garbage-collected; they can own GC-references.
67 : :
68 : : * Integration with rest of GCC: recording objects are unrelated to the
69 : : rest of GCC, whereas playback objects are wrappers around "tree"
70 : : instances. Hence you can't ask a recording rvalue or lvalue what its
71 : : type is, whereas you can for a playback rvalue of lvalue (since it
72 : : can work with the underlying GCC tree nodes).
73 : :
74 : : * Instancing: There can be multiple recording contexts "alive" at once
75 : : (albeit it only one compiling at once), whereas there can only be one
76 : : playback context alive at one time (since it interacts with the GC).
77 : :
78 : : Ultimately if GCC could support multiple GC heaps and contexts, and
79 : : finer-grained initialization, then this recording vs playback
80 : : distinction could be eliminated.
81 : :
82 : : During a playback, we associate objects from the recording with
83 : : their counterparts during this playback. For simplicity, we store this
84 : : within the recording objects, as ``void *m_playback_obj``, casting it to
85 : : the appropriate playback object subclass. For these casts to make
86 : : sense, the two class hierarchies need to have the same structure.
87 : :
88 : : Note that the playback objects that ``m_playback_obj`` points to are
89 : : GC-allocated, but the recording objects don't own references:
90 : : these associations only exist within a part of the code where
91 : : the GC doesn't collect, and are set back to NULL before the GC can
92 : : run.
93 : :
94 : : End of comment for inclusion in the docs. */
95 : :
96 : : /* See c_tree_chain_next in gcc/c-family/c-common.h. */
97 : : static inline tree
98 : 13872529870 : jit_tree_chain_next (tree t)
99 : : {
100 : : /* TREE_CHAIN of a type is TYPE_STUB_DECL, which is different
101 : : kind of object, never a long chain of nodes. Prefer
102 : : TYPE_NEXT_VARIANT for types. */
103 : 13872529870 : if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPE_COMMON))
104 : 1408048316 : return TYPE_NEXT_VARIANT (t);
105 : : /* Otherwise, if there is TREE_CHAIN, return it. */
106 : 12464481554 : if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_COMMON))
107 : 11726462698 : return TREE_CHAIN (t);
108 : : return NULL;
109 : : }
110 : :
111 : : namespace gcc {
112 : :
113 : : namespace jit {
114 : :
115 : : class result;
116 : : class dump;
117 : : class logger;
118 : : class builtins_manager; // declared within jit-builtins.h
119 : : class tempdir;
120 : :
121 : : namespace recording {
122 : :
123 : : /* Recording types. */
124 : :
125 : : /* Indentation indicates inheritance: */
126 : : class context;
127 : : class memento;
128 : : class string;
129 : : class location;
130 : : class type;
131 : : class function_type;
132 : : class compound_type;
133 : : class struct_;
134 : : class union_;
135 : : class vector_type;
136 : : class array_type;
137 : : class field;
138 : : class bitfield;
139 : : class fields;
140 : : class function;
141 : : class block;
142 : : class rvalue;
143 : : class lvalue;
144 : : class local;
145 : : class global;
146 : : class param;
147 : : class base_call;
148 : : class function_pointer;
149 : : class statement;
150 : : class extended_asm;
151 : : class case_;
152 : : class memento_of_get_aligned;
153 : : class top_level_asm;
154 : :
155 : : /* End of recording types. */
156 : : }
157 : :
158 : : namespace playback {
159 : : /* Playback types. */
160 : :
161 : : /* Indentation indicates inheritance: */
162 : : class context;
163 : : class wrapper;
164 : : class type;
165 : : class compound_type;
166 : : class field;
167 : : class function;
168 : : class block;
169 : : class rvalue;
170 : : class lvalue;
171 : : class param;
172 : : class source_file;
173 : : class source_line;
174 : : class location;
175 : : class case_;
176 : :
177 : : /* End of playback types. */
178 : : }
179 : :
180 : : typedef playback::context replayer;
181 : :
182 : : class dump
183 : : {
184 : : public:
185 : : dump (recording::context &ctxt,
186 : : const char *filename,
187 : : bool update_locations);
188 : : ~dump ();
189 : :
190 : 0 : recording::context &get_context () { return m_ctxt; }
191 : :
192 : : void write (const char *fmt, ...)
193 : : GNU_PRINTF(2, 3);
194 : :
195 : 186 : bool update_locations () const { return m_update_locations; }
196 : :
197 : : recording::location *
198 : : make_location () const;
199 : :
200 : 1143 : FILE *get_file () const { return m_file; }
201 : :
202 : : private:
203 : : recording::context &m_ctxt;
204 : : const char *m_filename;
205 : : bool m_update_locations;
206 : : int m_line;
207 : : int m_column;
208 : : FILE *m_file;
209 : : };
210 : :
211 : : /* A hidden enum of boolean options that are only exposed via API
212 : : entrypoints, rather than via gcc_jit_context_set_bool_option. */
213 : :
214 : : enum inner_bool_option
215 : : {
216 : : INNER_BOOL_OPTION_ALLOW_UNREACHABLE_BLOCKS,
217 : : INNER_BOOL_OPTION_USE_EXTERNAL_DRIVER,
218 : : INNER_BOOL_OPTION_PRINT_ERRORS_TO_STDERR,
219 : :
220 : : NUM_INNER_BOOL_OPTIONS
221 : : };
222 : :
223 : : /* Flags for global variables class. For when the playback of the
224 : : global need to know what will happen to it later. */
225 : : enum global_var_flags
226 : : {
227 : : GLOBAL_VAR_FLAGS_NONE = 0,
228 : : GLOBAL_VAR_FLAGS_WILL_BE_RVAL_INIT = 1,
229 : : GLOBAL_VAR_FLAGS_WILL_BE_BLOB_INIT = 2,
230 : : };
231 : :
232 : : } // namespace gcc::jit
233 : :
234 : : } // namespace gcc
235 : :
236 : : #endif /* JIT_COMMON_H */
|
