|
111
|
1 /* Core of implementation of libgccjit.so
|
|
145
|
2 Copyright (C) 2013-2020 Free Software Foundation, Inc.
|
|
111
|
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_COMPLEX_LONG_DOUBLE + 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 namespace gcc {
|
|
|
97
|
|
|
98 namespace jit {
|
|
|
99
|
|
|
100 class result;
|
|
|
101 class dump;
|
|
|
102 class logger;
|
|
|
103 class builtins_manager; // declared within jit-builtins.h
|
|
|
104 class tempdir;
|
|
|
105
|
|
|
106 namespace recording {
|
|
|
107
|
|
|
108 /* Recording types. */
|
|
|
109
|
|
|
110 /* Indentation indicates inheritance: */
|
|
|
111 class context;
|
|
|
112 class memento;
|
|
|
113 class string;
|
|
|
114 class location;
|
|
|
115 class type;
|
|
|
116 class function_type;
|
|
|
117 class compound_type;
|
|
|
118 class struct_;
|
|
|
119 class union_;
|
|
|
120 class vector_type;
|
|
|
121 class field;
|
|
145
|
122 class bitfield;
|
|
111
|
123 class fields;
|
|
|
124 class function;
|
|
|
125 class block;
|
|
|
126 class rvalue;
|
|
|
127 class lvalue;
|
|
|
128 class local;
|
|
|
129 class global;
|
|
|
130 class param;
|
|
|
131 class base_call;
|
|
|
132 class function_pointer;
|
|
|
133 class statement;
|
|
|
134 class case_;
|
|
|
135
|
|
|
136 /* End of recording types. */
|
|
|
137 }
|
|
|
138
|
|
|
139 namespace playback {
|
|
|
140 /* Playback types. */
|
|
|
141
|
|
|
142 /* Indentation indicates inheritance: */
|
|
|
143 class context;
|
|
|
144 class wrapper;
|
|
|
145 class type;
|
|
|
146 class compound_type;
|
|
|
147 class field;
|
|
|
148 class function;
|
|
|
149 class block;
|
|
|
150 class rvalue;
|
|
|
151 class lvalue;
|
|
|
152 class param;
|
|
|
153 class source_file;
|
|
|
154 class source_line;
|
|
|
155 class location;
|
|
|
156 class case_;
|
|
|
157
|
|
|
158 /* End of playback types. */
|
|
|
159 }
|
|
|
160
|
|
|
161 typedef playback::context replayer;
|
|
|
162
|
|
|
163 class dump
|
|
|
164 {
|
|
|
165 public:
|
|
|
166 dump (recording::context &ctxt,
|
|
|
167 const char *filename,
|
|
|
168 bool update_locations);
|
|
|
169 ~dump ();
|
|
|
170
|
|
|
171 recording::context &get_context () { return m_ctxt; }
|
|
|
172
|
|
|
173 void write (const char *fmt, ...)
|
|
|
174 GNU_PRINTF(2, 3);
|
|
|
175
|
|
|
176 bool update_locations () const { return m_update_locations; }
|
|
|
177
|
|
|
178 recording::location *
|
|
|
179 make_location () const;
|
|
|
180
|
|
|
181 FILE *get_file () const { return m_file; }
|
|
|
182
|
|
|
183 private:
|
|
|
184 recording::context &m_ctxt;
|
|
|
185 const char *m_filename;
|
|
|
186 bool m_update_locations;
|
|
|
187 int m_line;
|
|
|
188 int m_column;
|
|
|
189 FILE *m_file;
|
|
|
190 };
|
|
|
191
|
|
|
192 /* A hidden enum of boolean options that are only exposed via API
|
|
|
193 entrypoints, rather than via gcc_jit_context_set_bool_option. */
|
|
|
194
|
|
|
195 enum inner_bool_option
|
|
|
196 {
|
|
|
197 INNER_BOOL_OPTION_ALLOW_UNREACHABLE_BLOCKS,
|
|
|
198 INNER_BOOL_OPTION_USE_EXTERNAL_DRIVER,
|
|
|
199
|
|
|
200 NUM_INNER_BOOL_OPTIONS
|
|
|
201 };
|
|
|
202
|
|
|
203 } // namespace gcc::jit
|
|
|
204
|
|
|
205 } // namespace gcc
|
|
|
206
|
|
|
207 #endif /* JIT_COMMON_H */
|
