preserving after type_reconstructor

4 files changed, 83 insertions, 140 deletions

diff --git a/gcc/ipa-dfe.c b/gcc/ipa-dfe.c
index 5b4926dfd29..033fb7564e7 100644
--- a/gcc/ipa-dfe.c
+++ b/gcc/ipa-dfe.c
@@ -194,7 +194,7 @@ get_all_types_pointing_to (record_field_offset_map3_t record_field_offset_map,
  */
 reorg_maps_t
 get_types_replacement (record_field_offset_map3_t record_field_offset_map,
-		       hash_set<tree> &to_modify)
+		       hash_set<tree> &to_modify, reorg_record_map2_t &map2, reorg_field_map2_t &field_map2)
 {
   type_stringifier stringifier;
 
@@ -204,7 +204,7 @@ get_types_replacement (record_field_offset_map3_t record_field_offset_map,
      record_field_offset_map2.put(i->first, i->second);
   }
 
-  type_reconstructor reconstructor (record_field_offset_map2, "reorg");
+  type_reconstructor reconstructor (record_field_offset_map2, "reorg", map2, field_map2);
   for (hash_set<tree>::iterator i = to_modify.begin (),
 					    e = to_modify.end ();
        i != e; ++i)
@@ -221,22 +221,11 @@ get_types_replacement (record_field_offset_map3_t record_field_offset_map,
       reconstructor.walk (record);
     }
 
-  //reorg_record_map_t map = reconstructor.get_map ();
-  reorg_record_map2_t *map2 = reconstructor.get_map2 ();
-
-  reorg_field_map_t field_map;
-  reorg_field_map2_t *field_map2 = reconstructor.get_field_map2 ();
-  for (reorg_field_map2_t::iterator i = field_map2->begin(), e = field_map2->end(); i != e; ++i)
-  {
-    field_map.insert({(*i).first, (*i).second});
-  }
-  std::map<tree, tree> map;
-
   // Here, we are just making sure that we are not doing anything too crazy.
   // Also, we found some types for which TYPE_CACHED_VALUES_P is not being
   // rewritten.  This is probably indicative of a bug in TypeReconstructor.
-  for (hash_map<tree, tree>::iterator i = map2->begin (),
-						  e = map2->end ();
+  for (hash_map<tree, tree>::iterator i = map2.begin (),
+						  e = map2.end ();
        i != e; ++i)
     {
       tree o_record = (*i).first;
@@ -246,7 +235,6 @@ get_types_replacement (record_field_offset_map3_t record_field_offset_map,
       std::string r_name
 	= r_record ? stringifier.stringify (r_record) : std::string ("");
       log ("modified: %s\n", r_name.c_str ());
-      map.insert({o_record, r_record});
       if (!r_record)
 	continue;
       tree m_record = TYPE_MAIN_VARIANT (r_record);
@@ -255,17 +243,17 @@ get_types_replacement (record_field_offset_map3_t record_field_offset_map,
       TYPE_CACHED_VALUES_P (_o_record) = false;
       TYPE_CACHED_VALUES_P (m_record) = false;
 
-      bool in_map = map2->get (m_record);
+      bool in_map = map2.get (m_record);
       if (!in_map)
 	continue;
-      tree mm_record = *map2->get (m_record);
+      tree mm_record = *map2.get (m_record);
       // Info: I think this is no longer needed...
       // Please verify
       TYPE_MAIN_VARIANT (r_record) = mm_record;
     }
 
   // TODO: Ok, we will need to change this some time...
-  return std::make_pair (map, field_map);
+  return std::make_pair (&map2, &field_map2);
 }
 
 /* Walk the gimple program and substitute
@@ -273,8 +261,8 @@ get_types_replacement (record_field_offset_map3_t record_field_offset_map,
  * * the trees in field_map with field_map's values.
  */
 void
-substitute_types_in_program (reorg_record_map_t map,
-			     reorg_field_map_t field_map, bool _delete)
+substitute_types_in_program (reorg_record_map2_t &map,
+			     reorg_field_map2_t &field_map, bool _delete)
 {
   gimple_type_rewriter rewriter (map, field_map, _delete);
   rewriter.walk ();
@@ -353,30 +341,11 @@ specific_type_collector::_walk_RECORD_TYPE_post (tree t)
   path2.remove (t);
 }
 
-/*
- * old RECORD_TYPE -> new RECORD_TYPE.
- */
-reorg_record_map2_t*
-type_reconstructor::get_map2 ()
-{
-  return _reorg_map2;
-}
-
-/*
- * old FIELD_DECL -> new FIELD_DECL.
- */
-
-reorg_field_map2_t*
-type_reconstructor::get_field_map2 ()
-{
-  return _reorg_fields2;
-}
-
 void
 type_reconstructor::set_is_not_modified_yet (tree t)
 {
   gcc_assert (t);
-  const bool is_in_reorg_map = _reorg_map2->get (t);
+  const bool is_in_reorg_map = _reorg_map2.get (t);
   modified_map2->put(t, false);
   if (is_in_reorg_map)
     mark_all_pointing_here_as_modified ();
@@ -385,11 +354,11 @@ type_reconstructor::set_is_not_modified_yet (tree t)
   if (!tt)
     return;
 
-  const bool is_in_reorg_map_2 = _reorg_map2->get (tt);
+  const bool is_in_reorg_map_2 = _reorg_map2.get (tt);
   if (!is_in_reorg_map_2)
     return;
 
-  tree type = *_reorg_map2->get(tt);
+  tree type = *_reorg_map2.get(tt);
   bool is_modified
     = strstr (type_stringifier::get_type_identifier (type).c_str (), ".reorg");
   is_modified
@@ -435,7 +404,7 @@ type_reconstructor::get_is_modified (tree t)
 bool
 type_reconstructor::is_memoized (tree t)
 {
-  const bool already_changed = _reorg_map2->get (t);
+  const bool already_changed = _reorg_map2.get (t);
   mark_all_pointing_here_as_modified ();
   return already_changed;
 }
@@ -508,7 +477,7 @@ type_reconstructor::_walk_ARRAY_TYPE_post (tree t)
 
   TREE_TYPE (copy) = build_variant_type_copy (TREE_TYPE (copy));
   copy = is_modified ? build_distinct_type_copy (copy) : copy;
-  TREE_TYPE (copy) = is_modified ? *_reorg_map2->get(TREE_TYPE (t)) : TREE_TYPE (copy);
+  TREE_TYPE (copy) = is_modified ? *_reorg_map2.get(TREE_TYPE (t)) : TREE_TYPE (copy);
   TYPE_NAME (copy) = is_modified
 		       ? get_new_identifier (copy, this->get_new_suffix ())
 		       : TYPE_NAME (copy);
@@ -537,7 +506,7 @@ type_reconstructor::_walk_ARRAY_TYPE_post (tree t)
   if (!points_to_record)
     return;
 
-  _reorg_map2->put (t, is_modified ? copy : _t);
+  _reorg_map2.put (t, is_modified ? copy : _t);
 }
 
 void
@@ -563,7 +532,7 @@ type_reconstructor::_walk_POINTER_TYPE_post (tree t)
   bool is_modified = get_is_modified (t);
 
   copy = is_modified ? build_variant_type_copy (copy) : copy;
-  TREE_TYPE (copy) = is_modified ? *_reorg_map2->get(TREE_TYPE (t)) : TREE_TYPE (copy);
+  TREE_TYPE (copy) = is_modified ? *_reorg_map2.get(TREE_TYPE (t)) : TREE_TYPE (copy);
   TYPE_NAME (copy) = is_modified
 		       ? get_new_identifier (copy, this->get_new_suffix ())
 		       : TYPE_NAME (copy);
@@ -579,7 +548,7 @@ type_reconstructor::_walk_POINTER_TYPE_post (tree t)
   if (!points_to_record)
     return;
 
-  _reorg_map2->put(t, is_modified ? copy : _t);
+  _reorg_map2.put(t, is_modified ? copy : _t);
 }
 
 void
@@ -659,7 +628,7 @@ type_reconstructor::_walk_RECORD_TYPE_post (tree t)
   if (!is_main_variant)
     {
       tree main = TYPE_MAIN_VARIANT (t);
-      tree main_reorg = *_reorg_map2->get(main);
+      tree main_reorg = *_reorg_map2.get(main);
       tree copy_variant = build_variant_type_copy (main_reorg);
       TYPE_NAME (copy_variant)
 	= get_new_identifier (copy, this->get_new_suffix ());
@@ -667,7 +636,7 @@ type_reconstructor::_walk_RECORD_TYPE_post (tree t)
       TYPE_MAIN_VARIANT (copy_variant) = main_reorg;
       TYPE_SIZE (main_reorg) = NULL;
       layout_type (copy_variant);
-      _reorg_map2->put(t, copy_variant);
+      _reorg_map2.put(t, copy_variant);
     }
   else
     {
@@ -683,10 +652,10 @@ type_reconstructor::_walk_RECORD_TYPE_post (tree t)
       if (is_modified)
 	layout_type (copy);
       tree _t = tree_to_tree (t);
-      _reorg_map2->put(t, is_modified ? copy : _t);
+      _reorg_map2.put(t, is_modified ? copy : _t);
     }
 
-  tree record = *_reorg_map2->get(t);
+  tree record = *_reorg_map2.get(t);
   for (tree field = TYPE_FIELDS (record); field; field = DECL_CHAIN (field))
     {
       relayout_decl (field);
@@ -740,17 +709,17 @@ type_reconstructor::_walk_field_post (tree t)
   const bool type_memoized = is_memoized (original_type);
 
   TREE_TYPE (copy)
-    = type_memoized ? *_reorg_map2->get(original_type) : TREE_TYPE (copy);
+    = type_memoized ? *_reorg_map2.get(original_type) : TREE_TYPE (copy);
 
   field_tuple_t tuple = std::make_pair (t, can_field_be_deleted ? NULL : copy);
 
   // Put the field into the vector
   field_tuple_list2_t &field_tuple_list2 = field_list2_stack2.last ();
   field_tuple_list2.safe_push (tuple);
-  const bool already_has_field = _reorg_fields2->get (t);
+  const bool already_has_field = _reorg_fields2.get (t);
   if (already_has_field)
     return;
-  _reorg_fields2->put(t, std::make_pair (copy, can_field_be_deleted));
+  _reorg_fields2.put(t, std::make_pair (copy, can_field_be_deleted));
 }
 
 // Relayout parameters
@@ -786,11 +755,11 @@ expr_type_rewriter::_walk_FUNCTION_DECL_post (tree t)
   // Therefore it is awkward to do this in the expr-walker...
   // const bool is_interesting = is_interesting_type (ret_type);
   // Instead use the following map
-  const bool is_interesting = _map2->get (ret_type);
+  const bool is_interesting = _map2.get (ret_type);
   if (!is_interesting)
     return;
 
-  tree r_t = *_map2->get(ret_type);
+  tree r_t = *_map2.get(ret_type);
   TREE_TYPE (fn_type) = r_t;
 }
 
@@ -800,7 +769,7 @@ expr_type_rewriter::_walk_MEM_REF_post (tree e)
 {
   tree op0 = TREE_OPERAND (e, 0);
   tree t2 = TREE_TYPE (op0);
-  const bool in_map2 = _map2->get(t2);
+  const bool in_map2 = _map2.get(t2);
 
   log ("trying out substituting expression in component_Ref directly\n");
   type_stringifier stringifier;
@@ -809,7 +778,7 @@ expr_type_rewriter::_walk_MEM_REF_post (tree e)
   if (in_map2)
     {
       log ("success\n");
-      tree r_t = *_map2->get(t2);
+      tree r_t = *_map2.get(t2);
       tree _e = tree_to_tree (op0);
       TREE_TYPE (_e) = r_t;
     }
@@ -1141,11 +1110,11 @@ expr_type_rewriter::_walk_post (tree e)
 {
   gcc_assert (e);
   tree t = TREE_TYPE (e);
-  const bool in_map = _map2->get(t);
+  const bool in_map = _map2.get(t);
   if (!in_map)
     return;
 
-  tree r_t = *_map2->get(t);
+  tree r_t = *_map2.get(t);
   tree _e = tree_to_tree (e);
   TREE_TYPE (_e) = r_t;
 }
@@ -1158,11 +1127,11 @@ expr_type_rewriter::_walk_COMPONENT_REF_post (tree e)
 
   tree f = TREE_OPERAND (e, 1);
   // So, what we need is a map between this field and the new field
-  const bool in_map = _fields2->get(f);
+  const bool in_map = _fields2.get(f);
   if (!in_map)
     return;
 
-  std::pair<tree, bool> p = *_fields2->get(f);
+  std::pair<tree, bool> p = *_fields2.get(f);
   tree n_f = p.first;
   bool is_deleted = p.second;
   tree _e = tree_to_tree (e);
diff --git a/gcc/ipa-dfe.h b/gcc/ipa-dfe.h
index 8a83a954b98..d8c9b856d37 100644
--- a/gcc/ipa-dfe.h
+++ b/gcc/ipa-dfe.h
@@ -70,33 +70,26 @@ typedef hash_map<tree, std::pair<tree, bool> > reorg_field_map2_t;
 class type_reconstructor : public type_walker
 {
 public:
-  type_reconstructor (record_field_offset_map4_t &records, const char *suffix)
-    : _records2(records), _suffix (suffix), in_progress2(vNULL), for_reference2(vNULL), field_list2_stack2 (vNULL)
+  type_reconstructor (record_field_offset_map4_t &records, const char *suffix, reorg_record_map2_t &a, reorg_field_map2_t &b)
+    : _records2(records), _suffix (suffix), in_progress2(vNULL), for_reference2(vNULL), field_list2_stack2 (vNULL), _reorg_map2(a), _reorg_fields2(b)
   {
-    _reorg_map2 = new reorg_record_map2_t;
-    _reorg_fields2 = new reorg_field_map2_t;
     modified_map2 = new is_modified_map2_t;
   };
   ~type_reconstructor()
   {
-    delete _reorg_map2;
-    delete _reorg_fields2;
     delete modified_map2;
   }
 
   /* Whether a type has already been modified.  */
   virtual bool is_memoized (tree t);
 
-  // Final result for record map.
-  reorg_record_map2_t *get_map2 ();
-
-  /* Final result for field map.  */
-  reorg_field_map2_t *get_field_map2 ();
-
   /* Map RECORD_TYPE -> is_modified.  */
   typedef hash_map<tree, bool> is_modified_map2_t;
 
 protected:
+  // Which records can be modified.
+  record_field_offset_map4_t& _records2;
+
   // The new suffix
   const char *_suffix;
 
@@ -116,19 +109,16 @@ protected:
   // of field_tuple_list_t
   typedef vec<field_tuple_list2_t> field_tuple_list2_stack2_t;
 
-  // Which records can be modified.
-  record_field_offset_map4_t& _records2;
-
   const char *get_new_suffix ();
 
   // Which fields will be deleted.
   field_tuple_list2_stack2_t field_list2_stack2;
 
   // old RECORD_TYPE -> new RECORD_TYPE
-  reorg_record_map2_t *_reorg_map2;
+  reorg_record_map2_t &_reorg_map2;
 
   // old FIELD_DECL -> new FIELD_DECL
-  reorg_field_map2_t *_reorg_fields2;
+  reorg_field_map2_t &_reorg_fields2;
 
   // old RECORD_TYPE -> is_modified
   is_modified_map2_t *modified_map2;
@@ -167,38 +157,22 @@ private:
 class expr_type_rewriter : public expr_walker
 {
 public:
-  expr_type_rewriter (reorg_record_map_t map, reorg_field_map_t map2,
+  expr_type_rewriter (reorg_record_map2_t &map, reorg_field_map2_t &map2,
 		    bool can_delete)
-    : _delete (false), _can_delete (can_delete)
+    : _delete (false), _can_delete (can_delete), _map2(map), _fields2(map2)
   {
     /* Create an inverse map new RECORD_TYPE -> old RECORD_TYPE.  */
-
-    _map2 = new reorg_record_map2_t;
-    _fields2 = new reorg_field_map2_t;
-    for (auto i = map.begin(), e = map.end(); i != e; ++i)
-    {
-      _map2->put (i->first, i->second);
-    }
-
-    for (auto i = map2.begin(), e = map2.end(); i != e; ++i)
-    {
-      _fields2->put (i->first, i->second);
-    }
-
     _imap2 = new hash_map<tree, tree>;
-    for (reorg_record_map_t::iterator i = map.begin (),
-	e = map.end (); i != e; ++i)
+    for (auto i = map.begin (), e = map.end (); i != e; ++i)
       {
-	tree original = i->first;
-	tree modified = i->second;
+	tree original = (*i).first;
+	tree modified = (*i).second;
 	_imap2->put (modified, original);
       }
   };
 
   ~expr_type_rewriter()
   {
-    delete _map2;
-    delete _fields2;
     delete _imap2;
   };
 
@@ -221,10 +195,10 @@ public:
 
 private:
   // Old RECORD_TYPE -> new RECORD_TYPE.
-  reorg_record_map2_t* _map2;
+  reorg_record_map2_t& _map2;
 
   // Old FIELD_DECL -> new FIELD_DECL.
-  reorg_field_map2_t* _fields2;
+  reorg_field_map2_t& _fields2;
 
   // New RECORD_TYPE -> old RECORD_TYPE.
   hash_map<tree, tree>* _imap2;
@@ -248,7 +222,7 @@ private:
 class gimple_type_rewriter : public gimple_walker
 {
 public:
-  gimple_type_rewriter (reorg_record_map_t map, reorg_field_map_t map2,
+  gimple_type_rewriter (reorg_record_map2_t &map, reorg_field_map2_t &map2,
 		      bool can_delete)
     : exprTypeRewriter (map, map2, can_delete)
   {};
@@ -275,17 +249,19 @@ get_all_types_pointing_to (record_field_offset_map3_t record_field_offset_map,
 			   tpartitions2_t casting,
 			   hash_set<tree> &to_modify);
 
-typedef std::pair<reorg_record_map_t, reorg_field_map_t> reorg_maps_t;
+typedef std::pair<reorg_record_map2_t*, reorg_field_map2_t*> reorg_maps_t;
 
 // Compute the replacement types.
 reorg_maps_t
 get_types_replacement (record_field_offset_map3_t record_field_offset_map,
-		       hash_set<tree> &to_modify);
+		       hash_set<tree> &to_modify,
+		       reorg_record_map2_t &,
+		       reorg_field_map2_t &);
 
 // Substitute types.
 void
-substitute_types_in_program (reorg_record_map_t map,
-			     reorg_field_map_t field_map, bool _delete);
+substitute_types_in_program (reorg_record_map2_t &map,
+			     reorg_field_map2_t &field_map, bool _delete);
 
 tree
 get_new_identifier (tree type, const char *suffix);
diff --git a/gcc/ipa-field-reorder.c b/gcc/ipa-field-reorder.c
index f02f57b5888..07f930a0caf 100644
--- a/gcc/ipa-field-reorder.c
+++ b/gcc/ipa-field-reorder.c
@@ -171,8 +171,9 @@ class TypeReconstructorFieldReordering : public type_reconstructor
 {
 public:
   TypeReconstructorFieldReordering (record_field_offset_map4_t &records,
-				    const char *suffix)
-    : type_reconstructor (records, suffix)
+				    const char *suffix,
+				    reorg_record_map2_t &a, reorg_field_map2_t &b)
+    : type_reconstructor (records, suffix, a, b)
   {};
 
 private:
@@ -329,7 +330,7 @@ TypeReconstructorFieldReordering::_walk_RECORD_TYPE_post (tree t)
 	      unsigned haystack_i = bitpos_of_field (field);
 	      if (haystack_i == to_find_i)
 		{
-		  _reorg_fields2->put(field, std::make_pair (tree_to_tree (to_find), false));
+		  _reorg_fields2.put(field, std::make_pair (tree_to_tree (to_find), false));
 		  log ("substituting %s for %s\n", to_find_str, haystack);
 		}
 	    }
@@ -341,7 +342,7 @@ TypeReconstructorFieldReordering::_walk_RECORD_TYPE_post (tree t)
   if (!is_main_variant)
     {
       tree main = TYPE_MAIN_VARIANT (t);
-      tree main_reorg = *_reorg_map2->get(main);
+      tree main_reorg = *_reorg_map2.get(main);
       tree copy_variant = build_distinct_type_copy (main_reorg);
       TYPE_NAME (copy_variant)
 	= get_new_identifier (copy, this->get_new_suffix ());
@@ -349,7 +350,7 @@ TypeReconstructorFieldReordering::_walk_RECORD_TYPE_post (tree t)
       TYPE_ALIAS_SET (copy_variant) = -1;
       layout_type (copy_variant);
       TYPE_MAIN_VARIANT (copy_variant) = main_reorg;
-      _reorg_map2->put (t, copy_variant);
+      _reorg_map2.put (t, copy_variant);
     }
   else
     {
@@ -365,10 +366,10 @@ TypeReconstructorFieldReordering::_walk_RECORD_TYPE_post (tree t)
       if (is_modified)
 	layout_type (copy);
       tree _t = tree_to_tree (t);
-      _reorg_map2->put (t, is_modified ? copy : _t);
+      _reorg_map2.put (t, is_modified ? copy : _t);
     }
 
-  tree record = *_reorg_map2->get(t);
+  tree record = *_reorg_map2.get(t);
   for (tree field = TYPE_FIELDS (record); field; field = DECL_CHAIN (field))
     {
       relayout_decl (field);
@@ -520,7 +521,8 @@ record_field_map_t static find_fields_accessed ()
  */
 reorg_maps_t
 get_reordered_field_maps (record_field_offset_map3_t record_field_offset_map,
-			  hash_set<tree> & to_modify)
+			  hash_set<tree> & to_modify,
+			  reorg_record_map2_t &map2, reorg_field_map2_t &field_map2)
 {
   type_stringifier stringifier;
 
@@ -531,7 +533,7 @@ get_reordered_field_maps (record_field_offset_map3_t record_field_offset_map,
   }
 
   TypeReconstructorFieldReordering reconstructor (record_field_offset_map2,
-						  "reorder");
+						  "reorder", map2, field_map2);
   for (hash_set<tree>::iterator i = to_modify.begin (),
 					    e = to_modify.end ();
        i != e; ++i)
@@ -549,22 +551,13 @@ get_reordered_field_maps (record_field_offset_map3_t record_field_offset_map,
     }
 
   typedef hash_map<tree, tree> reorg_record_map2_t;
-  reorg_record_map2_t *map2 = reconstructor.get_map2 ();
-  std::map<tree, tree> map;
-
-  reorg_field_map2_t *field_map2 = reconstructor.get_field_map2 ();
-  reorg_field_map_t field_map;
-  for (reorg_field_map2_t::iterator i = field_map2->begin(), e = field_map2->end(); i != e; ++i)
-  {
-    field_map.insert({(*i).first, (*i).second});
-  }
 
   // Here, we are just making sure that we are not doing anything too crazy.
   // Also, we found some types for which TYPE_CACHED_VALUES_P is not being
   // rewritten.  This is probably indicative of a bug in
   // TypeReconstructorFieldReordering.
-  for (reorg_record_map2_t::iterator i = map2->begin (),
-						  e = map2->end ();
+  for (reorg_record_map2_t::iterator i = map2.begin (),
+						  e = map2.end ();
        i != e; ++i)
     {
       tree o_record = (*i).first;
@@ -574,7 +567,6 @@ get_reordered_field_maps (record_field_offset_map3_t record_field_offset_map,
       std::string r_name
 	= r_record ? stringifier.stringify (r_record) : std::string ("");
       log ("modified: %s\n", r_name.c_str ());
-      map.insert({o_record, r_record});
       if (!r_record)
 	continue;
       tree m_record = TYPE_MAIN_VARIANT (r_record);
@@ -583,17 +575,17 @@ get_reordered_field_maps (record_field_offset_map3_t record_field_offset_map,
       TYPE_CACHED_VALUES_P (_o_record) = false;
       TYPE_CACHED_VALUES_P (m_record) = false;
 
-      bool in_map = map2->get (m_record);
+      bool in_map = map2.get (m_record);
       if (!in_map)
 	continue;
-      tree mm_record = *map2->get(m_record);
+      tree mm_record = *map2.get(m_record);
       // Info: I think this is no longer needed...
       // Please verify
       TYPE_MAIN_VARIANT (r_record) = mm_record;
     }
 
   // TODO: change this to return the GCC types...
-  return std::make_pair (map, field_map);
+  return std::make_pair (&map2, &field_map2);
 }
 
 /* Top level function.  */
@@ -619,11 +611,14 @@ lto_fr_execute ()
   get_all_types_pointing_to (record_field_offset_map,
 				 escaping_nonescaping_sets, to_modify);
 
+  reorg_record_map2_t a;
+  reorg_field_map2_t b;
   reorg_maps_t replacements
-    = get_reordered_field_maps (record_field_offset_map, to_modify);
-  reorg_record_map_t map = replacements.first;
-  reorg_field_map_t field_map = replacements.second;
-  substitute_types_in_program (map, field_map, false);
+    = get_reordered_field_maps (record_field_offset_map, to_modify, a, b);
+  reorg_record_map2_t *map = replacements.first;
+  reorg_field_map2_t *field_map = replacements.second;
+  gcc_assert(map && field_map);
+  substitute_types_in_program (*map, *field_map, false);
 
   gimple_walker walker;
   walker.walk ();
diff --git a/gcc/ipa-type-escape-analysis.c b/gcc/ipa-type-escape-analysis.c
index 5b78bbe424f..0f920358424 100644
--- a/gcc/ipa-type-escape-analysis.c
+++ b/gcc/ipa-type-escape-analysis.c
@@ -372,12 +372,15 @@ lto_dead_field_elimination ()
   hash_set<tree> to_modify2;
   get_all_types_pointing_to (record_field_offset_map,
 				 escaping_nonescaping_sets, to_modify2);
+  reorg_record_map2_t a;
+  reorg_field_map2_t b;
   reorg_maps_t replacements
-    = get_types_replacement (record_field_offset_map, to_modify2);
-  reorg_record_map_t map = replacements.first;
-  reorg_field_map_t field_map = replacements.second;
+    = get_types_replacement (record_field_offset_map, to_modify2, a, b);
+  reorg_record_map2_t *map = replacements.first;
+  reorg_field_map2_t *field_map = replacements.second;
+  gcc_assert(map && field_map);
   // Transformation.
-  substitute_types_in_program (map, field_map, true);
+  substitute_types_in_program (*map, *field_map, true);
 }
 
 /* Iterate all gimple bodies and collect trees