Line data Source code
1 : /* Header file for gimple ranger SSA cache.
2 : Copyright (C) 2017-2026 Free Software Foundation, Inc.
3 : Contributed by Andrew MacLeod <amacleod@redhat.com>.
4 :
5 : This file is part of GCC.
6 :
7 : GCC is free software; you can redistribute it and/or modify it under
8 : the terms of the GNU General Public License as published by the Free
9 : Software Foundation; either version 3, or (at your option) any later
10 : version.
11 :
12 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 : for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with GCC; see the file COPYING3. If not see
19 : <http://www.gnu.org/licenses/>. */
20 :
21 : #ifndef GCC_SSA_RANGE_CACHE_H
22 : #define GCC_SSA_RANGE_CACHE_H
23 :
24 : #include "gimple-range-gori.h"
25 : #include "gimple-range-infer.h"
26 : #include "gimple-range-phi.h"
27 :
28 : // This class manages a vector of pointers to ssa_block ranges. It
29 : // provides the basis for the "range on entry" cache for all
30 : // SSA names.
31 :
32 : class block_range_cache
33 : {
34 : public:
35 : block_range_cache ();
36 : ~block_range_cache ();
37 :
38 : bool set_bb_range (tree name, const_basic_block bb, const vrange &v);
39 : bool get_bb_range (vrange &v, tree name, const_basic_block bb);
40 : bool bb_range_p (tree name, const_basic_block bb);
41 : void clear (tree name);
42 :
43 : void dump (FILE *f);
44 : void dump (FILE *f, basic_block bb, bool print_varying = true);
45 : private:
46 : vec<class ssa_block_ranges *> m_ssa_ranges;
47 : ssa_block_ranges &get_block_ranges (tree name);
48 : ssa_block_ranges *query_block_ranges (tree name);
49 : class vrange_allocator *m_range_allocator;
50 : bitmap_obstack m_bitmaps;
51 : };
52 :
53 : // This global cache is used with the range engine as markers for what
54 : // has been visited during this incarnation. Once the ranger evaluates
55 : // a name, it is typically not re-evaluated again.
56 :
57 : class ssa_cache : public range_query
58 : {
59 : public:
60 : ssa_cache ();
61 : ~ssa_cache ();
62 : virtual bool has_range (tree name) const;
63 : virtual bool get_range (vrange &r, tree name) const;
64 : virtual bool set_range (tree name, const vrange &r);
65 : virtual bool merge_range (tree name, const vrange &r);
66 : virtual void clear_range (tree name);
67 : virtual void clear ();
68 : void dump (FILE *f = stderr);
69 : virtual bool range_of_expr (vrange &r, tree expr, gimple *stmt = NULL);
70 : protected:
71 : vec<vrange_storage *> m_tab;
72 : vrange_allocator *m_range_allocator;
73 : };
74 :
75 : // This is the same as global cache, except it maintains an active bitmap
76 : // rather than depending on a zero'd out vector of pointers. This is better
77 : // for sparsely/lightly used caches.
78 :
79 : class ssa_lazy_cache : public ssa_cache
80 : {
81 : public:
82 : ssa_lazy_cache (bitmap_obstack *ob = NULL);
83 : ~ssa_lazy_cache ();
84 94 : inline bool empty_p () const { return bitmap_empty_p (active_p); }
85 : virtual bool has_range (tree name) const;
86 : virtual bool set_range (tree name, const vrange &r);
87 : virtual bool merge_range (tree name, const vrange &r);
88 : virtual bool get_range (vrange &r, tree name) const;
89 : virtual void clear_range (tree name);
90 : virtual void clear ();
91 : void merge (const ssa_lazy_cache &);
92 : protected:
93 : bitmap_obstack m_bitmaps;
94 : bitmap_obstack *m_ob;
95 : bitmap active_p;
96 : };
97 :
98 : // This class provides all the caches a global ranger may need, and makes
99 : // them available for gori-computes to query so outgoing edges can be
100 : // properly calculated.
101 :
102 : class ranger_cache : public range_query
103 : {
104 : public:
105 : ranger_cache (int not_executable_flag, bool use_imm_uses);
106 : ~ranger_cache ();
107 :
108 : bool range_of_expr (vrange &r, tree name, gimple *stmt) final override;
109 : bool range_on_edge (vrange &r, edge e, tree expr) final override;
110 : bool block_range (vrange &r, basic_block bb, tree name, bool calc = true);
111 :
112 : bool get_global_range (vrange &r, tree name) const;
113 : bool get_global_range (vrange &r, tree name, bool ¤t_p);
114 : void set_global_range (tree name, const vrange &r, bool changed = true);
115 : void mark_stale (tree name);
116 : void update_consumers (tree name);
117 0 : range_query &const_query () { return m_globals; }
118 :
119 : void propagate_updated_value (tree name, basic_block bb);
120 :
121 : void register_inferred_value (const vrange &r, tree name, basic_block bb);
122 : void apply_inferred_ranges (gimple *s);
123 :
124 : void reset_range_info (tree name);
125 :
126 : void dump_bb (FILE *f, basic_block bb);
127 : virtual void dump (FILE *f) override;
128 : private:
129 : ssa_cache m_globals;
130 : block_range_cache m_on_entry;
131 : class temporal_cache *m_temporal;
132 : void fill_block_cache (tree name, basic_block bb, basic_block def_bb);
133 : void propagate_cache (tree name);
134 :
135 : enum rfd_mode
136 : {
137 : RFD_NONE, // Only look at current block cache.
138 : RFD_READ_ONLY, // Scan DOM tree, do not write to cache.
139 : RFD_FILL // Scan DOM tree, updating important nodes.
140 : };
141 : bool range_from_dom (vrange &r, tree name, basic_block bb, enum rfd_mode);
142 : void resolve_dom (vrange &r, tree name, basic_block bb);
143 : void range_of_def (vrange &r, tree name, basic_block bb = NULL);
144 : void entry_range (vrange &r, tree expr, basic_block bb, enum rfd_mode);
145 : void exit_range (vrange &r, tree expr, basic_block bb, enum rfd_mode);
146 : bool edge_range (vrange &r, edge e, tree name, enum rfd_mode);
147 :
148 : vec<basic_block> m_workback;
149 : class update_list *m_update;
150 : bitmap m_stale;
151 : };
152 :
153 : #endif // GCC_SSA_RANGE_CACHE_H
|
