diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc
index 92622fc5000..07c69ef858a 100644
--- a/gcc/gimple-range-cache.cc
+++ b/gcc/gimple-range-cache.cc
@@ -320,7 +320,7 @@ sbr_sparse_bitmap::set_bb_range (const_basic_block bb, const vrange &r)
 
   // Loop thru the values to see if R is already present.
   for (int x = 0; x < SBR_NUM; x++)
-    if (!m_range[x] || m_range[x]->equal_p (r, m_type))
+    if (!m_range[x] || m_range[x]->equal_p (r))
       {
 	if (!m_range[x])
 	  m_range[x] = m_range_allocator->clone (r);
diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc
index 14bec500dbc..2f82739680c 100644
--- a/gcc/value-range-storage.cc
+++ b/gcc/value-range-storage.cc
@@ -205,20 +205,22 @@ vrange_storage::fits_p (const vrange &r) const
   return false;
 }
 
-// Return TRUE if the range in storage is equal to R.
+// Return TRUE if the range in storage is equal to R.  It is the
+// caller's responsibility to verify that the type of the range in
+// storage matches that of R.
 
 bool
-vrange_storage::equal_p (const vrange &r, tree type) const
+vrange_storage::equal_p (const vrange &r) const
 {
   if (is_a <irange> (r))
     {
       const irange_storage *s = static_cast <const irange_storage *> (this);
-      return s->equal_p (as_a <irange> (r), type);
+      return s->equal_p (as_a <irange> (r));
     }
   if (is_a <frange> (r))
     {
       const frange_storage *s = static_cast <const frange_storage *> (this);
-      return s->equal_p (as_a <frange> (r), type);
+      return s->equal_p (as_a <frange> (r));
     }
   gcc_unreachable ();
 }
@@ -374,21 +376,17 @@ irange_storage::get_irange (irange &r, tree type) const
 }
 
 bool
-irange_storage::equal_p (const irange &r, tree type) const
+irange_storage::equal_p (const irange &r) const
 {
   if (m_kind == VR_UNDEFINED || r.undefined_p ())
     return m_kind == r.m_kind;
   if (m_kind == VR_VARYING || r.varying_p ())
-    return m_kind == r.m_kind && types_compatible_p (r.type (), type);
-
-  tree rtype = r.type ();
-  if (!types_compatible_p (rtype, type))
-    return false;
+    return m_kind == r.m_kind;
 
   // ?? We could make this faster by doing the comparison in place,
   // without going through get_irange.
   int_range_max tmp;
-  get_irange (tmp, rtype);
+  get_irange (tmp, r.type ());
   return tmp == r;
 }
 
@@ -525,17 +523,13 @@ frange_storage::get_frange (frange &r, tree type) const
 }
 
 bool
-frange_storage::equal_p (const frange &r, tree type) const
+frange_storage::equal_p (const frange &r) const
 {
   if (r.undefined_p ())
     return m_kind == VR_UNDEFINED;
 
-  tree rtype = type;
-  if (!types_compatible_p (rtype, type))
-    return false;
-
   frange tmp;
-  get_frange (tmp, rtype);
+  get_frange (tmp, r.type ());
   return tmp == r;
 }
 
diff --git a/gcc/value-range-storage.h b/gcc/value-range-storage.h
index a90b64b2bf0..99fb815cdc2 100644
--- a/gcc/value-range-storage.h
+++ b/gcc/value-range-storage.h
@@ -53,7 +53,7 @@ public:
   void get_vrange (vrange &r, tree type) const;
   void set_vrange (const vrange &r);
   bool fits_p (const vrange &r) const;
-  bool equal_p (const vrange &r, tree type) const;
+  bool equal_p (const vrange &r) const;
 protected:
   // Stack initialization disallowed.
   vrange_storage () { }
@@ -67,7 +67,7 @@ public:
   static irange_storage *alloc (vrange_internal_alloc &, const irange &);
   void set_irange (const irange &r);
   void get_irange (irange &r, tree type) const;
-  bool equal_p (const irange &r, tree type) const;
+  bool equal_p (const irange &r) const;
   bool fits_p (const irange &r) const;
   void dump () const;
 private:
@@ -110,7 +110,7 @@ class frange_storage : public vrange_storage
   static frange_storage *alloc (vrange_internal_alloc &, const frange &r);
   void set_frange (const frange &r);
   void get_frange (frange &r, tree type) const;
-  bool equal_p (const frange &r, tree type) const;
+  bool equal_p (const frange &r) const;
   bool fits_p (const frange &) const;
  private:
   frange_storage (const frange &r) { set_frange (r); }