GCC Middle and Back End API Reference
common.h
Go to the documentation of this file.
1/* Base header for the analyzer, plus utility functions.
2 Copyright (C) 2019-2025 Free Software Foundation, Inc.
3 Contributed by David Malcolm <dmalcolm@redhat.com>.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it
8under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 3, or (at your option)
10any later version.
11
12GCC is distributed in the hope that it will be useful, but
13WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#ifndef GCC_ANALYZER_COMMON_H
22#define GCC_ANALYZER_COMMON_H
23
24#include "config.h"
25#define INCLUDE_VECTOR
26#include "system.h"
27#include "coretypes.h"
28#include "tree.h"
29#include "function.h"
30#include "basic-block.h"
31#include "gimple.h"
32#include "options.h"
33#include "bitmap.h"
34#include "diagnostic-core.h"
35#include "diagnostic-path.h"
36#include "rich-location.h"
37#include "function.h"
38#include "json.h"
39#include "tristate.h"
40
41class graphviz_out;
42
43namespace ana {
44
45/* Forward decls of common types, with indentation to show inheritance. */
46
47class supergraph;
48class supernode;
49class superedge;
50 class cfg_superedge;
51 class switch_cfg_superedge;
52 class eh_dispatch_cfg_superedge;
53 class eh_dispatch_try_cfg_superedge;
54 class eh_dispatch_allowed_cfg_superedge;
55 class callgraph_superedge;
56 class call_superedge;
57 class return_superedge;
58
59class svalue;
60 class region_svalue;
61 class constant_svalue;
62 class unknown_svalue;
63 class poisoned_svalue;
64 class setjmp_svalue;
65 class initial_svalue;
66 class unaryop_svalue;
67 class binop_svalue;
68 class sub_svalue;
69 class repeated_svalue;
70 class bits_within_svalue;
71 class unmergeable_svalue;
72 class placeholder_svalue;
73 class widening_svalue;
74 class compound_svalue;
75 class conjured_svalue;
76 class asm_output_svalue;
77 class const_fn_result_svalue;
79class region;
80 class frame_region;
81 class function_region;
82 class label_region;
83 class decl_region;
84 class symbolic_region;
85 class element_region;
86 class offset_region;
87 class sized_region;
88 class cast_region;
89 class field_region;
90 class string_region;
91 class bit_range_region;
92 class var_arg_region;
94class conjured_purge;
95struct model_merger;
96class store_manager;
97class store;
98class region_model;
101class call_details;
104class equiv_class;
106class bounded_ranges;
108
109struct pending_location;
111class pending_note;
112class saved_diagnostic;
113struct event_loc_info;
114class checker_event;
115 class state_change_event;
116 class warning_event;
117class checker_path;
118class extrinsic_state;
119class sm_state_map;
120class stmt_finder;
121class program_point;
122class function_point;
123class program_state;
124class exploded_graph;
125class exploded_node;
126class exploded_edge;
128class exploded_cluster;
129class exploded_path;
130class analysis_plan;
131class state_purge_map;
134class state_change;
135class rewind_info_t;
136
137class engine;
138class state_machine;
139class logger;
140class visitor;
142class call_summary;
144struct per_function_data;
145struct interesting_t;
146
147class feasible_node;
148
149class known_function;
152
153/* Forward decls of functions. */
154
155extern void dump_tree (pretty_printer *pp, tree t);
159extern int readability_comparator (const void *p1, const void *p2);
160extern int tree_cmp (const void *p1, const void *p2);
163
164/* A tree, extended with stack frame information for locals, so that
165 we can distinguish between different values of locals within a potentially
166 recursive callstack. */
167
169{
170public:
171 path_var (tree t, int stack_depth)
172 : m_tree (t), m_stack_depth (stack_depth)
173 {
174 // TODO: ignore stack depth for globals and constants
175 }
176
177 bool operator== (const path_var &other) const
178 {
179 return (m_tree == other.m_tree
180 && m_stack_depth == other.m_stack_depth);
181 }
182
183 operator bool () const
184 {
185 return m_tree != NULL_TREE;
186 }
187
188 void dump (pretty_printer *pp) const;
189
191 int m_stack_depth; // or -1 for globals?
192};
193
194typedef offset_int bit_offset_t;
195typedef offset_int bit_size_t;
196typedef offset_int byte_offset_t;
197typedef offset_int byte_size_t;
198
200
202
203/* The location of a region expressesd as an offset relative to a
204 base region. */
205
207{
208public:
213
214 static region_offset make_concrete (const region *base_region,
215 bit_offset_t offset)
216 {
217 return region_offset (base_region, offset, NULL);
218 }
219 static region_offset make_symbolic (const region *base_region,
220 const svalue *sym_offset)
221 {
222 return region_offset (base_region, 0, sym_offset);
223 }
224 static region_offset make_byte_offset (const region *base_region,
225 const svalue *num_bytes_sval);
226
227 const region *get_base_region () const { return m_base_region; }
228
229 bool concrete_p () const { return m_sym_offset == NULL; }
230 bool symbolic_p () const { return m_sym_offset != NULL; }
231
233 {
235 return m_offset;
236 }
237
239 {
241 if (m_offset % BITS_PER_UNIT == 0)
242 {
243 *out = m_offset / BITS_PER_UNIT;
244 return true;
245 }
246 return false;
247 }
248
250 {
252 return m_sym_offset;
253 }
254
257
258 bool operator== (const region_offset &other) const
259 {
260 return (m_base_region == other.m_base_region
261 && m_offset == other.m_offset
262 && m_sym_offset == other.m_sym_offset);
263 }
264
265 void dump_to_pp (pretty_printer *pp, bool) const;
266 void dump (bool) const;
267
268private:
269 region_offset (const region *base_region, bit_offset_t offset,
270 const svalue *sym_offset)
271 : m_base_region (base_region), m_offset (offset), m_sym_offset (sym_offset)
272 {}
273
277};
278
279extern bool operator< (const region_offset &, const region_offset &);
280extern bool operator<= (const region_offset &, const region_offset &);
281extern bool operator> (const region_offset &, const region_offset &);
282extern bool operator>= (const region_offset &, const region_offset &);
283
284extern location_t get_stmt_location (const gimple *stmt, function *fun);
285
286extern bool compat_types_p (tree src_type, tree dst_type);
287
288/* Abstract base class for simulating the behavior of known functions,
289 supplied by the core of the analyzer, or by plugins.
290 The former are typically implemented in the various kf*.cc */
291
293{
294public:
295 virtual ~known_function () {}
296 virtual bool matches_call_types_p (const call_details &cd) const = 0;
297 virtual void impl_call_pre (const call_details &) const
298 {
299 return;
300 }
301 virtual void impl_call_post (const call_details &) const
302 {
303 return;
304 }
305
306 virtual const builtin_known_function *
307 dyn_cast_builtin_kf () const { return NULL; }
308};
309
310/* Subclass of known_function for builtin functions. */
311
313{
314public:
315 virtual enum built_in_function builtin_code () const = 0;
318 return builtin_info[builtin_code ()].decl;
319 }
320
322 dyn_cast_builtin_kf () const final override { return this; }
323};
324
325/* Subclass of known_function for IFN_* functions. */
326
328{
329public:
330 bool matches_call_types_p (const call_details &) const final override
331 {
332 /* Types are assumed to be correct. */
333 return true;
334 }
335};
336
337/* Abstract subclass of known_function that merely sets the return
338 value of the function (based on function attributes), and assumes
339 it has no side-effects. */
340
342{
343public:
344 void impl_call_pre (const call_details &cd) const override;
345};
346
354
355/* Passed by pointer to PLUGIN_ANALYZER_INIT callbacks. */
356
358{
359public:
360 virtual void register_state_machine (std::unique_ptr<state_machine>) = 0;
361 virtual void register_known_function (const char *name,
362 std::unique_ptr<known_function>) = 0;
363 virtual logger *get_logger () const = 0;
364};
365
366/* An enum for describing the direction of an access to memory. */
367
369{
372};
373
374/* Abstract base class for associating custom data with an
375 exploded_edge, for handling non-standard edges such as
376 rewinding from a longjmp, signal handlers, etc.
377 Also used when "bifurcating" state: splitting the execution
378 path in non-standard ways (e.g. for simulating the various
379 outcomes of "realloc"). */
380
382{
383public:
384 virtual ~custom_edge_info () {}
385
386 /* Hook for making .dot label more readable. */
387 virtual void print (pretty_printer *pp) const = 0;
388
389 /* Hook for updating STATE when handling bifurcation. */
391 const exploded_edge *eedge,
392 region_model_context *ctxt) const;
393
394 /* Hook for updating MODEL within exploded_path::feasible_p
395 and when handling bifurcation. */
396 virtual bool update_model (region_model *model,
397 const exploded_edge *eedge,
398 region_model_context *ctxt) const = 0;
399
400 virtual void add_events_to_path (checker_path *emission_path,
401 const exploded_edge &eedge) const = 0;
402
404 const program_point &point,
406 exploded_node *enode_for_diag,
407 region_model_context *ctxt) const;
408};
409
410/* Abstract base class for splitting state.
411
412 Most of the state-management code in the analyzer involves
413 modifying state objects in-place, which assumes a single outcome.
414
415 This class provides an escape hatch to allow for multiple outcomes
416 for such updates e.g. for modelling multiple outcomes from function
417 calls, such as the various outcomes of "realloc". */
418
420{
421public:
422 virtual ~path_context () {}
423
424 /* Hook for clients to split state with a non-standard path. */
425 virtual void bifurcate (std::unique_ptr<custom_edge_info> info) = 0;
426
427 /* Hook for clients to terminate the standard path. */
428 virtual void terminate_path () = 0;
429
430 /* Hook for clients to determine if the standard path has been
431 terminated. */
432 virtual bool terminate_path_p () const = 0;
433};
434
435extern tree get_stashed_constant_by_name (const char *name);
437
439
440extern std::unique_ptr<json::value>
442
443extern std::unique_ptr<json::value>
445
446extern std::unique_ptr<json::value>
448
449extern std::unique_ptr<json::value>
451
452extern tristate
453compare_constants (tree lhs_const, enum tree_code op, tree rhs_const);
454
455extern tree
457
458extern tree
460
461extern const svalue *
463
464extern region_offset
466
468
469} // namespace ana
470
471extern bool is_special_named_call_p (const gcall &call, const char *funcname,
472 unsigned int num_args,
473 bool look_in_std = false);
474extern bool is_named_call_p (const_tree fndecl, const char *funcname);
475extern bool is_named_call_p (const_tree fndecl, const char *funcname,
476 const gcall &call, unsigned int num_args);
477extern bool is_std_function_p (const_tree fndecl);
478extern bool is_std_named_call_p (const_tree fndecl, const char *funcname);
479extern bool is_std_named_call_p (const_tree fndecl, const char *funcname,
480 const gcall &call, unsigned int num_args);
481extern bool is_setjmp_call_p (const gcall &call);
482extern bool is_longjmp_call_p (const gcall &call);
483extern bool is_placement_new_p (const gcall &call);
484extern bool is_cxa_throw_p (const gcall &call);
485extern bool is_cxa_rethrow_p (const gcall &call);
486
487extern const char *get_user_facing_name (const gcall &call);
488
490
491extern label_text make_label_text (bool can_colorize, const char *fmt, ...);
492extern label_text make_label_text_n (bool can_colorize,
493 unsigned HOST_WIDE_INT n,
494 const char *singular_fmt,
495 const char *plural_fmt, ...);
496
497extern bool fndecl_has_gimple_body_p (tree fndecl);
498
499/* An RAII-style class for pushing/popping cfun within a scope.
500 Doing so ensures we get "In function " announcements
501 from the diagnostics subsystem. */
502
504{
505public:
506 auto_cfun (function *fun) { push_cfun (fun); }
508};
509
510/* A template for creating hash traits for a POD type. */
511
512template <typename Type>
514{
515 typedef Type value_type;
516 typedef Type compare_type;
517 static inline hashval_t hash (value_type);
518 static inline bool equal (const value_type &existing,
519 const value_type &candidate);
520 static inline void mark_deleted (Type &);
521 static inline void mark_empty (Type &);
522 static inline bool is_deleted (Type);
523 static inline bool is_empty (Type);
524};
525
526/* A hash traits class that uses member functions to implement
527 the various required ops. */
528
529template <typename Type>
531{
532 typedef Type value_type;
533 typedef Type compare_type;
534 static inline hashval_t hash (value_type v) { return v.hash (); }
535 static inline bool equal (const value_type &existing,
536 const value_type &candidate)
537 {
538 return existing == candidate;
539 }
540 static inline void mark_deleted (Type &t) { t.mark_deleted (); }
541 static inline void mark_empty (Type &t) { t.mark_empty (); }
542 static inline bool is_deleted (Type t) { return t.is_deleted (); }
543 static inline bool is_empty (Type t) { return t.is_empty (); }
544};
545
546/* A map from T::key_t to T* for use in consolidating instances of T.
547 Owns all instances of T.
548 T::key_t should have operator== and be hashable. */
549
550template <typename T>
552{
553public:
554 typedef typename T::key_t key_t;
555 typedef T instance_t;
557 typedef typename inner_map_t::iterator iterator;
558
559 /* Delete all instances of T. */
560
562 {
563 for (typename inner_map_t::iterator iter = m_inner_map.begin ();
564 iter != m_inner_map.end (); ++iter)
565 delete (*iter).second;
566 }
567
568 /* Get the instance of T for K if one exists, or NULL. */
569
570 T *get (const key_t &k) const
571 {
572 if (instance_t **slot = const_cast<inner_map_t &> (m_inner_map).get (k))
573 return *slot;
574 return NULL;
575 }
576
577 /* Take ownership of INSTANCE. */
578
579 void put (const key_t &k, T *instance)
580 {
581 m_inner_map.put (k, instance);
582 }
583
584 size_t elements () const { return m_inner_map.elements (); }
585
586 iterator begin () const { return m_inner_map.begin (); }
587 iterator end () const { return m_inner_map.end (); }
588
589private:
591};
592
593/* Disable -Wformat-diag; we want to be able to use pp_printf
594 for logging/dumping without complying with the rules for diagnostics. */
595#if __GNUC__ >= 10
596#pragma GCC diagnostic ignored "-Wformat-diag"
597#endif
598
599#if !ENABLE_ANALYZER
600extern void sorry_no_analyzer ();
601#endif /* #if !ENABLE_ANALYZER */
602
603#endif /* GCC_ANALYZER_COMMON_H */
Definition analysis-plan.h:35
Definition region.h:1316
Definition constraint-manager.h:181
Definition common.h:313
virtual enum built_in_function builtin_code() const =0
const builtin_known_function * dyn_cast_builtin_kf() const final override
Definition common.h:322
tree builtin_decl() const
Definition common.h:316
Definition call-details.h:29
Definition call-summary.h:68
Definition call-summary.h:34
Definition region.h:1168
Definition checker-event.h:97
Definition checker-path.h:32
Definition svalue.h:1493
Definition constraint-manager.h:425
Definition common.h:382
virtual bool update_state(program_state *state, const exploded_edge *eedge, region_model_context *ctxt) const
virtual bool update_model(region_model *model, const exploded_edge *eedge, region_model_context *ctxt) const =0
virtual exploded_node * create_enode(exploded_graph &eg, const program_point &point, program_state &&state, exploded_node *enode_for_diag, region_model_context *ctxt) const
virtual void print(pretty_printer *pp) const =0
virtual void add_events_to_path(checker_path *emission_path, const exploded_edge &eedge) const =0
virtual ~custom_edge_info()
Definition common.h:384
Definition region.h:742
Definition region.h:879
Definition region-model.h:1338
Definition constraint-manager.h:255
Definition exploded-graph.h:394
Definition exploded-graph.h:804
Definition exploded-graph.h:203
Definition exploded-graph.h:965
Definition program-state.h:31
Definition exploded-graph.h:993
Definition feasible-graph.h:84
Definition region.h:802
Definition region.h:319
Definition program-point.h:73
Definition region.h:481
Definition exploded-graph.h:39
Definition common.h:328
bool matches_call_types_p(const call_details &) const final override
Definition common.h:330
Definition known-function-manager.h:41
Definition common.h:293
virtual void impl_call_post(const call_details &) const
Definition common.h:301
virtual void impl_call_pre(const call_details &) const
Definition common.h:297
virtual bool matches_call_types_p(const call_details &cd) const =0
virtual const builtin_known_function * dyn_cast_builtin_kf() const
Definition common.h:307
virtual ~known_function()
Definition common.h:295
Definition region.h:520
Definition analyzer-logging.h:34
Definition region.h:973
Definition common.h:420
virtual bool terminate_path_p() const =0
virtual void bifurcate(std::unique_ptr< custom_edge_info > info)=0
virtual void terminate_path()=0
virtual ~path_context()
Definition common.h:422
bool operator==(const path_var &other) const
Definition common.h:177
int m_stack_depth
Definition common.h:191
path_var(tree t, int stack_depth)
Definition common.h:171
void dump(pretty_printer *pp) const
tree m_tree
Definition common.h:190
Definition pending-diagnostic.h:190
Definition pending-diagnostic.h:430
Definition common.h:358
virtual void register_state_machine(std::unique_ptr< state_machine >)=0
virtual logger * get_logger() const =0
virtual void register_known_function(const char *name, std::unique_ptr< known_function >)=0
Definition program-point.h:175
Definition program-state.h:221
void impl_call_pre(const call_details &cd) const override
Definition region-model-reachability.h:36
Definition region-model.h:815
Definition region-model-manager.h:32
Definition region-model.h:298
Definition common.h:207
bit_offset_t get_bit_offset() const
Definition common.h:232
bool symbolic_p() const
Definition common.h:230
const region * get_base_region() const
Definition common.h:227
bit_offset_t m_offset
Definition common.h:275
static region_offset make_byte_offset(const region *base_region, const svalue *num_bytes_sval)
const svalue * m_sym_offset
Definition common.h:276
static region_offset make_concrete(const region *base_region, bit_offset_t offset)
Definition common.h:214
void dump_to_pp(pretty_printer *pp, bool) const
region_offset()
Definition common.h:209
const svalue * calc_symbolic_byte_offset(region_model_manager *mgr) const
region_offset(const region *base_region, bit_offset_t offset, const svalue *sym_offset)
Definition common.h:269
void dump(bool) const
bool operator==(const region_offset &other) const
Definition common.h:258
const svalue & calc_symbolic_bit_offset(region_model_manager *mgr) const
const region * m_base_region
Definition common.h:274
bool get_concrete_byte_offset(byte_offset_t *out) const
Definition common.h:238
static region_offset make_symbolic(const region *base_region, const svalue *sym_offset)
Definition common.h:219
const svalue * get_symbolic_byte_offset() const
Definition common.h:249
bool concrete_p() const
Definition common.h:229
Definition region.h:126
Definition region-model.h:1278
Definition exploded-graph.h:470
Definition diagnostic-manager.h:31
Definition region.h:1067
Definition program-state.h:89
Definition checker-event.h:354
Definition sm.h:40
Definition state-purge.h:78
Definition state-purge.h:194
Definition state-purge.h:162
Definition exploded-graph.h:1051
Definition store.h:861
Definition store.h:736
Definition region.h:1276
Definition svalue.h:92
Definition region.h:663
Definition region.h:1406
Definition region-model.h:222
Definition checker-event.h:790
~auto_cfun()
Definition common.h:507
auto_cfun(function *fun)
Definition common.h:506
Definition common.h:552
inner_map_t::iterator iterator
Definition common.h:557
inner_map_t m_inner_map
Definition common.h:590
T * get(const key_t &k) const
Definition common.h:570
T::key_t key_t
Definition common.h:554
~consolidation_map()
Definition common.h:561
iterator begin() const
Definition common.h:586
T instance_t
Definition common.h:555
hash_map< key_t, instance_t * > inner_map_t
Definition common.h:556
void put(const key_t &k, T *instance)
Definition common.h:579
size_t elements() const
Definition common.h:584
iterator end() const
Definition common.h:587
Definition diagnostic-event-id.h:37
Definition genmatch.cc:1506
Definition graphviz.h:29
Definition hash-map.h:40
Definition hash-set.h:37
Definition pretty-print.h:241
Definition lra-spills.cc:101
Definition tristate.h:26
bool is_named_call_p(const_tree fndecl, const char *funcname)
bool is_cxa_rethrow_p(const gcall &call)
bool is_std_function_p(const_tree fndecl)
bool is_placement_new_p(const gcall &call)
bool is_setjmp_call_p(const gcall &call)
void sorry_no_analyzer()
Definition analyzer-pass.cc:104
bool is_std_named_call_p(const_tree fndecl, const char *funcname)
label_text make_label_text_n(bool can_colorize, unsigned HOST_WIDE_INT n, const char *singular_fmt, const char *plural_fmt,...)
bool is_cxa_throw_p(const gcall &call)
bool fndecl_has_gimple_body_p(tree fndecl)
label_text make_label_text(bool can_colorize, const char *fmt,...)
const char * get_user_facing_name(const gcall &call)
bool is_special_named_call_p(const gcall &call, const char *funcname, unsigned int num_args, bool look_in_std=false)
void register_analyzer_pass()
bool is_longjmp_call_p(const gcall &call)
const union tree_node * const_tree
Definition coretypes.h:98
union tree_node * tree
Definition coretypes.h:97
void final(rtx_insn *first, FILE *file, int optimize_p)
Definition final.cc:2008
void push_cfun(struct function *new_cfun)
Definition function.cc:4758
void pop_cfun(void)
Definition function.cc:4784
static struct token T
Definition gengtype-parse.cc:45
static void record_type(type_p type)
Definition gengtype-state.cc:1426
built_in_function
Definition genmatch.cc:1009
tree_code
Definition genmatch.cc:1002
Definition access-diagram.h:30
bool compat_types_p(tree src_type, tree dst_type)
void register_known_functions_lang_cp(known_function_manager &kfm)
void register_known_functions(known_function_manager &kfm, region_model_manager &rmm)
std::unique_ptr< json::value > byte_offset_to_json(const byte_offset_t &offset)
std::unique_ptr< json::value > bit_offset_to_json(const bit_offset_t &offset)
offset_int byte_size_t
Definition common.h:197
@ stmt
Definition checker-event.h:37
@ state_change
Definition checker-event.h:40
bool operator>(const region_offset &, const region_offset &)
offset_int bit_offset_t
Definition common.h:194
tree fixup_tree_for_diagnostic(tree)
void dump_tree(pretty_printer *pp, tree t)
bool operator>=(const region_offset &, const region_offset &)
tree get_string_cst_size(const_tree string_cst)
bool operator<(const region_offset &, const region_offset &)
void register_known_analyzer_functions(known_function_manager &kfm)
access_direction
Definition common.h:369
@ read
Definition common.h:370
@ write
Definition common.h:371
bool operator<=(const region_offset &, const region_offset &)
tree get_field_at_bit_offset(tree record_type, bit_offset_t bit_offset)
void print_expr_for_user(pretty_printer *pp, tree t)
tristate compare_constants(tree lhs_const, enum tree_code op, tree rhs_const)
tree get_stashed_constant_by_name(const char *name)
bool int_size_in_bits(const_tree type, bit_size_t *out)
std::unique_ptr< json::value > tree_to_json(tree node)
tree get_ssa_default_def(const function &fun, tree var)
offset_int byte_offset_t
Definition common.h:196
location_t get_stmt_location(const gimple *stmt, function *fun)
const svalue * strip_types(const svalue *sval, region_model_manager &mgr)
FILE * get_or_create_any_logfile()
void dump_quoted_tree(pretty_printer *pp, tree t)
void log_stashed_constants(logger *logger)
offset_int bit_size_t
Definition common.h:195
int tree_cmp(const void *p1, const void *p2)
tree remove_ssa_names(tree expr)
tree get_diagnostic_tree_for_gassign(const gassign *)
hash_set< const svalue * > svalue_set
Definition common.h:78
void register_varargs_builtins(known_function_manager &kfm)
std::unique_ptr< json::value > diagnostic_event_id_to_json(const diagnostic_event_id_t &)
void register_known_fd_functions(known_function_manager &kfm)
int readability_comparator(const void *p1, const void *p2)
void register_known_file_functions(known_function_manager &kfm)
void print_quoted_type(pretty_printer *pp, tree t)
Definition constraint-manager.h:123
Definition event-loc-info.h:29
Definition pending-diagnostic.h:38
Definition region-model.h:1229
Definition diagnostic-manager.h:108
Definition exploded-graph.h:678
Definition tree-loop-distribution.cc:240
Definition function.h:249
Definition gimple.h:904
Definition gimple.h:352
Definition gimple.h:221
Definition common.h:531
static void mark_empty(Type &t)
Definition common.h:541
static hashval_t hash(value_type v)
Definition common.h:534
Type compare_type
Definition common.h:533
Type value_type
Definition common.h:532
static bool equal(const value_type &existing, const value_type &candidate)
Definition common.h:535
static void mark_deleted(Type &t)
Definition common.h:540
static bool is_empty(Type t)
Definition common.h:543
static bool is_deleted(Type t)
Definition common.h:542
Definition common.h:514
static void mark_deleted(Type &)
Type compare_type
Definition common.h:516
static bool is_empty(Type)
static bool equal(const value_type &existing, const value_type &candidate)
static bool is_deleted(Type)
Type value_type
Definition common.h:515
static hashval_t hash(value_type)
static void mark_empty(Type &)
Definition genautomata.cc:669
Definition gengtype.h:252
Definition hash-traits.h:75
#define NULL
Definition system.h:50
#define gcc_assert(EXPR)
Definition system.h:814
#define bool
Definition system.h:886
@ END_BUILTINS
Definition tree-core.h:3541
static tree candidate(unsigned uid)
Definition tree-sra.cc:326
static control_dependences * cd
Definition tree-ssa-dce.cc:104
#define NULL_TREE
Definition tree.h:317