record_field_offset_map3_t

5 files changed, 35 insertions, 47 deletions

diff --git a/gcc/ipa-dfe.c b/gcc/ipa-dfe.c
index f2a49c49bb8..5b4926dfd29 100644
--- a/gcc/ipa-dfe.c
+++ b/gcc/ipa-dfe.c
@@ -130,7 +130,7 @@ along with GCC; see the file COPYING3.  If not see
  * record_field_offset_map.
  */
 void
-get_all_types_pointing_to (record_field_offset_map_t record_field_offset_map,
+get_all_types_pointing_to (record_field_offset_map3_t record_field_offset_map,
 			   tpartitions2_t casting,
 			   hash_set<tree> &to_modify2)
 {
@@ -138,10 +138,10 @@ get_all_types_pointing_to (record_field_offset_map_t record_field_offset_map,
 
   type_stringifier stringifier;
   hash_set<tree> specific_types2;
-  hash_map<tree, field_offsets_t> record_field_offset_map2;
+  record_field_offset_map4_t record_field_offset_map2;
 
   // Here we are just placing the types of interest in a set.
-  for (std::map<tree, field_offsets_t>::const_iterator i
+  for (std::map<tree, field_offsets2_t*>::iterator i
        = record_field_offset_map.begin (),
        e = record_field_offset_map.end ();
        i != e; ++i)
@@ -150,7 +150,7 @@ get_all_types_pointing_to (record_field_offset_map_t record_field_offset_map,
     }
 
   // Here we are just placing the types of interest in a set.
-  for (hash_map<tree, field_offsets_t>::iterator i
+  for (hash_map<tree, field_offsets2_t*>::iterator i
        = record_field_offset_map2.begin (),
        e = record_field_offset_map2.end ();
        i != e; ++i)
@@ -193,7 +193,7 @@ get_all_types_pointing_to (record_field_offset_map_t record_field_offset_map,
  * The second maps old FIELD_DECLs trees to the new FIELD_DECLs.
  */
 reorg_maps_t
-get_types_replacement (record_field_offset_map_t record_field_offset_map,
+get_types_replacement (record_field_offset_map3_t record_field_offset_map,
 		       hash_set<tree> &to_modify)
 {
   type_stringifier stringifier;
@@ -201,13 +201,7 @@ get_types_replacement (record_field_offset_map_t record_field_offset_map,
   record_field_offset_map4_t record_field_offset_map2;
   for (auto i = record_field_offset_map.begin(), e = record_field_offset_map.end(); i != e; ++i)
   {
-     field_offsets2_t *_second2 = new field_offsets2_t;
-     std::set<unsigned> _second1 = i->second;
-     for (auto j = _second1.begin(), f = _second1.end(); j != f; ++j)
-     {
-       _second2->add (*j);
-     }
-     record_field_offset_map2.put(i->first, _second2);
+     record_field_offset_map2.put(i->first, i->second);
   }
 
   type_reconstructor reconstructor (record_field_offset_map2, "reorg");
diff --git a/gcc/ipa-dfe.h b/gcc/ipa-dfe.h
index e60a99e6ab6..8a83a954b98 100644
--- a/gcc/ipa-dfe.h
+++ b/gcc/ipa-dfe.h
@@ -271,7 +271,7 @@ private:
 
 // Get a set of all types pointing to types in RECORD_FIELD_OFFSET_MAP.
 void
-get_all_types_pointing_to (record_field_offset_map_t record_field_offset_map,
+get_all_types_pointing_to (record_field_offset_map3_t record_field_offset_map,
 			   tpartitions2_t casting,
 			   hash_set<tree> &to_modify);
 
@@ -279,7 +279,7 @@ typedef std::pair<reorg_record_map_t, reorg_field_map_t> reorg_maps_t;
 
 // Compute the replacement types.
 reorg_maps_t
-get_types_replacement (record_field_offset_map_t record_field_offset_map,
+get_types_replacement (record_field_offset_map3_t record_field_offset_map,
 		       hash_set<tree> &to_modify);
 
 // Substitute types.
diff --git a/gcc/ipa-field-reorder.c b/gcc/ipa-field-reorder.c
index 936fd735224..f02f57b5888 100644
--- a/gcc/ipa-field-reorder.c
+++ b/gcc/ipa-field-reorder.c
@@ -519,7 +519,7 @@ record_field_map_t static find_fields_accessed ()
  * The second maps old FIELD_DECLs trees to the new FIELD_DECLs.
  */
 reorg_maps_t
-get_reordered_field_maps (record_field_offset_map_t record_field_offset_map,
+get_reordered_field_maps (record_field_offset_map3_t record_field_offset_map,
 			  hash_set<tree> & to_modify)
 {
   type_stringifier stringifier;
@@ -527,13 +527,7 @@ get_reordered_field_maps (record_field_offset_map_t record_field_offset_map,
   record_field_offset_map4_t record_field_offset_map2;
   for (auto i = record_field_offset_map.begin(), e = record_field_offset_map.end(); i != e; ++i)
   {
-     field_offsets2_t *_second2 = new field_offsets2_t;
-     std::set<unsigned> _second1 = i->second;
-     for (auto j = _second1.begin(), f = _second1.end(); j != f; ++j)
-     {
-       _second2->add (*j);
-     }
-     record_field_offset_map2.put(i->first, _second2);
+     record_field_offset_map2.put(i->first, i->second);
   }
 
   TypeReconstructorFieldReordering reconstructor (record_field_offset_map2,
@@ -613,7 +607,7 @@ lto_fr_execute ()
   tpartitions2_t escaping_nonescaping_sets;
   partition_types_into_escaping_nonescaping (escaping_nonescaping_sets, whitelisted2);
   record_field_map_t record_field_map = find_fields_accessed ();
-  record_field_offset_map_t record_field_offset_map
+  record_field_offset_map3_t record_field_offset_map
     = obtain_nonescaping_unaccessed_fields (escaping_nonescaping_sets,
 					    record_field_map, 0);
 
diff --git a/gcc/ipa-type-escape-analysis.c b/gcc/ipa-type-escape-analysis.c
index 6735b9e5b70..5b78bbe424f 100644
--- a/gcc/ipa-type-escape-analysis.c
+++ b/gcc/ipa-type-escape-analysis.c
@@ -362,7 +362,7 @@ lto_dead_field_elimination ()
   if (detected_incompatible_syntax) return;
   record_field_map_t record_field_map = find_fields_accessed ();
   if (detected_incompatible_syntax) return;
-  record_field_offset_map_t record_field_offset_map
+  record_field_offset_map3_t record_field_offset_map
     = obtain_nonescaping_unaccessed_fields (escaping_nonescaping_sets, 
 					    record_field_map, OPT_Wdfa);
   if (detected_incompatible_syntax || record_field_offset_map.empty ())
@@ -475,7 +475,7 @@ find_equivalent_trees (tree r_i, record_field_map_t record_field_map,
  */
 static void
 add_offset_only_if_read (tree field, unsigned access,
-			 field_offsets_t &field_offset)
+			 field_offsets2_t &field_offset2)
 {
   assert_is_type (field, FIELD_DECL);
   const bool is_read = access & Read;
@@ -484,7 +484,7 @@ add_offset_only_if_read (tree field, unsigned access,
 
   tree _field = tree_to_tree (field);
   unsigned f_offset = bitpos_of_field (_field);
-  field_offset.insert (f_offset);
+  field_offset2.add (f_offset);
 }
 
 /*
@@ -496,13 +496,13 @@ add_offset_only_if_read (tree field, unsigned access,
  */
 static void
 keep_only_read_fields_from_field_map (field_access_map_t &field_map,
-				      field_offsets_t &field_offset)
+				      field_offsets2_t &field_offset2)
 {
   for (std::map<tree, unsigned>::iterator j = field_map.begin (),
 						f = field_map.end ();
        j != f; ++j)
     {
-      add_offset_only_if_read (j->first, j->second, field_offset);
+      add_offset_only_if_read (j->first, j->second, field_offset2);
     }
 }
 
@@ -513,7 +513,7 @@ keep_only_read_fields_from_field_map (field_access_map_t &field_map,
 static void
 keep_only_read_fields_from_equivalent_field_maps (
   std::vector<tree> equivalent, record_field_map_t &record_field_map,
-  field_offsets_t &field_offset)
+  field_offsets2_t &field_offset2)
 {
   for (std::vector<tree>::iterator j = equivalent.begin (),
 					 f = equivalent.end ();
@@ -521,7 +521,7 @@ keep_only_read_fields_from_equivalent_field_maps (
     {
       tree r_j = *j;
       field_access_map_t equivalent_field_map = record_field_map[r_j];
-      keep_only_read_fields_from_field_map (equivalent_field_map, field_offset);
+      keep_only_read_fields_from_field_map (equivalent_field_map, field_offset2);
     }
 }
 
@@ -531,10 +531,10 @@ keep_only_read_fields_from_equivalent_field_maps (
  */
 static void
 erase_if_no_fields_can_be_deleted (
-  record_field_offset_map_t &record_field_offset_map,
+  record_field_offset_map3_t &record_field_offset_map,
   std::set<tree> &to_keep, std::set<tree> &to_erase)
 {
-  for (std::map<tree, field_offsets_t>::iterator i
+  for (std::map<tree, field_offsets2_t*>::iterator i
        = record_field_offset_map.begin (),
        e = record_field_offset_map.end ();
        i != e; ++i)
@@ -562,11 +562,11 @@ erase_if_no_fields_can_be_deleted (
  */
 static void
 mark_escaping_types_to_be_deleted (
-  record_field_offset_map_t &record_field_offset_map,
+  record_field_offset_map3_t &record_field_offset_map,
   std::set<tree> &to_erase, tpartitions2_t casting)
 {
   tset2_t &non_escaping = casting.non_escaping;
-  for (std::map<tree, field_offsets_t>::iterator i
+  for (std::map<tree, field_offsets2_t*>::iterator i
        = record_field_offset_map.begin (),
        e = record_field_offset_map.end ();
        i != e; ++i)
@@ -581,13 +581,13 @@ mark_escaping_types_to_be_deleted (
 }
 
 // Obtain nonescaping unaccessed fields
-record_field_offset_map_t
+record_field_offset_map3_t
 obtain_nonescaping_unaccessed_fields (tpartitions2_t casting,
 				      record_field_map_t record_field_map,
 				      int _warning)
 {
   bool has_fields_that_can_be_deleted = false;
-  record_field_offset_map_t record_field_offset_map;
+  record_field_offset_map3_t record_field_offset_map;
   for (std::map<tree, field_access_map_t>::iterator i
        = record_field_map.begin (),
        e = record_field_map.end ();
@@ -596,12 +596,12 @@ obtain_nonescaping_unaccessed_fields (tpartitions2_t casting,
       tree r_i = i->first;
       std::vector<tree> equivalence
 	= find_equivalent_trees (r_i, record_field_map, casting);
-      field_offsets_t field_offset;
+      field_offsets2_t *field_offset = new field_offsets2_t;
       field_access_map_t original_field_map = record_field_map[r_i];
-      keep_only_read_fields_from_field_map (original_field_map, field_offset);
+      keep_only_read_fields_from_field_map (original_field_map, *field_offset);
       keep_only_read_fields_from_equivalent_field_maps (equivalence,
 							record_field_map,
-							field_offset);
+							*field_offset);
       // These map holds the following:
       // RECORD_TYPE -> unsigned (bit_pos_offset which has been read)
       record_field_offset_map[r_i] = field_offset;
@@ -615,7 +615,7 @@ obtain_nonescaping_unaccessed_fields (tpartitions2_t casting,
   std::set<tree> to_keep;
   mark_escaping_types_to_be_deleted (record_field_offset_map, to_erase,
 				     casting);
-  for (std::map<tree, field_offsets_t>::iterator i
+  for (std::map<tree, field_offsets2_t*>::iterator i
        = record_field_offset_map.begin (),
        e = record_field_offset_map.end ();
        i != e; ++i)
@@ -626,18 +626,18 @@ obtain_nonescaping_unaccessed_fields (tpartitions2_t casting,
       if (will_be_erased)
 	continue;
 
-      field_offsets_t field_offset = i->second;
+      field_offsets2_t *field_offset = i->second;
       for (tree field = TYPE_FIELDS (record); field; field = DECL_CHAIN (field))
 	{
 	  unsigned f_offset = bitpos_of_field (field);
-	  bool in_set2 = field_offset.find (f_offset) != field_offset.end ();
+	  bool in_set2 = field_offset->contains(f_offset);
 	  if (in_set2)
 	    {
-	      field_offset.erase (f_offset);
+	      field_offset->remove (f_offset);
 	      continue;
 	    }
 	  to_keep.insert (record);
-	  field_offset.insert (f_offset);
+	  field_offset->add (f_offset);
 	  has_fields_that_can_be_deleted = true;
 	  // NOTE: With anonymous fields this might be weird to print.
 	  log ("%s.%s may be deleted\n",
@@ -656,7 +656,7 @@ obtain_nonescaping_unaccessed_fields (tpartitions2_t casting,
   // Improve: Make this more elegant.
   if (!has_fields_that_can_be_deleted)
     {
-      record_field_offset_map_t empty;
+      record_field_offset_map3_t empty;
       return empty;
     }
 
diff --git a/gcc/ipa-type-escape-analysis.h b/gcc/ipa-type-escape-analysis.h
index cf09c0705de..f61c15299e9 100644
--- a/gcc/ipa-type-escape-analysis.h
+++ b/gcc/ipa-type-escape-analysis.h
@@ -1236,7 +1236,7 @@ typedef std::set<unsigned> field_offsets_t;
 typedef hash_set<int_hash <int , -1, -2>> field_offsets2_t;
 
 typedef std::map<tree, field_offsets_t> record_field_offset_map_t;
-typedef std::map<tree, field_offsets2_t> record_field_offset_map3_t;
+typedef std::map<tree, field_offsets2_t*> record_field_offset_map3_t;
 typedef hash_map<tree, field_offsets_t> record_field_offset_map2_t;
 typedef hash_map<tree, field_offsets2_t*> record_field_offset_map4_t;
 
@@ -1245,7 +1245,7 @@ void
 partition_types_into_escaping_nonescaping (tpartitions2_t &p, hash_map<tree, bool>*);
 
 // Compute set of not escaping unaccessed fields
-record_field_offset_map_t
+record_field_offset_map3_t
 obtain_nonescaping_unaccessed_fields (tpartitions2_t casting,
 				      record_field_map_t record_field_map,
 				      int warning);