summaryrefslogtreecommitdiffstats
path: root/scripts/gcc-plugins/gcc-common.h
diff options
context:
space:
mode:
Diffstat (limited to 'scripts/gcc-plugins/gcc-common.h')
-rw-r--r--scripts/gcc-plugins/gcc-common.h830
1 files changed, 830 insertions, 0 deletions
diff --git a/scripts/gcc-plugins/gcc-common.h b/scripts/gcc-plugins/gcc-common.h
new file mode 100644
index 000000000000..172850bcd0d9
--- /dev/null
+++ b/scripts/gcc-plugins/gcc-common.h
@@ -0,0 +1,830 @@
1#ifndef GCC_COMMON_H_INCLUDED
2#define GCC_COMMON_H_INCLUDED
3
4#include "bversion.h"
5#if BUILDING_GCC_VERSION >= 6000
6#include "gcc-plugin.h"
7#else
8#include "plugin.h"
9#endif
10#include "plugin-version.h"
11#include "config.h"
12#include "system.h"
13#include "coretypes.h"
14#include "tm.h"
15#include "line-map.h"
16#include "input.h"
17#include "tree.h"
18
19#include "tree-inline.h"
20#include "version.h"
21#include "rtl.h"
22#include "tm_p.h"
23#include "flags.h"
24#include "hard-reg-set.h"
25#include "output.h"
26#include "except.h"
27#include "function.h"
28#include "toplev.h"
29#include "basic-block.h"
30#include "intl.h"
31#include "ggc.h"
32#include "timevar.h"
33
34#include "params.h"
35
36#if BUILDING_GCC_VERSION <= 4009
37#include "pointer-set.h"
38#else
39#include "hash-map.h"
40#endif
41
42#include "emit-rtl.h"
43#include "debug.h"
44#include "target.h"
45#include "langhooks.h"
46#include "cfgloop.h"
47#include "cgraph.h"
48#include "opts.h"
49
50#if BUILDING_GCC_VERSION == 4005
51#include <sys/mman.h>
52#endif
53
54#if BUILDING_GCC_VERSION >= 4007
55#include "tree-pretty-print.h"
56#include "gimple-pretty-print.h"
57#endif
58
59#if BUILDING_GCC_VERSION >= 4006
60#include "c-family/c-common.h"
61#else
62#include "c-common.h"
63#endif
64
65#if BUILDING_GCC_VERSION <= 4008
66#include "tree-flow.h"
67#else
68#include "tree-cfgcleanup.h"
69#include "tree-ssa-operands.h"
70#include "tree-into-ssa.h"
71#endif
72
73#if BUILDING_GCC_VERSION >= 4008
74#include "is-a.h"
75#endif
76
77#include "diagnostic.h"
78#include "tree-dump.h"
79#include "tree-pass.h"
80#include "predict.h"
81#include "ipa-utils.h"
82
83#if BUILDING_GCC_VERSION >= 4009
84#include "attribs.h"
85#include "varasm.h"
86#include "stor-layout.h"
87#include "internal-fn.h"
88#include "gimple-expr.h"
89#include "gimple-fold.h"
90#include "context.h"
91#include "tree-ssa-alias.h"
92#include "tree-ssa.h"
93#include "stringpool.h"
94#include "tree-ssanames.h"
95#include "print-tree.h"
96#include "tree-eh.h"
97#include "stmt.h"
98#include "gimplify.h"
99#endif
100
101#include "gimple.h"
102
103#if BUILDING_GCC_VERSION >= 4009
104#include "tree-ssa-operands.h"
105#include "tree-phinodes.h"
106#include "tree-cfg.h"
107#include "gimple-iterator.h"
108#include "gimple-ssa.h"
109#include "ssa-iterators.h"
110#endif
111
112#if BUILDING_GCC_VERSION >= 5000
113#include "builtins.h"
114#endif
115
116/* #include "expr.h" where are you... */
117extern rtx emit_move_insn(rtx x, rtx y);
118
119/* missing from basic_block.h... */
120extern void debug_dominance_info(enum cdi_direction dir);
121extern void debug_dominance_tree(enum cdi_direction dir, basic_block root);
122
123#if BUILDING_GCC_VERSION == 4006
124extern void debug_gimple_stmt(gimple);
125extern void debug_gimple_seq(gimple_seq);
126extern void print_gimple_seq(FILE *, gimple_seq, int, int);
127extern void print_gimple_stmt(FILE *, gimple, int, int);
128extern void print_gimple_expr(FILE *, gimple, int, int);
129extern void dump_gimple_stmt(pretty_printer *, gimple, int, int);
130#endif
131
132#define __unused __attribute__((__unused__))
133
134#define DECL_NAME_POINTER(node) IDENTIFIER_POINTER(DECL_NAME(node))
135#define DECL_NAME_LENGTH(node) IDENTIFIER_LENGTH(DECL_NAME(node))
136#define TYPE_NAME_POINTER(node) IDENTIFIER_POINTER(TYPE_NAME(node))
137#define TYPE_NAME_LENGTH(node) IDENTIFIER_LENGTH(TYPE_NAME(node))
138
139/* should come from c-tree.h if only it were installed for gcc 4.5... */
140#define C_TYPE_FIELDS_READONLY(TYPE) TREE_LANG_FLAG_1(TYPE)
141
142#if BUILDING_GCC_VERSION == 4005
143#define FOR_EACH_LOCAL_DECL(FUN, I, D) \
144 for (tree vars = (FUN)->local_decls, (I) = 0; \
145 vars && ((D) = TREE_VALUE(vars)); \
146 vars = TREE_CHAIN(vars), (I)++)
147#define DECL_CHAIN(NODE) (TREE_CHAIN(DECL_MINIMAL_CHECK(NODE)))
148#define FOR_EACH_VEC_ELT(T, V, I, P) \
149 for (I = 0; VEC_iterate(T, (V), (I), (P)); ++(I))
150#define TODO_rebuild_cgraph_edges 0
151#define SCOPE_FILE_SCOPE_P(EXP) (!(EXP))
152
153#ifndef O_BINARY
154#define O_BINARY 0
155#endif
156
157typedef struct varpool_node *varpool_node_ptr;
158
159static inline bool gimple_call_builtin_p(gimple stmt, enum built_in_function code)
160{
161 tree fndecl;
162
163 if (!is_gimple_call(stmt))
164 return false;
165 fndecl = gimple_call_fndecl(stmt);
166 if (!fndecl || DECL_BUILT_IN_CLASS(fndecl) != BUILT_IN_NORMAL)
167 return false;
168 return DECL_FUNCTION_CODE(fndecl) == code;
169}
170
171static inline bool is_simple_builtin(tree decl)
172{
173 if (decl && DECL_BUILT_IN_CLASS(decl) != BUILT_IN_NORMAL)
174 return false;
175
176 switch (DECL_FUNCTION_CODE(decl)) {
177 /* Builtins that expand to constants. */
178 case BUILT_IN_CONSTANT_P:
179 case BUILT_IN_EXPECT:
180 case BUILT_IN_OBJECT_SIZE:
181 case BUILT_IN_UNREACHABLE:
182 /* Simple register moves or loads from stack. */
183 case BUILT_IN_RETURN_ADDRESS:
184 case BUILT_IN_EXTRACT_RETURN_ADDR:
185 case BUILT_IN_FROB_RETURN_ADDR:
186 case BUILT_IN_RETURN:
187 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
188 case BUILT_IN_FRAME_ADDRESS:
189 case BUILT_IN_VA_END:
190 case BUILT_IN_STACK_SAVE:
191 case BUILT_IN_STACK_RESTORE:
192 /* Exception state returns or moves registers around. */
193 case BUILT_IN_EH_FILTER:
194 case BUILT_IN_EH_POINTER:
195 case BUILT_IN_EH_COPY_VALUES:
196 return true;
197
198 default:
199 return false;
200 }
201}
202
203static inline void add_local_decl(struct function *fun, tree d)
204{
205 gcc_assert(TREE_CODE(d) == VAR_DECL);
206 fun->local_decls = tree_cons(NULL_TREE, d, fun->local_decls);
207}
208#endif
209
210#if BUILDING_GCC_VERSION <= 4006
211#define ANY_RETURN_P(rtx) (GET_CODE(rtx) == RETURN)
212#define C_DECL_REGISTER(EXP) DECL_LANG_FLAG_4(EXP)
213#define EDGE_PRESERVE 0ULL
214#define HOST_WIDE_INT_PRINT_HEX_PURE "%" HOST_WIDE_INT_PRINT "x"
215#define flag_fat_lto_objects true
216
217#define get_random_seed(noinit) ({ \
218 unsigned HOST_WIDE_INT seed; \
219 sscanf(get_random_seed(noinit), "%" HOST_WIDE_INT_PRINT "x", &seed); \
220 seed * seed; })
221
222#define int_const_binop(code, arg1, arg2) \
223 int_const_binop((code), (arg1), (arg2), 0)
224
225static inline bool gimple_clobber_p(gimple s __unused)
226{
227 return false;
228}
229
230static inline bool gimple_asm_clobbers_memory_p(const_gimple stmt)
231{
232 unsigned i;
233
234 for (i = 0; i < gimple_asm_nclobbers(stmt); i++) {
235 tree op = gimple_asm_clobber_op(stmt, i);
236
237 if (!strcmp(TREE_STRING_POINTER(TREE_VALUE(op)), "memory"))
238 return true;
239 }
240
241 return false;
242}
243
244static inline tree builtin_decl_implicit(enum built_in_function fncode)
245{
246 return implicit_built_in_decls[fncode];
247}
248
249static inline int ipa_reverse_postorder(struct cgraph_node **order)
250{
251 return cgraph_postorder(order);
252}
253
254static inline struct cgraph_node *cgraph_create_node(tree decl)
255{
256 return cgraph_node(decl);
257}
258
259static inline struct cgraph_node *cgraph_get_create_node(tree decl)
260{
261 struct cgraph_node *node = cgraph_get_node(decl);
262
263 return node ? node : cgraph_node(decl);
264}
265
266static inline bool cgraph_function_with_gimple_body_p(struct cgraph_node *node)
267{
268 return node->analyzed && !node->thunk.thunk_p && !node->alias;
269}
270
271static inline struct cgraph_node *cgraph_first_function_with_gimple_body(void)
272{
273 struct cgraph_node *node;
274
275 for (node = cgraph_nodes; node; node = node->next)
276 if (cgraph_function_with_gimple_body_p(node))
277 return node;
278 return NULL;
279}
280
281static inline struct cgraph_node *cgraph_next_function_with_gimple_body(struct cgraph_node *node)
282{
283 for (node = node->next; node; node = node->next)
284 if (cgraph_function_with_gimple_body_p(node))
285 return node;
286 return NULL;
287}
288
289#define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
290 for ((node) = cgraph_first_function_with_gimple_body(); (node); \
291 (node) = cgraph_next_function_with_gimple_body(node))
292
293static inline void varpool_add_new_variable(tree decl)
294{
295 varpool_finalize_decl(decl);
296}
297#endif
298
299#if BUILDING_GCC_VERSION <= 4007
300#define FOR_EACH_FUNCTION(node) \
301 for (node = cgraph_nodes; node; node = node->next)
302#define FOR_EACH_VARIABLE(node) \
303 for (node = varpool_nodes; node; node = node->next)
304#define PROP_loops 0
305#define NODE_SYMBOL(node) (node)
306#define NODE_DECL(node) (node)->decl
307#define INSN_LOCATION(INSN) RTL_LOCATION(INSN)
308#define vNULL NULL
309
310static inline int bb_loop_depth(const_basic_block bb)
311{
312 return bb->loop_father ? loop_depth(bb->loop_father) : 0;
313}
314
315static inline bool gimple_store_p(gimple gs)
316{
317 tree lhs = gimple_get_lhs(gs);
318
319 return lhs && !is_gimple_reg(lhs);
320}
321
322static inline void gimple_init_singleton(gimple g __unused)
323{
324}
325#endif
326
327#if BUILDING_GCC_VERSION == 4007 || BUILDING_GCC_VERSION == 4008
328static inline struct cgraph_node *cgraph_alias_target(struct cgraph_node *n)
329{
330 return cgraph_alias_aliased_node(n);
331}
332#endif
333
334#if BUILDING_GCC_VERSION >= 4007 && BUILDING_GCC_VERSION <= 4009
335#define cgraph_create_edge(caller, callee, call_stmt, count, freq, nest) \
336 cgraph_create_edge((caller), (callee), (call_stmt), (count), (freq))
337#define cgraph_create_edge_including_clones(caller, callee, old_call_stmt, call_stmt, count, freq, nest, reason) \
338 cgraph_create_edge_including_clones((caller), (callee), (old_call_stmt), (call_stmt), (count), (freq), (reason))
339#endif
340
341#if BUILDING_GCC_VERSION <= 4008
342#define ENTRY_BLOCK_PTR_FOR_FN(FN) ENTRY_BLOCK_PTR_FOR_FUNCTION(FN)
343#define EXIT_BLOCK_PTR_FOR_FN(FN) EXIT_BLOCK_PTR_FOR_FUNCTION(FN)
344#define basic_block_info_for_fn(FN) ((FN)->cfg->x_basic_block_info)
345#define n_basic_blocks_for_fn(FN) ((FN)->cfg->x_n_basic_blocks)
346#define n_edges_for_fn(FN) ((FN)->cfg->x_n_edges)
347#define last_basic_block_for_fn(FN) ((FN)->cfg->x_last_basic_block)
348#define label_to_block_map_for_fn(FN) ((FN)->cfg->x_label_to_block_map)
349#define profile_status_for_fn(FN) ((FN)->cfg->x_profile_status)
350#define BASIC_BLOCK_FOR_FN(FN, N) BASIC_BLOCK_FOR_FUNCTION((FN), (N))
351#define NODE_IMPLICIT_ALIAS(node) (node)->same_body_alias
352#define VAR_P(NODE) (TREE_CODE(NODE) == VAR_DECL)
353
354static inline bool tree_fits_shwi_p(const_tree t)
355{
356 if (t == NULL_TREE || TREE_CODE(t) != INTEGER_CST)
357 return false;
358
359 if (TREE_INT_CST_HIGH(t) == 0 && (HOST_WIDE_INT)TREE_INT_CST_LOW(t) >= 0)
360 return true;
361
362 if (TREE_INT_CST_HIGH(t) == -1 && (HOST_WIDE_INT)TREE_INT_CST_LOW(t) < 0 && !TYPE_UNSIGNED(TREE_TYPE(t)))
363 return true;
364
365 return false;
366}
367
368static inline bool tree_fits_uhwi_p(const_tree t)
369{
370 if (t == NULL_TREE || TREE_CODE(t) != INTEGER_CST)
371 return false;
372
373 return TREE_INT_CST_HIGH(t) == 0;
374}
375
376static inline HOST_WIDE_INT tree_to_shwi(const_tree t)
377{
378 gcc_assert(tree_fits_shwi_p(t));
379 return TREE_INT_CST_LOW(t);
380}
381
382static inline unsigned HOST_WIDE_INT tree_to_uhwi(const_tree t)
383{
384 gcc_assert(tree_fits_uhwi_p(t));
385 return TREE_INT_CST_LOW(t);
386}
387
388static inline const char *get_tree_code_name(enum tree_code code)
389{
390 gcc_assert(code < MAX_TREE_CODES);
391 return tree_code_name[code];
392}
393
394#define ipa_remove_stmt_references(cnode, stmt)
395
396typedef union gimple_statement_d gasm;
397typedef union gimple_statement_d gassign;
398typedef union gimple_statement_d gcall;
399typedef union gimple_statement_d gcond;
400typedef union gimple_statement_d gdebug;
401typedef union gimple_statement_d gphi;
402typedef union gimple_statement_d greturn;
403
404static inline gasm *as_a_gasm(gimple stmt)
405{
406 return stmt;
407}
408
409static inline const gasm *as_a_const_gasm(const_gimple stmt)
410{
411 return stmt;
412}
413
414static inline gassign *as_a_gassign(gimple stmt)
415{
416 return stmt;
417}
418
419static inline const gassign *as_a_const_gassign(const_gimple stmt)
420{
421 return stmt;
422}
423
424static inline gcall *as_a_gcall(gimple stmt)
425{
426 return stmt;
427}
428
429static inline const gcall *as_a_const_gcall(const_gimple stmt)
430{
431 return stmt;
432}
433
434static inline gcond *as_a_gcond(gimple stmt)
435{
436 return stmt;
437}
438
439static inline const gcond *as_a_const_gcond(const_gimple stmt)
440{
441 return stmt;
442}
443
444static inline gdebug *as_a_gdebug(gimple stmt)
445{
446 return stmt;
447}
448
449static inline const gdebug *as_a_const_gdebug(const_gimple stmt)
450{
451 return stmt;
452}
453
454static inline gphi *as_a_gphi(gimple stmt)
455{
456 return stmt;
457}
458
459static inline const gphi *as_a_const_gphi(const_gimple stmt)
460{
461 return stmt;
462}
463
464static inline greturn *as_a_greturn(gimple stmt)
465{
466 return stmt;
467}
468
469static inline const greturn *as_a_const_greturn(const_gimple stmt)
470{
471 return stmt;
472}
473#endif
474
475#if BUILDING_GCC_VERSION == 4008
476#define NODE_SYMBOL(node) (&(node)->symbol)
477#define NODE_DECL(node) (node)->symbol.decl
478#endif
479
480#if BUILDING_GCC_VERSION >= 4008
481#define add_referenced_var(var)
482#define mark_sym_for_renaming(var)
483#define varpool_mark_needed_node(node)
484#define create_var_ann(var)
485#define TODO_dump_func 0
486#define TODO_dump_cgraph 0
487#endif
488
489#if BUILDING_GCC_VERSION <= 4009
490#define TODO_verify_il 0
491#define AVAIL_INTERPOSABLE AVAIL_OVERWRITABLE
492
493#define section_name_prefix LTO_SECTION_NAME_PREFIX
494#define fatal_error(loc, gmsgid, ...) fatal_error((gmsgid), __VA_ARGS__)
495
496typedef struct rtx_def rtx_insn;
497
498static inline void set_decl_section_name(tree node, const char *value)
499{
500 if (value)
501 DECL_SECTION_NAME(node) = build_string(strlen(value) + 1, value);
502 else
503 DECL_SECTION_NAME(node) = NULL;
504}
505#endif
506
507#if BUILDING_GCC_VERSION == 4009
508typedef struct gimple_statement_asm gasm;
509typedef struct gimple_statement_base gassign;
510typedef struct gimple_statement_call gcall;
511typedef struct gimple_statement_base gcond;
512typedef struct gimple_statement_base gdebug;
513typedef struct gimple_statement_phi gphi;
514typedef struct gimple_statement_base greturn;
515
516static inline gasm *as_a_gasm(gimple stmt)
517{
518 return as_a<gasm>(stmt);
519}
520
521static inline const gasm *as_a_const_gasm(const_gimple stmt)
522{
523 return as_a<const gasm>(stmt);
524}
525
526static inline gassign *as_a_gassign(gimple stmt)
527{
528 return stmt;
529}
530
531static inline const gassign *as_a_const_gassign(const_gimple stmt)
532{
533 return stmt;
534}
535
536static inline gcall *as_a_gcall(gimple stmt)
537{
538 return as_a<gcall>(stmt);
539}
540
541static inline const gcall *as_a_const_gcall(const_gimple stmt)
542{
543 return as_a<const gcall>(stmt);
544}
545
546static inline gcond *as_a_gcond(gimple stmt)
547{
548 return stmt;
549}
550
551static inline const gcond *as_a_const_gcond(const_gimple stmt)
552{
553 return stmt;
554}
555
556static inline gdebug *as_a_gdebug(gimple stmt)
557{
558 return stmt;
559}
560
561static inline const gdebug *as_a_const_gdebug(const_gimple stmt)
562{
563 return stmt;
564}
565
566static inline gphi *as_a_gphi(gimple stmt)
567{
568 return as_a<gphi>(stmt);
569}
570
571static inline const gphi *as_a_const_gphi(const_gimple stmt)
572{
573 return as_a<const gphi>(stmt);
574}
575
576static inline greturn *as_a_greturn(gimple stmt)
577{
578 return stmt;
579}
580
581static inline const greturn *as_a_const_greturn(const_gimple stmt)
582{
583 return stmt;
584}
585#endif
586
587#if BUILDING_GCC_VERSION >= 4009
588#define TODO_ggc_collect 0
589#define NODE_SYMBOL(node) (node)
590#define NODE_DECL(node) (node)->decl
591#define cgraph_node_name(node) (node)->name()
592#define NODE_IMPLICIT_ALIAS(node) (node)->cpp_implicit_alias
593#endif
594
595#if BUILDING_GCC_VERSION >= 5000 && BUILDING_GCC_VERSION < 6000
596/* gimple related */
597template <>
598template <>
599inline bool is_a_helper<const gassign *>::test(const_gimple gs)
600{
601 return gs->code == GIMPLE_ASSIGN;
602}
603#endif
604
605#if BUILDING_GCC_VERSION >= 5000
606#define TODO_verify_ssa TODO_verify_il
607#define TODO_verify_flow TODO_verify_il
608#define TODO_verify_stmts TODO_verify_il
609#define TODO_verify_rtl_sharing TODO_verify_il
610
611#define INSN_DELETED_P(insn) (insn)->deleted()
612
613/* symtab/cgraph related */
614#define debug_cgraph_node(node) (node)->debug()
615#define cgraph_get_node(decl) cgraph_node::get(decl)
616#define cgraph_get_create_node(decl) cgraph_node::get_create(decl)
617#define cgraph_create_node(decl) cgraph_node::create(decl)
618#define cgraph_n_nodes symtab->cgraph_count
619#define cgraph_max_uid symtab->cgraph_max_uid
620#define varpool_get_node(decl) varpool_node::get(decl)
621
622#define cgraph_create_edge(caller, callee, call_stmt, count, freq, nest) \
623 (caller)->create_edge((callee), (call_stmt), (count), (freq))
624#define cgraph_create_edge_including_clones(caller, callee, old_call_stmt, call_stmt, count, freq, nest, reason) \
625 (caller)->create_edge_including_clones((callee), (old_call_stmt), (call_stmt), (count), (freq), (reason))
626
627typedef struct cgraph_node *cgraph_node_ptr;
628typedef struct cgraph_edge *cgraph_edge_p;
629typedef struct varpool_node *varpool_node_ptr;
630
631static inline void change_decl_assembler_name(tree decl, tree name)
632{
633 symtab->change_decl_assembler_name(decl, name);
634}
635
636static inline void varpool_finalize_decl(tree decl)
637{
638 varpool_node::finalize_decl(decl);
639}
640
641static inline void varpool_add_new_variable(tree decl)
642{
643 varpool_node::add(decl);
644}
645
646static inline unsigned int rebuild_cgraph_edges(void)
647{
648 return cgraph_edge::rebuild_edges();
649}
650
651static inline cgraph_node_ptr cgraph_function_node(cgraph_node_ptr node, enum availability *availability)
652{
653 return node->function_symbol(availability);
654}
655
656static inline cgraph_node_ptr cgraph_function_or_thunk_node(cgraph_node_ptr node, enum availability *availability = NULL)
657{
658 return node->ultimate_alias_target(availability);
659}
660
661static inline bool cgraph_only_called_directly_p(cgraph_node_ptr node)
662{
663 return node->only_called_directly_p();
664}
665
666static inline enum availability cgraph_function_body_availability(cgraph_node_ptr node)
667{
668 return node->get_availability();
669}
670
671static inline cgraph_node_ptr cgraph_alias_target(cgraph_node_ptr node)
672{
673 return node->get_alias_target();
674}
675
676static inline struct cgraph_node_hook_list *cgraph_add_function_insertion_hook(cgraph_node_hook hook, void *data)
677{
678 return symtab->add_cgraph_insertion_hook(hook, data);
679}
680
681static inline void cgraph_remove_function_insertion_hook(struct cgraph_node_hook_list *entry)
682{
683 symtab->remove_cgraph_insertion_hook(entry);
684}
685
686static inline struct cgraph_node_hook_list *cgraph_add_node_removal_hook(cgraph_node_hook hook, void *data)
687{
688 return symtab->add_cgraph_removal_hook(hook, data);
689}
690
691static inline void cgraph_remove_node_removal_hook(struct cgraph_node_hook_list *entry)
692{
693 symtab->remove_cgraph_removal_hook(entry);
694}
695
696static inline struct cgraph_2node_hook_list *cgraph_add_node_duplication_hook(cgraph_2node_hook hook, void *data)
697{
698 return symtab->add_cgraph_duplication_hook(hook, data);
699}
700
701static inline void cgraph_remove_node_duplication_hook(struct cgraph_2node_hook_list *entry)
702{
703 symtab->remove_cgraph_duplication_hook(entry);
704}
705
706static inline void cgraph_call_node_duplication_hooks(cgraph_node_ptr node, cgraph_node_ptr node2)
707{
708 symtab->call_cgraph_duplication_hooks(node, node2);
709}
710
711static inline void cgraph_call_edge_duplication_hooks(cgraph_edge *cs1, cgraph_edge *cs2)
712{
713 symtab->call_edge_duplication_hooks(cs1, cs2);
714}
715
716#if BUILDING_GCC_VERSION >= 6000
717typedef gimple *gimple_ptr;
718typedef const gimple *const_gimple_ptr;
719#define gimple gimple_ptr
720#define const_gimple const_gimple_ptr
721#undef CONST_CAST_GIMPLE
722#define CONST_CAST_GIMPLE(X) CONST_CAST(gimple, (X))
723#endif
724
725/* gimple related */
726static inline gimple gimple_build_assign_with_ops(enum tree_code subcode, tree lhs, tree op1, tree op2 MEM_STAT_DECL)
727{
728 return gimple_build_assign(lhs, subcode, op1, op2 PASS_MEM_STAT);
729}
730
731template <>
732template <>
733inline bool is_a_helper<const greturn *>::test(const_gimple gs)
734{
735 return gs->code == GIMPLE_RETURN;
736}
737
738static inline gasm *as_a_gasm(gimple stmt)
739{
740 return as_a<gasm *>(stmt);
741}
742
743static inline const gasm *as_a_const_gasm(const_gimple stmt)
744{
745 return as_a<const gasm *>(stmt);
746}
747
748static inline gassign *as_a_gassign(gimple stmt)
749{
750 return as_a<gassign *>(stmt);
751}
752
753static inline const gassign *as_a_const_gassign(const_gimple stmt)
754{
755 return as_a<const gassign *>(stmt);
756}
757
758static inline gcall *as_a_gcall(gimple stmt)
759{
760 return as_a<gcall *>(stmt);
761}
762
763static inline const gcall *as_a_const_gcall(const_gimple stmt)
764{
765 return as_a<const gcall *>(stmt);
766}
767
768static inline gphi *as_a_gphi(gimple stmt)
769{
770 return as_a<gphi *>(stmt);
771}
772
773static inline const gphi *as_a_const_gphi(const_gimple stmt)
774{
775 return as_a<const gphi *>(stmt);
776}
777
778static inline greturn *as_a_greturn(gimple stmt)
779{
780 return as_a<greturn *>(stmt);
781}
782
783static inline const greturn *as_a_const_greturn(const_gimple stmt)
784{
785 return as_a<const greturn *>(stmt);
786}
787
788/* IPA/LTO related */
789#define ipa_ref_list_referring_iterate(L, I, P) \
790 (L)->referring.iterate((I), &(P))
791#define ipa_ref_list_reference_iterate(L, I, P) \
792 (L)->reference.iterate((I), &(P))
793
794static inline cgraph_node_ptr ipa_ref_referring_node(struct ipa_ref *ref)
795{
796 return dyn_cast<cgraph_node_ptr>(ref->referring);
797}
798
799static inline void ipa_remove_stmt_references(symtab_node *referring_node, gimple stmt)
800{
801 referring_node->remove_stmt_references(stmt);
802}
803#endif
804
805#if BUILDING_GCC_VERSION < 6000
806#define get_inner_reference(exp, pbitsize, pbitpos, poffset, pmode, punsignedp, preversep, pvolatilep, keep_aligning) \
807 get_inner_reference(exp, pbitsize, pbitpos, poffset, pmode, punsignedp, pvolatilep, keep_aligning)
808#define gen_rtx_set(ARG0, ARG1) gen_rtx_SET(VOIDmode, (ARG0), (ARG1))
809#endif
810
811#if BUILDING_GCC_VERSION >= 6000
812#define gen_rtx_set(ARG0, ARG1) gen_rtx_SET((ARG0), (ARG1))
813#endif
814
815#ifdef __cplusplus
816static inline void debug_tree(const_tree t)
817{
818 debug_tree(CONST_CAST_TREE(t));
819}
820
821static inline void debug_gimple_stmt(const_gimple s)
822{
823 debug_gimple_stmt(CONST_CAST_GIMPLE(s));
824}
825#else
826#define debug_tree(t) debug_tree(CONST_CAST_TREE(t))
827#define debug_gimple_stmt(s) debug_gimple_stmt(CONST_CAST_GIMPLE(s))
828#endif
829
830#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-23 10:33:08 -0400