get_global_range_query ()->range_of_expr (vr, size);
if (vr.undefined_p ())
vr.set_varying (TREE_TYPE (size));
- vr.intersect (&valid_range);
+ vr.intersect (valid_range);
return vr.zero_p ();
}
const value_range_equiv *old_vr
= get_value_range (vrs[i].first);
value_range tem (*old_vr);
- tem.intersect (vrs[i].second);
+ tem.legacy_verbose_intersect (vrs[i].second);
if (tem.equal_p (*old_vr))
{
free_value_range (vrs[i].second);
return set_to_bottom ();
value_range save (m_vr);
- m_vr.union_ (other_vr);
+ m_vr.union_ (*other_vr);
return !m_vr.equal_p (save);
}
if (TREE_CODE (op) != SSA_NAME)
return NULL_TREE;
- const value_range_equiv *vr = m_vr_values->get_value_range (op);
+ const value_range *vr = m_vr_values->get_value_range (op);
return find_case_label_range (switch_stmt, vr);
}
if (gassign *assign_stmt = dyn_cast <gassign *> (stmt))
value_range vrres;
extract_range_from_plus_minus_expr (&vrres, code, expr_type,
&vrtem1, vr1_);
- vr->union_ (&vrres);
+ vr->union_ (vrres);
}
return;
}
value_range vrres;
extract_range_from_plus_minus_expr (&vrres, code, expr_type,
vr0_, &vrtem1);
- vr->union_ (&vrres);
+ vr->union_ (vrres);
}
return;
}
int_range_max label_range (CASE_LOW (label), case_high);
if (!types_compatible_p (label_range.type (), range_of_op->type ()))
range_cast (label_range, range_of_op->type ());
- label_range.intersect (range_of_op);
+ label_range.intersect (*range_of_op);
if (label_range == *range_of_op)
return label;
}
int_range_max label_range (CASE_LOW (min_label), case_high);
if (!types_compatible_p (label_range.type (), range_of_op->type ()))
range_cast (label_range, range_of_op->type ());
- label_range.intersect (range_of_op);
+ label_range.intersect (*range_of_op);
if (label_range.undefined_p ())
return gimple_switch_label (switch_stmt, 0);
}
}
void
-value_range_equiv::intersect (const value_range_equiv *other)
+value_range_equiv::legacy_verbose_intersect (const value_range_equiv *other)
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
}
void
-value_range_equiv::union_ (const value_range_equiv *other)
+value_range_equiv::legacy_verbose_union_ (const value_range_equiv *other)
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
bool operator== (const value_range_equiv &) const /* = delete */;
bool operator!= (const value_range_equiv &) const /* = delete */;
- void intersect (const value_range_equiv *);
- void union_ (const value_range_equiv *);
+ void legacy_verbose_intersect (const value_range_equiv *);
+ void legacy_verbose_union_ (const value_range_equiv *);
bool equal_p (const value_range_equiv &, bool ignore_equivs) const;
/* Types of value ranges. */
may not be the smallest possible such range. */
void
-irange::union_ (const irange *other)
+irange::legacy_verbose_union_ (const irange *other)
{
if (legacy_mode_p ())
{
}
void
-irange::intersect (const irange *other)
+irange::legacy_verbose_intersect (const irange *other)
{
if (legacy_mode_p ())
{
bool may_contain_p (tree) const; // DEPRECATED
void set (tree); // DEPRECATED
bool equal_p (const irange &) const; // DEPRECATED
- void union_ (const class irange *); // DEPRECATED
- void intersect (const irange *); // DEPRECATED
+ void legacy_verbose_union_ (const class irange *); // DEPRECATED
+ void legacy_verbose_intersect (const irange *); // DEPRECATED
protected:
irange (tree *, unsigned);
{
dump_flags_t m_flags = dump_flags;
dump_flags &= ~TDF_DETAILS;
- irange::union_ (&r);
+ irange::legacy_verbose_union_ (&r);
dump_flags = m_flags;
}
{
dump_flags_t m_flags = dump_flags;
dump_flags &= ~TDF_DETAILS;
- irange::intersect (&r);
+ irange::legacy_verbose_intersect (&r);
dump_flags = m_flags;
}
value_range_equiv nr;
get_global_range_query ()->range_of_expr (nr, const_cast <tree> (var));
if (!nr.undefined_p ())
- new_vr->intersect (&nr);
+ new_vr->legacy_verbose_intersect (&nr);
}
/* Update the value range, if necessary. If we cannot allocate a lattice
gcc_unreachable ();
/* Finally intersect the new range with what we already know about var. */
- vr_p->intersect (get_value_range (var));
+ vr_p->legacy_verbose_intersect (get_value_range (var));
}
/* Extract value range information from an ASSERT_EXPR EXPR and store
/* The resulting value range is the union of the operand ranges */
vr->deep_copy (vr0);
- vr->union_ (vr1);
+ vr->legacy_verbose_union_ (vr1);
}
for previously LE_ or LT_EXPR and GT_EXPR otherwise, but
the comments next to the enclosing if suggest it's not
generally profitable to do so. */
- vro.intersect (vr0);
+ vro.legacy_verbose_intersect (vr0);
if (vro.undefined_p ())
return boolean_false_node;
- vri.intersect (vr0);
+ vri.legacy_verbose_intersect (vr0);
if (vri.undefined_p ())
return boolean_true_node;
}
if (first)
vr_result->deep_copy (vr_arg);
else
- vr_result->union_ (vr_arg);
+ vr_result->legacy_verbose_union_ (vr_arg);
first = false;
if (vr_result->varying_p ())