]>
Commit | Line | Data |
---|---|---|
863e76f9 | 1 | /* Core of implementation of libgccjit.so |
fbd26352 | 2 | Copyright (C) 2013-2019 Free Software Foundation, Inc. |
863e76f9 | 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 | ||
608f349b | 26 | #include "vec.h" |
863e76f9 | 27 | #include "tree.h" |
9ef16211 | 28 | #include "inchash.h" |
863e76f9 | 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 | ||
7140b255 | 39 | const int NUM_GCC_JIT_TYPES = GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE + 1; |
863e76f9 | 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; | |
3a9ccc11 | 102 | class logger; |
7140b255 | 103 | class builtins_manager; // declared within jit-builtins.h |
7f91822b | 104 | class tempdir; |
863e76f9 | 105 | |
106 | namespace recording { | |
107 | ||
108 | /* Recording types. */ | |
109 | ||
110 | /* Indentation indicates inheritance: */ | |
111 | class context; | |
863e76f9 | 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_; | |
94c6c040 | 120 | class vector_type; |
863e76f9 | 121 | class field; |
122 | class fields; | |
123 | class function; | |
124 | class block; | |
125 | class rvalue; | |
126 | class lvalue; | |
127 | class local; | |
128 | class global; | |
129 | class param; | |
9954d230 | 130 | class base_call; |
0173cb00 | 131 | class function_pointer; |
863e76f9 | 132 | class statement; |
a24ef8d2 | 133 | class case_; |
863e76f9 | 134 | |
135 | /* End of recording types. */ | |
136 | } | |
137 | ||
138 | namespace playback { | |
139 | /* Playback types. */ | |
140 | ||
141 | /* Indentation indicates inheritance: */ | |
142 | class context; | |
143 | class wrapper; | |
144 | class type; | |
145 | class compound_type; | |
146 | class field; | |
147 | class function; | |
148 | class block; | |
149 | class rvalue; | |
150 | class lvalue; | |
151 | class param; | |
152 | class source_file; | |
153 | class source_line; | |
154 | class location; | |
a24ef8d2 | 155 | class case_; |
863e76f9 | 156 | |
157 | /* End of playback types. */ | |
158 | } | |
159 | ||
160 | typedef playback::context replayer; | |
161 | ||
162 | class dump | |
163 | { | |
164 | public: | |
165 | dump (recording::context &ctxt, | |
166 | const char *filename, | |
167 | bool update_locations); | |
168 | ~dump (); | |
169 | ||
c97b0d1d | 170 | recording::context &get_context () { return m_ctxt; } |
171 | ||
863e76f9 | 172 | void write (const char *fmt, ...) |
173 | GNU_PRINTF(2, 3); | |
174 | ||
175 | bool update_locations () const { return m_update_locations; } | |
176 | ||
177 | recording::location * | |
178 | make_location () const; | |
179 | ||
b86fa9da | 180 | FILE *get_file () const { return m_file; } |
181 | ||
863e76f9 | 182 | private: |
183 | recording::context &m_ctxt; | |
184 | const char *m_filename; | |
185 | bool m_update_locations; | |
186 | int m_line; | |
187 | int m_column; | |
188 | FILE *m_file; | |
189 | }; | |
190 | ||
04feb56e | 191 | /* A hidden enum of boolean options that are only exposed via API |
192 | entrypoints, rather than via gcc_jit_context_set_bool_option. */ | |
193 | ||
194 | enum inner_bool_option | |
195 | { | |
196 | INNER_BOOL_OPTION_ALLOW_UNREACHABLE_BLOCKS, | |
26a4a13d | 197 | INNER_BOOL_OPTION_USE_EXTERNAL_DRIVER, |
04feb56e | 198 | |
199 | NUM_INNER_BOOL_OPTIONS | |
200 | }; | |
201 | ||
863e76f9 | 202 | } // namespace gcc::jit |
203 | ||
204 | } // namespace gcc | |
205 | ||
206 | #endif /* JIT_COMMON_H */ |