1*38fd1498Szrj /* Support routines for Value Range Propagation (VRP).
2*38fd1498Szrj Copyright (C) 2005-2018 Free Software Foundation, Inc.
3*38fd1498Szrj
4*38fd1498Szrj This file is part of GCC.
5*38fd1498Szrj
6*38fd1498Szrj GCC is free software; you can redistribute it and/or modify
7*38fd1498Szrj it under the terms of the GNU General Public License as published by
8*38fd1498Szrj the Free Software Foundation; either version 3, or (at your option)
9*38fd1498Szrj any later version.
10*38fd1498Szrj
11*38fd1498Szrj GCC is distributed in the hope that it will be useful,
12*38fd1498Szrj but WITHOUT ANY WARRANTY; without even the implied warranty of
13*38fd1498Szrj MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14*38fd1498Szrj GNU General Public License for more details.
15*38fd1498Szrj
16*38fd1498Szrj You should have received a copy of the GNU General Public License
17*38fd1498Szrj along with GCC; see the file COPYING3. If not see
18*38fd1498Szrj <http://www.gnu.org/licenses/>. */
19*38fd1498Szrj
20*38fd1498Szrj #include "config.h"
21*38fd1498Szrj #include "system.h"
22*38fd1498Szrj #include "coretypes.h"
23*38fd1498Szrj #include "backend.h"
24*38fd1498Szrj #include "tree.h"
25*38fd1498Szrj #include "gimple.h"
26*38fd1498Szrj #include "tree-pass.h"
27*38fd1498Szrj #include "ssa.h"
28*38fd1498Szrj #include "gimple-pretty-print.h"
29*38fd1498Szrj #include "cfganal.h"
30*38fd1498Szrj #include "gimple-fold.h"
31*38fd1498Szrj #include "tree-eh.h"
32*38fd1498Szrj #include "gimple-iterator.h"
33*38fd1498Szrj #include "tree-cfg.h"
34*38fd1498Szrj #include "tree-ssa-loop-manip.h"
35*38fd1498Szrj #include "tree-ssa-loop.h"
36*38fd1498Szrj #include "cfgloop.h"
37*38fd1498Szrj #include "tree-scalar-evolution.h"
38*38fd1498Szrj #include "tree-ssa-propagate.h"
39*38fd1498Szrj #include "alloc-pool.h"
40*38fd1498Szrj #include "domwalk.h"
41*38fd1498Szrj #include "tree-cfgcleanup.h"
42*38fd1498Szrj #include "vr-values.h"
43*38fd1498Szrj #include "gimple-ssa-evrp-analyze.h"
44*38fd1498Szrj
evrp_range_analyzer()45*38fd1498Szrj evrp_range_analyzer::evrp_range_analyzer () : stack (10)
46*38fd1498Szrj {
47*38fd1498Szrj edge e;
48*38fd1498Szrj edge_iterator ei;
49*38fd1498Szrj basic_block bb;
50*38fd1498Szrj FOR_EACH_BB_FN (bb, cfun)
51*38fd1498Szrj {
52*38fd1498Szrj bb->flags &= ~BB_VISITED;
53*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->preds)
54*38fd1498Szrj e->flags |= EDGE_EXECUTABLE;
55*38fd1498Szrj }
56*38fd1498Szrj vr_values = new class vr_values;
57*38fd1498Szrj }
58*38fd1498Szrj
59*38fd1498Szrj /* Push an unwinding marker onto the unwinding stack. */
60*38fd1498Szrj
61*38fd1498Szrj void
push_marker()62*38fd1498Szrj evrp_range_analyzer::push_marker ()
63*38fd1498Szrj {
64*38fd1498Szrj stack.safe_push (std::make_pair (NULL_TREE, (value_range *)NULL));
65*38fd1498Szrj }
66*38fd1498Szrj
67*38fd1498Szrj /* Analyze ranges as we enter basic block BB. */
68*38fd1498Szrj
69*38fd1498Szrj void
enter(basic_block bb)70*38fd1498Szrj evrp_range_analyzer::enter (basic_block bb)
71*38fd1498Szrj {
72*38fd1498Szrj if (!optimize)
73*38fd1498Szrj return;
74*38fd1498Szrj push_marker ();
75*38fd1498Szrj record_ranges_from_incoming_edge (bb);
76*38fd1498Szrj record_ranges_from_phis (bb);
77*38fd1498Szrj bb->flags |= BB_VISITED;
78*38fd1498Szrj }
79*38fd1498Szrj
80*38fd1498Szrj /* Find new range for NAME such that (OP CODE LIMIT) is true. */
81*38fd1498Szrj value_range *
try_find_new_range(tree name,tree op,tree_code code,tree limit)82*38fd1498Szrj evrp_range_analyzer::try_find_new_range (tree name,
83*38fd1498Szrj tree op, tree_code code, tree limit)
84*38fd1498Szrj {
85*38fd1498Szrj value_range vr = VR_INITIALIZER;
86*38fd1498Szrj value_range *old_vr = get_value_range (name);
87*38fd1498Szrj
88*38fd1498Szrj /* Discover VR when condition is true. */
89*38fd1498Szrj vr_values->extract_range_for_var_from_comparison_expr (name, code, op,
90*38fd1498Szrj limit, &vr);
91*38fd1498Szrj /* If we found any usable VR, set the VR to ssa_name and create a
92*38fd1498Szrj PUSH old value in the stack with the old VR. */
93*38fd1498Szrj if (vr.type == VR_RANGE || vr.type == VR_ANTI_RANGE)
94*38fd1498Szrj {
95*38fd1498Szrj if (old_vr->type == vr.type
96*38fd1498Szrj && vrp_operand_equal_p (old_vr->min, vr.min)
97*38fd1498Szrj && vrp_operand_equal_p (old_vr->max, vr.max))
98*38fd1498Szrj return NULL;
99*38fd1498Szrj value_range *new_vr = vr_values->allocate_value_range ();
100*38fd1498Szrj *new_vr = vr;
101*38fd1498Szrj return new_vr;
102*38fd1498Szrj }
103*38fd1498Szrj return NULL;
104*38fd1498Szrj }
105*38fd1498Szrj
106*38fd1498Szrj /* For LHS record VR in the SSA info. */
107*38fd1498Szrj void
set_ssa_range_info(tree lhs,value_range * vr)108*38fd1498Szrj evrp_range_analyzer::set_ssa_range_info (tree lhs, value_range *vr)
109*38fd1498Szrj {
110*38fd1498Szrj /* Set the SSA with the value range. */
111*38fd1498Szrj if (INTEGRAL_TYPE_P (TREE_TYPE (lhs)))
112*38fd1498Szrj {
113*38fd1498Szrj if ((vr->type == VR_RANGE
114*38fd1498Szrj || vr->type == VR_ANTI_RANGE)
115*38fd1498Szrj && (TREE_CODE (vr->min) == INTEGER_CST)
116*38fd1498Szrj && (TREE_CODE (vr->max) == INTEGER_CST))
117*38fd1498Szrj set_range_info (lhs, vr->type,
118*38fd1498Szrj wi::to_wide (vr->min),
119*38fd1498Szrj wi::to_wide (vr->max));
120*38fd1498Szrj }
121*38fd1498Szrj else if (POINTER_TYPE_P (TREE_TYPE (lhs))
122*38fd1498Szrj && ((vr->type == VR_RANGE
123*38fd1498Szrj && range_includes_zero_p (vr->min,
124*38fd1498Szrj vr->max) == 0)
125*38fd1498Szrj || (vr->type == VR_ANTI_RANGE
126*38fd1498Szrj && range_includes_zero_p (vr->min,
127*38fd1498Szrj vr->max) == 1)))
128*38fd1498Szrj set_ptr_nonnull (lhs);
129*38fd1498Szrj }
130*38fd1498Szrj
131*38fd1498Szrj /* Return true if all uses of NAME are dominated by STMT or feed STMT
132*38fd1498Szrj via a chain of single immediate uses. */
133*38fd1498Szrj
134*38fd1498Szrj static bool
all_uses_feed_or_dominated_by_stmt(tree name,gimple * stmt)135*38fd1498Szrj all_uses_feed_or_dominated_by_stmt (tree name, gimple *stmt)
136*38fd1498Szrj {
137*38fd1498Szrj use_operand_p use_p, use2_p;
138*38fd1498Szrj imm_use_iterator iter;
139*38fd1498Szrj basic_block stmt_bb = gimple_bb (stmt);
140*38fd1498Szrj
141*38fd1498Szrj FOR_EACH_IMM_USE_FAST (use_p, iter, name)
142*38fd1498Szrj {
143*38fd1498Szrj gimple *use_stmt = USE_STMT (use_p), *use_stmt2;
144*38fd1498Szrj if (use_stmt == stmt
145*38fd1498Szrj || is_gimple_debug (use_stmt)
146*38fd1498Szrj || (gimple_bb (use_stmt) != stmt_bb
147*38fd1498Szrj && dominated_by_p (CDI_DOMINATORS,
148*38fd1498Szrj gimple_bb (use_stmt), stmt_bb)))
149*38fd1498Szrj continue;
150*38fd1498Szrj while (use_stmt != stmt
151*38fd1498Szrj && is_gimple_assign (use_stmt)
152*38fd1498Szrj && TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME
153*38fd1498Szrj && single_imm_use (gimple_assign_lhs (use_stmt),
154*38fd1498Szrj &use2_p, &use_stmt2))
155*38fd1498Szrj use_stmt = use_stmt2;
156*38fd1498Szrj if (use_stmt != stmt)
157*38fd1498Szrj return false;
158*38fd1498Szrj }
159*38fd1498Szrj return true;
160*38fd1498Szrj }
161*38fd1498Szrj
162*38fd1498Szrj void
record_ranges_from_incoming_edge(basic_block bb)163*38fd1498Szrj evrp_range_analyzer::record_ranges_from_incoming_edge (basic_block bb)
164*38fd1498Szrj {
165*38fd1498Szrj edge pred_e = single_pred_edge_ignoring_loop_edges (bb, false);
166*38fd1498Szrj if (pred_e)
167*38fd1498Szrj {
168*38fd1498Szrj gimple *stmt = last_stmt (pred_e->src);
169*38fd1498Szrj tree op0 = NULL_TREE;
170*38fd1498Szrj
171*38fd1498Szrj if (stmt
172*38fd1498Szrj && gimple_code (stmt) == GIMPLE_COND
173*38fd1498Szrj && (op0 = gimple_cond_lhs (stmt))
174*38fd1498Szrj && TREE_CODE (op0) == SSA_NAME
175*38fd1498Szrj && (INTEGRAL_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt)))
176*38fd1498Szrj || POINTER_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt)))))
177*38fd1498Szrj {
178*38fd1498Szrj if (dump_file && (dump_flags & TDF_DETAILS))
179*38fd1498Szrj {
180*38fd1498Szrj fprintf (dump_file, "Visiting controlling predicate ");
181*38fd1498Szrj print_gimple_stmt (dump_file, stmt, 0);
182*38fd1498Szrj }
183*38fd1498Szrj /* Entering a new scope. Try to see if we can find a VR
184*38fd1498Szrj here. */
185*38fd1498Szrj tree op1 = gimple_cond_rhs (stmt);
186*38fd1498Szrj if (TREE_OVERFLOW_P (op1))
187*38fd1498Szrj op1 = drop_tree_overflow (op1);
188*38fd1498Szrj tree_code code = gimple_cond_code (stmt);
189*38fd1498Szrj
190*38fd1498Szrj auto_vec<assert_info, 8> asserts;
191*38fd1498Szrj register_edge_assert_for (op0, pred_e, code, op0, op1, asserts);
192*38fd1498Szrj if (TREE_CODE (op1) == SSA_NAME)
193*38fd1498Szrj register_edge_assert_for (op1, pred_e, code, op0, op1, asserts);
194*38fd1498Szrj
195*38fd1498Szrj auto_vec<std::pair<tree, value_range *>, 8> vrs;
196*38fd1498Szrj for (unsigned i = 0; i < asserts.length (); ++i)
197*38fd1498Szrj {
198*38fd1498Szrj value_range *vr = try_find_new_range (asserts[i].name,
199*38fd1498Szrj asserts[i].expr,
200*38fd1498Szrj asserts[i].comp_code,
201*38fd1498Szrj asserts[i].val);
202*38fd1498Szrj if (vr)
203*38fd1498Szrj vrs.safe_push (std::make_pair (asserts[i].name, vr));
204*38fd1498Szrj }
205*38fd1498Szrj
206*38fd1498Szrj /* If pred_e is really a fallthru we can record value ranges
207*38fd1498Szrj in SSA names as well. */
208*38fd1498Szrj bool is_fallthru = assert_unreachable_fallthru_edge_p (pred_e);
209*38fd1498Szrj
210*38fd1498Szrj /* Push updated ranges only after finding all of them to avoid
211*38fd1498Szrj ordering issues that can lead to worse ranges. */
212*38fd1498Szrj for (unsigned i = 0; i < vrs.length (); ++i)
213*38fd1498Szrj {
214*38fd1498Szrj push_value_range (vrs[i].first, vrs[i].second);
215*38fd1498Szrj if (is_fallthru
216*38fd1498Szrj && all_uses_feed_or_dominated_by_stmt (vrs[i].first, stmt))
217*38fd1498Szrj {
218*38fd1498Szrj set_ssa_range_info (vrs[i].first, vrs[i].second);
219*38fd1498Szrj maybe_set_nonzero_bits (pred_e, vrs[i].first);
220*38fd1498Szrj }
221*38fd1498Szrj }
222*38fd1498Szrj }
223*38fd1498Szrj }
224*38fd1498Szrj }
225*38fd1498Szrj
226*38fd1498Szrj void
record_ranges_from_phis(basic_block bb)227*38fd1498Szrj evrp_range_analyzer::record_ranges_from_phis (basic_block bb)
228*38fd1498Szrj {
229*38fd1498Szrj /* Visit PHI stmts and discover any new VRs possible. */
230*38fd1498Szrj bool has_unvisited_preds = false;
231*38fd1498Szrj edge_iterator ei;
232*38fd1498Szrj edge e;
233*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->preds)
234*38fd1498Szrj if (e->flags & EDGE_EXECUTABLE
235*38fd1498Szrj && !(e->src->flags & BB_VISITED))
236*38fd1498Szrj {
237*38fd1498Szrj has_unvisited_preds = true;
238*38fd1498Szrj break;
239*38fd1498Szrj }
240*38fd1498Szrj
241*38fd1498Szrj for (gphi_iterator gpi = gsi_start_phis (bb);
242*38fd1498Szrj !gsi_end_p (gpi); gsi_next (&gpi))
243*38fd1498Szrj {
244*38fd1498Szrj gphi *phi = gpi.phi ();
245*38fd1498Szrj tree lhs = PHI_RESULT (phi);
246*38fd1498Szrj if (virtual_operand_p (lhs))
247*38fd1498Szrj continue;
248*38fd1498Szrj
249*38fd1498Szrj value_range vr_result = VR_INITIALIZER;
250*38fd1498Szrj bool interesting = stmt_interesting_for_vrp (phi);
251*38fd1498Szrj if (!has_unvisited_preds && interesting)
252*38fd1498Szrj vr_values->extract_range_from_phi_node (phi, &vr_result);
253*38fd1498Szrj else
254*38fd1498Szrj {
255*38fd1498Szrj set_value_range_to_varying (&vr_result);
256*38fd1498Szrj /* When we have an unvisited executable predecessor we can't
257*38fd1498Szrj use PHI arg ranges which may be still UNDEFINED but have
258*38fd1498Szrj to use VARYING for them. But we can still resort to
259*38fd1498Szrj SCEV for loop header PHIs. */
260*38fd1498Szrj struct loop *l;
261*38fd1498Szrj if (scev_initialized_p ()
262*38fd1498Szrj && interesting
263*38fd1498Szrj && (l = loop_containing_stmt (phi))
264*38fd1498Szrj && l->header == gimple_bb (phi))
265*38fd1498Szrj vr_values->adjust_range_with_scev (&vr_result, l, phi, lhs);
266*38fd1498Szrj }
267*38fd1498Szrj vr_values->update_value_range (lhs, &vr_result);
268*38fd1498Szrj
269*38fd1498Szrj /* Set the SSA with the value range. */
270*38fd1498Szrj set_ssa_range_info (lhs, &vr_result);
271*38fd1498Szrj }
272*38fd1498Szrj }
273*38fd1498Szrj
274*38fd1498Szrj /* Record ranges from STMT into our VR_VALUES class. If TEMPORARY is
275*38fd1498Szrj true, then this is a temporary equivalence and should be recorded
276*38fd1498Szrj into the unwind table. Othewise record the equivalence into the
277*38fd1498Szrj global table. */
278*38fd1498Szrj
279*38fd1498Szrj void
record_ranges_from_stmt(gimple * stmt,bool temporary)280*38fd1498Szrj evrp_range_analyzer::record_ranges_from_stmt (gimple *stmt, bool temporary)
281*38fd1498Szrj {
282*38fd1498Szrj tree output = NULL_TREE;
283*38fd1498Szrj
284*38fd1498Szrj if (!optimize)
285*38fd1498Szrj return;
286*38fd1498Szrj
287*38fd1498Szrj if (dyn_cast <gcond *> (stmt))
288*38fd1498Szrj ;
289*38fd1498Szrj else if (stmt_interesting_for_vrp (stmt))
290*38fd1498Szrj {
291*38fd1498Szrj edge taken_edge;
292*38fd1498Szrj value_range vr = VR_INITIALIZER;
293*38fd1498Szrj vr_values->extract_range_from_stmt (stmt, &taken_edge, &output, &vr);
294*38fd1498Szrj if (output)
295*38fd1498Szrj {
296*38fd1498Szrj /* Set the SSA with the value range. There are two cases to
297*38fd1498Szrj consider. First (the the most common) is we are processing
298*38fd1498Szrj STMT in a context where its resulting range globally holds
299*38fd1498Szrj and thus it can be reflected into the global ranges and need
300*38fd1498Szrj not be unwound as we leave scope.
301*38fd1498Szrj
302*38fd1498Szrj The second case occurs if we are processing a statement in
303*38fd1498Szrj a context where the resulting range must not be reflected
304*38fd1498Szrj into the global tables and must be unwound as we leave
305*38fd1498Szrj the current context. This happens in jump threading for
306*38fd1498Szrj example. */
307*38fd1498Szrj if (!temporary)
308*38fd1498Szrj {
309*38fd1498Szrj /* Case one. We can just update the underlying range
310*38fd1498Szrj information as well as the global information. */
311*38fd1498Szrj vr_values->update_value_range (output, &vr);
312*38fd1498Szrj set_ssa_range_info (output, &vr);
313*38fd1498Szrj }
314*38fd1498Szrj else
315*38fd1498Szrj {
316*38fd1498Szrj /* We're going to need to unwind this range. We can
317*38fd1498Szrj not use VR as that's a stack object. We have to allocate
318*38fd1498Szrj a new range and push the old range onto the stack. We
319*38fd1498Szrj also have to be very careful about sharing the underlying
320*38fd1498Szrj bitmaps. Ugh. */
321*38fd1498Szrj value_range *new_vr = vr_values->allocate_value_range ();
322*38fd1498Szrj *new_vr = vr;
323*38fd1498Szrj new_vr->equiv = NULL;
324*38fd1498Szrj push_value_range (output, new_vr);
325*38fd1498Szrj }
326*38fd1498Szrj }
327*38fd1498Szrj else
328*38fd1498Szrj vr_values->set_defs_to_varying (stmt);
329*38fd1498Szrj }
330*38fd1498Szrj else
331*38fd1498Szrj vr_values->set_defs_to_varying (stmt);
332*38fd1498Szrj
333*38fd1498Szrj /* See if we can derive a range for any of STMT's operands. */
334*38fd1498Szrj tree op;
335*38fd1498Szrj ssa_op_iter i;
336*38fd1498Szrj FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE)
337*38fd1498Szrj {
338*38fd1498Szrj tree value;
339*38fd1498Szrj enum tree_code comp_code;
340*38fd1498Szrj
341*38fd1498Szrj /* If OP is used in such a way that we can infer a value
342*38fd1498Szrj range for it, and we don't find a previous assertion for
343*38fd1498Szrj it, create a new assertion location node for OP. */
344*38fd1498Szrj if (infer_value_range (stmt, op, &comp_code, &value))
345*38fd1498Szrj {
346*38fd1498Szrj /* If we are able to infer a nonzero value range for OP,
347*38fd1498Szrj then walk backwards through the use-def chain to see if OP
348*38fd1498Szrj was set via a typecast.
349*38fd1498Szrj If so, then we can also infer a nonzero value range
350*38fd1498Szrj for the operand of the NOP_EXPR. */
351*38fd1498Szrj if (comp_code == NE_EXPR && integer_zerop (value))
352*38fd1498Szrj {
353*38fd1498Szrj tree t = op;
354*38fd1498Szrj gimple *def_stmt = SSA_NAME_DEF_STMT (t);
355*38fd1498Szrj while (is_gimple_assign (def_stmt)
356*38fd1498Szrj && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))
357*38fd1498Szrj && TREE_CODE
358*38fd1498Szrj (gimple_assign_rhs1 (def_stmt)) == SSA_NAME
359*38fd1498Szrj && POINTER_TYPE_P
360*38fd1498Szrj (TREE_TYPE (gimple_assign_rhs1 (def_stmt))))
361*38fd1498Szrj {
362*38fd1498Szrj t = gimple_assign_rhs1 (def_stmt);
363*38fd1498Szrj def_stmt = SSA_NAME_DEF_STMT (t);
364*38fd1498Szrj
365*38fd1498Szrj /* Add VR when (T COMP_CODE value) condition is
366*38fd1498Szrj true. */
367*38fd1498Szrj value_range *op_range
368*38fd1498Szrj = try_find_new_range (t, t, comp_code, value);
369*38fd1498Szrj if (op_range)
370*38fd1498Szrj push_value_range (t, op_range);
371*38fd1498Szrj }
372*38fd1498Szrj }
373*38fd1498Szrj /* Add VR when (OP COMP_CODE value) condition is true. */
374*38fd1498Szrj value_range *op_range = try_find_new_range (op, op,
375*38fd1498Szrj comp_code, value);
376*38fd1498Szrj if (op_range)
377*38fd1498Szrj push_value_range (op, op_range);
378*38fd1498Szrj }
379*38fd1498Szrj }
380*38fd1498Szrj }
381*38fd1498Szrj
382*38fd1498Szrj /* Unwind recorded ranges to their most recent state. */
383*38fd1498Szrj
384*38fd1498Szrj void
pop_to_marker(void)385*38fd1498Szrj evrp_range_analyzer::pop_to_marker (void)
386*38fd1498Szrj {
387*38fd1498Szrj gcc_checking_assert (!stack.is_empty ());
388*38fd1498Szrj while (stack.last ().first != NULL_TREE)
389*38fd1498Szrj pop_value_range (stack.last ().first);
390*38fd1498Szrj stack.pop ();
391*38fd1498Szrj }
392*38fd1498Szrj
393*38fd1498Szrj /* Restore/pop VRs valid only for BB when we leave BB. */
394*38fd1498Szrj
395*38fd1498Szrj void
leave(basic_block bb ATTRIBUTE_UNUSED)396*38fd1498Szrj evrp_range_analyzer::leave (basic_block bb ATTRIBUTE_UNUSED)
397*38fd1498Szrj {
398*38fd1498Szrj if (!optimize)
399*38fd1498Szrj return;
400*38fd1498Szrj pop_to_marker ();
401*38fd1498Szrj }
402*38fd1498Szrj
403*38fd1498Szrj
404*38fd1498Szrj /* Push the Value Range of VAR to the stack and update it with new VR. */
405*38fd1498Szrj
406*38fd1498Szrj void
push_value_range(tree var,value_range * vr)407*38fd1498Szrj evrp_range_analyzer::push_value_range (tree var, value_range *vr)
408*38fd1498Szrj {
409*38fd1498Szrj if (dump_file && (dump_flags & TDF_DETAILS))
410*38fd1498Szrj {
411*38fd1498Szrj fprintf (dump_file, "pushing new range for ");
412*38fd1498Szrj print_generic_expr (dump_file, var);
413*38fd1498Szrj fprintf (dump_file, ": ");
414*38fd1498Szrj dump_value_range (dump_file, vr);
415*38fd1498Szrj fprintf (dump_file, "\n");
416*38fd1498Szrj }
417*38fd1498Szrj stack.safe_push (std::make_pair (var, get_value_range (var)));
418*38fd1498Szrj vr_values->set_vr_value (var, vr);
419*38fd1498Szrj }
420*38fd1498Szrj
421*38fd1498Szrj /* Pop the Value Range from the vrp_stack and update VAR with it. */
422*38fd1498Szrj
423*38fd1498Szrj value_range *
pop_value_range(tree var)424*38fd1498Szrj evrp_range_analyzer::pop_value_range (tree var)
425*38fd1498Szrj {
426*38fd1498Szrj value_range *vr = stack.last ().second;
427*38fd1498Szrj gcc_checking_assert (var == stack.last ().first);
428*38fd1498Szrj if (dump_file && (dump_flags & TDF_DETAILS))
429*38fd1498Szrj {
430*38fd1498Szrj fprintf (dump_file, "popping range for ");
431*38fd1498Szrj print_generic_expr (dump_file, var);
432*38fd1498Szrj fprintf (dump_file, ", restoring ");
433*38fd1498Szrj dump_value_range (dump_file, vr);
434*38fd1498Szrj fprintf (dump_file, "\n");
435*38fd1498Szrj }
436*38fd1498Szrj vr_values->set_vr_value (var, vr);
437*38fd1498Szrj stack.pop ();
438*38fd1498Szrj return vr;
439*38fd1498Szrj }
440