diff --git a/include/abg-fwd.h b/include/abg-fwd.h
index 4b09929c..36c73f7a 100644
--- a/include/abg-fwd.h
+++ b/include/abg-fwd.h
@@ -708,6 +708,9 @@ is_array_of_qualified_element(type_base_sptr&);
 qualified_type_def_sptr
 is_array_of_qualified_element(const array_type_def_sptr&);
 
+array_type_def_sptr
+is_typedef_of_array(const type_base_sptr&);
+
 void
 set_data_member_offset(var_decl_sptr, uint64_t);
 
@@ -848,6 +851,9 @@ peel_qualified_type(const type_base_sptr&);
 type_base*
 peel_qualified_or_typedef_type(const type_base* type);
 
+type_base_sptr
+peel_qualified_or_typedef_type(const type_base_sptr &type);
+
 type_base_sptr
 peel_typedef_pointer_or_reference_type(const type_base_sptr);
 
diff --git a/src/abg-dwarf-reader.cc b/src/abg-dwarf-reader.cc
index 7257052e..45f3cf62 100644
--- a/src/abg-dwarf-reader.cc
+++ b/src/abg-dwarf-reader.cc
@@ -14342,6 +14342,33 @@ maybe_strip_qualification(const qualified_type_def_sptr t,
 	// delayed until after all editing is done.
 	ABG_ASSERT_NOT_REACHED;
     }
+  else if (array_type_def_sptr array = is_typedef_of_array(u))
+    {
+      // We should not be editing types that are already canonicalized.
+      ABG_ASSERT(!array->get_canonical_type());
+      type_base_sptr element_type = array->get_element_type();
+
+      if (qualified_type_def_sptr qualified = is_qualified_type(element_type))
+	{
+	  // We should not be editing types that are already canonicalized.
+	  ABG_ASSERT(!qualified->get_canonical_type());
+	  qualified_type_def::CV quals = qualified->get_cv_quals();
+	  quals |= t->get_cv_quals();
+	  qualified->set_cv_quals(quals);
+	  result = is_decl(u);
+	}
+      else
+	{
+	  qualified_type_def_sptr qual_type
+	    (new qualified_type_def(element_type,
+				    t->get_cv_quals(),
+				    t->get_location()));
+	  add_decl_to_scope(qual_type, is_decl(element_type)->get_scope());
+	  array->set_element_type(qual_type);
+	  ctxt.schedule_type_for_late_canonicalization(is_type(qual_type));
+	  result = is_decl(u);
+	}
+    }
 
   return result;
 }
diff --git a/src/abg-ir.cc b/src/abg-ir.cc
index 8c04797f..5e5937a5 100644
--- a/src/abg-ir.cc
+++ b/src/abg-ir.cc
@@ -5813,6 +5813,35 @@ peel_qualified_or_typedef_type(const type_base* type)
   return const_cast<type_base*>(type);
 }
 
+/// Return the leaf underlying type of a qualified or typedef type.
+///
+/// If the underlying type is itself a qualified or typedef type, then
+/// recursively return the first underlying type of that qualified or
+/// typedef type to return the first underlying type that is not a
+/// qualified or typedef type.
+///
+/// If the underlying type is NOT a qualified nor a typedef type, then
+/// just return that underlying type.
+///
+/// @param type the qualified or typedef type to consider.
+///
+/// @return the leaf underlying type.
+type_base_sptr
+peel_qualified_or_typedef_type(const type_base_sptr &t)
+{
+  type_base_sptr type = t;
+  while (is_typedef(type) || is_qualified_type(type))
+    {
+      if (typedef_decl_sptr t = is_typedef(type))
+	type = peel_typedef_type(t);
+
+      if (qualified_type_def_sptr t = is_qualified_type(type))
+	type = peel_qualified_type(t);
+    }
+
+  return type;
+}
+
 /// Return the leaf underlying or pointed-to type node of a @ref
 /// typedef_decl, @ref pointer_type_def or @ref reference_type_def
 /// node.
@@ -8646,6 +8675,34 @@ is_array_of_qualified_element(type_base_sptr& type)
   return array_type_def_sptr();
 }
 
+/// Test if a type is a typedef of an array.
+///
+/// Note that the function looks through qualified and typedefs types
+/// of the underlying type of the current typedef.  In other words, if
+/// we are looking at a typedef of a CV-qualified array, or at a
+/// typedef of a CV-qualified typedef of an array, this function will
+/// still return TRUE.
+///
+/// @param t the type to consider.
+///
+/// @return true if t is a typedef which underlying type is an array.
+/// That array might be either cv-qualified array or a typedef'ed
+/// array, or a combination of both.
+array_type_def_sptr
+is_typedef_of_array(const type_base_sptr& t)
+{
+  array_type_def_sptr result;
+
+  if (typedef_decl_sptr typdef = is_typedef(t))
+    {
+      type_base_sptr u =
+	peel_qualified_or_typedef_type(typdef->get_underlying_type());
+      result = is_array_type(u);
+    }
+
+  return result;
+}
+
 /// Test if a type is an array_type_def::subrange_type.
 ///
 /// @param type the type to consider.
diff --git a/tests/data/Makefile.am b/tests/data/Makefile.am
index 40a575fa..db9a8e36 100644
--- a/tests/data/Makefile.am
+++ b/tests/data/Makefile.am
@@ -888,6 +888,11 @@ test-diff-filter/test-PR26309-v1.c           \
 test-diff-filter/test-PR26309-v0.o           \
 test-diff-filter/test-PR26309-v1.o           \
 test-diff-filter/test-PR26309-report-0.txt   \
+test-diff-filter/test-PR26739-v0.c           \
+test-diff-filter/test-PR26739-v1.c           \
+test-diff-filter/test-PR26739-v0.o           \
+test-diff-filter/test-PR26739-v1.o           \
+test-diff-filter/test-PR26739-report-0.txt   \
 \
 test-diff-suppr/test0-type-suppr-v0.cc	\
 test-diff-suppr/test0-type-suppr-v1.cc	\
diff --git a/tests/data/test-diff-filter/test-PR26739-report-0.txt b/tests/data/test-diff-filter/test-PR26739-report-0.txt
new file mode 100644
index 00000000..9666a8fd
--- /dev/null
+++ b/tests/data/test-diff-filter/test-PR26739-report-0.txt
@@ -0,0 +1,3 @@
+Functions changes summary: 0 Removed, 0 Changed (1 filtered out), 0 Added function
+Variables changes summary: 0 Removed, 0 Changed, 0 Added variable
+
diff --git a/tests/data/test-diff-filter/test-PR26739-v0.c b/tests/data/test-diff-filter/test-PR26739-v0.c
new file mode 100644
index 00000000..e9148ac4
--- /dev/null
+++ b/tests/data/test-diff-filter/test-PR26739-v0.c
@@ -0,0 +1,8 @@
+typedef const int immutable[7];
+typedef immutable monster;
+
+struct A {
+  monster q;
+};
+
+void fun(struct A * a) { (void) a; }
diff --git a/tests/data/test-diff-filter/test-PR26739-v0.o b/tests/data/test-diff-filter/test-PR26739-v0.o
new file mode 100644
index 0000000000000000000000000000000000000000..5a4ae08f964055b0a411d330d9f3ba3d727a7b89
GIT binary patch
diff --git a/tests/data/test-diff-filter/test-PR26739-v1.c b/tests/data/test-diff-filter/test-PR26739-v1.c
new file mode 100644
index 00000000..5c31e40c
--- /dev/null
+++ b/tests/data/test-diff-filter/test-PR26739-v1.c
@@ -0,0 +1,12 @@
+typedef int plain[7];
+typedef const plain monster;
+
+struct A {
+  monster q;
+};
+
+void fun(struct A * a) {
+  (void) a;
+  // assignment to read-only location
+  // a->q[0] = 0;
+}
diff --git a/tests/data/test-diff-filter/test-PR26739-v1.o b/tests/data/test-diff-filter/test-PR26739-v1.o
new file mode 100644
index 0000000000000000000000000000000000000000..9966762568f70b7ac8f631b4c8ba904f7557a9c5
GIT binary patch
diff --git a/tests/test-diff-filter.cc b/tests/test-diff-filter.cc
index b3b1e91b..8d90b13e 100644
--- a/tests/test-diff-filter.cc
+++ b/tests/test-diff-filter.cc
@@ -773,6 +773,13 @@ InOutSpec in_out_specs[] =
    "data/test-diff-filter/test-PR26309-report-0.txt",
    "output/test-diff-filter/test-PR26309-report-0.txt",
   },
+  {
+   "data/test-diff-filter/test-PR26739-v0.o",
+   "data/test-diff-filter/test-PR26739-v1.o",
+   "--no-default-suppression",
+   "data/test-diff-filter/test-PR26739-report-0.txt",
+   "output/test-diff-filter/test-PR26739-report-0.txt",
+  },
   // This should be the last entry
   {NULL, NULL, NULL, NULL, NULL}
 };
