1 /* Core of implementation of libgccjit.so
2    Copyright (C) 2013-2019 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_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;
122     class fields;
123     class function;
124     class block;
125     class rvalue;
126       class lvalue;
127         class local;
128 	class global;
129         class param;
130       class base_call;
131       class function_pointer;
132     class statement;
133     class case_;
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;
155     class case_;
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 
get_context()170   recording::context &get_context () { return m_ctxt; }
171 
172   void write (const char *fmt, ...)
173     GNU_PRINTF(2, 3);
174 
update_locations()175   bool update_locations () const { return m_update_locations; }
176 
177   recording::location *
178   make_location () const;
179 
get_file()180   FILE *get_file () const { return m_file; }
181 
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 
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,
197   INNER_BOOL_OPTION_USE_EXTERNAL_DRIVER,
198 
199   NUM_INNER_BOOL_OPTIONS
200 };
201 
202 } // namespace gcc::jit
203 
204 } // namespace gcc
205 
206 #endif /* JIT_COMMON_H */
207