Don't warn when alignment of global common data exceeds maximum alignment.
[official-gcc.git] / gcc / gimple-range-edge.cc
blobd11153e677e74d088667e52a1830f62fbfd7daa3
1 /* Gimple range edge functionaluity.
2 Copyright (C) 2020-2021 Free Software Foundation, Inc.
3 Contributed by Andrew MacLeod <amacleod@redhat.com>
4 and Aldy Hernandez <aldyh@redhat.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "backend.h"
27 #include "tree.h"
28 #include "gimple.h"
29 #include "ssa.h"
30 #include "gimple-pretty-print.h"
31 #include "gimple-iterator.h"
32 #include "tree-cfg.h"
33 #include "gimple-range.h"
35 // If there is a range control statment at the end of block BB, return it.
36 // Otherwise return NULL.
38 gimple *
39 gimple_outgoing_range_stmt_p (basic_block bb)
41 gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
42 if (!gsi_end_p (gsi))
44 gimple *s = gsi_stmt (gsi);
45 if (is_a<gcond *> (s) && gimple_range_handler (s))
46 return gsi_stmt (gsi);
47 gswitch *sw = dyn_cast<gswitch *> (s);
48 if (sw && irange::supports_type_p (TREE_TYPE (gimple_switch_index (sw))))
49 return gsi_stmt (gsi);
51 return NULL;
55 // Return a TRUE or FALSE range representing the edge value of a GCOND.
57 void
58 gcond_edge_range (irange &r, edge e)
60 gcc_checking_assert (e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE));
61 if (e->flags & EDGE_TRUE_VALUE)
62 r = int_range<2> (boolean_true_node, boolean_true_node);
63 else
64 r = int_range<2> (boolean_false_node, boolean_false_node);
68 gimple_outgoing_range::gimple_outgoing_range ()
70 m_edge_table = NULL;
74 gimple_outgoing_range::~gimple_outgoing_range ()
76 if (m_edge_table)
77 delete m_edge_table;
81 // Get a range for a switch edge E from statement S and return it in R.
82 // Use a cached value if it exists, or calculate it if not.
84 bool
85 gimple_outgoing_range::get_edge_range (irange &r, gimple *s, edge e)
87 gcc_checking_assert (is_a<gswitch *> (s));
88 gswitch *sw = as_a<gswitch *> (s);
90 // ADA currently has cases where the index is 64 bits and the case
91 // arguments are 32 bit, causing a trap when we create a case_range.
92 // Until this is resolved (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87798)
93 // punt on switches where the labels dont match the argument.
94 if (gimple_switch_num_labels (sw) > 1 &&
95 TYPE_PRECISION (TREE_TYPE (CASE_LOW (gimple_switch_label (sw, 1)))) !=
96 TYPE_PRECISION (TREE_TYPE (gimple_switch_index (sw))))
97 return false;
99 if (!m_edge_table)
100 m_edge_table = new hash_map<edge, irange *> (n_edges_for_fn (cfun));
102 irange **val = m_edge_table->get (e);
103 if (!val)
105 calc_switch_ranges (sw);
106 val = m_edge_table->get (e);
107 gcc_checking_assert (val);
109 r = **val;
110 return true;
114 // Calculate all switch edges from SW and cache them in the hash table.
116 void
117 gimple_outgoing_range::calc_switch_ranges (gswitch *sw)
119 bool existed;
120 unsigned x, lim;
121 lim = gimple_switch_num_labels (sw);
122 tree type = TREE_TYPE (gimple_switch_index (sw));
123 edge default_edge = gimple_switch_default_edge (cfun, sw);
125 // This should be the first call into this switch.
127 // Allocate an int_range_max for the default range case, start with
128 // varying and intersect each other case from it.
129 int_range_max default_range (type);
131 for (x = 1; x < lim; x++)
133 edge e = gimple_switch_edge (cfun, sw, x);
135 // If this edge is the same as the default edge, do nothing else.
136 if (e == default_edge)
137 continue;
139 tree low = CASE_LOW (gimple_switch_label (sw, x));
140 tree high = CASE_HIGH (gimple_switch_label (sw, x));
141 if (!high)
142 high = low;
144 // Remove the case range from the default case.
145 int_range_max def_range (low, high);
146 range_cast (def_range, type);
147 def_range.invert ();
148 default_range.intersect (def_range);
150 // Create/union this case with anything on else on the edge.
151 int_range_max case_range (low, high);
152 range_cast (case_range, type);
153 irange *&slot = m_edge_table->get_or_insert (e, &existed);
154 if (existed)
156 case_range.union_ (*slot);
157 if (slot->fits_p (case_range))
159 *slot = case_range;
160 continue;
163 // If there was an existing range and it doesn't fit, we lose the memory.
164 // It'll get reclaimed when the obstack is freed. This seems less
165 // intrusive than allocating max ranges for each case.
166 slot = m_range_allocator.allocate (case_range);
169 irange *&slot = m_edge_table->get_or_insert (default_edge, &existed);
170 // This should be the first call into this switch.
171 gcc_checking_assert (!existed);
172 irange *dr = m_range_allocator.allocate (default_range);
173 slot = dr;
177 // Calculate the range forced on on edge E by control flow, return it
178 // in R. Return the statment which defines the range, otherwise
179 // return NULL
181 gimple *
182 gimple_outgoing_range::edge_range_p (irange &r, edge e)
184 // Determine if there is an outgoing edge.
185 gimple *s = gimple_outgoing_range_stmt_p (e->src);
186 if (!s)
187 return NULL;
189 if (is_a<gcond *> (s))
191 gcond_edge_range (r, e);
192 return s;
195 gcc_checking_assert (is_a<gswitch *> (s));
196 gswitch *sw = as_a<gswitch *> (s);
197 tree type = TREE_TYPE (gimple_switch_index (sw));
199 if (!irange::supports_type_p (type))
200 return NULL;
202 if (get_edge_range (r, sw, e))
203 return s;
205 return NULL;