diff --git a/include/abg-fwd.h b/include/abg-fwd.h
index f23f4a46..14b95a96 100644
--- a/include/abg-fwd.h
+++ b/include/abg-fwd.h
@@ -819,12 +819,10 @@ type_base*
 peel_qualified_or_typedef_type(const type_base* type);
 
 type_base_sptr
-peel_typedef_pointer_or_reference_type(const type_base_sptr,
-				       bool peel_qualified_type = true);
+peel_typedef_pointer_or_reference_type(const type_base_sptr);
 
 type_base*
-peel_typedef_pointer_or_reference_type(const type_base* type,
-				       bool peel_qualified_type = true);
+peel_typedef_pointer_or_reference_type(const type_base* type);
 
 type_base*
 peel_pointer_or_reference_type(const type_base *type,
diff --git a/src/abg-comp-filter.cc b/src/abg-comp-filter.cc
index 702d223f..a9bf2c70 100644
--- a/src/abg-comp-filter.cc
+++ b/src/abg-comp-filter.cc
@@ -1067,10 +1067,8 @@ is_mostly_distinct_diff(const diff *d)
   type_base_sptr first = is_type(td->first_subject());
   type_base_sptr second = is_type(td->second_subject());
 
-  first = peel_typedef_pointer_or_reference_type(first,
-						 /*peel_qualified_type=*/false);
-  second = peel_typedef_pointer_or_reference_type(second,
-						  /*peel_qual_type=*/false);
+  first = peel_typedef_pointer_or_reference_type(first);
+  second = peel_typedef_pointer_or_reference_type(second);
   ABG_ASSERT(first && second);
 
   return distinct_diff::entities_are_of_distinct_kinds(first, second);
diff --git a/src/abg-dwarf-reader.cc b/src/abg-dwarf-reader.cc
index ba4e750f..054ac91b 100644
--- a/src/abg-dwarf-reader.cc
+++ b/src/abg-dwarf-reader.cc
@@ -15740,8 +15740,7 @@ maybe_canonicalize_type(const Dwarf_Die *die, read_context& ctxt)
   if (!t)
     return;
 
-  type_base_sptr peeled_type =
-    peel_typedef_pointer_or_reference_type(t, /*peel_qual_types=*/false);
+  type_base_sptr peeled_type = peel_typedef_pointer_or_reference_type(t);
   if (is_class_type(peeled_type)
       || is_union_type(peeled_type)
       || is_function_type(peeled_type)
@@ -15794,8 +15793,7 @@ maybe_canonicalize_type(const type_base_sptr& t,
   if (!t)
     return;
 
-  type_base_sptr peeled_type =
-    peel_typedef_pointer_or_reference_type(t, /*peel_qual_types=*/false);
+  type_base_sptr peeled_type = peel_typedef_pointer_or_reference_type(t);
   if (is_class_type(peeled_type)
       || is_union_type(peeled_type)
       || is_function_type(peeled_type)
diff --git a/src/abg-ir.cc b/src/abg-ir.cc
index a434ec69..5ad60dfa 100644
--- a/src/abg-ir.cc
+++ b/src/abg-ir.cc
@@ -5707,23 +5707,19 @@ peel_qualified_or_typedef_type(const type_base* type)
 }
 
 /// Return the leaf underlying or pointed-to type node of a @ref
-/// typedef_decl, @ref pointer_type_def, @ref reference_type_def or
-/// @ref qualified_type_def node.
+/// typedef_decl, @ref pointer_type_def or @ref reference_type_def
+/// node.
 ///
 /// @param type the type to peel.
 ///
-/// @param peel_qualified_type if true, also peel qualified types.
-///
 /// @return the leaf underlying or pointed-to type node of @p type.
 type_base_sptr
-peel_typedef_pointer_or_reference_type(const type_base_sptr type,
-				       bool peel_qual_type)
+peel_typedef_pointer_or_reference_type(const type_base_sptr type)
 {
-  type_base_sptr typ  = type;
+  type_base_sptr typ = type;
   while (is_typedef(typ)
 	 || is_pointer_type(typ)
-	 || is_reference_type(typ)
-	 || (peel_qual_type && is_qualified_type(typ)))
+	 || is_reference_type(typ))
     {
       if (typedef_decl_sptr t = is_typedef(typ))
 	typ = peel_typedef_type(t);
@@ -5733,35 +5729,24 @@ peel_typedef_pointer_or_reference_type(const type_base_sptr type,
 
       if (reference_type_def_sptr t = is_reference_type(typ))
 	typ = peel_reference_type(t);
-
-      if (array_type_def_sptr t = is_array_type(typ))
-	typ = peel_array_type(t);
-
-      if (peel_qual_type)
-	if (qualified_type_def_sptr t = is_qualified_type(typ))
-	  typ = peel_qualified_type(t);
     }
 
   return typ;
 }
 
 /// Return the leaf underlying or pointed-to type node of a @ref
-/// typedef_decl, @ref pointer_type_def, @ref reference_type_def or
-/// @ref qualified_type_def type node.
+/// typedef_decl, @ref pointer_type_def or @ref reference_type_def
+/// node.
 ///
 /// @param type the type to peel.
 ///
-/// @param peel_qualified_type if true, also peel qualified types.
-///
 /// @return the leaf underlying or pointed-to type node of @p type.
 type_base*
-peel_typedef_pointer_or_reference_type(const type_base* type,
-				       bool peel_qual_type)
+peel_typedef_pointer_or_reference_type(const type_base* type)
 {
   while (is_typedef(type)
 	 || is_pointer_type(type)
-	 || is_reference_type(type)
-	 || (peel_qual_type && is_qualified_type(type)))
+	 || is_reference_type(type))
     {
       if (const typedef_decl* t = is_typedef(type))
 	type = peel_typedef_type(t);
@@ -5771,13 +5756,6 @@ peel_typedef_pointer_or_reference_type(const type_base* type,
 
       if (const reference_type_def* t = is_reference_type(type))
 	type = peel_reference_type(t);
-
-      if (const array_type_def* t = is_array_type(type))
-	type = peel_array_type(t);
-
-      if (peel_qual_type)
-	if (const qualified_type_def* t = is_qualified_type(type))
-	  type = peel_qualified_type(t);
     }
 
   return const_cast<type_base*>(type);
