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_MAP
26#define INCLUDE_STRING
27#define INCLUDE_VECTOR
28#include "system.h"
29#include "coretypes.h"
30#include "tree.h"
31#include "function.h"
32#include "basic-block.h"
33#include "gimple.h"
34#include "options.h"
35#include "bitmap.h"
36#include "diagnostic-core.h"
37#include "diagnostic-path.h"
38#include "rich-location.h"
39#include "function.h"
40#include "json.h"
41#include "tristate.h"
42
43class graphviz_out;
44
45namespace ana {
46
47/* Forward decls of common types, with indentation to show inheritance. */
48
49class supergraph;
50class supernode;
51class superedge;
52 class cfg_superedge;
53 class switch_cfg_superedge;
54 class eh_dispatch_cfg_superedge;
55 class eh_dispatch_try_cfg_superedge;
56 class eh_dispatch_allowed_cfg_superedge;
57 class callgraph_superedge;
58 class call_superedge;
59 class return_superedge;
60
61class svalue;
62 class region_svalue;
63 class constant_svalue;
64 class unknown_svalue;
65 class poisoned_svalue;
66 class setjmp_svalue;
67 class initial_svalue;
68 class unaryop_svalue;
69 class binop_svalue;
70 class sub_svalue;
71 class repeated_svalue;
72 class bits_within_svalue;
73 class unmergeable_svalue;
74 class placeholder_svalue;
75 class widening_svalue;
76 class compound_svalue;
77 class conjured_svalue;
78 class asm_output_svalue;
79 class const_fn_result_svalue;
81class region;
82 class frame_region;
83 class function_region;
84 class label_region;
85 class decl_region;
86 class symbolic_region;
87 class element_region;
88 class offset_region;
89 class sized_region;
90 class cast_region;
91 class field_region;
92 class string_region;
93 class bit_range_region;
94 class var_arg_region;
96class conjured_purge;
97struct model_merger;
98class store_manager;
99class store;
100class region_model;
103class call_details;
106class equiv_class;
108class bounded_ranges;
110
111struct pending_location;
113class pending_note;
114class saved_diagnostic;
115struct event_loc_info;
116class checker_event;
117 class state_change_event;
118 class warning_event;
119class checker_path;
120class extrinsic_state;
121class sm_state_map;
122class stmt_finder;
123class program_point;
124class function_point;
125class program_state;
126class exploded_graph;
127class exploded_node;
128class exploded_edge;
130class exploded_cluster;
131class exploded_path;
132class analysis_plan;
133class state_purge_map;
136class state_change;
137class rewind_info_t;
138
139class engine;
140class state_machine;
141class logger;
142class visitor;
144class call_summary;
146struct per_function_data;
147struct interesting_t;
148
149class feasible_node;
150
151class known_function;
154
155/* Forward decls of functions. */
156
157extern void dump_tree (pretty_printer *pp, tree t);
161extern int readability_comparator (const void *p1, const void *p2);
162extern int tree_cmp (const void *p1, const void *p2);
165
166/* A tree, extended with stack frame information for locals, so that
167 we can distinguish between different values of locals within a potentially
168 recursive callstack. */
169
171{
172public:
173 path_var (tree t, int stack_depth)
174 : m_tree (t), m_stack_depth (stack_depth)
175 {
176 // TODO: ignore stack depth for globals and constants
177 }
178
179 bool operator== (const path_var &other) const
180 {
181 return (m_tree == other.m_tree
182 && m_stack_depth == other.m_stack_depth);
183 }
184
185 operator bool () const
186 {
187 return m_tree != NULL_TREE;
188 }
189
190 void dump (pretty_printer *pp) const;
191
193 int m_stack_depth; // or -1 for globals?
194};
195
196typedef offset_int bit_offset_t;
197typedef offset_int bit_size_t;
198typedef offset_int byte_offset_t;
199typedef offset_int byte_size_t;
200
202
204
205/* The location of a region expressesd as an offset relative to a
206 base region. */
207
209{
210public:
212 : m_base_region (nullptr), m_offset (0), m_sym_offset (nullptr)
213 {
214 }
215
216 static region_offset make_concrete (const region *base_region,
217 bit_offset_t offset)
218 {
219 return region_offset (base_region, offset, nullptr);
220 }
221 static region_offset make_symbolic (const region *base_region,
222 const svalue *sym_offset)
223 {
224 return region_offset (base_region, 0, sym_offset);
225 }
226 static region_offset make_byte_offset (const region *base_region,
227 const svalue *num_bytes_sval);
228
229 const region *get_base_region () const { return m_base_region; }
230
231 bool concrete_p () const { return m_sym_offset == nullptr; }
232 bool symbolic_p () const { return m_sym_offset != nullptr; }
233
235 {
237 return m_offset;
238 }
239
241 {
243 if (m_offset % BITS_PER_UNIT == 0)
244 {
245 *out = m_offset / BITS_PER_UNIT;
246 return true;
247 }
248 return false;
249 }
250
252 {
254 return m_sym_offset;
255 }
256
259
260 bool operator== (const region_offset &other) const
261 {
262 return (m_base_region == other.m_base_region
263 && m_offset == other.m_offset
264 && m_sym_offset == other.m_sym_offset);
265 }
266
267 void dump_to_pp (pretty_printer *pp, bool) const;
268 void dump (bool) const;
269
270private:
271 region_offset (const region *base_region, bit_offset_t offset,
272 const svalue *sym_offset)
273 : m_base_region (base_region), m_offset (offset), m_sym_offset (sym_offset)
274 {}
275
279};
280
281extern bool operator< (const region_offset &, const region_offset &);
282extern bool operator<= (const region_offset &, const region_offset &);
283extern bool operator> (const region_offset &, const region_offset &);
284extern bool operator>= (const region_offset &, const region_offset &);
285
286extern location_t get_stmt_location (const gimple *stmt, function *fun);
287
288extern bool compat_types_p (tree src_type, tree dst_type);
289
290/* Abstract base class for simulating the behavior of known functions,
291 supplied by the core of the analyzer, or by plugins.
292 The former are typically implemented in the various kf*.cc */
293
295{
296public:
297 virtual ~known_function () {}
298 virtual bool matches_call_types_p (const call_details &cd) const = 0;
299 virtual void impl_call_pre (const call_details &) const
300 {
301 return;
302 }
303 virtual void impl_call_post (const call_details &) const
304 {
305 return;
306 }
307
308 virtual const builtin_known_function *
309 dyn_cast_builtin_kf () const { return nullptr; }
310};
311
312/* Subclass of known_function for builtin functions. */
313
315{
316public:
317 virtual enum built_in_function builtin_code () const = 0;
320 return builtin_info[builtin_code ()].decl;
321 }
322
324 dyn_cast_builtin_kf () const final override { return this; }
325};
326
327/* Subclass of known_function for IFN_* functions. */
328
330{
331public:
332 bool matches_call_types_p (const call_details &) const final override
333 {
334 /* Types are assumed to be correct. */
335 return true;
336 }
337};
338
339/* Abstract subclass of known_function that merely sets the return
340 value of the function (based on function attributes), and assumes
341 it has no side-effects. */
342
344{
345public:
346 void impl_call_pre (const call_details &cd) const override;
347};
348
356
357/* Passed by pointer to PLUGIN_ANALYZER_INIT callbacks. */
358
360{
361public:
362 virtual void register_state_machine (std::unique_ptr<state_machine>) = 0;
363 virtual void register_known_function (const char *name,
364 std::unique_ptr<known_function>) = 0;
365 virtual logger *get_logger () const = 0;
366};
367
368/* An enum for describing the direction of an access to memory. */
369
371{
374};
375
376/* Abstract base class for associating custom data with an
377 exploded_edge, for handling non-standard edges such as
378 rewinding from a longjmp, signal handlers, etc.
379 Also used when "bifurcating" state: splitting the execution
380 path in non-standard ways (e.g. for simulating the various
381 outcomes of "realloc"). */
382
384{
385public:
386 virtual ~custom_edge_info () {}
387
388 /* Hook for making .dot label more readable. */
389 virtual void print (pretty_printer *pp) const = 0;
390
391 /* Hook for updating STATE when handling bifurcation. */
393 const exploded_edge *eedge,
394 region_model_context *ctxt) const;
395
396 /* Hook for updating MODEL within exploded_path::feasible_p
397 and when handling bifurcation. */
398 virtual bool update_model (region_model *model,
399 const exploded_edge *eedge,
400 region_model_context *ctxt) const = 0;
401
402 virtual void add_events_to_path (checker_path *emission_path,
403 const exploded_edge &eedge) const = 0;
404
406 const program_point &point,
408 exploded_node *enode_for_diag,
409 region_model_context *ctxt) const;
410};
411
412/* Abstract base class for splitting state.
413
414 Most of the state-management code in the analyzer involves
415 modifying state objects in-place, which assumes a single outcome.
416
417 This class provides an escape hatch to allow for multiple outcomes
418 for such updates e.g. for modelling multiple outcomes from function
419 calls, such as the various outcomes of "realloc". */
420
422{
423public:
424 virtual ~path_context () {}
425
426 /* Hook for clients to split state with a non-standard path. */
427 virtual void bifurcate (std::unique_ptr<custom_edge_info> info) = 0;
428
429 /* Hook for clients to terminate the standard path. */
430 virtual void terminate_path () = 0;
431
432 /* Hook for clients to determine if the standard path has been
433 terminated. */
434 virtual bool terminate_path_p () const = 0;
435};
436
437extern tree get_stashed_constant_by_name (const char *name);
439
441
442extern std::unique_ptr<json::value>
444
445extern std::unique_ptr<json::value>
447
448extern std::unique_ptr<json::value>
450
451extern std::unique_ptr<json::value>
453
454extern tristate
455compare_constants (tree lhs_const, enum tree_code op, tree rhs_const);
456
457extern tree
459
460extern tree
462
463extern const svalue *
465
466extern region_offset
468
470
471} // namespace ana
472
473extern bool is_special_named_call_p (const gcall &call, const char *funcname,
474 unsigned int num_args,
475 bool look_in_std = false);
476extern bool is_named_call_p (const_tree fndecl, const char *funcname);
477extern bool is_named_call_p (const_tree fndecl, const char *funcname,
478 const gcall &call, unsigned int num_args);
479extern bool is_std_function_p (const_tree fndecl);
480extern bool is_std_named_call_p (const_tree fndecl, const char *funcname);
481extern bool is_std_named_call_p (const_tree fndecl, const char *funcname,
482 const gcall &call, unsigned int num_args);
483extern bool is_setjmp_call_p (const gcall &call);
484extern bool is_longjmp_call_p (const gcall &call);
485extern bool is_placement_new_p (const gcall &call);
486extern bool is_cxa_throw_p (const gcall &call);
487extern bool is_cxa_rethrow_p (const gcall &call);
488
489extern const char *get_user_facing_name (const gcall &call);
490
492
493extern label_text make_label_text (bool can_colorize, const char *fmt, ...);
494extern label_text make_label_text_n (bool can_colorize,
495 unsigned HOST_WIDE_INT n,
496 const char *singular_fmt,
497 const char *plural_fmt, ...);
498
499extern bool fndecl_has_gimple_body_p (tree fndecl);
500
501/* An RAII-style class for pushing/popping cfun within a scope.
502 Doing so ensures we get "In function " announcements
503 from the diagnostics subsystem. */
504
506{
507public:
508 auto_cfun (function *fun) { push_cfun (fun); }
510};
511
512/* A template for creating hash traits for a POD type. */
513
514template <typename Type>
516{
517 typedef Type value_type;
518 typedef Type compare_type;
519 static inline hashval_t hash (value_type);
520 static inline bool equal (const value_type &existing,
521 const value_type &candidate);
522 static inline void mark_deleted (Type &);
523 static inline void mark_empty (Type &);
524 static inline bool is_deleted (Type);
525 static inline bool is_empty (Type);
526};
527
528/* A hash traits class that uses member functions to implement
529 the various required ops. */
530
531template <typename Type>
533{
534 typedef Type value_type;
535 typedef Type compare_type;
536 static inline hashval_t hash (value_type v) { return v.hash (); }
537 static inline bool equal (const value_type &existing,
538 const value_type &candidate)
539 {
540 return existing == candidate;
541 }
542 static inline void mark_deleted (Type &t) { t.mark_deleted (); }
543 static inline void mark_empty (Type &t) { t.mark_empty (); }
544 static inline bool is_deleted (Type t) { return t.is_deleted (); }
545 static inline bool is_empty (Type t) { return t.is_empty (); }
546};
547
548/* A map from T::key_t to T* for use in consolidating instances of T.
549 Owns all instances of T.
550 T::key_t should have operator== and be hashable. */
551
552template <typename T>
554{
555public:
556 typedef typename T::key_t key_t;
557 typedef T instance_t;
559 typedef typename inner_map_t::iterator iterator;
560
561 /* Delete all instances of T. */
562
564 {
565 for (typename inner_map_t::iterator iter = m_inner_map.begin ();
566 iter != m_inner_map.end (); ++iter)
567 delete (*iter).second;
568 }
569
570 /* Get the instance of T for K if one exists, or nullptr. */
571
572 T *get (const key_t &k) const
573 {
574 if (instance_t **slot = const_cast<inner_map_t &> (m_inner_map).get (k))
575 return *slot;
576 return nullptr;
577 }
578
579 /* Take ownership of INSTANCE. */
580
581 void put (const key_t &k, T *instance)
582 {
583 m_inner_map.put (k, instance);
584 }
585
586 size_t elements () const { return m_inner_map.elements (); }
587
588 iterator begin () const { return m_inner_map.begin (); }
589 iterator end () const { return m_inner_map.end (); }
590
591private:
593};
594
595/* Disable -Wformat-diag; we want to be able to use pp_printf
596 for logging/dumping without complying with the rules for diagnostics. */
597#if __GNUC__ >= 10
598#pragma GCC diagnostic ignored "-Wformat-diag"
599#endif
600
601#if !ENABLE_ANALYZER
602extern void sorry_no_analyzer ();
603#endif /* #if !ENABLE_ANALYZER */
604
605#endif /* GCC_ANALYZER_COMMON_H */
Definition analysis-plan.h:35
Definition region.h:1316
Definition constraint-manager.h:181
Definition common.h:315
virtual enum built_in_function builtin_code() const =0
const builtin_known_function * dyn_cast_builtin_kf() const final override
Definition common.h:324
tree builtin_decl() const
Definition common.h:318
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:384
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:386
Definition region.h:742
Definition region.h:879
Definition region-model.h:1352
Definition constraint-manager.h:255
Definition exploded-graph.h:396
Definition exploded-graph.h:806
Definition exploded-graph.h:205
Definition exploded-graph.h:967
Definition program-state.h:36
Definition exploded-graph.h:995
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:330
bool matches_call_types_p(const call_details &) const final override
Definition common.h:332
Definition known-function-manager.h:41
Definition common.h:295
virtual void impl_call_post(const call_details &) const
Definition common.h:303
virtual void impl_call_pre(const call_details &) const
Definition common.h:299
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:309
virtual ~known_function()
Definition common.h:297
Definition region.h:520
Definition analyzer-logging.h:34
Definition region.h:973
Definition common.h:422
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:424
bool operator==(const path_var &other) const
Definition common.h:179
int m_stack_depth
Definition common.h:193
path_var(tree t, int stack_depth)
Definition common.h:173
void dump(pretty_printer *pp) const
tree m_tree
Definition common.h:192
Definition pending-diagnostic.h:190
Definition pending-diagnostic.h:436
Definition common.h:360
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:226
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:209
bit_offset_t get_bit_offset() const
Definition common.h:234
bool symbolic_p() const
Definition common.h:232
const region * get_base_region() const
Definition common.h:229
bit_offset_t m_offset
Definition common.h:277
static region_offset make_byte_offset(const region *base_region, const svalue *num_bytes_sval)
const svalue * m_sym_offset
Definition common.h:278
static region_offset make_concrete(const region *base_region, bit_offset_t offset)
Definition common.h:216
void dump_to_pp(pretty_printer *pp, bool) const
region_offset()
Definition common.h:211
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:271
void dump(bool) const
bool operator==(const region_offset &other) const
Definition common.h:260
const svalue & calc_symbolic_bit_offset(region_model_manager *mgr) const
const region * m_base_region
Definition common.h:276
bool get_concrete_byte_offset(byte_offset_t *out) const
Definition common.h:240
static region_offset make_symbolic(const region *base_region, const svalue *sym_offset)
Definition common.h:221
const svalue * get_symbolic_byte_offset() const
Definition common.h:251
bool concrete_p() const
Definition common.h:231
Definition region.h:126
Definition region-model.h:1292
Definition exploded-graph.h:472
Definition diagnostic-manager.h:31
Definition region.h:1067
Definition program-state.h:94
Definition checker-event.h:379
Definition sm.h:41
Definition state-purge.h:78
Definition state-purge.h:194
Definition state-purge.h:162
Definition exploded-graph.h:1053
Definition store.h:871
Definition store.h:746
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:827
~auto_cfun()
Definition common.h:509
auto_cfun(function *fun)
Definition common.h:508
Definition common.h:554
inner_map_t::iterator iterator
Definition common.h:559
inner_map_t m_inner_map
Definition common.h:592
T * get(const key_t &k) const
Definition common.h:572
T::key_t key_t
Definition common.h:556
~consolidation_map()
Definition common.h:563
iterator begin() const
Definition common.h:588
T instance_t
Definition common.h:557
hash_map< key_t, instance_t * > inner_map_t
Definition common.h:558
void put(const key_t &k, T *instance)
Definition common.h:581
size_t elements() const
Definition common.h:586
iterator end() const
Definition common.h:589
Definition diagnostic-event-id.h:37
Definition genmatch.cc:1506
Definition graphviz.h:375
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:4756
void pop_cfun(void)
Definition function.cc:4782
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:199
@ 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:196
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:371
@ read
Definition common.h:372
@ write
Definition common.h:373
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:198
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:197
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:80
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:1243
Definition diagnostic-manager.h:108
Definition exploded-graph.h:680
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:533
static void mark_empty(Type &t)
Definition common.h:543
static hashval_t hash(value_type v)
Definition common.h:536
Type compare_type
Definition common.h:535
Type value_type
Definition common.h:534
static bool equal(const value_type &existing, const value_type &candidate)
Definition common.h:537
static void mark_deleted(Type &t)
Definition common.h:542
static bool is_empty(Type t)
Definition common.h:545
static bool is_deleted(Type t)
Definition common.h:544
Definition common.h:516
static void mark_deleted(Type &)
Type compare_type
Definition common.h:518
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:517
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 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