GCC Middle and Back End API Reference
value-relation.h
Go to the documentation of this file.
1/* Header file for the value range relational processing.
2 Copyright (C) 2020-2025 Free Software Foundation, Inc.
3 Contributed by Andrew MacLeod <amacleod@redhat.com>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 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_VALUE_RELATION_H
22#define GCC_VALUE_RELATION_H
23
24
25// This file provides access to a relation oracle which can be used to
26// maintain and query relations and equivalences between SSA_NAMES.
27//
28// The general range_query object provided in value-query.h provides
29// access to an oracle, if one is available, via the oracle() method.
30// There are also a couple of access routines provided, which even if there is
31// no oracle, will return the default VREL_VARYING no relation.
32//
33// Typically, when a ranger object is active, there will be an oracle, and
34// any information available can be directly queried. Ranger also sets and
35// utilizes the relation information to enhance it's range calculations, this
36// is totally transparent to the client, and they are free to make queries.
37//
38// relation_kind is a new enum which represents the different relations,
39// often with a direct mapping to tree codes. ie VREL_EQ is equivalent to
40// EQ_EXPR.
41//
42// A query is made requesting the relation between SSA1 and SSA@ in a basic
43// block, or on an edge, the possible return values are:
44//
45// VREL_EQ, VREL_NE, VREL_LT, VREL_LE, VREL_GT, and VREL_GE mean the same.
46// VREL_VARYING : No relation between the 2 names.
47// VREL_UNDEFINED : Impossible relation (ie, A < B && A > B)
48//
49// The oracle maintains VREL_EQ relations with equivalency sets, so if a
50// relation comes back VREL_EQ, it is also possible to query the set of
51// equivalencies. These are basically bitmaps over ssa_names. An iterator is
52// provided later for this activity.
53//
54// Relations are maintained via the dominance trees and are optimized assuming
55// they are registered in dominance order. When a new relation is added, it
56// is intersected with whatever existing relation exists in the dominance tree
57// and registered at the specified block.
58
59
60// These codes are arranged such that VREL_VARYING is the first code, and all
61// the rest are contiguous.
62
63typedef enum relation_kind_t
64{
65 VREL_VARYING = 0, // No known relation, AKA varying.
66 VREL_UNDEFINED, // Impossible relation, ie (r1 < r2) && (r2 > r1)
67 VREL_LT, // r1 < r2
68 VREL_LE, // r1 <= r2
69 VREL_GT, // r1 > r2
70 VREL_GE, // r1 >= r2
71 VREL_EQ, // r1 == r2
72 VREL_NE, // r1 != r2
73 VREL_PE8, // 8 bit partial equivalency
74 VREL_PE16, // 16 bit partial equivalency
75 VREL_PE32, // 32 bit partial equivalency
76 VREL_PE64, // 64 bit partial equivalency
77 VREL_LAST // terminate, not a real relation.
79
80// General relation kind transformations.
86 { return (r >= VREL_LT && r <= VREL_GE); }
88 { return (r >= VREL_PE8 && r <= VREL_PE64); }
90 { return r == VREL_EQ || relation_partial_equiv_p (r); }
91
92void print_relation (FILE *f, relation_kind rel);
93
94// Adjust range as an equivalence.
96
98{
99public:
100 virtual ~relation_oracle () { }
101
102 // register a relation between 2 ssa names.
103 void record (gimple *, relation_kind, tree, tree);
106
107 // Query if there is any relation between SSA1 and SSA2.
108 relation_kind query (gimple *s, tree ssa1, tree ssa2);
109 relation_kind query (edge e, tree ssa1, tree ssa2);
111
112 virtual void dump (FILE *, basic_block) const { }
113 virtual void dump (FILE *) const { }
114 void debug () const;
115protected:
120 tree) const
121 { return NULL; }
122 // Return equivalency set for an SSA name in a basic block.
124 // Return partial equivalency record for an SSA name.
125 virtual const class pe_slice *partial_equiv_set (tree) { return NULL; }
126 void valid_equivs (bitmap b, const_bitmap equivs, basic_block bb);
127 // Query for a relation between two equivalency sets in a basic block.
130 friend class path_oracle;
131};
132
133// Instance with no storage used for default queries with no active oracle.
135
136// This class represents an equivalency set, and contains a link to the next
137// one in the list to be searched.
138
140{
141public:
142 bitmap m_names; // ssa-names in equiv set.
143 basic_block m_bb; // Block this belongs to
144 equiv_chain *m_next; // Next in block list.
145 void dump (FILE *f) const; // Show names in this list.
146 equiv_chain *find (unsigned ssa);
147};
148
150{
151public:
152 tree ssa_base; // Slice of this name.
153 relation_kind code; // bits that are equivalent.
154 bitmap members; // Other members in the partial equivalency.
155};
156
157// The equivalency oracle maintains equivalencies using the dominator tree.
158// Equivalencies apply to an entire basic block. Equivalencies on edges
159// can be represented only on edges whose destination is a single-pred block,
160// and the equivalence is simply applied to that successor block.
161
163{
164public:
165 equiv_oracle ();
166 ~equiv_oracle ();
167
168 const_bitmap equiv_set (tree ssa, basic_block bb) final override;
169 void record (basic_block bb, relation_kind k, tree ssa1, tree ssa2) override;
170
171 relation_kind partial_equiv (tree ssa1, tree ssa2, tree *base = NULL) const;
174 void dump (FILE *f, basic_block bb) const override;
175 void dump (FILE *f) const override;
176
177protected:
179 const pe_slice *partial_equiv_set (tree name) final override;
180 inline bool has_equiv_p (unsigned v) { return bitmap_bit_p (m_equiv_set, v); }
183private:
184 bitmap m_equiv_set; // Index by ssa-name. true if an equivalence exists.
185 vec <equiv_chain *> m_equiv; // Index by BB. list of equivalences.
186 vec <bitmap> m_self_equiv; // Index by ssa-name, self equivalency set.
187 vec <pe_slice> m_partial; // Partial equivalencies.
188
189 void limit_check (basic_block bb = NULL);
190 equiv_chain *find_equiv_block (unsigned ssa, int bb) const;
191 equiv_chain *find_equiv_dom (tree name, basic_block bb) const;
192
193 bitmap register_equiv (basic_block bb, unsigned v, equiv_chain *equiv_1);
195 equiv_chain *equiv_2);
196 void register_initial_def (tree ssa);
197 void add_equiv_to_block (basic_block bb, bitmap equiv);
198};
199
200// Summary block header for relations.
201
203{
204public:
205 bitmap m_names; // ssa_names with relations in this block.
206 class relation_chain *m_head; // List of relations in block.
207 int m_num_relations; // Number of relations in block.
209};
210
211// A relation oracle maintains a set of relations between ssa_names using the
212// dominator tree structures. Equivalencies are considered a subset of
213// a general relation and maintained by an equivalence oracle by transparently
214// passing any EQ_EXPR relations to it.
215// Relations are handled at the basic block level. All relations apply to
216// an entire block, and are thus kept in a summary index by block.
217// Similar to the equivalence oracle, edges are handled by applying the
218// relation to the destination block of the edge, but ONLY if that block
219// has a single successor. For now.
220
222{
223public:
224 dom_oracle (bool do_trans_p = true);
225 ~dom_oracle ();
226
227 void record (basic_block bb, relation_kind k, tree op1, tree op2)
228 final override;
229
230 relation_kind query (basic_block bb, tree ssa1, tree ssa2) final override;
232 final override;
233
234 void dump (FILE *f, basic_block bb) const final override;
235 void dump (FILE *f) const final override;
236protected:
238 tree) const;
241 bitmap m_relation_set; // Index by ssa-name. True if a relation exists
242 vec <relation_chain_head> m_relations; // Index by BB, list of relations.
244 const_bitmap b2) const;
245 relation_kind find_relation_block (int bb, unsigned v1, unsigned v2,
246 relation_chain **obj = NULL) const;
247 relation_kind find_relation_dom (basic_block bb, unsigned v1, unsigned v2) const;
249 tree op2);
250 void register_transitives (basic_block, const class value_relation &);
251
252};
253
254// A path_oracle implements relations in a list. The only sense of ordering
255// is the latest registered relation is the first found during a search.
256// It can be constructed with an optional "root" oracle which will be used
257// to look up any relations not found in the list.
258// This allows the client to walk paths starting at some block and register
259// and query relations along that path, ignoring other edges.
260//
261// For registering a relation, a query if made of the root oracle if there is
262// any known relationship at block BB, and it is combined with this new
263// relation and entered in the list.
264//
265// Queries are resolved by looking first in the list, and only if nothing is
266// found is the root oracle queried at block BB.
267//
268// reset_path is used to clear all locally registered paths to initial state.
269
271{
272public:
273 path_oracle (relation_oracle *oracle = NULL);
274 ~path_oracle ();
275 const_bitmap equiv_set (tree, basic_block) final override;
276 void record (basic_block, relation_kind, tree, tree) final override;
277 void killing_def (tree);
278 relation_kind query (basic_block, tree, tree) final override;
280 void reset_path (relation_oracle *oracle = NULL);
281 void set_root_oracle (relation_oracle *oracle) { m_root = oracle; }
282 void dump (FILE *, basic_block) const final override;
283 void dump (FILE *) const final override;
284private:
285 void register_equiv (basic_block bb, tree ssa1, tree ssa2);
290
293};
294
295// Used to assist with iterating over the equivalence list.
297public:
299 bool full = true, bool partial = false);
300 void next ();
302protected:
307 unsigned m_y;
309};
310
311#define FOR_EACH_EQUIVALENCE(oracle, bb, name, equiv_name) \
312 for (equiv_relation_iterator iter (oracle, bb, name, true, false); \
313 ((equiv_name) = iter.get_name ()); \
314 iter.next ())
315
316#define FOR_EACH_PARTIAL_EQUIV(oracle, bb, name, equiv_name, equiv_rel) \
317 for (equiv_relation_iterator iter (oracle, bb, name, false, true); \
318 ((equiv_name) = iter.get_name (&equiv_rel)); \
319 iter.next ())
320
321#define FOR_EACH_PARTIAL_AND_FULL_EQUIV(oracle, bb, name, equiv_name, \
322 equiv_rel) \
323 for (equiv_relation_iterator iter (oracle, bb, name, true, true); \
324 ((equiv_name) = iter.get_name (&equiv_rel)); \
325 iter.next ())
326
327// -----------------------------------------------------------------------
328
329// Range-ops deals with a LHS and 2 operands. A relation trio is a set of
330// 3 potential relations packed into a single unsigned value.
331// 1 - LHS relation OP1
332// 2 - LHS relation OP2
333// 3 - OP1 relation OP2
334// VREL_VARYING is a value of 0, and is the default for each position.
353
354// Default VREL_VARYING for all 3 relations.
355#define TRIO_VARYING relation_trio ()
356
357#define TRIO_SHIFT 4
358#define TRIO_MASK 0x000F
359
360// These 3 classes are shortcuts for when a caller has a single relation to
361// pass as a trio, it can simply construct the appropriate one. The other
362// unspecified relations will be VREL_VARYING.
363
365{
367 m_val = 0;
368}
369
373{
375 unsigned i1 = (unsigned) lhs_op1;
376 unsigned i2 = ((unsigned) lhs_op2) << TRIO_SHIFT;
377 unsigned i3 = ((unsigned) op1_op2) << (TRIO_SHIFT * 2);
378 m_val = i1 | i2 | i3;
379}
380
381inline relation_trio
386inline relation_trio
391inline relation_trio
396
397inline relation_kind
402
403inline relation_kind
408
409inline relation_kind
411{
412 return (relation_kind) ((m_val >> (TRIO_SHIFT * 2)) & TRIO_MASK);
413}
414
415inline relation_trio
420
421// -----------------------------------------------------------------------
422
423// The value-relation class is used to encapsulate the representation of an
424// individual relation between 2 ssa-names, and to facilitate operating on
425// the relation.
426
428{
429public:
432 void set_relation (relation_kind kind, tree n1, tree n2);
433
434 inline relation_kind kind () const { return related; }
435 inline tree op1 () const { return name1; }
436 inline tree op2 () const { return name2; }
437
439 bool union_ (value_relation &p);
440 bool intersect (value_relation &p);
441 void swap ();
442 bool apply_transitive (const value_relation &rel);
443
444 void dump (FILE *f) const;
445private:
448};
449
450// Set relation R between ssa_name N1 and N2.
451
452inline void
454{
455 gcc_checking_assert (TREE_CODE (n1) == SSA_NAME
456 && TREE_CODE (n2) == SSA_NAME);
457 related = r;
458 name1 = n1;
459 name2 = n2;
460}
461
462// Default constructor.
463
464inline
471
472// Constructor for relation R between SSA version N1 and N2.
473
474inline
479
480
492
493#define FOR_EACH_RELATION_BB(oracle, bb, vr) \
494 for (block_relation_iterator iter (oracle, bb, vr); \
495 !iter.m_done; \
496 iter.get_next_relation (vr))
497
498#define FOR_EACH_RELATION_NAME(oracle, bb, name, vr) \
499 for (block_relation_iterator iter (oracle, bb, vr, name); \
500 !iter.m_done; \
501 iter.get_next_relation (vr))
502
503
504// Return the number of bits associated with partial equivalency T.
505// Return 0 if this is not a supported partial equivalency relation.
506
507inline int
509{
510 switch (t)
511 {
512 case VREL_PE8:
513 return 8;
514 case VREL_PE16:
515 return 16;
516 case VREL_PE32:
517 return 32;
518 case VREL_PE64:
519 return 64;
520 default:
521 return 0;
522 }
523}
524
525// Return the partial equivalency code associated with the number of BITS.
526// return VREL_VARYING if there is no exact match.
527
528inline relation_kind
529bits_to_pe (int bits)
530{
531 switch (bits)
532 {
533 case 8:
534 return VREL_PE8;
535 case 16:
536 return VREL_PE16;
537 case 32:
538 return VREL_PE32;
539 case 64:
540 return VREL_PE64;
541 default:
542 return VREL_VARYING;
543 }
544}
545
546// Given partial equivalencies T1 and T2, return the smallest kind.
547
548inline relation_kind
550{
553 // VREL_PE are declared small to large, so simple min will suffice.
554 return MIN (t1, t2);
555}
556#endif /* GCC_VALUE_RELATION_H */
const relation_oracle * m_oracle
Definition value-relation.h:486
basic_block m_bb
Definition value-relation.h:487
void get_next_relation(value_relation &vr)
Definition value-relation.cc:1013
block_relation_iterator(const relation_oracle *oracle, basic_block bb, value_relation &, tree name=NULL)
Definition value-relation.cc:992
bool m_done
Definition value-relation.h:489
tree m_name
Definition value-relation.h:490
relation_chain * m_ptr
Definition value-relation.h:488
void record(basic_block bb, relation_kind k, tree op1, tree op2) final override
Definition value-relation.cc:1157
bitmap m_tmp2
Definition value-relation.h:240
relation_chain * set_one_relation(basic_block bb, relation_kind k, tree op1, tree op2)
Definition value-relation.cc:1186
relation_kind find_relation_dom(basic_block bb, unsigned v1, unsigned v2) const
Definition value-relation.cc:1455
~dom_oracle()
Definition value-relation.cc:1076
void register_transitives(basic_block, const class value_relation &)
Definition value-relation.cc:1265
bool m_do_trans_p
Definition value-relation.h:239
void dump(FILE *f, basic_block bb) const final override
Definition value-relation.cc:1513
bitmap m_relation_set
Definition value-relation.h:241
relation_kind query(basic_block bb, tree ssa1, tree ssa2) final override
Definition value-relation.cc:1476
relation_kind find_relation_block(unsigned bb, const_bitmap b1, const_bitmap b2) const
Definition value-relation.cc:1376
dom_oracle(bool do_trans_p=true)
Definition value-relation.cc:1064
bitmap m_tmp
Definition value-relation.h:240
virtual relation_chain * next_relation(basic_block, relation_chain *, tree) const
Definition value-relation.cc:965
vec< relation_chain_head > m_relations
Definition value-relation.h:242
Definition value-relation.h:140
void dump(FILE *f) const
Definition value-relation.cc:295
equiv_chain * find(unsigned ssa)
Definition value-relation.cc:278
equiv_chain * m_next
Definition value-relation.h:144
bitmap m_names
Definition value-relation.h:142
basic_block m_bb
Definition value-relation.h:143
relation_kind partial_equiv(tree ssa1, tree ssa2, tree *base=NULL) const
Definition value-relation.cc:435
bool has_equiv_p(unsigned v)
Definition value-relation.h:180
equiv_chain * find_equiv_dom(tree name, basic_block bb) const
Definition value-relation.cc:520
const_bitmap equiv_set(tree ssa, basic_block bb) final override
Definition value-relation.cc:459
vec< pe_slice > m_partial
Definition value-relation.h:187
bitmap m_equiv_set
Definition value-relation.h:184
bitmap_obstack m_bitmaps
Definition value-relation.h:181
void record(basic_block bb, relation_kind k, tree ssa1, tree ssa2) override
Definition value-relation.cc:632
void limit_check(basic_block bb=NULL)
Definition value-relation.cc:723
struct obstack m_chain_obstack
Definition value-relation.h:182
vec< bitmap > m_self_equiv
Definition value-relation.h:186
~equiv_oracle()
Definition value-relation.cc:334
equiv_oracle()
Definition value-relation.cc:318
void add_partial_equiv(relation_kind, tree, tree)
Definition value-relation.cc:346
void dump(FILE *f, basic_block bb) const override
Definition value-relation.cc:733
relation_kind query(basic_block, tree, tree) override
Definition value-relation.cc:482
equiv_chain * find_equiv_block(unsigned ssa, int bb) const
Definition value-relation.cc:508
vec< equiv_chain * > m_equiv
Definition value-relation.h:185
const pe_slice * partial_equiv_set(tree name) final override
Definition value-relation.cc:422
void add_equiv_to_block(basic_block bb, bitmap equiv)
Definition value-relation.cc:692
void register_initial_def(tree ssa)
Definition value-relation.cc:606
bitmap register_equiv(basic_block bb, unsigned v, equiv_chain *equiv_1)
Definition value-relation.cc:542
const pe_slice * m_pe
Definition value-relation.h:305
tree get_name(relation_kind *rel=NULL)
Definition value-relation.cc:1824
tree m_name
Definition value-relation.h:308
relation_oracle * m_oracle
Definition value-relation.h:303
unsigned m_y
Definition value-relation.h:307
bitmap_iterator m_bi
Definition value-relation.h:306
const_bitmap m_bm
Definition value-relation.h:304
void next()
Definition value-relation.cc:1815
equiv_relation_iterator(relation_oracle *oracle, basic_block bb, tree name, bool full=true, bool partial=false)
Definition value-relation.cc:1796
equiv_chain m_equiv
Definition value-relation.h:286
relation_kind query(basic_block, tree, tree) final override
Definition value-relation.cc:1731
relation_oracle * m_root
Definition value-relation.h:288
void reset_path(relation_oracle *oracle=NULL)
Definition value-relation.cc:1751
void dump(FILE *, basic_block) const final override
Definition value-relation.cc:1764
void record(basic_block, relation_kind, tree, tree) final override
Definition value-relation.cc:1670
void killing_def(tree)
Definition value-relation.cc:1623
struct obstack m_chain_obstack
Definition value-relation.h:292
bitmap_obstack m_bitmaps
Definition value-relation.h:291
path_oracle(relation_oracle *oracle=NULL)
Definition value-relation.cc:1551
bitmap m_killed_defs
Definition value-relation.h:289
void set_root_oracle(relation_oracle *oracle)
Definition value-relation.h:281
~path_oracle()
Definition value-relation.cc:1566
void register_equiv(basic_block bb, tree ssa1, tree ssa2)
Definition value-relation.cc:1597
const_bitmap equiv_set(tree, basic_block) final override
Definition value-relation.cc:1576
relation_chain_head m_relations
Definition value-relation.h:287
Definition value-relation.h:150
tree ssa_base
Definition value-relation.h:152
relation_kind code
Definition value-relation.h:153
bitmap members
Definition value-relation.h:154
Definition value-relation.h:203
relation_kind find_relation(const_bitmap b1, const_bitmap b2) const
Definition value-relation.cc:1038
bitmap m_names
Definition value-relation.h:205
int m_num_relations
Definition value-relation.h:207
class relation_chain * m_head
Definition value-relation.h:206
Definition value-relation.cc:954
Definition value-relation.h:98
relation_kind query(gimple *s, tree ssa1, tree ssa2)
Definition value-relation.cc:236
virtual void dump(FILE *, basic_block) const
Definition value-relation.h:112
virtual ~relation_oracle()
Definition value-relation.h:100
virtual relation_kind query(basic_block, tree, tree)
Definition value-relation.h:110
friend class path_oracle
Definition value-relation.h:130
virtual void dump(FILE *) const
Definition value-relation.h:113
void debug() const
Definition value-relation.cc:1546
virtual const class pe_slice * partial_equiv_set(tree)
Definition value-relation.h:125
virtual void record(basic_block, relation_kind, tree, tree)
Definition value-relation.h:105
void valid_equivs(bitmap b, const_bitmap equivs, basic_block bb)
Definition value-relation.cc:215
void record(gimple *, relation_kind, tree, tree)
Definition value-relation.cc:1084
virtual relation_kind query(basic_block, const_bitmap, const_bitmap)
Definition value-relation.h:128
friend class block_relation_iterator
Definition value-relation.h:117
virtual const_bitmap equiv_set(tree, basic_block)
Definition value-relation.h:123
virtual class relation_chain * next_relation(basic_block, relation_chain *, tree) const
Definition value-relation.h:118
friend class equiv_relation_iterator
Definition value-relation.h:116
Definition value-relation.h:336
relation_kind op1_op2()
Definition value-relation.h:410
relation_kind lhs_op2()
Definition value-relation.h:404
unsigned m_val
Definition value-relation.h:351
relation_trio swap_op1_op2()
Definition value-relation.h:416
relation_trio()
Definition value-relation.h:364
relation_kind lhs_op1()
Definition value-relation.h:398
Definition value-relation.h:428
tree name1
Definition value-relation.h:447
relation_trio create_trio(tree lhs, tree op1, tree op2)
Definition value-relation.cc:903
tree name2
Definition value-relation.h:447
bool union_(value_relation &p)
Definition value-relation.cc:817
void set_relation(relation_kind kind, tree n1, tree n2)
Definition value-relation.h:453
void dump(FILE *f) const
Definition value-relation.cc:937
value_relation()
Definition value-relation.h:465
relation_kind kind() const
Definition value-relation.h:434
relation_kind related
Definition value-relation.h:446
bool apply_transitive(const value_relation &rel)
Definition value-relation.cc:836
tree op1() const
Definition value-relation.h:435
void swap()
Definition value-relation.cc:787
tree op2() const
Definition value-relation.h:436
bool intersect(value_relation &p)
Definition value-relation.cc:799
Definition value-range.h:78
struct basic_block_def * basic_block
Definition coretypes.h:355
class edge_def * edge
Definition coretypes.h:352
const class bitmap_head * const_bitmap
Definition coretypes.h:52
class bitmap_head * bitmap
Definition coretypes.h:51
union tree_node * tree
Definition coretypes.h:97
int i2
Definition fp-test.cc:66
int i1
Definition fp-test.cc:66
static struct obstack obstack
Definition gcc.cc:364
#define bitmap_bit_p(bitstring, bitno)
Definition genautomata.cc:3429
poly_int< N, C > r
Definition poly-int.h:774
Ca const poly_int< N, Cb > & b
Definition poly-int.h:771
Definition bitmap.h:519
Definition bitmap.h:294
Definition gimple.h:221
#define NULL
Definition system.h:50
#define MIN(X, Y)
Definition system.h:396
#define STATIC_ASSERT(X)
Definition system.h:864
#define gcc_checking_assert(EXPR)
Definition system.h:821
#define TREE_CODE(NODE)
Definition tree.h:324
#define NULL_TREE
Definition tree.h:317
relation_oracle default_relation_oracle
Definition value-query.cc:183
void adjust_equivalence_range(vrange &range)
Definition value-relation.cc:191
#define TRIO_MASK
Definition value-relation.h:358
enum relation_kind_t relation_kind
#define TRIO_SHIFT
Definition value-relation.h:357
relation_kind relation_intersect(relation_kind r1, relation_kind r2)
Definition value-relation.cc:105
int pe_to_bits(relation_kind t)
Definition value-relation.h:508
relation_kind_t
Definition value-relation.h:64
@ VREL_PE8
Definition value-relation.h:73
@ VREL_PE16
Definition value-relation.h:74
@ VREL_GT
Definition value-relation.h:69
@ VREL_LT
Definition value-relation.h:67
@ VREL_LE
Definition value-relation.h:68
@ VREL_LAST
Definition value-relation.h:77
@ VREL_NE
Definition value-relation.h:72
@ VREL_EQ
Definition value-relation.h:71
@ VREL_PE32
Definition value-relation.h:75
@ VREL_VARYING
Definition value-relation.h:65
@ VREL_UNDEFINED
Definition value-relation.h:66
@ VREL_GE
Definition value-relation.h:70
@ VREL_PE64
Definition value-relation.h:76
relation_kind relation_union(relation_kind r1, relation_kind r2)
Definition value-relation.cc:142
relation_kind pe_min(relation_kind t1, relation_kind t2)
Definition value-relation.h:549
void print_relation(FILE *f, relation_kind rel)
Definition value-relation.cc:42
bool relation_partial_equiv_p(relation_kind r)
Definition value-relation.h:87
relation_kind bits_to_pe(int bits)
Definition value-relation.h:529
bool relation_equiv_p(relation_kind r)
Definition value-relation.h:89
relation_kind relation_swap(relation_kind r)
Definition value-relation.cc:68
relation_kind relation_negate(relation_kind r)
Definition value-relation.cc:55
bool relation_lt_le_gt_ge_p(relation_kind r)
Definition value-relation.h:85