1 /* Internals of libgccjit: classes for recording calls made to the JIT API.
2 Copyright (C) 2013-2014 Free Software Foundation, Inc.
3 Contributed by David Malcolm <dmalcolm@redhat.com>.
5 This file is part of GCC.
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)
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.
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/>. */
21 #ifndef JIT_RECORDING_H
22 #define JIT_RECORDING_H
24 #include "jit-common.h"
33 /**********************************************************************
35 **********************************************************************/
40 playback_location (replayer
*r
, location
*loc
);
43 playback_string (string
*str
);
46 playback_block (block
*b
);
48 /* A JIT-compilation context. */
52 context (context
*parent_ctxt
);
55 void record (memento
*m
);
56 void replay_into (replayer
*r
);
57 void disassociate_from_playback ();
60 new_string (const char *text
);
63 new_location (const char *filename
,
68 get_type (enum gcc_jit_types type
);
71 get_int_type (int num_bytes
, int is_signed
);
74 new_array_type (location
*loc
,
79 new_field (location
*loc
,
84 new_struct_type (location
*loc
,
88 new_union_type (location
*loc
,
92 new_function_ptr_type (location
*loc
,
99 new_param (location
*loc
,
104 new_function (location
*loc
,
105 enum gcc_jit_function_kind kind
,
111 enum built_in_function builtin_id
);
114 get_builtin_function (const char *name
);
117 new_global (location
*loc
,
122 new_rvalue_from_int (type
*numeric_type
,
126 new_rvalue_from_double (type
*numeric_type
,
130 new_rvalue_from_ptr (type
*pointer_type
,
134 new_string_literal (const char *value
);
137 new_unary_op (location
*loc
,
138 enum gcc_jit_unary_op op
,
143 new_binary_op (location
*loc
,
144 enum gcc_jit_binary_op op
,
146 rvalue
*a
, rvalue
*b
);
149 new_comparison (location
*loc
,
150 enum gcc_jit_comparison op
,
151 rvalue
*a
, rvalue
*b
);
154 new_call (location
*loc
,
156 int numargs
, rvalue
**args
);
159 new_call_through_ptr (location
*loc
,
161 int numargs
, rvalue
**args
);
164 new_cast (location
*loc
,
169 new_array_access (location
*loc
,
174 set_str_option (enum gcc_jit_str_option opt
,
178 set_int_option (enum gcc_jit_int_option opt
,
182 set_bool_option (enum gcc_jit_bool_option opt
,
186 get_str_option (enum gcc_jit_str_option opt
) const
188 return m_str_options
[opt
];
192 get_int_option (enum gcc_jit_int_option opt
) const
194 return m_int_options
[opt
];
198 get_bool_option (enum gcc_jit_bool_option opt
) const
200 return m_bool_options
[opt
];
207 add_error (location
*loc
, const char *fmt
, ...)
211 add_error_va (location
*loc
, const char *fmt
, va_list ap
)
215 get_first_error () const;
217 bool errors_occurred () const
220 if (m_parent_ctxt
->errors_occurred ())
222 return m_error_count
;
225 type
*get_opaque_FILE_type ();
227 void dump_to_file (const char *path
, bool update_locations
);
233 context
*m_parent_ctxt
;
237 char *m_first_error_str
;
238 bool m_owns_first_error_str
;
240 const char *m_str_options
[GCC_JIT_NUM_STR_OPTIONS
];
241 int m_int_options
[GCC_JIT_NUM_INT_OPTIONS
];
242 bool m_bool_options
[GCC_JIT_NUM_BOOL_OPTIONS
];
244 /* Recorded API usage. */
245 vec
<memento
*> m_mementos
;
247 /* Specific recordings, for use by dump_to_file. */
248 vec
<compound_type
*> m_compound_types
;
249 vec
<function
*> m_functions
;
251 type
*m_basic_types
[NUM_GCC_JIT_TYPES
];
254 builtins_manager
*m_builtins_manager
; // lazily created
258 /* An object with lifetime managed by the context i.e.
259 it lives until the context is released, at which
260 point it itself is cleaned up. */
265 virtual ~memento () {}
267 /* Hook for replaying this. */
268 virtual void replay_into (replayer
*r
) = 0;
270 void set_playback_obj (void *obj
) { m_playback_obj
= obj
; }
273 /* Get the context that owns this object.
275 Implements the post-error-checking part of
276 gcc_jit_object_get_context. */
277 context
*get_context () { return m_ctxt
; }
280 as_object () { return this; }
282 /* Debugging hook, for use in generating error messages etc.
283 Implements the post-error-checking part of
284 gcc_jit_object_get_debug_string. */
288 virtual void write_to_dump (dump
&d
);
291 memento (context
*ctxt
)
293 m_playback_obj (NULL
),
294 m_debug_string (NULL
)
299 string
*new_string (const char *text
) { return m_ctxt
->new_string (text
); }
302 virtual string
* make_debug_string () = 0;
308 void *m_playback_obj
;
311 string
*m_debug_string
;
314 /* or just use std::string? */
315 class string
: public memento
318 string (context
*ctxt
, const char *text
);
321 const char *c_str () { return m_buffer
; }
323 static string
* from_printf (context
*ctxt
, const char *fmt
, ...)
326 void replay_into (replayer
*) {}
329 string
* make_debug_string ();
336 class location
: public memento
339 location (context
*ctxt
, string
*filename
, int line
, int column
)
341 m_filename (filename
),
346 void replay_into (replayer
*r
);
349 playback_location (replayer
*r
)
351 /* Normally during playback, we can walk forwards through the list of
352 recording objects, playing them back. The ordering of recording
353 ensures that everything that a recording object refers to has
354 already been played back, so we can simply look up the relevant
357 Locations are an exception, due to the "write_to_dump" method of
358 recording::statement. This method can set a new location on a
359 statement after the statement is created, and thus the location
360 appears in the context's memento list *after* the statement that
363 In such circumstances, the statement is replayed *before* the location,
364 when the latter doesn't yet have a playback object.
366 Hence we need to ensure that locations have playback objects. */
371 gcc_assert (m_playback_obj
);
372 return static_cast <playback::location
*> (m_playback_obj
);
376 string
* make_debug_string ();
384 class type
: public memento
387 type
*get_pointer ();
389 type
*get_volatile ();
391 /* Get the type obtained when dereferencing this type.
393 This will return NULL if it's not valid to dereference this type.
394 The caller is responsible for setting an error. */
395 virtual type
*dereference () = 0;
398 virtual function_type
*dyn_cast_function_type () { return NULL
; }
399 virtual function_type
*as_a_function_type() { gcc_unreachable (); return NULL
; }
400 virtual struct_
*dyn_cast_struct () { return NULL
; }
402 /* Is it typesafe to copy to this type from rtype? */
403 virtual bool accepts_writes_from (type
*rtype
)
406 return this == rtype
->unqualified ();
409 /* Strip off "const" etc */
410 virtual type
*unqualified ()
415 virtual bool is_int () const = 0;
416 virtual bool is_float () const = 0;
417 virtual bool is_bool () const = 0;
418 virtual type
*is_pointer () = 0;
419 virtual type
*is_array () = 0;
421 bool is_numeric () const
423 return is_int () || is_float () || is_bool ();
429 return static_cast <playback::type
*> (m_playback_obj
);
435 m_pointer_to_this_type (NULL
)
439 type
*m_pointer_to_this_type
;
442 /* Result of "gcc_jit_type_get_type". */
443 class memento_of_get_type
: public type
446 memento_of_get_type (context
*ctxt
,
447 enum gcc_jit_types kind
)
451 type
*dereference ();
453 bool accepts_writes_from (type
*rtype
)
455 if (m_kind
== GCC_JIT_TYPE_VOID_PTR
)
456 if (rtype
->is_pointer ())
458 /* LHS (this) is type (void *), and the RHS is a pointer:
463 return type::accepts_writes_from (rtype
);
466 bool is_int () const;
467 bool is_float () const;
468 bool is_bool () const;
469 type
*is_pointer () { return dereference (); }
470 type
*is_array () { return NULL
; }
473 void replay_into (replayer
*r
);
476 string
* make_debug_string ();
479 enum gcc_jit_types m_kind
;
482 /* Result of "gcc_jit_type_get_pointer". */
483 class memento_of_get_pointer
: public type
486 memento_of_get_pointer (type
*other_type
)
487 : type (other_type
->m_ctxt
),
488 m_other_type (other_type
) {}
490 type
*dereference () { return m_other_type
; }
492 bool accepts_writes_from (type
*rtype
);
494 void replay_into (replayer
*r
);
496 bool is_int () const { return false; }
497 bool is_float () const { return false; }
498 bool is_bool () const { return false; }
499 type
*is_pointer () { return m_other_type
; }
500 type
*is_array () { return NULL
; }
503 string
* make_debug_string ();
509 /* Result of "gcc_jit_type_get_const". */
510 class memento_of_get_const
: public type
513 memento_of_get_const (type
*other_type
)
514 : type (other_type
->m_ctxt
),
515 m_other_type (other_type
) {}
517 type
*dereference () { return m_other_type
->dereference (); }
519 bool accepts_writes_from (type */
*rtype*/
)
521 /* Can't write to a "const". */
525 /* Strip off the "const", giving the underlying type. */
526 type
*unqualified () { return m_other_type
; }
528 bool is_int () const { return m_other_type
->is_int (); }
529 bool is_float () const { return m_other_type
->is_float (); }
530 bool is_bool () const { return m_other_type
->is_bool (); }
531 type
*is_pointer () { return m_other_type
->is_pointer (); }
532 type
*is_array () { return m_other_type
->is_array (); }
534 void replay_into (replayer
*);
537 string
* make_debug_string ();
543 /* Result of "gcc_jit_type_get_volatile". */
544 class memento_of_get_volatile
: public type
547 memento_of_get_volatile (type
*other_type
)
548 : type (other_type
->m_ctxt
),
549 m_other_type (other_type
) {}
551 type
*dereference () { return m_other_type
->dereference (); }
553 /* Strip off the "volatile", giving the underlying type. */
554 type
*unqualified () { return m_other_type
; }
556 bool is_int () const { return m_other_type
->is_int (); }
557 bool is_float () const { return m_other_type
->is_float (); }
558 bool is_bool () const { return m_other_type
->is_bool (); }
559 type
*is_pointer () { return m_other_type
->is_pointer (); }
560 type
*is_array () { return m_other_type
->is_array (); }
562 void replay_into (replayer
*);
565 string
* make_debug_string ();
571 class array_type
: public type
574 array_type (context
*ctxt
,
580 m_element_type (element_type
),
581 m_num_elements (num_elements
)
584 type
*dereference ();
586 bool is_int () const { return false; }
587 bool is_float () const { return false; }
588 bool is_bool () const { return false; }
589 type
*is_pointer () { return NULL
; }
590 type
*is_array () { return m_element_type
; }
592 void replay_into (replayer
*);
595 string
* make_debug_string ();
599 type
*m_element_type
;
603 class function_type
: public type
606 function_type (context
*ctxt
,
612 type
*dereference ();
613 function_type
*dyn_cast_function_type () { return this; }
614 function_type
*as_a_function_type () { return this; }
616 bool is_int () const { return false; }
617 bool is_float () const { return false; }
618 bool is_bool () const { return false; }
619 type
*is_pointer () { return NULL
; }
620 type
*is_array () { return NULL
; }
622 void replay_into (replayer
*);
624 type
* get_return_type () const { return m_return_type
; }
625 vec
<type
*> get_param_types () const { return m_param_types
; }
626 int is_variadic () const { return m_is_variadic
; }
628 string
* make_debug_string_with_ptr ();
631 string
* make_debug_string ();
632 string
* make_debug_string_with (const char *);
636 vec
<type
*> m_param_types
;
640 class field
: public memento
643 field (context
*ctxt
,
654 type
* get_type () const { return m_type
; }
656 compound_type
* get_container () const { return m_container
; }
657 void set_container (compound_type
*c
) { m_container
= c
; }
659 void replay_into (replayer
*);
661 void write_to_dump (dump
&d
);
664 playback_field () const
666 return static_cast <playback::field
*> (m_playback_obj
);
670 string
* make_debug_string ();
676 compound_type
*m_container
;
679 /* Base class for struct_ and union_ */
680 class compound_type
: public type
683 compound_type (context
*ctxt
,
687 string
*get_name () const { return m_name
; }
688 location
*get_loc () const { return m_loc
; }
689 fields
* get_fields () { return m_fields
; }
692 set_fields (location
*loc
,
696 type
*dereference ();
698 bool is_int () const { return false; }
699 bool is_float () const { return false; }
700 bool is_bool () const { return false; }
701 type
*is_pointer () { return NULL
; }
702 type
*is_array () { return NULL
; }
704 playback::compound_type
*
705 playback_compound_type ()
707 return static_cast <playback::compound_type
*> (m_playback_obj
);
716 class struct_
: public compound_type
719 struct_ (context
*ctxt
,
723 struct_
*dyn_cast_struct () { return this; }
726 as_type () { return this; }
728 void replay_into (replayer
*r
);
731 string
* make_debug_string ();
735 // memento of struct_::set_fields
736 class fields
: public memento
739 fields (compound_type
*struct_or_union
,
743 void replay_into (replayer
*r
);
745 void write_to_dump (dump
&d
);
748 string
* make_debug_string ();
751 compound_type
*m_struct_or_union
;
752 vec
<field
*> m_fields
;
755 class union_
: public compound_type
758 union_ (context
*ctxt
,
762 void replay_into (replayer
*r
);
765 string
* make_debug_string ();
773 class rvalue
: public memento
776 rvalue (context
*ctxt
,
786 /* Get the recording::type of this rvalue.
788 Implements the post-error-checking part of
789 gcc_jit_rvalue_get_type. */
790 type
* get_type () const { return m_type
; }
793 playback_rvalue () const
795 return static_cast <playback::rvalue
*> (m_playback_obj
);
798 access_field (location
*loc
,
802 dereference_field (location
*loc
,
806 dereference (location
*loc
);
813 class lvalue
: public rvalue
816 lvalue (context
*ctxt
,
819 : rvalue (ctxt
, loc
, type_
)
823 playback_lvalue () const
825 return static_cast <playback::lvalue
*> (m_playback_obj
);
829 access_field (location
*loc
,
833 get_address (location
*loc
);
836 as_rvalue () { return this; }
839 class param
: public lvalue
842 param (context
*ctxt
,
846 : lvalue (ctxt
, loc
, type
),
850 as_lvalue () { return this; }
852 void replay_into (replayer
*r
);
855 playback_param () const
857 return static_cast <playback::param
*> (m_playback_obj
);
861 string
* make_debug_string () { return m_name
; }
867 class function
: public memento
870 function (context
*ctxt
,
872 enum gcc_jit_function_kind kind
,
878 enum built_in_function builtin_id
);
880 void replay_into (replayer
*r
);
883 playback_function () const
885 return static_cast <playback::function
*> (m_playback_obj
);
888 enum gcc_jit_function_kind
get_kind () const { return m_kind
; }
891 new_local (location
*loc
,
896 new_block (const char *name
);
898 type
*get_return_type () const { return m_return_type
; }
899 string
* get_name () const { return m_name
; }
900 vec
<param
*> get_params () const { return m_params
; }
902 /* Get the given param by index.
903 Implements the post-error-checking part of
904 gcc_jit_function_get_param. */
905 param
*get_param (int i
) const { return m_params
[i
]; }
907 bool is_variadic () const { return m_is_variadic
; }
909 void write_to_dump (dump
&d
);
913 void dump_to_dot (const char *path
);
916 string
* make_debug_string ();
920 enum gcc_jit_function_kind m_kind
;
923 vec
<param
*> m_params
;
925 enum built_in_function m_builtin_id
;
926 vec
<local
*> m_locals
;
927 vec
<block
*> m_blocks
;
930 class block
: public memento
933 block (function
*func
, int index
, string
*name
)
934 : memento (func
->m_ctxt
),
939 m_has_been_terminated (false),
940 m_is_reachable (false)
944 /* Get the recording::function containing this block.
945 Implements the post-error-checking part of
946 gcc_jit_block_get_function. */
947 function
*get_function () { return m_func
; }
949 bool has_been_terminated () { return m_has_been_terminated
; }
950 bool is_reachable () { return m_is_reachable
; }
953 add_eval (location
*loc
,
957 add_assignment (location
*loc
,
962 add_assignment_op (location
*loc
,
964 enum gcc_jit_binary_op op
,
968 add_comment (location
*loc
,
972 end_with_conditional (location
*loc
,
978 end_with_jump (location
*loc
,
982 end_with_return (location
*loc
,
986 playback_block () const
988 return static_cast <playback::block
*> (m_playback_obj
);
991 void write_to_dump (dump
&d
);
995 location
*get_loc () const;
997 statement
*get_first_statement () const;
998 statement
*get_last_statement () const;
1000 int get_successor_blocks (block
**next1
, block
**next2
) const;
1003 string
* make_debug_string ();
1005 void replay_into (replayer
*r
);
1007 void dump_to_dot (pretty_printer
*pp
);
1008 void dump_edges_to_dot (pretty_printer
*pp
);
1014 vec
<statement
*> m_statements
;
1015 bool m_has_been_terminated
;
1016 bool m_is_reachable
;
1018 friend class function
;
1021 class global
: public lvalue
1024 global (context
*ctxt
,
1028 : lvalue (ctxt
, loc
, type
),
1032 void replay_into (replayer
*);
1035 string
* make_debug_string () { return m_name
; }
1041 class memento_of_new_rvalue_from_int
: public rvalue
1044 memento_of_new_rvalue_from_int (context
*ctxt
,
1048 : rvalue (ctxt
, loc
, numeric_type
),
1051 void replay_into (replayer
*r
);
1054 string
* make_debug_string ();
1060 class memento_of_new_rvalue_from_double
: public rvalue
1063 memento_of_new_rvalue_from_double (context
*ctxt
,
1067 : rvalue (ctxt
, loc
, numeric_type
),
1071 void replay_into (replayer
*);
1074 string
* make_debug_string ();
1080 class memento_of_new_rvalue_from_ptr
: public rvalue
1083 memento_of_new_rvalue_from_ptr (context
*ctxt
,
1087 : rvalue (ctxt
, loc
, pointer_type
),
1091 void replay_into (replayer
*);
1094 string
* make_debug_string ();
1100 class memento_of_new_string_literal
: public rvalue
1103 memento_of_new_string_literal (context
*ctxt
,
1106 : rvalue (ctxt
, loc
, ctxt
->get_type (GCC_JIT_TYPE_CONST_CHAR_PTR
)),
1109 void replay_into (replayer
*r
);
1112 string
* make_debug_string ();
1118 class unary_op
: public rvalue
1121 unary_op (context
*ctxt
,
1123 enum gcc_jit_unary_op op
,
1126 : rvalue (ctxt
, loc
, result_type
),
1131 void replay_into (replayer
*r
);
1134 string
* make_debug_string ();
1137 enum gcc_jit_unary_op m_op
;
1141 class binary_op
: public rvalue
1144 binary_op (context
*ctxt
,
1146 enum gcc_jit_binary_op op
,
1148 rvalue
*a
, rvalue
*b
)
1149 : rvalue (ctxt
, loc
, result_type
),
1154 void replay_into (replayer
*r
);
1157 string
* make_debug_string ();
1160 enum gcc_jit_binary_op m_op
;
1165 class comparison
: public rvalue
1168 comparison (context
*ctxt
,
1170 enum gcc_jit_comparison op
,
1171 rvalue
*a
, rvalue
*b
)
1172 : rvalue (ctxt
, loc
, ctxt
->get_type (GCC_JIT_TYPE_BOOL
)),
1178 void replay_into (replayer
*r
);
1181 string
* make_debug_string ();
1184 enum gcc_jit_comparison m_op
;
1189 class cast
: public rvalue
1192 cast (context
*ctxt
,
1196 : rvalue (ctxt
, loc
, type_
),
1200 void replay_into (replayer
*r
);
1203 string
* make_debug_string ();
1209 class call
: public rvalue
1212 call (context
*ctxt
,
1218 void replay_into (replayer
*r
);
1221 string
* make_debug_string ();
1225 vec
<rvalue
*> m_args
;
1228 class call_through_ptr
: public rvalue
1231 call_through_ptr (context
*ctxt
,
1237 void replay_into (replayer
*r
);
1240 string
* make_debug_string ();
1244 vec
<rvalue
*> m_args
;
1247 class array_access
: public lvalue
1250 array_access (context
*ctxt
,
1254 : lvalue (ctxt
, loc
, ptr
->get_type ()->dereference ()),
1259 void replay_into (replayer
*r
);
1262 string
* make_debug_string ();
1269 class access_field_of_lvalue
: public lvalue
1272 access_field_of_lvalue (context
*ctxt
,
1276 : lvalue (ctxt
, loc
, field
->get_type ()),
1281 void replay_into (replayer
*r
);
1284 string
* make_debug_string ();
1291 class access_field_rvalue
: public rvalue
1294 access_field_rvalue (context
*ctxt
,
1298 : rvalue (ctxt
, loc
, field
->get_type ()),
1303 void replay_into (replayer
*r
);
1306 string
* make_debug_string ();
1313 class dereference_field_rvalue
: public lvalue
1316 dereference_field_rvalue (context
*ctxt
,
1320 : lvalue (ctxt
, loc
, field
->get_type ()),
1325 void replay_into (replayer
*r
);
1328 string
* make_debug_string ();
1335 class dereference_rvalue
: public lvalue
1338 dereference_rvalue (context
*ctxt
,
1341 : lvalue (ctxt
, loc
, val
->get_type ()->dereference ()),
1344 void replay_into (replayer
*r
);
1347 string
* make_debug_string ();
1353 class get_address_of_lvalue
: public rvalue
1356 get_address_of_lvalue (context
*ctxt
,
1359 : rvalue (ctxt
, loc
, val
->get_type ()->get_pointer ()),
1363 void replay_into (replayer
*r
);
1366 string
* make_debug_string ();
1372 class local
: public lvalue
1375 local (function
*func
, location
*loc
, type
*type_
, string
*name
)
1376 : lvalue (func
->m_ctxt
, loc
, type_
),
1380 void replay_into (replayer
*r
);
1382 void write_to_dump (dump
&d
);
1385 string
* make_debug_string () { return m_name
; }
1392 class statement
: public memento
1395 virtual int get_successor_blocks (block
**out_next1
,
1396 block
**out_next2
) const;
1398 void write_to_dump (dump
&d
);
1400 location
*get_loc () const { return m_loc
; }
1403 statement (block
*b
, location
*loc
)
1404 : memento (b
->m_ctxt
),
1408 block
*get_block () const { return m_block
; }
1410 playback::location
*
1411 playback_location (replayer
*r
) const
1413 return ::gcc::jit::recording::playback_location (r
, m_loc
);
1421 class eval
: public statement
1427 : statement (b
, loc
),
1428 m_rvalue (rvalue
) {}
1430 void replay_into (replayer
*r
);
1433 string
* make_debug_string ();
1439 class assignment
: public statement
1442 assignment (block
*b
,
1446 : statement (b
, loc
),
1448 m_rvalue (rvalue
) {}
1450 void replay_into (replayer
*r
);
1453 string
* make_debug_string ();
1460 class assignment_op
: public statement
1463 assignment_op (block
*b
,
1466 enum gcc_jit_binary_op op
,
1468 : statement (b
, loc
),
1471 m_rvalue (rvalue
) {}
1473 void replay_into (replayer
*r
);
1476 string
* make_debug_string ();
1480 enum gcc_jit_binary_op m_op
;
1484 class comment
: public statement
1490 : statement (b
, loc
),
1493 void replay_into (replayer
*r
);
1496 string
* make_debug_string ();
1502 class conditional
: public statement
1505 conditional (block
*b
,
1510 : statement (b
, loc
),
1511 m_boolval (boolval
),
1512 m_on_true (on_true
),
1513 m_on_false (on_false
) {}
1515 void replay_into (replayer
*r
);
1517 int get_successor_blocks (block
**out_next1
,
1518 block
**out_next2
) const;
1521 string
* make_debug_string ();
1529 class jump
: public statement
1535 : statement (b
, loc
),
1536 m_target (target
) {}
1538 void replay_into (replayer
*r
);
1540 int get_successor_blocks (block
**out_next1
,
1541 block
**out_next2
) const;
1544 string
* make_debug_string ();
1550 class return_
: public statement
1556 : statement (b
, loc
),
1557 m_rvalue (rvalue
) {}
1559 void replay_into (replayer
*r
);
1561 int get_successor_blocks (block
**out_next1
,
1562 block
**out_next2
) const;
1565 string
* make_debug_string ();
1571 } // namespace gcc::jit::recording
1573 /* The result of JIT-compilation. */
1577 result(void *dso_handle
);
1582 get_code (const char *funcname
);
1588 } // namespace gcc::jit
1592 #endif /* JIT_RECORDING_H */