|
111
|
1 /* Internals of libgccjit: classes for recording calls made to the JIT API.
|
|
131
|
2 Copyright (C) 2013-2018 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_RECORDING_H
|
|
|
22 #define JIT_RECORDING_H
|
|
|
23
|
|
|
24 #include "jit-common.h"
|
|
|
25 #include "jit-logging.h"
|
|
|
26
|
|
|
27 class timer;
|
|
|
28
|
|
|
29 namespace gcc {
|
|
|
30
|
|
|
31 namespace jit {
|
|
|
32
|
|
|
33 class result;
|
|
|
34 class dump;
|
|
|
35 class reproducer;
|
|
|
36
|
|
|
37 /**********************************************************************
|
|
|
38 Recording.
|
|
|
39 **********************************************************************/
|
|
|
40
|
|
|
41 namespace recording {
|
|
|
42
|
|
|
43 playback::location *
|
|
|
44 playback_location (replayer *r, location *loc);
|
|
|
45
|
|
|
46 const char *
|
|
|
47 playback_string (string *str);
|
|
|
48
|
|
|
49 playback::block *
|
|
|
50 playback_block (block *b);
|
|
|
51
|
|
|
52 /* A recording of a call to gcc_jit_context_enable_dump. */
|
|
|
53 struct requested_dump
|
|
|
54 {
|
|
|
55 const char *m_dumpname;
|
|
|
56 char **m_out_ptr;
|
|
|
57 };
|
|
|
58
|
|
|
59 /* A JIT-compilation context. */
|
|
|
60 class context : public log_user
|
|
|
61 {
|
|
|
62 public:
|
|
|
63 context (context *parent_ctxt);
|
|
|
64 ~context ();
|
|
|
65
|
|
|
66 builtins_manager *
|
|
|
67 get_builtins_manager ();
|
|
|
68
|
|
|
69 void record (memento *m);
|
|
|
70 void replay_into (replayer *r);
|
|
|
71 void disassociate_from_playback ();
|
|
|
72
|
|
|
73 string *
|
|
|
74 new_string (const char *text);
|
|
|
75
|
|
|
76 location *
|
|
|
77 new_location (const char *filename,
|
|
|
78 int line,
|
|
|
79 int column,
|
|
|
80 bool created_by_user);
|
|
|
81
|
|
|
82 type *
|
|
|
83 get_type (enum gcc_jit_types type);
|
|
|
84
|
|
|
85 type *
|
|
|
86 get_int_type (int num_bytes, int is_signed);
|
|
|
87
|
|
|
88 type *
|
|
|
89 new_array_type (location *loc,
|
|
|
90 type *element_type,
|
|
|
91 int num_elements);
|
|
|
92
|
|
|
93 field *
|
|
|
94 new_field (location *loc,
|
|
|
95 type *type,
|
|
|
96 const char *name);
|
|
|
97
|
|
|
98 struct_ *
|
|
|
99 new_struct_type (location *loc,
|
|
|
100 const char *name);
|
|
|
101
|
|
|
102 union_ *
|
|
|
103 new_union_type (location *loc,
|
|
|
104 const char *name);
|
|
|
105
|
|
|
106 function_type *
|
|
|
107 new_function_type (type *return_type,
|
|
|
108 int num_params,
|
|
|
109 type **param_types,
|
|
|
110 int is_variadic);
|
|
|
111
|
|
|
112 type *
|
|
|
113 new_function_ptr_type (location *loc,
|
|
|
114 type *return_type,
|
|
|
115 int num_params,
|
|
|
116 type **param_types,
|
|
|
117 int is_variadic);
|
|
|
118
|
|
|
119 param *
|
|
|
120 new_param (location *loc,
|
|
|
121 type *type,
|
|
|
122 const char *name);
|
|
|
123
|
|
|
124 function *
|
|
|
125 new_function (location *loc,
|
|
|
126 enum gcc_jit_function_kind kind,
|
|
|
127 type *return_type,
|
|
|
128 const char *name,
|
|
|
129 int num_params,
|
|
|
130 param **params,
|
|
|
131 int is_variadic,
|
|
|
132 enum built_in_function builtin_id);
|
|
|
133
|
|
|
134 function *
|
|
|
135 get_builtin_function (const char *name);
|
|
|
136
|
|
|
137 lvalue *
|
|
|
138 new_global (location *loc,
|
|
|
139 enum gcc_jit_global_kind kind,
|
|
|
140 type *type,
|
|
|
141 const char *name);
|
|
|
142
|
|
|
143 template <typename HOST_TYPE>
|
|
|
144 rvalue *
|
|
|
145 new_rvalue_from_const (type *type,
|
|
|
146 HOST_TYPE value);
|
|
|
147
|
|
|
148 rvalue *
|
|
|
149 new_string_literal (const char *value);
|
|
|
150
|
|
|
151 rvalue *
|
|
|
152 new_rvalue_from_vector (location *loc,
|
|
|
153 vector_type *type,
|
|
|
154 rvalue **elements);
|
|
|
155
|
|
|
156 rvalue *
|
|
|
157 new_unary_op (location *loc,
|
|
|
158 enum gcc_jit_unary_op op,
|
|
|
159 type *result_type,
|
|
|
160 rvalue *a);
|
|
|
161
|
|
|
162 rvalue *
|
|
|
163 new_binary_op (location *loc,
|
|
|
164 enum gcc_jit_binary_op op,
|
|
|
165 type *result_type,
|
|
|
166 rvalue *a, rvalue *b);
|
|
|
167
|
|
|
168 rvalue *
|
|
|
169 new_comparison (location *loc,
|
|
|
170 enum gcc_jit_comparison op,
|
|
|
171 rvalue *a, rvalue *b);
|
|
|
172
|
|
|
173 rvalue *
|
|
|
174 new_call (location *loc,
|
|
|
175 function *func,
|
|
|
176 int numargs, rvalue **args);
|
|
|
177
|
|
|
178 rvalue *
|
|
|
179 new_call_through_ptr (location *loc,
|
|
|
180 rvalue *fn_ptr,
|
|
|
181 int numargs, rvalue **args);
|
|
|
182
|
|
|
183 rvalue *
|
|
|
184 new_cast (location *loc,
|
|
|
185 rvalue *expr,
|
|
|
186 type *type_);
|
|
|
187
|
|
|
188 lvalue *
|
|
|
189 new_array_access (location *loc,
|
|
|
190 rvalue *ptr,
|
|
|
191 rvalue *index);
|
|
|
192
|
|
|
193 case_ *
|
|
|
194 new_case (rvalue *min_value,
|
|
|
195 rvalue *max_value,
|
|
|
196 block *block);
|
|
|
197
|
|
|
198 void
|
|
|
199 set_str_option (enum gcc_jit_str_option opt,
|
|
|
200 const char *value);
|
|
|
201
|
|
|
202 void
|
|
|
203 set_int_option (enum gcc_jit_int_option opt,
|
|
|
204 int value);
|
|
|
205
|
|
|
206 void
|
|
|
207 set_bool_option (enum gcc_jit_bool_option opt,
|
|
|
208 int value);
|
|
|
209
|
|
|
210 void
|
|
|
211 set_inner_bool_option (enum inner_bool_option inner_opt,
|
|
|
212 int value);
|
|
|
213
|
|
|
214 void
|
|
|
215 add_command_line_option (const char *optname);
|
|
|
216
|
|
|
217 void
|
|
|
218 append_command_line_options (vec <char *> *argvec);
|
|
|
219
|
|
|
220 void
|
|
|
221 enable_dump (const char *dumpname,
|
|
|
222 char **out_ptr);
|
|
|
223
|
|
|
224 const char *
|
|
|
225 get_str_option (enum gcc_jit_str_option opt) const
|
|
|
226 {
|
|
|
227 return m_str_options[opt];
|
|
|
228 }
|
|
|
229
|
|
|
230 int
|
|
|
231 get_int_option (enum gcc_jit_int_option opt) const
|
|
|
232 {
|
|
|
233 return m_int_options[opt];
|
|
|
234 }
|
|
|
235
|
|
|
236 int
|
|
|
237 get_bool_option (enum gcc_jit_bool_option opt) const
|
|
|
238 {
|
|
|
239 return m_bool_options[opt];
|
|
|
240 }
|
|
|
241
|
|
|
242 int
|
|
|
243 get_inner_bool_option (enum inner_bool_option opt) const
|
|
|
244 {
|
|
|
245 return m_inner_bool_options[opt];
|
|
|
246 }
|
|
|
247
|
|
|
248 result *
|
|
|
249 compile ();
|
|
|
250
|
|
|
251 void
|
|
|
252 compile_to_file (enum gcc_jit_output_kind output_kind,
|
|
|
253 const char *output_path);
|
|
|
254
|
|
|
255 void
|
|
|
256 add_error (location *loc, const char *fmt, ...)
|
|
|
257 GNU_PRINTF(3, 4);
|
|
|
258
|
|
|
259 void
|
|
|
260 add_error_va (location *loc, const char *fmt, va_list ap)
|
|
|
261 GNU_PRINTF(3, 0);
|
|
|
262
|
|
|
263 const char *
|
|
|
264 get_first_error () const;
|
|
|
265
|
|
|
266 const char *
|
|
|
267 get_last_error () const;
|
|
|
268
|
|
|
269 bool errors_occurred () const
|
|
|
270 {
|
|
|
271 if (m_parent_ctxt)
|
|
|
272 if (m_parent_ctxt->errors_occurred ())
|
|
|
273 return true;
|
|
|
274 return m_error_count;
|
|
|
275 }
|
|
|
276
|
|
|
277 type *get_opaque_FILE_type ();
|
|
|
278
|
|
|
279 void dump_to_file (const char *path, bool update_locations);
|
|
|
280
|
|
|
281 void dump_reproducer_to_file (const char *path);
|
|
|
282
|
|
|
283 void
|
|
|
284 get_all_requested_dumps (vec <recording::requested_dump> *out);
|
|
|
285
|
|
|
286 void set_timer (timer *t) { m_timer = t; }
|
|
|
287 timer *get_timer () const { return m_timer; }
|
|
|
288
|
|
|
289 private:
|
|
|
290 void log_all_options () const;
|
|
|
291 void log_str_option (enum gcc_jit_str_option opt) const;
|
|
|
292 void log_int_option (enum gcc_jit_int_option opt) const;
|
|
|
293 void log_bool_option (enum gcc_jit_bool_option opt) const;
|
|
|
294 void log_inner_bool_option (enum inner_bool_option opt) const;
|
|
|
295
|
|
|
296 void validate ();
|
|
|
297
|
|
|
298 private:
|
|
|
299 context *m_parent_ctxt;
|
|
|
300
|
|
|
301 /* The ultimate ancestor of the contexts within a family tree of
|
|
|
302 contexts. This has itself as its own m_toplevel_ctxt. */
|
|
|
303 context *m_toplevel_ctxt;
|
|
|
304
|
|
|
305 timer *m_timer;
|
|
|
306
|
|
|
307 int m_error_count;
|
|
|
308
|
|
|
309 char *m_first_error_str;
|
|
|
310 bool m_owns_first_error_str;
|
|
|
311
|
|
|
312 char *m_last_error_str;
|
|
|
313 bool m_owns_last_error_str;
|
|
|
314
|
|
|
315 char *m_str_options[GCC_JIT_NUM_STR_OPTIONS];
|
|
|
316 int m_int_options[GCC_JIT_NUM_INT_OPTIONS];
|
|
|
317 bool m_bool_options[GCC_JIT_NUM_BOOL_OPTIONS];
|
|
|
318 bool m_inner_bool_options[NUM_INNER_BOOL_OPTIONS];
|
|
|
319 auto_vec <char *> m_command_line_options;
|
|
|
320
|
|
|
321 /* Dumpfiles that were requested via gcc_jit_context_enable_dump. */
|
|
|
322 auto_vec<requested_dump> m_requested_dumps;
|
|
|
323
|
|
|
324 /* Recorded API usage. */
|
|
|
325 auto_vec<memento *> m_mementos;
|
|
|
326
|
|
|
327 /* Specific recordings, for use by dump_to_file. */
|
|
|
328 auto_vec<compound_type *> m_compound_types;
|
|
|
329 auto_vec<global *> m_globals;
|
|
|
330 auto_vec<function *> m_functions;
|
|
|
331
|
|
|
332 type *m_basic_types[NUM_GCC_JIT_TYPES];
|
|
|
333 type *m_FILE_type;
|
|
|
334
|
|
|
335 builtins_manager *m_builtins_manager; // lazily created
|
|
|
336 };
|
|
|
337
|
|
|
338
|
|
|
339 /* An object with lifetime managed by the context i.e.
|
|
|
340 it lives until the context is released, at which
|
|
|
341 point it itself is cleaned up. */
|
|
|
342
|
|
|
343 class memento
|
|
|
344 {
|
|
|
345 public:
|
|
|
346 virtual ~memento () {}
|
|
|
347
|
|
|
348 /* Hook for replaying this. */
|
|
|
349 virtual void replay_into (replayer *r) = 0;
|
|
|
350
|
|
|
351 void set_playback_obj (void *obj) { m_playback_obj = obj; }
|
|
|
352
|
|
|
353
|
|
|
354 /* Get the context that owns this object.
|
|
|
355
|
|
|
356 Implements the post-error-checking part of
|
|
|
357 gcc_jit_object_get_context. */
|
|
|
358 context *get_context () { return m_ctxt; }
|
|
|
359
|
|
|
360 memento *
|
|
|
361 as_object () { return this; }
|
|
|
362
|
|
|
363 /* Debugging hook, for use in generating error messages etc.
|
|
|
364 Implements the post-error-checking part of
|
|
|
365 gcc_jit_object_get_debug_string. */
|
|
|
366 const char *
|
|
|
367 get_debug_string ();
|
|
|
368
|
|
|
369 virtual void write_to_dump (dump &d);
|
|
|
370 virtual void write_reproducer (reproducer &r) = 0;
|
|
|
371 virtual location *dyn_cast_location () { return NULL; }
|
|
|
372
|
|
|
373 protected:
|
|
|
374 memento (context *ctxt)
|
|
|
375 : m_ctxt (ctxt),
|
|
|
376 m_playback_obj (NULL),
|
|
|
377 m_debug_string (NULL)
|
|
|
378 {
|
|
|
379 gcc_assert (ctxt);
|
|
|
380 }
|
|
|
381
|
|
|
382 string *new_string (const char *text) { return m_ctxt->new_string (text); }
|
|
|
383
|
|
|
384 private:
|
|
|
385 virtual string * make_debug_string () = 0;
|
|
|
386
|
|
|
387 public:
|
|
|
388 context *m_ctxt;
|
|
|
389
|
|
|
390 protected:
|
|
|
391 void *m_playback_obj;
|
|
|
392
|
|
|
393 private:
|
|
|
394 string *m_debug_string;
|
|
|
395 };
|
|
|
396
|
|
|
397 /* or just use std::string? */
|
|
|
398 class string : public memento
|
|
|
399 {
|
|
|
400 public:
|
|
|
401 string (context *ctxt, const char *text);
|
|
|
402 ~string ();
|
|
|
403
|
|
|
404 const char *c_str () { return m_buffer; }
|
|
|
405
|
|
|
406 static string * from_printf (context *ctxt, const char *fmt, ...)
|
|
|
407 GNU_PRINTF(2, 3);
|
|
|
408
|
|
|
409 void replay_into (replayer *) FINAL OVERRIDE {}
|
|
|
410
|
|
|
411 private:
|
|
|
412 string * make_debug_string () FINAL OVERRIDE;
|
|
|
413 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
414
|
|
|
415 private:
|
|
|
416 size_t m_len;
|
|
|
417 char *m_buffer;
|
|
|
418 };
|
|
|
419
|
|
|
420 class location : public memento
|
|
|
421 {
|
|
|
422 public:
|
|
|
423 location (context *ctxt, string *filename, int line, int column,
|
|
|
424 bool created_by_user)
|
|
|
425 : memento (ctxt),
|
|
|
426 m_filename (filename),
|
|
|
427 m_line (line),
|
|
|
428 m_column (column),
|
|
|
429 m_created_by_user (created_by_user)
|
|
|
430 {}
|
|
|
431
|
|
|
432 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
433
|
|
|
434 playback::location *
|
|
|
435 playback_location (replayer *r)
|
|
|
436 {
|
|
|
437 /* Normally during playback, we can walk forwards through the list of
|
|
|
438 recording objects, playing them back. The ordering of recording
|
|
|
439 ensures that everything that a recording object refers to has
|
|
|
440 already been played back, so we can simply look up the relevant
|
|
|
441 m_playback_obj.
|
|
|
442
|
|
|
443 Locations are an exception, due to the "write_to_dump" method of
|
|
|
444 recording::statement. This method can set a new location on a
|
|
|
445 statement after the statement is created, and thus the location
|
|
|
446 appears in the context's memento list *after* the statement that
|
|
|
447 refers to it.
|
|
|
448
|
|
|
449 In such circumstances, the statement is replayed *before* the location,
|
|
|
450 when the latter doesn't yet have a playback object.
|
|
|
451
|
|
|
452 Hence we need to ensure that locations have playback objects. */
|
|
|
453 if (!m_playback_obj)
|
|
|
454 {
|
|
|
455 replay_into (r);
|
|
|
456 }
|
|
|
457 gcc_assert (m_playback_obj);
|
|
|
458 return static_cast <playback::location *> (m_playback_obj);
|
|
|
459 }
|
|
|
460
|
|
|
461 location *dyn_cast_location () FINAL OVERRIDE { return this; }
|
|
|
462 bool created_by_user () const { return m_created_by_user; }
|
|
|
463
|
|
|
464 private:
|
|
|
465 string * make_debug_string () FINAL OVERRIDE;
|
|
|
466 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
467
|
|
|
468 private:
|
|
|
469 string *m_filename;
|
|
|
470 int m_line;
|
|
|
471 int m_column;
|
|
|
472 bool m_created_by_user;
|
|
|
473 };
|
|
|
474
|
|
|
475 class type : public memento
|
|
|
476 {
|
|
|
477 public:
|
|
|
478 type *get_pointer ();
|
|
|
479 type *get_const ();
|
|
|
480 type *get_volatile ();
|
|
|
481 type *get_aligned (size_t alignment_in_bytes);
|
|
|
482 type *get_vector (size_t num_units);
|
|
|
483
|
|
|
484 /* Get the type obtained when dereferencing this type.
|
|
|
485
|
|
|
486 This will return NULL if it's not valid to dereference this type.
|
|
|
487 The caller is responsible for setting an error. */
|
|
|
488 virtual type *dereference () = 0;
|
|
|
489
|
|
|
490 /* Dynamic casts. */
|
|
|
491 virtual function_type *dyn_cast_function_type () { return NULL; }
|
|
|
492 virtual function_type *as_a_function_type() { gcc_unreachable (); return NULL; }
|
|
|
493 virtual struct_ *dyn_cast_struct () { return NULL; }
|
|
|
494 virtual vector_type *dyn_cast_vector_type () { return NULL; }
|
|
|
495
|
|
|
496 /* Is it typesafe to copy to this type from rtype? */
|
|
|
497 virtual bool accepts_writes_from (type *rtype)
|
|
|
498 {
|
|
|
499 gcc_assert (rtype);
|
|
|
500 return this->unqualified ()->is_same_type_as (rtype->unqualified ());
|
|
|
501 }
|
|
|
502
|
|
|
503 virtual bool is_same_type_as (type *other)
|
|
|
504 {
|
|
|
505 return this == other;
|
|
|
506 }
|
|
|
507
|
|
|
508 /* Strip off "const" etc */
|
|
|
509 virtual type *unqualified ()
|
|
|
510 {
|
|
|
511 return this;
|
|
|
512 }
|
|
|
513
|
|
|
514 virtual bool is_int () const = 0;
|
|
|
515 virtual bool is_float () const = 0;
|
|
|
516 virtual bool is_bool () const = 0;
|
|
|
517 virtual type *is_pointer () = 0;
|
|
|
518 virtual type *is_array () = 0;
|
|
|
519 virtual bool is_void () const { return false; }
|
|
|
520 virtual bool has_known_size () const { return true; }
|
|
|
521
|
|
|
522 bool is_numeric () const
|
|
|
523 {
|
|
|
524 return is_int () || is_float () || is_bool ();
|
|
|
525 }
|
|
|
526
|
|
|
527 playback::type *
|
|
|
528 playback_type ()
|
|
|
529 {
|
|
|
530 return static_cast <playback::type *> (m_playback_obj);
|
|
|
531 }
|
|
|
532
|
|
|
533 virtual const char *access_as_type (reproducer &r);
|
|
|
534
|
|
|
535 protected:
|
|
|
536 type (context *ctxt)
|
|
|
537 : memento (ctxt),
|
|
|
538 m_pointer_to_this_type (NULL)
|
|
|
539 {}
|
|
|
540
|
|
|
541 private:
|
|
|
542 type *m_pointer_to_this_type;
|
|
|
543 };
|
|
|
544
|
|
|
545 /* Result of "gcc_jit_context_get_type". */
|
|
|
546 class memento_of_get_type : public type
|
|
|
547 {
|
|
|
548 public:
|
|
|
549 memento_of_get_type (context *ctxt,
|
|
|
550 enum gcc_jit_types kind)
|
|
|
551 : type (ctxt),
|
|
|
552 m_kind (kind) {}
|
|
|
553
|
|
|
554 type *dereference () FINAL OVERRIDE;
|
|
|
555
|
|
|
556 bool accepts_writes_from (type *rtype) FINAL OVERRIDE
|
|
|
557 {
|
|
|
558 if (m_kind == GCC_JIT_TYPE_VOID_PTR)
|
|
|
559 if (rtype->is_pointer ())
|
|
|
560 {
|
|
|
561 /* LHS (this) is type (void *), and the RHS is a pointer:
|
|
|
562 accept it: */
|
|
|
563 return true;
|
|
|
564 }
|
|
|
565
|
|
|
566 return type::accepts_writes_from (rtype);
|
|
|
567 }
|
|
|
568
|
|
|
569 bool is_int () const FINAL OVERRIDE;
|
|
|
570 bool is_float () const FINAL OVERRIDE;
|
|
|
571 bool is_bool () const FINAL OVERRIDE;
|
|
|
572 type *is_pointer () FINAL OVERRIDE { return dereference (); }
|
|
|
573 type *is_array () FINAL OVERRIDE { return NULL; }
|
|
|
574 bool is_void () const FINAL OVERRIDE { return m_kind == GCC_JIT_TYPE_VOID; }
|
|
|
575
|
|
|
576 public:
|
|
|
577 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
578
|
|
|
579 private:
|
|
|
580 string * make_debug_string () FINAL OVERRIDE;
|
|
|
581 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
582
|
|
|
583 private:
|
|
|
584 enum gcc_jit_types m_kind;
|
|
|
585 };
|
|
|
586
|
|
|
587 /* Result of "gcc_jit_type_get_pointer". */
|
|
|
588 class memento_of_get_pointer : public type
|
|
|
589 {
|
|
|
590 public:
|
|
|
591 memento_of_get_pointer (type *other_type)
|
|
|
592 : type (other_type->m_ctxt),
|
|
|
593 m_other_type (other_type) {}
|
|
|
594
|
|
|
595 type *dereference () FINAL OVERRIDE { return m_other_type; }
|
|
|
596
|
|
|
597 bool accepts_writes_from (type *rtype) FINAL OVERRIDE;
|
|
|
598
|
|
|
599 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
600
|
|
|
601 bool is_int () const FINAL OVERRIDE { return false; }
|
|
|
602 bool is_float () const FINAL OVERRIDE { return false; }
|
|
|
603 bool is_bool () const FINAL OVERRIDE { return false; }
|
|
|
604 type *is_pointer () FINAL OVERRIDE { return m_other_type; }
|
|
|
605 type *is_array () FINAL OVERRIDE { return NULL; }
|
|
|
606
|
|
|
607 private:
|
|
|
608 string * make_debug_string () FINAL OVERRIDE;
|
|
|
609 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
610
|
|
|
611 private:
|
|
|
612 type *m_other_type;
|
|
|
613 };
|
|
|
614
|
|
|
615 /* A decorated version of a type, for get_const, get_volatile,
|
|
|
616 get_aligned, and get_vector. */
|
|
|
617
|
|
|
618 class decorated_type : public type
|
|
|
619 {
|
|
|
620 public:
|
|
|
621 decorated_type (type *other_type)
|
|
|
622 : type (other_type->m_ctxt),
|
|
|
623 m_other_type (other_type) {}
|
|
|
624
|
|
|
625 type *dereference () FINAL OVERRIDE { return m_other_type->dereference (); }
|
|
|
626
|
|
|
627 bool is_int () const FINAL OVERRIDE { return m_other_type->is_int (); }
|
|
|
628 bool is_float () const FINAL OVERRIDE { return m_other_type->is_float (); }
|
|
|
629 bool is_bool () const FINAL OVERRIDE { return m_other_type->is_bool (); }
|
|
|
630 type *is_pointer () FINAL OVERRIDE { return m_other_type->is_pointer (); }
|
|
|
631 type *is_array () FINAL OVERRIDE { return m_other_type->is_array (); }
|
|
|
632
|
|
|
633 protected:
|
|
|
634 type *m_other_type;
|
|
|
635 };
|
|
|
636
|
|
|
637 /* Result of "gcc_jit_type_get_const". */
|
|
|
638 class memento_of_get_const : public decorated_type
|
|
|
639 {
|
|
|
640 public:
|
|
|
641 memento_of_get_const (type *other_type)
|
|
|
642 : decorated_type (other_type) {}
|
|
|
643
|
|
|
644 bool accepts_writes_from (type */*rtype*/) FINAL OVERRIDE
|
|
|
645 {
|
|
|
646 /* Can't write to a "const". */
|
|
|
647 return false;
|
|
|
648 }
|
|
|
649
|
|
|
650 /* Strip off the "const", giving the underlying type. */
|
|
|
651 type *unqualified () FINAL OVERRIDE { return m_other_type; }
|
|
|
652
|
|
|
653 void replay_into (replayer *) FINAL OVERRIDE;
|
|
|
654
|
|
|
655 private:
|
|
|
656 string * make_debug_string () FINAL OVERRIDE;
|
|
|
657 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
658 };
|
|
|
659
|
|
|
660 /* Result of "gcc_jit_type_get_volatile". */
|
|
|
661 class memento_of_get_volatile : public decorated_type
|
|
|
662 {
|
|
|
663 public:
|
|
|
664 memento_of_get_volatile (type *other_type)
|
|
|
665 : decorated_type (other_type) {}
|
|
|
666
|
|
|
667 /* Strip off the "volatile", giving the underlying type. */
|
|
|
668 type *unqualified () FINAL OVERRIDE { return m_other_type; }
|
|
|
669
|
|
|
670 void replay_into (replayer *) FINAL OVERRIDE;
|
|
|
671
|
|
|
672 private:
|
|
|
673 string * make_debug_string () FINAL OVERRIDE;
|
|
|
674 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
675 };
|
|
|
676
|
|
|
677 /* Result of "gcc_jit_type_get_aligned". */
|
|
|
678 class memento_of_get_aligned : public decorated_type
|
|
|
679 {
|
|
|
680 public:
|
|
|
681 memento_of_get_aligned (type *other_type, size_t alignment_in_bytes)
|
|
|
682 : decorated_type (other_type),
|
|
|
683 m_alignment_in_bytes (alignment_in_bytes) {}
|
|
|
684
|
|
|
685 /* Strip off the alignment, giving the underlying type. */
|
|
|
686 type *unqualified () FINAL OVERRIDE { return m_other_type; }
|
|
|
687
|
|
|
688 void replay_into (replayer *) FINAL OVERRIDE;
|
|
|
689
|
|
|
690 private:
|
|
|
691 string * make_debug_string () FINAL OVERRIDE;
|
|
|
692 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
693
|
|
|
694 private:
|
|
|
695 size_t m_alignment_in_bytes;
|
|
|
696 };
|
|
|
697
|
|
|
698 /* Result of "gcc_jit_type_get_vector". */
|
|
|
699 class vector_type : public decorated_type
|
|
|
700 {
|
|
|
701 public:
|
|
|
702 vector_type (type *other_type, size_t num_units)
|
|
|
703 : decorated_type (other_type),
|
|
|
704 m_num_units (num_units) {}
|
|
|
705
|
|
|
706 size_t get_num_units () const { return m_num_units; }
|
|
|
707
|
|
|
708 vector_type *dyn_cast_vector_type () FINAL OVERRIDE { return this; }
|
|
|
709
|
|
|
710 type *get_element_type () { return m_other_type; }
|
|
|
711
|
|
|
712 void replay_into (replayer *) FINAL OVERRIDE;
|
|
|
713
|
|
|
714 private:
|
|
|
715 string * make_debug_string () FINAL OVERRIDE;
|
|
|
716 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
717
|
|
|
718 private:
|
|
|
719 size_t m_num_units;
|
|
|
720 };
|
|
|
721
|
|
|
722 class array_type : public type
|
|
|
723 {
|
|
|
724 public:
|
|
|
725 array_type (context *ctxt,
|
|
|
726 location *loc,
|
|
|
727 type *element_type,
|
|
|
728 int num_elements)
|
|
|
729 : type (ctxt),
|
|
|
730 m_loc (loc),
|
|
|
731 m_element_type (element_type),
|
|
|
732 m_num_elements (num_elements)
|
|
|
733 {}
|
|
|
734
|
|
|
735 type *dereference () FINAL OVERRIDE;
|
|
|
736
|
|
|
737 bool is_int () const FINAL OVERRIDE { return false; }
|
|
|
738 bool is_float () const FINAL OVERRIDE { return false; }
|
|
|
739 bool is_bool () const FINAL OVERRIDE { return false; }
|
|
|
740 type *is_pointer () FINAL OVERRIDE { return NULL; }
|
|
|
741 type *is_array () FINAL OVERRIDE { return m_element_type; }
|
|
|
742
|
|
|
743 void replay_into (replayer *) FINAL OVERRIDE;
|
|
|
744
|
|
|
745 private:
|
|
|
746 string * make_debug_string () FINAL OVERRIDE;
|
|
|
747 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
748
|
|
|
749 private:
|
|
|
750 location *m_loc;
|
|
|
751 type *m_element_type;
|
|
|
752 int m_num_elements;
|
|
|
753 };
|
|
|
754
|
|
|
755 class function_type : public type
|
|
|
756 {
|
|
|
757 public:
|
|
|
758 function_type (context *ctxt,
|
|
|
759 type *return_type,
|
|
|
760 int num_params,
|
|
|
761 type **param_types,
|
|
|
762 int is_variadic);
|
|
|
763
|
|
|
764 type *dereference () FINAL OVERRIDE;
|
|
|
765 function_type *dyn_cast_function_type () FINAL OVERRIDE { return this; }
|
|
|
766 function_type *as_a_function_type () FINAL OVERRIDE { return this; }
|
|
|
767
|
|
|
768 bool is_same_type_as (type *other) FINAL OVERRIDE;
|
|
|
769
|
|
|
770 bool is_int () const FINAL OVERRIDE { return false; }
|
|
|
771 bool is_float () const FINAL OVERRIDE { return false; }
|
|
|
772 bool is_bool () const FINAL OVERRIDE { return false; }
|
|
|
773 type *is_pointer () FINAL OVERRIDE { return NULL; }
|
|
|
774 type *is_array () FINAL OVERRIDE { return NULL; }
|
|
|
775
|
|
|
776 void replay_into (replayer *) FINAL OVERRIDE;
|
|
|
777
|
|
|
778 type * get_return_type () const { return m_return_type; }
|
|
|
779 const vec<type *> &get_param_types () const { return m_param_types; }
|
|
|
780 int is_variadic () const { return m_is_variadic; }
|
|
|
781
|
|
|
782 string * make_debug_string_with_ptr ();
|
|
|
783
|
|
|
784 void
|
|
|
785 write_deferred_reproducer (reproducer &r,
|
|
|
786 memento *ptr_type);
|
|
|
787
|
|
|
788 private:
|
|
|
789 string * make_debug_string () FINAL OVERRIDE;
|
|
|
790 string * make_debug_string_with (const char *);
|
|
|
791 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
792
|
|
|
793 private:
|
|
|
794 type *m_return_type;
|
|
|
795 auto_vec<type *> m_param_types;
|
|
|
796 int m_is_variadic;
|
|
|
797 };
|
|
|
798
|
|
|
799 class field : public memento
|
|
|
800 {
|
|
|
801 public:
|
|
|
802 field (context *ctxt,
|
|
|
803 location *loc,
|
|
|
804 type *type,
|
|
|
805 string *name)
|
|
|
806 : memento (ctxt),
|
|
|
807 m_loc (loc),
|
|
|
808 m_type (type),
|
|
|
809 m_name (name),
|
|
|
810 m_container (NULL)
|
|
|
811 {}
|
|
|
812
|
|
|
813 type * get_type () const { return m_type; }
|
|
|
814
|
|
|
815 compound_type * get_container () const { return m_container; }
|
|
|
816 void set_container (compound_type *c) { m_container = c; }
|
|
|
817
|
|
|
818 void replay_into (replayer *) FINAL OVERRIDE;
|
|
|
819
|
|
|
820 void write_to_dump (dump &d) FINAL OVERRIDE;
|
|
|
821
|
|
|
822 playback::field *
|
|
|
823 playback_field () const
|
|
|
824 {
|
|
|
825 return static_cast <playback::field *> (m_playback_obj);
|
|
|
826 }
|
|
|
827
|
|
|
828 private:
|
|
|
829 string * make_debug_string () FINAL OVERRIDE;
|
|
|
830 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
831
|
|
|
832 private:
|
|
|
833 location *m_loc;
|
|
|
834 type *m_type;
|
|
|
835 string *m_name;
|
|
|
836 compound_type *m_container;
|
|
|
837 };
|
|
|
838
|
|
|
839 /* Base class for struct_ and union_ */
|
|
|
840 class compound_type : public type
|
|
|
841 {
|
|
|
842 public:
|
|
|
843 compound_type (context *ctxt,
|
|
|
844 location *loc,
|
|
|
845 string *name);
|
|
|
846
|
|
|
847 string *get_name () const { return m_name; }
|
|
|
848 location *get_loc () const { return m_loc; }
|
|
|
849 fields * get_fields () { return m_fields; }
|
|
|
850
|
|
|
851 void
|
|
|
852 set_fields (location *loc,
|
|
|
853 int num_fields,
|
|
|
854 field **fields);
|
|
|
855
|
|
|
856 type *dereference () FINAL OVERRIDE;
|
|
|
857
|
|
|
858 bool is_int () const FINAL OVERRIDE { return false; }
|
|
|
859 bool is_float () const FINAL OVERRIDE { return false; }
|
|
|
860 bool is_bool () const FINAL OVERRIDE { return false; }
|
|
|
861 type *is_pointer () FINAL OVERRIDE { return NULL; }
|
|
|
862 type *is_array () FINAL OVERRIDE { return NULL; }
|
|
|
863
|
|
|
864 bool has_known_size () const FINAL OVERRIDE { return m_fields != NULL; }
|
|
|
865
|
|
|
866 playback::compound_type *
|
|
|
867 playback_compound_type ()
|
|
|
868 {
|
|
|
869 return static_cast <playback::compound_type *> (m_playback_obj);
|
|
|
870 }
|
|
|
871
|
|
|
872 private:
|
|
|
873 location *m_loc;
|
|
|
874 string *m_name;
|
|
|
875 fields *m_fields;
|
|
|
876 };
|
|
|
877
|
|
|
878 class struct_ : public compound_type
|
|
|
879 {
|
|
|
880 public:
|
|
|
881 struct_ (context *ctxt,
|
|
|
882 location *loc,
|
|
|
883 string *name);
|
|
|
884
|
|
|
885 struct_ *dyn_cast_struct () FINAL OVERRIDE { return this; }
|
|
|
886
|
|
|
887 type *
|
|
|
888 as_type () { return this; }
|
|
|
889
|
|
|
890 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
891
|
|
|
892 const char *access_as_type (reproducer &r) FINAL OVERRIDE;
|
|
|
893
|
|
|
894 private:
|
|
|
895 string * make_debug_string () FINAL OVERRIDE;
|
|
|
896 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
897 };
|
|
|
898
|
|
|
899 // memento of struct_::set_fields
|
|
|
900 class fields : public memento
|
|
|
901 {
|
|
|
902 public:
|
|
|
903 fields (compound_type *struct_or_union,
|
|
|
904 int num_fields,
|
|
|
905 field **fields);
|
|
|
906
|
|
|
907 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
908
|
|
|
909 void write_to_dump (dump &d) FINAL OVERRIDE;
|
|
|
910
|
|
|
911 int length () const { return m_fields.length (); }
|
|
|
912 field *get_field (int i) const { return m_fields[i]; }
|
|
|
913
|
|
|
914 private:
|
|
|
915 string * make_debug_string () FINAL OVERRIDE;
|
|
|
916 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
917
|
|
|
918 private:
|
|
|
919 compound_type *m_struct_or_union;
|
|
|
920 auto_vec<field *> m_fields;
|
|
|
921 };
|
|
|
922
|
|
|
923 class union_ : public compound_type
|
|
|
924 {
|
|
|
925 public:
|
|
|
926 union_ (context *ctxt,
|
|
|
927 location *loc,
|
|
|
928 string *name);
|
|
|
929
|
|
|
930 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
931
|
|
|
932 private:
|
|
|
933 string * make_debug_string () FINAL OVERRIDE;
|
|
|
934 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
935 };
|
|
|
936
|
|
|
937 /* An abstract base class for operations that visit all rvalues within an
|
|
|
938 expression tree.
|
|
|
939 Currently the only implementation is class rvalue_usage_validator within
|
|
|
940 jit-recording.c. */
|
|
|
941
|
|
|
942 class rvalue_visitor
|
|
|
943 {
|
|
|
944 public:
|
|
|
945 virtual ~rvalue_visitor () {}
|
|
|
946 virtual void visit (rvalue *rvalue) = 0;
|
|
|
947 };
|
|
|
948
|
|
|
949 /* When generating debug strings for rvalues we mimic C, so we need to
|
|
|
950 mimic C's precedence levels when handling compound expressions.
|
|
|
951 These are in order from strongest precedence to weakest. */
|
|
|
952 enum precedence
|
|
|
953 {
|
|
|
954 PRECEDENCE_PRIMARY,
|
|
|
955 PRECEDENCE_POSTFIX,
|
|
|
956 PRECEDENCE_UNARY,
|
|
|
957 PRECEDENCE_CAST,
|
|
|
958 PRECEDENCE_MULTIPLICATIVE,
|
|
|
959 PRECEDENCE_ADDITIVE,
|
|
|
960 PRECEDENCE_SHIFT,
|
|
|
961 PRECEDENCE_RELATIONAL,
|
|
|
962 PRECEDENCE_EQUALITY,
|
|
|
963 PRECEDENCE_BITWISE_AND,
|
|
|
964 PRECEDENCE_BITWISE_XOR,
|
|
|
965 PRECEDENCE_BITWISE_IOR,
|
|
|
966 PRECEDENCE_LOGICAL_AND,
|
|
|
967 PRECEDENCE_LOGICAL_OR
|
|
|
968 };
|
|
|
969
|
|
|
970 class rvalue : public memento
|
|
|
971 {
|
|
|
972 public:
|
|
|
973 rvalue (context *ctxt,
|
|
|
974 location *loc,
|
|
|
975 type *type_)
|
|
|
976 : memento (ctxt),
|
|
|
977 m_loc (loc),
|
|
|
978 m_type (type_),
|
|
|
979 m_scope (NULL),
|
|
|
980 m_parenthesized_string (NULL)
|
|
|
981 {
|
|
|
982 gcc_assert (type_);
|
|
|
983 }
|
|
|
984
|
|
|
985 location * get_loc () const { return m_loc; }
|
|
|
986
|
|
|
987 /* Get the recording::type of this rvalue.
|
|
|
988
|
|
|
989 Implements the post-error-checking part of
|
|
|
990 gcc_jit_rvalue_get_type. */
|
|
|
991 type * get_type () const { return m_type; }
|
|
|
992
|
|
|
993 playback::rvalue *
|
|
|
994 playback_rvalue () const
|
|
|
995 {
|
|
|
996 return static_cast <playback::rvalue *> (m_playback_obj);
|
|
|
997 }
|
|
|
998 rvalue *
|
|
|
999 access_field (location *loc,
|
|
|
1000 field *field);
|
|
|
1001
|
|
|
1002 lvalue *
|
|
|
1003 dereference_field (location *loc,
|
|
|
1004 field *field);
|
|
|
1005
|
|
|
1006 lvalue *
|
|
|
1007 dereference (location *loc);
|
|
|
1008
|
|
|
1009 void
|
|
|
1010 verify_valid_within_stmt (const char *api_funcname, statement *s);
|
|
|
1011
|
|
|
1012 virtual void visit_children (rvalue_visitor *v) = 0;
|
|
|
1013
|
|
|
1014 void set_scope (function *scope);
|
|
|
1015 function *get_scope () const { return m_scope; }
|
|
|
1016
|
|
|
1017 /* Dynamic casts. */
|
|
|
1018 virtual param *dyn_cast_param () { return NULL; }
|
|
|
1019 virtual base_call *dyn_cast_base_call () { return NULL; }
|
|
|
1020
|
|
|
1021 virtual const char *access_as_rvalue (reproducer &r);
|
|
|
1022
|
|
|
1023 /* Get the debug string, wrapped in parentheses. */
|
|
|
1024 const char *
|
|
|
1025 get_debug_string_parens (enum precedence outer_prec);
|
|
|
1026
|
|
|
1027 virtual bool is_constant () const { return false; }
|
|
|
1028 virtual bool get_wide_int (wide_int *) const { return false; }
|
|
|
1029
|
|
|
1030 private:
|
|
|
1031 virtual enum precedence get_precedence () const = 0;
|
|
|
1032
|
|
|
1033 protected:
|
|
|
1034 location *m_loc;
|
|
|
1035 type *m_type;
|
|
|
1036
|
|
|
1037 private:
|
|
|
1038 function *m_scope; /* NULL for globals, non-NULL for locals/params */
|
|
|
1039 string *m_parenthesized_string;
|
|
|
1040 };
|
|
|
1041
|
|
|
1042 class lvalue : public rvalue
|
|
|
1043 {
|
|
|
1044 public:
|
|
|
1045 lvalue (context *ctxt,
|
|
|
1046 location *loc,
|
|
|
1047 type *type_)
|
|
|
1048 : rvalue (ctxt, loc, type_)
|
|
|
1049 {}
|
|
|
1050
|
|
|
1051 playback::lvalue *
|
|
|
1052 playback_lvalue () const
|
|
|
1053 {
|
|
|
1054 return static_cast <playback::lvalue *> (m_playback_obj);
|
|
|
1055 }
|
|
|
1056
|
|
|
1057 lvalue *
|
|
|
1058 access_field (location *loc,
|
|
|
1059 field *field);
|
|
|
1060
|
|
|
1061 rvalue *
|
|
|
1062 get_address (location *loc);
|
|
|
1063
|
|
|
1064 rvalue *
|
|
|
1065 as_rvalue () { return this; }
|
|
|
1066
|
|
|
1067 const char *access_as_rvalue (reproducer &r) OVERRIDE;
|
|
|
1068 virtual const char *access_as_lvalue (reproducer &r);
|
|
|
1069 };
|
|
|
1070
|
|
|
1071 class param : public lvalue
|
|
|
1072 {
|
|
|
1073 public:
|
|
|
1074 param (context *ctxt,
|
|
|
1075 location *loc,
|
|
|
1076 type *type,
|
|
|
1077 string *name)
|
|
|
1078 : lvalue (ctxt, loc, type),
|
|
|
1079 m_name (name) {}
|
|
|
1080
|
|
|
1081 lvalue *
|
|
|
1082 as_lvalue () { return this; }
|
|
|
1083
|
|
|
1084 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1085
|
|
|
1086 void visit_children (rvalue_visitor *) FINAL OVERRIDE {}
|
|
|
1087
|
|
|
1088 playback::param *
|
|
|
1089 playback_param () const
|
|
|
1090 {
|
|
|
1091 return static_cast <playback::param *> (m_playback_obj);
|
|
|
1092 }
|
|
|
1093
|
|
|
1094 param *dyn_cast_param () FINAL OVERRIDE { return this; }
|
|
|
1095
|
|
|
1096 const char *access_as_rvalue (reproducer &r) FINAL OVERRIDE;
|
|
|
1097 const char *access_as_lvalue (reproducer &r) FINAL OVERRIDE;
|
|
|
1098
|
|
|
1099 private:
|
|
|
1100 string * make_debug_string () FINAL OVERRIDE { return m_name; }
|
|
|
1101 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1102 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1103 {
|
|
|
1104 return PRECEDENCE_PRIMARY;
|
|
|
1105 }
|
|
|
1106
|
|
|
1107 private:
|
|
|
1108 string *m_name;
|
|
|
1109 };
|
|
|
1110
|
|
|
1111 class function : public memento
|
|
|
1112 {
|
|
|
1113 public:
|
|
|
1114 function (context *ctxt,
|
|
|
1115 location *loc,
|
|
|
1116 enum gcc_jit_function_kind kind,
|
|
|
1117 type *return_type,
|
|
|
1118 string *name,
|
|
|
1119 int num_params,
|
|
|
1120 param **params,
|
|
|
1121 int is_variadic,
|
|
|
1122 enum built_in_function builtin_id);
|
|
|
1123
|
|
|
1124 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1125
|
|
|
1126 playback::function *
|
|
|
1127 playback_function () const
|
|
|
1128 {
|
|
|
1129 return static_cast <playback::function *> (m_playback_obj);
|
|
|
1130 }
|
|
|
1131
|
|
|
1132 enum gcc_jit_function_kind get_kind () const { return m_kind; }
|
|
|
1133
|
|
|
1134 lvalue *
|
|
|
1135 new_local (location *loc,
|
|
|
1136 type *type,
|
|
|
1137 const char *name);
|
|
|
1138
|
|
|
1139 block*
|
|
|
1140 new_block (const char *name);
|
|
|
1141
|
|
|
1142 location *get_loc () const { return m_loc; }
|
|
|
1143 type *get_return_type () const { return m_return_type; }
|
|
|
1144 string * get_name () const { return m_name; }
|
|
|
1145 const vec<param *> &get_params () const { return m_params; }
|
|
|
1146
|
|
|
1147 /* Get the given param by index.
|
|
|
1148 Implements the post-error-checking part of
|
|
|
1149 gcc_jit_function_get_param. */
|
|
|
1150 param *get_param (int i) const { return m_params[i]; }
|
|
|
1151
|
|
|
1152 bool is_variadic () const { return m_is_variadic; }
|
|
|
1153
|
|
|
1154 void write_to_dump (dump &d) FINAL OVERRIDE;
|
|
|
1155
|
|
|
1156 void validate ();
|
|
|
1157
|
|
|
1158 void dump_to_dot (const char *path);
|
|
|
1159
|
|
|
1160 rvalue *get_address (location *loc);
|
|
|
1161
|
|
|
1162 private:
|
|
|
1163 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1164 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1165
|
|
|
1166 private:
|
|
|
1167 location *m_loc;
|
|
|
1168 enum gcc_jit_function_kind m_kind;
|
|
|
1169 type *m_return_type;
|
|
|
1170 string *m_name;
|
|
|
1171 auto_vec<param *> m_params;
|
|
|
1172 int m_is_variadic;
|
|
|
1173 enum built_in_function m_builtin_id;
|
|
|
1174 auto_vec<local *> m_locals;
|
|
|
1175 auto_vec<block *> m_blocks;
|
|
|
1176 type *m_fn_ptr_type;
|
|
|
1177 };
|
|
|
1178
|
|
|
1179 class block : public memento
|
|
|
1180 {
|
|
|
1181 public:
|
|
|
1182 block (function *func, int index, string *name)
|
|
|
1183 : memento (func->m_ctxt),
|
|
|
1184 m_func (func),
|
|
|
1185 m_index (index),
|
|
|
1186 m_name (name),
|
|
|
1187 m_statements (),
|
|
|
1188 m_has_been_terminated (false),
|
|
|
1189 m_is_reachable (false)
|
|
|
1190 {
|
|
|
1191 }
|
|
|
1192
|
|
|
1193 /* Get the recording::function containing this block.
|
|
|
1194 Implements the post-error-checking part of
|
|
|
1195 gcc_jit_block_get_function. */
|
|
|
1196 function *get_function () { return m_func; }
|
|
|
1197
|
|
|
1198 bool has_been_terminated () { return m_has_been_terminated; }
|
|
|
1199 bool is_reachable () { return m_is_reachable; }
|
|
|
1200
|
|
|
1201 statement *
|
|
|
1202 add_eval (location *loc,
|
|
|
1203 rvalue *rvalue);
|
|
|
1204
|
|
|
1205 statement *
|
|
|
1206 add_assignment (location *loc,
|
|
|
1207 lvalue *lvalue,
|
|
|
1208 rvalue *rvalue);
|
|
|
1209
|
|
|
1210 statement *
|
|
|
1211 add_assignment_op (location *loc,
|
|
|
1212 lvalue *lvalue,
|
|
|
1213 enum gcc_jit_binary_op op,
|
|
|
1214 rvalue *rvalue);
|
|
|
1215
|
|
|
1216 statement *
|
|
|
1217 add_comment (location *loc,
|
|
|
1218 const char *text);
|
|
|
1219
|
|
|
1220 statement *
|
|
|
1221 end_with_conditional (location *loc,
|
|
|
1222 rvalue *boolval,
|
|
|
1223 block *on_true,
|
|
|
1224 block *on_false);
|
|
|
1225
|
|
|
1226 statement *
|
|
|
1227 end_with_jump (location *loc,
|
|
|
1228 block *target);
|
|
|
1229
|
|
|
1230 statement *
|
|
|
1231 end_with_return (location *loc,
|
|
|
1232 rvalue *rvalue);
|
|
|
1233
|
|
|
1234 statement *
|
|
|
1235 end_with_switch (location *loc,
|
|
|
1236 rvalue *expr,
|
|
|
1237 block *default_block,
|
|
|
1238 int num_cases,
|
|
|
1239 case_ **cases);
|
|
|
1240
|
|
|
1241 playback::block *
|
|
|
1242 playback_block () const
|
|
|
1243 {
|
|
|
1244 return static_cast <playback::block *> (m_playback_obj);
|
|
|
1245 }
|
|
|
1246
|
|
|
1247 void write_to_dump (dump &d) FINAL OVERRIDE;
|
|
|
1248
|
|
|
1249 bool validate ();
|
|
|
1250
|
|
|
1251 location *get_loc () const;
|
|
|
1252
|
|
|
1253 statement *get_first_statement () const;
|
|
|
1254 statement *get_last_statement () const;
|
|
|
1255
|
|
|
1256 vec <block *> get_successor_blocks () const;
|
|
|
1257
|
|
|
1258 private:
|
|
|
1259 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1260 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1261
|
|
|
1262 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1263
|
|
|
1264 void dump_to_dot (pretty_printer *pp);
|
|
|
1265 void dump_edges_to_dot (pretty_printer *pp);
|
|
|
1266
|
|
|
1267 private:
|
|
|
1268 function *m_func;
|
|
|
1269 int m_index;
|
|
|
1270 string *m_name;
|
|
|
1271 auto_vec<statement *> m_statements;
|
|
|
1272 bool m_has_been_terminated;
|
|
|
1273 bool m_is_reachable;
|
|
|
1274
|
|
|
1275 friend class function;
|
|
|
1276 };
|
|
|
1277
|
|
|
1278 class global : public lvalue
|
|
|
1279 {
|
|
|
1280 public:
|
|
|
1281 global (context *ctxt,
|
|
|
1282 location *loc,
|
|
|
1283 enum gcc_jit_global_kind kind,
|
|
|
1284 type *type,
|
|
|
1285 string *name)
|
|
|
1286 : lvalue (ctxt, loc, type),
|
|
|
1287 m_kind (kind),
|
|
|
1288 m_name (name)
|
|
|
1289 {}
|
|
|
1290
|
|
|
1291 void replay_into (replayer *) FINAL OVERRIDE;
|
|
|
1292
|
|
|
1293 void visit_children (rvalue_visitor *) FINAL OVERRIDE {}
|
|
|
1294
|
|
|
1295 void write_to_dump (dump &d) FINAL OVERRIDE;
|
|
|
1296
|
|
|
1297 private:
|
|
|
1298 string * make_debug_string () FINAL OVERRIDE { return m_name; }
|
|
|
1299 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1300 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1301 {
|
|
|
1302 return PRECEDENCE_PRIMARY;
|
|
|
1303 }
|
|
|
1304
|
|
|
1305 private:
|
|
|
1306 enum gcc_jit_global_kind m_kind;
|
|
|
1307 string *m_name;
|
|
|
1308 };
|
|
|
1309
|
|
|
1310 template <typename HOST_TYPE>
|
|
|
1311 class memento_of_new_rvalue_from_const : public rvalue
|
|
|
1312 {
|
|
|
1313 public:
|
|
|
1314 memento_of_new_rvalue_from_const (context *ctxt,
|
|
|
1315 location *loc,
|
|
|
1316 type *type,
|
|
|
1317 HOST_TYPE value)
|
|
|
1318 : rvalue (ctxt, loc, type),
|
|
|
1319 m_value (value) {}
|
|
|
1320
|
|
|
1321 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1322
|
|
|
1323 void visit_children (rvalue_visitor *) FINAL OVERRIDE {}
|
|
|
1324
|
|
|
1325 bool is_constant () const FINAL OVERRIDE { return true; }
|
|
|
1326
|
|
|
1327 bool get_wide_int (wide_int *out) const FINAL OVERRIDE;
|
|
|
1328
|
|
|
1329 private:
|
|
|
1330 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1331 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1332 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1333 {
|
|
|
1334 return PRECEDENCE_PRIMARY;
|
|
|
1335 }
|
|
|
1336
|
|
|
1337 private:
|
|
|
1338 HOST_TYPE m_value;
|
|
|
1339 };
|
|
|
1340
|
|
|
1341 class memento_of_new_string_literal : public rvalue
|
|
|
1342 {
|
|
|
1343 public:
|
|
|
1344 memento_of_new_string_literal (context *ctxt,
|
|
|
1345 location *loc,
|
|
|
1346 string *value)
|
|
|
1347 : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_CONST_CHAR_PTR)),
|
|
|
1348 m_value (value) {}
|
|
|
1349
|
|
|
1350 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1351
|
|
|
1352 void visit_children (rvalue_visitor *) FINAL OVERRIDE {}
|
|
|
1353
|
|
|
1354 private:
|
|
|
1355 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1356 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1357 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1358 {
|
|
|
1359 return PRECEDENCE_PRIMARY;
|
|
|
1360 }
|
|
|
1361
|
|
|
1362 private:
|
|
|
1363 string *m_value;
|
|
|
1364 };
|
|
|
1365
|
|
|
1366 class memento_of_new_rvalue_from_vector : public rvalue
|
|
|
1367 {
|
|
|
1368 public:
|
|
|
1369 memento_of_new_rvalue_from_vector (context *ctxt,
|
|
|
1370 location *loc,
|
|
|
1371 vector_type *type,
|
|
|
1372 rvalue **elements);
|
|
|
1373
|
|
|
1374 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1375
|
|
|
1376 void visit_children (rvalue_visitor *) FINAL OVERRIDE;
|
|
|
1377
|
|
|
1378 private:
|
|
|
1379 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1380 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1381 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1382 {
|
|
|
1383 return PRECEDENCE_PRIMARY;
|
|
|
1384 }
|
|
|
1385
|
|
|
1386 private:
|
|
|
1387 vector_type *m_vector_type;
|
|
|
1388 auto_vec<rvalue *> m_elements;
|
|
|
1389 };
|
|
|
1390
|
|
|
1391 class unary_op : public rvalue
|
|
|
1392 {
|
|
|
1393 public:
|
|
|
1394 unary_op (context *ctxt,
|
|
|
1395 location *loc,
|
|
|
1396 enum gcc_jit_unary_op op,
|
|
|
1397 type *result_type,
|
|
|
1398 rvalue *a)
|
|
|
1399 : rvalue (ctxt, loc, result_type),
|
|
|
1400 m_op (op),
|
|
|
1401 m_a (a)
|
|
|
1402 {}
|
|
|
1403
|
|
|
1404 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1405
|
|
|
1406 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1407
|
|
|
1408 private:
|
|
|
1409 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1410 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1411 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1412 {
|
|
|
1413 return PRECEDENCE_UNARY;
|
|
|
1414 }
|
|
|
1415
|
|
|
1416 private:
|
|
|
1417 enum gcc_jit_unary_op m_op;
|
|
|
1418 rvalue *m_a;
|
|
|
1419 };
|
|
|
1420
|
|
|
1421 class binary_op : public rvalue
|
|
|
1422 {
|
|
|
1423 public:
|
|
|
1424 binary_op (context *ctxt,
|
|
|
1425 location *loc,
|
|
|
1426 enum gcc_jit_binary_op op,
|
|
|
1427 type *result_type,
|
|
|
1428 rvalue *a, rvalue *b)
|
|
|
1429 : rvalue (ctxt, loc, result_type),
|
|
|
1430 m_op (op),
|
|
|
1431 m_a (a),
|
|
|
1432 m_b (b) {}
|
|
|
1433
|
|
|
1434 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1435
|
|
|
1436 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1437
|
|
|
1438 private:
|
|
|
1439 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1440 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1441 enum precedence get_precedence () const FINAL OVERRIDE;
|
|
|
1442
|
|
|
1443 private:
|
|
|
1444 enum gcc_jit_binary_op m_op;
|
|
|
1445 rvalue *m_a;
|
|
|
1446 rvalue *m_b;
|
|
|
1447 };
|
|
|
1448
|
|
|
1449 class comparison : public rvalue
|
|
|
1450 {
|
|
|
1451 public:
|
|
|
1452 comparison (context *ctxt,
|
|
|
1453 location *loc,
|
|
|
1454 enum gcc_jit_comparison op,
|
|
|
1455 rvalue *a, rvalue *b)
|
|
|
1456 : rvalue (ctxt, loc, ctxt->get_type (GCC_JIT_TYPE_BOOL)),
|
|
|
1457 m_op (op),
|
|
|
1458 m_a (a),
|
|
|
1459 m_b (b)
|
|
|
1460 {}
|
|
|
1461
|
|
|
1462 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1463
|
|
|
1464 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1465
|
|
|
1466 private:
|
|
|
1467 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1468 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1469 enum precedence get_precedence () const FINAL OVERRIDE;
|
|
|
1470
|
|
|
1471 private:
|
|
|
1472 enum gcc_jit_comparison m_op;
|
|
|
1473 rvalue *m_a;
|
|
|
1474 rvalue *m_b;
|
|
|
1475 };
|
|
|
1476
|
|
|
1477 class cast : public rvalue
|
|
|
1478 {
|
|
|
1479 public:
|
|
|
1480 cast (context *ctxt,
|
|
|
1481 location *loc,
|
|
|
1482 rvalue *a,
|
|
|
1483 type *type_)
|
|
|
1484 : rvalue (ctxt, loc, type_),
|
|
|
1485 m_rvalue (a)
|
|
|
1486 {}
|
|
|
1487
|
|
|
1488 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1489
|
|
|
1490 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1491
|
|
|
1492 private:
|
|
|
1493 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1494 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1495 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1496 {
|
|
|
1497 return PRECEDENCE_CAST;
|
|
|
1498 }
|
|
|
1499
|
|
|
1500 private:
|
|
|
1501 rvalue *m_rvalue;
|
|
|
1502 };
|
|
|
1503
|
|
|
1504 class base_call : public rvalue
|
|
|
1505 {
|
|
|
1506 public:
|
|
|
1507 base_call (context *ctxt,
|
|
|
1508 location *loc,
|
|
|
1509 type *type_,
|
|
|
1510 int numargs,
|
|
|
1511 rvalue **args);
|
|
|
1512
|
|
|
1513 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1514 {
|
|
|
1515 return PRECEDENCE_POSTFIX;
|
|
|
1516 }
|
|
|
1517
|
|
|
1518 base_call *dyn_cast_base_call () FINAL OVERRIDE { return this; }
|
|
|
1519
|
|
|
1520 void set_require_tail_call (bool require_tail_call)
|
|
|
1521 {
|
|
|
1522 m_require_tail_call = require_tail_call;
|
|
|
1523 }
|
|
|
1524
|
|
|
1525 protected:
|
|
|
1526 void write_reproducer_tail_call (reproducer &r, const char *id);
|
|
|
1527
|
|
|
1528 protected:
|
|
|
1529 auto_vec<rvalue *> m_args;
|
|
|
1530 bool m_require_tail_call;
|
|
|
1531 };
|
|
|
1532
|
|
|
1533 class call : public base_call
|
|
|
1534 {
|
|
|
1535 public:
|
|
|
1536 call (context *ctxt,
|
|
|
1537 location *loc,
|
|
|
1538 function *func,
|
|
|
1539 int numargs,
|
|
|
1540 rvalue **args);
|
|
|
1541
|
|
|
1542 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1543
|
|
|
1544 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1545
|
|
|
1546 private:
|
|
|
1547 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1548 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1549
|
|
|
1550 private:
|
|
|
1551 function *m_func;
|
|
|
1552 };
|
|
|
1553
|
|
|
1554 class call_through_ptr : public base_call
|
|
|
1555 {
|
|
|
1556 public:
|
|
|
1557 call_through_ptr (context *ctxt,
|
|
|
1558 location *loc,
|
|
|
1559 rvalue *fn_ptr,
|
|
|
1560 int numargs,
|
|
|
1561 rvalue **args);
|
|
|
1562
|
|
|
1563 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1564
|
|
|
1565 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1566
|
|
|
1567 private:
|
|
|
1568 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1569 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1570
|
|
|
1571 private:
|
|
|
1572 rvalue *m_fn_ptr;
|
|
|
1573 };
|
|
|
1574
|
|
|
1575 class array_access : public lvalue
|
|
|
1576 {
|
|
|
1577 public:
|
|
|
1578 array_access (context *ctxt,
|
|
|
1579 location *loc,
|
|
|
1580 rvalue *ptr,
|
|
|
1581 rvalue *index)
|
|
|
1582 : lvalue (ctxt, loc, ptr->get_type ()->dereference ()),
|
|
|
1583 m_ptr (ptr),
|
|
|
1584 m_index (index)
|
|
|
1585 {}
|
|
|
1586
|
|
|
1587 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1588
|
|
|
1589 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1590
|
|
|
1591 private:
|
|
|
1592 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1593 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1594 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1595 {
|
|
|
1596 return PRECEDENCE_POSTFIX;
|
|
|
1597 }
|
|
|
1598
|
|
|
1599 private:
|
|
|
1600 rvalue *m_ptr;
|
|
|
1601 rvalue *m_index;
|
|
|
1602 };
|
|
|
1603
|
|
|
1604 class access_field_of_lvalue : public lvalue
|
|
|
1605 {
|
|
|
1606 public:
|
|
|
1607 access_field_of_lvalue (context *ctxt,
|
|
|
1608 location *loc,
|
|
|
1609 lvalue *val,
|
|
|
1610 field *field)
|
|
|
1611 : lvalue (ctxt, loc, field->get_type ()),
|
|
|
1612 m_lvalue (val),
|
|
|
1613 m_field (field)
|
|
|
1614 {}
|
|
|
1615
|
|
|
1616 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1617
|
|
|
1618 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1619
|
|
|
1620 private:
|
|
|
1621 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1622 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1623 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1624 {
|
|
|
1625 return PRECEDENCE_POSTFIX;
|
|
|
1626 }
|
|
|
1627
|
|
|
1628 private:
|
|
|
1629 lvalue *m_lvalue;
|
|
|
1630 field *m_field;
|
|
|
1631 };
|
|
|
1632
|
|
|
1633 class access_field_rvalue : public rvalue
|
|
|
1634 {
|
|
|
1635 public:
|
|
|
1636 access_field_rvalue (context *ctxt,
|
|
|
1637 location *loc,
|
|
|
1638 rvalue *val,
|
|
|
1639 field *field)
|
|
|
1640 : rvalue (ctxt, loc, field->get_type ()),
|
|
|
1641 m_rvalue (val),
|
|
|
1642 m_field (field)
|
|
|
1643 {}
|
|
|
1644
|
|
|
1645 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1646
|
|
|
1647 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1648
|
|
|
1649 private:
|
|
|
1650 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1651 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1652 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1653 {
|
|
|
1654 return PRECEDENCE_POSTFIX;
|
|
|
1655 }
|
|
|
1656
|
|
|
1657 private:
|
|
|
1658 rvalue *m_rvalue;
|
|
|
1659 field *m_field;
|
|
|
1660 };
|
|
|
1661
|
|
|
1662 class dereference_field_rvalue : public lvalue
|
|
|
1663 {
|
|
|
1664 public:
|
|
|
1665 dereference_field_rvalue (context *ctxt,
|
|
|
1666 location *loc,
|
|
|
1667 rvalue *val,
|
|
|
1668 field *field)
|
|
|
1669 : lvalue (ctxt, loc, field->get_type ()),
|
|
|
1670 m_rvalue (val),
|
|
|
1671 m_field (field)
|
|
|
1672 {}
|
|
|
1673
|
|
|
1674 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1675
|
|
|
1676 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1677
|
|
|
1678 private:
|
|
|
1679 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1680 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1681 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1682 {
|
|
|
1683 return PRECEDENCE_POSTFIX;
|
|
|
1684 }
|
|
|
1685
|
|
|
1686 private:
|
|
|
1687 rvalue *m_rvalue;
|
|
|
1688 field *m_field;
|
|
|
1689 };
|
|
|
1690
|
|
|
1691 class dereference_rvalue : public lvalue
|
|
|
1692 {
|
|
|
1693 public:
|
|
|
1694 dereference_rvalue (context *ctxt,
|
|
|
1695 location *loc,
|
|
|
1696 rvalue *val)
|
|
|
1697 : lvalue (ctxt, loc, val->get_type ()->dereference ()),
|
|
|
1698 m_rvalue (val) {}
|
|
|
1699
|
|
|
1700 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1701
|
|
|
1702 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1703
|
|
|
1704 private:
|
|
|
1705 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1706 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1707 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1708 {
|
|
|
1709 return PRECEDENCE_UNARY;
|
|
|
1710 }
|
|
|
1711
|
|
|
1712 private:
|
|
|
1713 rvalue *m_rvalue;
|
|
|
1714 };
|
|
|
1715
|
|
|
1716 class get_address_of_lvalue : public rvalue
|
|
|
1717 {
|
|
|
1718 public:
|
|
|
1719 get_address_of_lvalue (context *ctxt,
|
|
|
1720 location *loc,
|
|
|
1721 lvalue *val)
|
|
|
1722 : rvalue (ctxt, loc, val->get_type ()->get_pointer ()),
|
|
|
1723 m_lvalue (val)
|
|
|
1724 {}
|
|
|
1725
|
|
|
1726 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1727
|
|
|
1728 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1729
|
|
|
1730 private:
|
|
|
1731 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1732 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1733 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1734 {
|
|
|
1735 return PRECEDENCE_UNARY;
|
|
|
1736 }
|
|
|
1737
|
|
|
1738 private:
|
|
|
1739 lvalue *m_lvalue;
|
|
|
1740 };
|
|
|
1741
|
|
|
1742 class function_pointer : public rvalue
|
|
|
1743 {
|
|
|
1744 public:
|
|
|
1745 function_pointer (context *ctxt,
|
|
|
1746 location *loc,
|
|
|
1747 function *fn,
|
|
|
1748 type *type)
|
|
|
1749 : rvalue (ctxt, loc, type),
|
|
|
1750 m_fn (fn) {}
|
|
|
1751
|
|
|
1752 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1753
|
|
|
1754 void visit_children (rvalue_visitor *v) FINAL OVERRIDE;
|
|
|
1755
|
|
|
1756 private:
|
|
|
1757 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1758 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1759 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1760 {
|
|
|
1761 return PRECEDENCE_UNARY;
|
|
|
1762 }
|
|
|
1763
|
|
|
1764 private:
|
|
|
1765 function *m_fn;
|
|
|
1766 };
|
|
|
1767
|
|
|
1768 class local : public lvalue
|
|
|
1769 {
|
|
|
1770 public:
|
|
|
1771 local (function *func, location *loc, type *type_, string *name)
|
|
|
1772 : lvalue (func->m_ctxt, loc, type_),
|
|
|
1773 m_func (func),
|
|
|
1774 m_name (name)
|
|
|
1775 {
|
|
|
1776 set_scope (func);
|
|
|
1777 }
|
|
|
1778
|
|
|
1779 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1780
|
|
|
1781 void visit_children (rvalue_visitor *) FINAL OVERRIDE {}
|
|
|
1782
|
|
|
1783 void write_to_dump (dump &d) FINAL OVERRIDE;
|
|
|
1784
|
|
|
1785 private:
|
|
|
1786 string * make_debug_string () FINAL OVERRIDE { return m_name; }
|
|
|
1787 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1788 enum precedence get_precedence () const FINAL OVERRIDE
|
|
|
1789 {
|
|
|
1790 return PRECEDENCE_PRIMARY;
|
|
|
1791 }
|
|
|
1792
|
|
|
1793 private:
|
|
|
1794 function *m_func;
|
|
|
1795 string *m_name;
|
|
|
1796 };
|
|
|
1797
|
|
|
1798 class statement : public memento
|
|
|
1799 {
|
|
|
1800 public:
|
|
|
1801 virtual vec <block *> get_successor_blocks () const;
|
|
|
1802
|
|
|
1803 void write_to_dump (dump &d) FINAL OVERRIDE;
|
|
|
1804
|
|
|
1805 block *get_block () const { return m_block; }
|
|
|
1806 location *get_loc () const { return m_loc; }
|
|
|
1807
|
|
|
1808 protected:
|
|
|
1809 statement (block *b, location *loc)
|
|
|
1810 : memento (b->m_ctxt),
|
|
|
1811 m_block (b),
|
|
|
1812 m_loc (loc) {}
|
|
|
1813
|
|
|
1814 playback::location *
|
|
|
1815 playback_location (replayer *r) const
|
|
|
1816 {
|
|
|
1817 return ::gcc::jit::recording::playback_location (r, m_loc);
|
|
|
1818 }
|
|
|
1819
|
|
|
1820 private:
|
|
|
1821 block *m_block;
|
|
|
1822 location *m_loc;
|
|
|
1823 };
|
|
|
1824
|
|
|
1825 class eval : public statement
|
|
|
1826 {
|
|
|
1827 public:
|
|
|
1828 eval (block *b,
|
|
|
1829 location *loc,
|
|
|
1830 rvalue *rvalue)
|
|
|
1831 : statement (b, loc),
|
|
|
1832 m_rvalue (rvalue) {}
|
|
|
1833
|
|
|
1834 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1835
|
|
|
1836 private:
|
|
|
1837 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1838 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1839
|
|
|
1840 private:
|
|
|
1841 rvalue *m_rvalue;
|
|
|
1842 };
|
|
|
1843
|
|
|
1844 class assignment : public statement
|
|
|
1845 {
|
|
|
1846 public:
|
|
|
1847 assignment (block *b,
|
|
|
1848 location *loc,
|
|
|
1849 lvalue *lvalue,
|
|
|
1850 rvalue *rvalue)
|
|
|
1851 : statement (b, loc),
|
|
|
1852 m_lvalue (lvalue),
|
|
|
1853 m_rvalue (rvalue) {}
|
|
|
1854
|
|
|
1855 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1856
|
|
|
1857 private:
|
|
|
1858 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1859 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1860
|
|
|
1861 private:
|
|
|
1862 lvalue *m_lvalue;
|
|
|
1863 rvalue *m_rvalue;
|
|
|
1864 };
|
|
|
1865
|
|
|
1866 class assignment_op : public statement
|
|
|
1867 {
|
|
|
1868 public:
|
|
|
1869 assignment_op (block *b,
|
|
|
1870 location *loc,
|
|
|
1871 lvalue *lvalue,
|
|
|
1872 enum gcc_jit_binary_op op,
|
|
|
1873 rvalue *rvalue)
|
|
|
1874 : statement (b, loc),
|
|
|
1875 m_lvalue (lvalue),
|
|
|
1876 m_op (op),
|
|
|
1877 m_rvalue (rvalue) {}
|
|
|
1878
|
|
|
1879 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1880
|
|
|
1881 private:
|
|
|
1882 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1883 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1884
|
|
|
1885 private:
|
|
|
1886 lvalue *m_lvalue;
|
|
|
1887 enum gcc_jit_binary_op m_op;
|
|
|
1888 rvalue *m_rvalue;
|
|
|
1889 };
|
|
|
1890
|
|
|
1891 class comment : public statement
|
|
|
1892 {
|
|
|
1893 public:
|
|
|
1894 comment (block *b,
|
|
|
1895 location *loc,
|
|
|
1896 string *text)
|
|
|
1897 : statement (b, loc),
|
|
|
1898 m_text (text) {}
|
|
|
1899
|
|
|
1900 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1901
|
|
|
1902 private:
|
|
|
1903 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1904 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1905
|
|
|
1906 private:
|
|
|
1907 string *m_text;
|
|
|
1908 };
|
|
|
1909
|
|
|
1910 class conditional : public statement
|
|
|
1911 {
|
|
|
1912 public:
|
|
|
1913 conditional (block *b,
|
|
|
1914 location *loc,
|
|
|
1915 rvalue *boolval,
|
|
|
1916 block *on_true,
|
|
|
1917 block *on_false)
|
|
|
1918 : statement (b, loc),
|
|
|
1919 m_boolval (boolval),
|
|
|
1920 m_on_true (on_true),
|
|
|
1921 m_on_false (on_false) {}
|
|
|
1922
|
|
|
1923 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1924
|
|
|
1925 vec <block *> get_successor_blocks () const FINAL OVERRIDE;
|
|
|
1926
|
|
|
1927 private:
|
|
|
1928 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1929 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1930
|
|
|
1931 private:
|
|
|
1932 rvalue *m_boolval;
|
|
|
1933 block *m_on_true;
|
|
|
1934 block *m_on_false;
|
|
|
1935 };
|
|
|
1936
|
|
|
1937 class jump : public statement
|
|
|
1938 {
|
|
|
1939 public:
|
|
|
1940 jump (block *b,
|
|
|
1941 location *loc,
|
|
|
1942 block *target)
|
|
|
1943 : statement (b, loc),
|
|
|
1944 m_target (target) {}
|
|
|
1945
|
|
|
1946 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1947
|
|
|
1948 vec <block *> get_successor_blocks () const FINAL OVERRIDE;
|
|
|
1949
|
|
|
1950 private:
|
|
|
1951 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1952 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1953
|
|
|
1954 private:
|
|
|
1955 block *m_target;
|
|
|
1956 };
|
|
|
1957
|
|
|
1958 class return_ : public statement
|
|
|
1959 {
|
|
|
1960 public:
|
|
|
1961 return_ (block *b,
|
|
|
1962 location *loc,
|
|
|
1963 rvalue *rvalue)
|
|
|
1964 : statement (b, loc),
|
|
|
1965 m_rvalue (rvalue) {}
|
|
|
1966
|
|
|
1967 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
1968
|
|
|
1969 vec <block *> get_successor_blocks () const FINAL OVERRIDE;
|
|
|
1970
|
|
|
1971 private:
|
|
|
1972 string * make_debug_string () FINAL OVERRIDE;
|
|
|
1973 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1974
|
|
|
1975 private:
|
|
|
1976 rvalue *m_rvalue;
|
|
|
1977 };
|
|
|
1978
|
|
|
1979 class case_ : public memento
|
|
|
1980 {
|
|
|
1981 public:
|
|
|
1982 case_ (context *ctxt,
|
|
|
1983 rvalue *min_value,
|
|
|
1984 rvalue *max_value,
|
|
|
1985 block *dest_block)
|
|
|
1986 : memento (ctxt),
|
|
|
1987 m_min_value (min_value),
|
|
|
1988 m_max_value (max_value),
|
|
|
1989 m_dest_block (dest_block)
|
|
|
1990 {}
|
|
|
1991
|
|
|
1992 rvalue *get_min_value () const { return m_min_value; }
|
|
|
1993 rvalue *get_max_value () const { return m_max_value; }
|
|
|
1994 block *get_dest_block () const { return m_dest_block; }
|
|
|
1995
|
|
|
1996 void replay_into (replayer *) FINAL OVERRIDE { /* empty */ }
|
|
|
1997
|
|
|
1998 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
1999
|
|
|
2000 private:
|
|
|
2001 string * make_debug_string () FINAL OVERRIDE;
|
|
|
2002
|
|
|
2003 private:
|
|
|
2004 rvalue *m_min_value;
|
|
|
2005 rvalue *m_max_value;
|
|
|
2006 block *m_dest_block;
|
|
|
2007 };
|
|
|
2008
|
|
|
2009 class switch_ : public statement
|
|
|
2010 {
|
|
|
2011 public:
|
|
|
2012 switch_ (block *b,
|
|
|
2013 location *loc,
|
|
|
2014 rvalue *expr,
|
|
|
2015 block *default_block,
|
|
|
2016 int num_cases,
|
|
|
2017 case_ **cases);
|
|
|
2018
|
|
|
2019 void replay_into (replayer *r) FINAL OVERRIDE;
|
|
|
2020
|
|
|
2021 vec <block *> get_successor_blocks () const FINAL OVERRIDE;
|
|
|
2022
|
|
|
2023 private:
|
|
|
2024 string * make_debug_string () FINAL OVERRIDE;
|
|
|
2025 void write_reproducer (reproducer &r) FINAL OVERRIDE;
|
|
|
2026
|
|
|
2027 private:
|
|
|
2028 rvalue *m_expr;
|
|
|
2029 block *m_default_block;
|
|
|
2030 auto_vec <case_ *> m_cases;
|
|
|
2031 };
|
|
|
2032
|
|
|
2033 } // namespace gcc::jit::recording
|
|
|
2034
|
|
|
2035 /* Create a recording::memento_of_new_rvalue_from_const instance and add
|
|
|
2036 it to this context's list of mementos.
|
|
|
2037
|
|
|
2038 Implements the post-error-checking part of
|
|
|
2039 gcc_jit_context_new_rvalue_from_{int|long|double|ptr}. */
|
|
|
2040
|
|
|
2041 template <typename HOST_TYPE>
|
|
|
2042 recording::rvalue *
|
|
|
2043 recording::context::new_rvalue_from_const (recording::type *type,
|
|
|
2044 HOST_TYPE value)
|
|
|
2045 {
|
|
|
2046 recording::rvalue *result =
|
|
|
2047 new memento_of_new_rvalue_from_const <HOST_TYPE> (this, NULL, type, value);
|
|
|
2048 record (result);
|
|
|
2049 return result;
|
|
|
2050 }
|
|
|
2051
|
|
|
2052 } // namespace gcc::jit
|
|
|
2053
|
|
|
2054 } // namespace gcc
|
|
|
2055
|
|
|
2056 #endif /* JIT_RECORDING_H */
|
