diff --git a/doc/manuals/libabigail-concepts.rst b/doc/manuals/libabigail-concepts.rst
index 28e71684..f9e27ff9 100644
--- a/doc/manuals/libabigail-concepts.rst
+++ b/doc/manuals/libabigail-concepts.rst
@@ -619,9 +619,28 @@ names start with the string "private_data_member".
 	  {72, end}
      }
 
+.. _suppr_has_strict_flexible_array_data_member_conversion_label:
 
 
- .. _suppr_has_size_change_property_label:
+* ``has_strict_flexible_array_data_member_conversion``
+
+ Usage:
+
+   ``has_strict_flexible_array_data_member_conversion`` ``=`` yes | no
+
+ Suppresses change reports involving a type which has a "fake"
+ flexible array member at the end of the struct which is converted
+ to a real flexible array member. This would be a member like
+ ``data[1]`` being converted to ``data[]``.
+
+ Please note: a conversion to a flex array like this
+ will *always* result in the structure changing size,
+ so the suppression will not take effect unless the
+ :ref:`has_size_change<suppr_has_size_change_property_label>`
+ property is present and set to ``yes``.
+
+.. _suppr_has_size_change_property_label:
+
 
 * ``has_size_change``
 
@@ -631,9 +650,10 @@ names start with the string "private_data_member".
 
 
 This property is to be used in conjunction with the properties
-:ref:`has_data_member_inserted_between<suppr_has_data_member_inserted_between_label>`
+:ref:`has_data_member_inserted_between<suppr_has_data_member_inserted_between_label>`,
+:ref:`has_data_members_inserted_between<suppr_has_data_members_inserted_between_label>`,
 and
-:ref:`has_data_members_inserted_between<suppr_has_data_members_inserted_between_label>`.
+:ref:`has_strict_flexible_array_data_member_conversion<suppr_has_strict_flexible_array_data_member_conversion_label>`
 Those properties will not match a type change if the size of the type
 changes, unless the ``has_size_changes`` property is set to ``yes``.
 
diff --git a/include/abg-fwd.h b/include/abg-fwd.h
index 7d6637b9..de5b72b0 100644
--- a/include/abg-fwd.h
+++ b/include/abg-fwd.h
@@ -490,6 +490,15 @@ has_flexible_array_data_member(const class_decl*);
 var_decl_sptr
 has_flexible_array_data_member(const class_decl_sptr&);
 
+var_decl_sptr
+has_fake_flexible_array_data_member(const class_decl&);
+
+var_decl_sptr
+has_fake_flexible_array_data_member(const class_decl*);
+
+var_decl_sptr
+has_fake_flexible_array_data_member(const class_decl_sptr&);
+
 bool
 is_declaration_only_class_or_union_type(const type_base *t,
 					bool look_through_decl_only = false);
diff --git a/include/abg-suppression.h b/include/abg-suppression.h
index 996600bb..dd0870bc 100644
--- a/include/abg-suppression.h
+++ b/include/abg-suppression.h
@@ -336,6 +336,12 @@ public:
   void
   set_changed_enumerators_regexp(const vector<regex::regex_t_sptr>&);
 
+  bool
+  has_strict_fam_conversion () const;
+
+  void
+  set_has_strict_fam_conversion(bool);
+
   virtual bool
   suppresses_diff(const diff* diff) const;
 
diff --git a/src/abg-ir.cc b/src/abg-ir.cc
index 4a652b0f..7ba7f72d 100644
--- a/src/abg-ir.cc
+++ b/src/abg-ir.cc
@@ -10822,6 +10822,34 @@ var_decl_sptr
 has_flexible_array_data_member(const class_decl_sptr& klass)
 {return has_flexible_array_data_member(klass.get());}
 
+var_decl_sptr
+has_fake_flexible_array_data_member(const class_decl& klass)
+{
+  var_decl_sptr nil;
+  const class_or_union::data_members& dms = klass.get_data_members();
+  if (dms.empty())
+    return nil;
+
+  if (array_type_def_sptr array = is_array_type(dms.back()->get_type()))
+    {// The type of the last data member is an array.
+      if (array->get_subranges().size() == 1
+	  && array->get_subranges()[0]->get_length() == 1)
+	// The array has a size of one. We are thus looking at a
+	// "fake" flexible array data member.  Let's return it.
+	return dms.back();
+    }
+
+  return nil;
+}
+
+var_decl_sptr
+has_fake_flexible_array_data_member(const class_decl* klass)
+{return has_fake_flexible_array_data_member(*klass);}
+
+var_decl_sptr
+has_fake_flexible_array_data_member(const class_decl_sptr& klass)
+{return has_fake_flexible_array_data_member(klass.get());}
+
 /// Test wheter a type is a declaration-only class.
 ///
 /// @param t the type to considier.
diff --git a/src/abg-suppression-priv.h b/src/abg-suppression-priv.h
index 351c5965..e4d65df8 100644
--- a/src/abg-suppression-priv.h
+++ b/src/abg-suppression-priv.h
@@ -586,6 +586,9 @@ class type_suppression::priv
   mutable regex::regex_t_sptr		source_location_to_keep_regex_;
   mutable vector<string>		changed_enumerator_names_;
   mutable vector<regex::regex_t_sptr>	changed_enumerators_regexp_;
+  // Whether the "has_strict_flexible_array_data_member_conversion"
+  // property was set.
+  bool					has_strict_fam_conv_;
 
   priv();
 
@@ -602,7 +605,8 @@ public:
       type_kind_(type_kind),
       consider_reach_kind_(consider_reach_kind),
       reach_kind_(reach_kind),
-      has_size_change_(false)
+      has_size_change_(false),
+      has_strict_fam_conv_(false)
   {}
 
   /// Get the regular expression object associated to the 'type_name_regex'
diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc
index 326d003e..91199629 100644
--- a/src/abg-suppression.cc
+++ b/src/abg-suppression.cc
@@ -808,6 +808,14 @@ void
 type_suppression::set_changed_enumerators_regexp(const vector<regex::regex_t_sptr>& n)
 {priv_->changed_enumerators_regexp_ = n;}
 
+bool
+type_suppression::has_strict_fam_conversion () const
+{return priv_->has_strict_fam_conv_;}
+
+void
+type_suppression::set_has_strict_fam_conversion(bool f)
+{priv_->has_strict_fam_conv_ = f;}
+
 /// Evaluate this suppression specification on a given diff node and
 /// say if the diff node should be suppressed or not.
 ///
@@ -967,6 +975,11 @@ type_suppression::suppresses_diff(const diff* diff) const
   const class_diff* klass_diff = dynamic_cast<const class_diff*>(d);
   if (klass_diff)
     {
+      const class_decl_sptr& first_class =
+	klass_diff->first_class_decl();
+      const class_decl_sptr& second_class =
+	klass_diff->second_class_decl();
+
       // We are looking at a class diff ...
       if (!get_data_member_insertion_ranges().empty())
 	{
@@ -981,9 +994,6 @@ type_suppression::suppresses_diff(const diff* diff) const
 	      // that suppression applies to types that have size
 	      // change.
 
-	      const class_decl_sptr& first_type_decl =
-		klass_diff->first_class_decl();
-
 	      if (klass_diff->inserted_data_members().empty()
 		  && klass_diff->changed_data_members().empty())
 		// So there is a has_data_member_inserted_* clause,
@@ -1001,7 +1011,7 @@ type_suppression::suppresses_diff(const diff* diff) const
 		  for (const auto& range : get_data_member_insertion_ranges())
 		    if (is_data_member_offset_in_range(is_var_decl(member),
 						       range,
-						       first_type_decl.get()))
+						       first_class.get()))
 		      matched = true;
 
 		  if (!matched)
@@ -1017,7 +1027,7 @@ type_suppression::suppresses_diff(const diff* diff) const
 
 		  for (const auto& range : get_data_member_insertion_ranges())
 		    if (is_data_member_offset_in_range(member, range,
-						       first_type_decl.get()))
+						       first_class.get()))
 		      matched = true;
 
 		  if (!matched)
@@ -1027,6 +1037,28 @@ type_suppression::suppresses_diff(const diff* diff) const
 	  else
 	    return false;
 	}
+
+      // Support for the
+      // "has_strict_flexible_array_data_member_conversion = true"
+      // clause.
+      if (has_strict_fam_conversion())
+	{
+	  // Let's detect if the first class of the diff has a fake
+	  // flexible array data member that got turned into a real
+	  // flexible array data member.
+	  if (!(
+		(get_has_size_change())
+		// This situation will always result in a size change,
+		// so check that "has_size_change = true" before
+		// processing further
+		&&
+		(has_fake_flexible_array_data_member(first_class)
+		 && has_flexible_array_data_member(second_class))
+		// A fake flexible array member has been changed into
+		// a real flexible array ...
+		))
+	    return false;
+	}
     }
 
   const enum_diff* enum_dif = dynamic_cast<const enum_diff*>(d);
@@ -2321,6 +2353,14 @@ read_type_suppression(const ini::config::section& section)
       }
     }
 
+  // Support "has_strict_flexible_array_data_member_conversion"
+  ini::simple_property_sptr has_strict_fam_conv =
+    is_simple_property
+    (section.find_property("has_strict_flexible_array_data_member_conversion"));
+  string has_strict_fam_conv_str = has_strict_fam_conv
+    ? has_strict_fam_conv->get_value()->as_string()
+    : "";
+
   if (section.get_name() == "suppress_type")
     result.reset(new type_suppression(label_str, name_regex_str, name_str));
   else if (section.get_name() == "allow_type")
@@ -2388,6 +2428,9 @@ read_type_suppression(const ini::config::section& section)
       && !changed_enumerators_regexp.empty())
     result->set_changed_enumerators_regexp(changed_enumerators_regexp);
 
+  if (has_strict_fam_conv_str == "yes" || has_strict_fam_conv_str == "true")
+    result->set_has_strict_fam_conversion(true);
+
   return result;
 }
 
diff --git a/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-1.suppr b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-1.suppr
new file mode 100644
index 00000000..5cb8d880
--- /dev/null
+++ b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-1.suppr
@@ -0,0 +1,4 @@
+[suppress_type]
+  type_kind = struct
+  has_size_change = true
+  has_strict_flexible_array_data_member_conversion = true
diff --git a/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-2.suppr b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-2.suppr
new file mode 100644
index 00000000..384409d0
--- /dev/null
+++ b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-2.suppr
@@ -0,0 +1,3 @@
+[suppress_type]
+  type_kind = struct
+  has_strict_flexible_array_data_member_conversion = true
diff --git a/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-report-1.txt b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-report-1.txt
new file mode 100644
index 00000000..b4ea5bf1
--- /dev/null
+++ b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-report-1.txt
@@ -0,0 +1,4 @@
+Functions changes summary: 0 Removed, 0 Changed, 0 Added function
+Variables changes summary: 0 Removed, 0 Changed, 0 Added variable
+Unreachable types summary: 0 removed, 0 changed (1 filtered out), 0 added type
+
diff --git a/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-report-2.txt b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-report-2.txt
new file mode 100644
index 00000000..2352dd4e
--- /dev/null
+++ b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-report-2.txt
@@ -0,0 +1,14 @@
+Functions changes summary: 0 Removed, 0 Changed, 0 Added function
+Variables changes summary: 0 Removed, 0 Changed, 0 Added variable
+Unreachable types summary: 0 removed, 1 changed, 0 added type
+
+1 changed type unreachable from any public interface:
+
+  [C] 'struct foo' changed:
+    type size changed from 64 to 32 (in bits)
+    1 data member change:
+      type of 'int flex[1]' changed:
+        type name changed from 'int[1]' to 'int[]'
+        array type size changed from 32 to 'unknown'
+        array type subrange 1 changed length from 1 to 'unknown'
+
diff --git a/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v0.c b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v0.c
new file mode 100644
index 00000000..1397cd52
--- /dev/null
+++ b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v0.c
@@ -0,0 +1,11 @@
+/*
+ * Compile this with:
+ *   gcc -g -c test-has-strict-flexible-array-data-member-conversion-v0.c
+ */
+struct foo
+{
+  int x;
+  int flex[1];
+};
+
+struct foo S;
diff --git a/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v0.o b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v0.o
new file mode 100644
index 0000000000000000000000000000000000000000..8d0a755d353d580e6afb96dc55a021322caf5a93
GIT binary patch
diff --git a/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v1.c b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v1.c
--- /dev/null
+++ b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v1.c
@@ -0,0 +1,11 @@
+/*
+ * Compile this with:
+ *   gcc -g -c test-has-strict-flexible-array-data-member-conversion-v1.c
+ */
+struct foo
+{
+  int x;
+  int flex[];
+};
+
+struct foo S;
diff --git a/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v1.o b/tests/data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v1.o
new file mode 100644
index 0000000000000000000000000000000000000000..da8d4137ad4639af460b144ceb464a021fb843ce
GIT binary patch
diff --git a/tests/test-diff-suppr.cc b/tests/test-diff-suppr.cc
--- a/tests/test-diff-suppr.cc
+++ b/tests/test-diff-suppr.cc
@@ -2376,6 +2376,26 @@ InOutSpec in_out_specs[] =
     "data/test-diff-suppr/test-has-data-member-inserted-at-2-report.3.txt",
     "output/test-diff-suppr/test-has-data-member-inserted-at-2-report.3.txt"
   },
+  {
+    "data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v0.o",
+    "data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v1.o",
+    "",
+    "",
+    "data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-1.suppr",
+    "--drop-private-types --no-default-suppression --non-reachable-types",
+    "data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-report-1.txt",
+    "output/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-report-1.txt",
+  },
+  {
+    "data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v0.o",
+    "data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-v1.o",
+    "",
+    "",
+    "data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-2.suppr",
+    "--drop-private-types --no-default-suppression --non-reachable-types",
+    "data/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-report-2.txt",
+    "output/test-diff-suppr/test-has-strict-flexible-array-data-member-conversion-report-2.txt",
+  },
   // This should be the last entry
   {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}
 };
