almost done

5 files changed, 69 insertions, 141 deletions

diff --git a/gcc/ipa-dfe.c b/gcc/ipa-dfe.c
index c4507a95091..98427e8e423 100644
--- a/gcc/ipa-dfe.c
+++ b/gcc/ipa-dfe.c
@@ -778,7 +778,7 @@ expr_type_rewriter::_walk_MEM_REF_post (tree e)
   if (!already_rewritten)
     return;
 
-  tree old_type = *_imap2->get(t);
+  tree old_type = *_imap2.get(t);
   assert_is_type (old_type, POINTER_TYPE);
   tree old_base_type = TREE_TYPE (old_type);
   tree old_type_size_tree = TYPE_SIZE_UNIT (old_base_type);
@@ -807,12 +807,12 @@ expr_type_rewriter::_walk_MEM_REF_post (tree e)
 bool
 expr_type_rewriter::is_interesting_type (tree t)
 {
-  const bool in_imap = _imap2->get(t);
-  bool interesting = in_imap;
+  const bool in_imap2 = _imap2.get(t);
+  bool interesting = in_imap2;
   if (!interesting)
     return false;
 
-  tree const_possibly_copy = *_imap2->get(t);
+  tree const_possibly_copy = *_imap2.get(t);
   tree possibly_copy = tree_to_tree (const_possibly_copy);
   const bool is_copy = possibly_copy == t;
   interesting = !is_copy;
@@ -854,7 +854,7 @@ expr_type_rewriter::handle_pointer_arithmetic_diff (gimple *s, tree op_0)
   tree reorg_type_size_tree = TYPE_SIZE_UNIT (inner_reorg_type);
   int reorg_type_size_int = tree_to_shwi (reorg_type_size_tree);
 
-  tree const_old_type = *_imap2->get(reorg_type);
+  tree const_old_type = *_imap2.get(reorg_type);
   tree old_type = tree_to_tree (const_old_type);
   tree inner_old_type = TREE_TYPE (old_type);
   gcc_assert (old_type);
@@ -969,7 +969,7 @@ expr_type_rewriter::handle_pointer_arithmetic_nonconstant (gimple *s, tree op_0,
   tree reorg_type_size_tree = TYPE_SIZE_UNIT (reorg_inner_type);
   int reorg_type_size_int = tree_to_shwi (reorg_type_size_tree);
   // That means that the old type is
-  tree const_old_type_tree = *_imap2->get(reorg_type_tree);
+  tree const_old_type_tree = *_imap2.get(reorg_type_tree);
   tree old_type_tree = tree_to_tree (const_old_type_tree);
   tree old_inner_type = TREE_TYPE (old_type_tree);
   tree old_type_size_tree = TYPE_SIZE_UNIT (old_inner_type);
@@ -1045,7 +1045,7 @@ expr_type_rewriter::handle_pointer_arithmetic_constants (gimple *s, tree p,
     return;
 
   tree reorg_type = possibly_reorged_type; // this is the type of the variable
-  tree original_type = *_imap2->get(reorg_type);
+  tree original_type = *_imap2.get(reorg_type);
   // If we are here, that means that our type has the ".reorg" suffix
   // Let's add a sanity check
   bool has_suffix
diff --git a/gcc/ipa-dfe.h b/gcc/ipa-dfe.h
index 99ae3b76805..180fdc9e2db 100644
--- a/gcc/ipa-dfe.h
+++ b/gcc/ipa-dfe.h
@@ -160,18 +160,16 @@ public:
     : _delete (false), _can_delete (can_delete), _map2(map), _fields2(map2)
   {
     /* Create an inverse map new RECORD_TYPE -> old RECORD_TYPE.  */
-    _imap2 = new hash_map<tree, tree>;
     for (auto i = map.begin (), e = map.end (); i != e; ++i)
       {
 	tree original = (*i).first;
 	tree modified = (*i).second;
-	_imap2->put (modified, original);
+	_imap2.put (modified, original);
       }
   };
 
   ~expr_type_rewriter()
   {
-    delete _imap2;
   };
 
   // Handle pointer arithmetic with constants.
@@ -199,7 +197,7 @@ private:
   reorg_field_map2_t& _fields2;
 
   // New RECORD_TYPE -> old RECORD_TYPE.
-  hash_map<tree, tree>* _imap2;
+  hash_map<tree, tree> _imap2;
 
   void _walk_post (tree e);
 
diff --git a/gcc/ipa-field-reorder.c b/gcc/ipa-field-reorder.c
index dd811ff01f6..e4c2ff4a62b 100644
--- a/gcc/ipa-field-reorder.c
+++ b/gcc/ipa-field-reorder.c
@@ -142,7 +142,7 @@ bitpos_of_field (const tree fdecl)
 class GimpleAccesserFieldReordering : public gimple_accessor
 {
 public:
-  GimpleAccesserFieldReordering ()
+  GimpleAccesserFieldReordering (record_field_map4_t &map) : gimple_accessor (map)
   {};
 
 private:
@@ -461,8 +461,8 @@ GimpleAccesserFieldReordering::_walk_pre_gcond (gcond *s)
 static unsigned int
 lto_fr_execute ();
 
-static record_field_map_t
-find_fields_accessed ();
+static void
+find_fields_accessed (record_field_map4_t &f);
 
 namespace {
 const pass_data pass_data_ipa_field_reorder = {
@@ -495,15 +495,10 @@ public:
 };
 } // namespace
 
-record_field_map_t static find_fields_accessed ()
+static void find_fields_accessed (record_field_map4_t &r)
 {
-  GimpleAccesserFieldReordering accesser;
+  GimpleAccesserFieldReordering accesser (r);
   accesser.walk ();
-
-  // This record_field_map holds
-  // RECORD_TYPE -> (FIELD_DECL -> how field is accessed)
-  record_field_map_t record_field_map = accesser.get_map ();
-  return record_field_map;
 }
 
 /* record_field_offset_map holds information on which FIELD_DECLs might be
@@ -592,7 +587,8 @@ lto_fr_execute ()
   hash_map<tree, bool> *whitelisted2 = get_whitelisted_nodes2();
   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_map4_t record_field_map;
+  find_fields_accessed (record_field_map);
   record_field_offset_map4_t record_field_offset_map;
   obtain_nonescaping_unaccessed_fields (escaping_nonescaping_sets,
 					    record_field_map, 0, record_field_offset_map);
diff --git a/gcc/ipa-type-escape-analysis.c b/gcc/ipa-type-escape-analysis.c
index bcc9901e5cb..3bbcfb8d1e9 100644
--- a/gcc/ipa-type-escape-analysis.c
+++ b/gcc/ipa-type-escape-analysis.c
@@ -193,8 +193,8 @@ static void
 fix_escaping_types_in_set (tpartitions2_t &types);
 
 // Find which fields are accessed.
-static record_field_map_t
-find_fields_accessed ();
+static void
+find_fields_accessed (record_field_map4_t &f);
 
 // TODO:
 // This was copy pasted from tree-ssa-structalias.c
@@ -360,7 +360,8 @@ lto_dead_field_elimination ()
   tpartitions2_t escaping_nonescaping_sets;
   partition_types_into_escaping_nonescaping (escaping_nonescaping_sets, whitelisted2);
   if (detected_incompatible_syntax) return;
-  record_field_map_t record_field_map = find_fields_accessed ();
+  record_field_map4_t record_field_map;
+  find_fields_accessed (record_field_map);
   if (detected_incompatible_syntax) return;
   record_field_offset_map4_t record_field_offset_map;
   obtain_nonescaping_unaccessed_fields (escaping_nonescaping_sets, 
@@ -418,15 +419,10 @@ partition_types_into_escaping_nonescaping (tpartitions2_t &partitions, hash_map<
  * which fields are accessed for all RECORD_TYPE
  * types.
  */
-record_field_map_t static find_fields_accessed ()
+static void find_fields_accessed (record_field_map4_t &record_field_map)
 {
-  gimple_accessor accesser;
+  gimple_accessor accesser (record_field_map) ;
   accesser.walk ();
-
-  // This record_field_map holds
-  // RECORD_TYPE -> (FIELD_DECL -> how field is accessed)
-  record_field_map_t record_field_map = accesser.get_map ();
-  return record_field_map;
 }
 
 /* Find equivalent RECORD_TYPE trees to tree r_i.
@@ -438,7 +434,7 @@ record_field_map_t static find_fields_accessed ()
  * equivalent trees found in record_field_map.
  */
 static std::vector<tree>
-find_equivalent_trees (tree r_i, record_field_map_t record_field_map,
+find_equivalent_trees (tree r_i, record_field_map4_t &record_field_map,
 		       tpartitions2_t casting)
 {
   type_incomplete_equality equality;
@@ -447,12 +443,11 @@ find_equivalent_trees (tree r_i, record_field_map_t record_field_map,
   if (!is_rin_record)
     return equivalence;
 
-  for (std::map<tree, field_access_map_t>::const_iterator j
-       = record_field_map.begin (),
+  for (auto j = record_field_map.begin (),
        f = record_field_map.end ();
-       j != f; j++)
+       j != f; ++j)
     {
-      tree r_j = j->first;
+      tree r_j = (*j).first;
       const bool pointer_equal = r_i == r_j;
       if (pointer_equal)
 	continue;
@@ -480,6 +475,7 @@ static void
 add_offset_only_if_read (tree field, unsigned access,
 			 field_offsets2_t &field_offset2)
 {
+  gcc_assert(field);
   assert_is_type (field, FIELD_DECL);
   const bool is_read = access & Read;
   if (!is_read)
@@ -498,14 +494,12 @@ add_offset_only_if_read (tree field, unsigned access,
  * tree (RECORD_TYPE) -> bitpos_of_field for read fields).
  */
 static void
-keep_only_read_fields_from_field_map (field_access_map_t &field_map,
+keep_only_read_fields_from_field_map (field_access_map2_t &field_map,
 				      field_offsets2_t &field_offset2)
 {
-  for (std::map<tree, unsigned>::iterator j = field_map.begin (),
-						f = field_map.end ();
-       j != f; ++j)
+  for (auto j = field_map.begin (), f = field_map.end (); j != f; ++j)
     {
-      add_offset_only_if_read (j->first, j->second, field_offset2);
+      add_offset_only_if_read ((*j).first, (*j).second, field_offset2);
     }
 }
 
@@ -515,7 +509,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,
+  std::vector<tree> equivalent, record_field_map4_t &record_field_map,
   field_offsets2_t &field_offset2)
 {
   for (std::vector<tree>::iterator j = equivalent.begin (),
@@ -523,8 +517,8 @@ keep_only_read_fields_from_equivalent_field_maps (
        j != f; j++)
     {
       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_offset2);
+      field_access_map2_t *equivalent_field_map = *record_field_map.get(r_j);
+      keep_only_read_fields_from_field_map (*equivalent_field_map, field_offset2);
     }
 }
 
@@ -586,22 +580,23 @@ mark_escaping_types_to_be_deleted (
 // Obtain nonescaping unaccessed fields
 void
 obtain_nonescaping_unaccessed_fields (tpartitions2_t casting,
-				      record_field_map_t record_field_map,
+				      record_field_map4_t &record_field_map,
 				      int _warning,
 				      record_field_offset_map4_t &record_field_offset_map)
 {
   bool has_fields_that_can_be_deleted = false;
-  for (std::map<tree, field_access_map_t>::iterator i
+  for (hash_map<tree, field_access_map2_t*>::iterator i
        = record_field_map.begin (),
        e = record_field_map.end ();
        i != e; ++i)
     {
-      tree r_i = i->first;
+      tree r_i = (*i).first;
       std::vector<tree> equivalence
 	= find_equivalent_trees (r_i, record_field_map, casting);
       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);
+      field_access_map2_t *original_field_map = (*i).second;
+      gcc_assert(original_field_map);
+      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);
@@ -2705,32 +2700,22 @@ type_accessor::is_in_record_field_map(tree t)
   return _map4.get (t);
 }
 
-field_access_map_t
+field_access_map2_t*
 type_accessor::get_from_record_field_map(tree t)
 {
   gcc_assert (_map4.get (t));
-  field_access_map_t temp;
   field_access_map2_t *value = *_map4.get(t);
-  for (auto i = value->begin(), e = value->end(); i != e; ++i)
-  {
-    temp.insert({(*i).first, (*i).second});
-  }
-  return temp;
+  return value;
 }
 
 void
-type_accessor::put_in_record_field_map(tree t, field_access_map_t f)
+type_accessor::put_in_record_field_map(tree t, field_access_map2_t* f)
 {
-  field_access_map2_t *f2 = new field_access_map2_t;
-  if (_map4.get (t))
+  if (_map4.get (t) && (*_map4.get (t) != f))
   {
     delete *(_map4.get(t));
   }
-  for (auto i = f.begin(), e = f.end(); i != e; ++i)
-  {
-    f2->put(i->first, i->second);
-  }
-  _map4.put(t, f2);
+  _map4.put(t, f);
 }
 
 bool
@@ -2757,48 +2742,22 @@ type_accessor::add_all_fields_in_struct (tree t)
     return;
 
   const bool record_already_in_map = is_in_record_field_map(t);
-  field_access_map_t field_map;
-  field_map = record_already_in_map ? get_from_record_field_map(t) : field_map;
+  field_access_map2_t *field_map;
+  field_map = record_already_in_map ? get_from_record_field_map(t) : new field_access_map2_t;
 
   // Let's add all fields to the field map as empty.
   for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
     {
       const bool field_already_in_map_2
-	= field_map.find (field) != field_map.end ();
+	= field_map->get (field);
       if (field_already_in_map_2)
 	continue;
-      field_map[field] = Empty;
+      field_map->put(field, Empty);
     }
 
   put_in_record_field_map(t, field_map);
 }
 
-record_field_map_t
-type_accessor::get_map ()
-{
-  // here we need to translate 
-  // record_field_map2_t to record_field_map
-  record_field_map_t return_value;
-  for (auto i = _map4.begin(), e = _map4.end(); i != e; ++i)
-  {
-    if (!(*i).second) continue;
-    field_access_map2_t *map = (*i).second;
-    field_access_map_t return_map;
-    for (auto j = map->begin(), f = map->end(); j != f; ++j)
-    {
-      return_map.insert({(*j).first, (*j).second});
-    }
-    return_value.insert({(*i).first, return_map});
-  }
-  return return_value;
-}
-
-record_field_map_t
-expr_accessor::get_map ()
-{
-  return _type_accessor.get_map ();
-}
-
 void
 expr_accessor::add_all_fields_in_struct (tree t)
 {
@@ -2881,8 +2840,8 @@ expr_accessor::_walk_ADDR_EXPR_pre (__attribute__ ((unused)) tree e)
   // We need to get the field that corresponds to the offset_int
   const bool record_already_in_map
     = _type_accessor.is_in_record_field_map (addr_expr_t);
-  field_access_map_t field_map;
-  field_map = record_already_in_map ? _type_accessor.get_from_record_field_map(addr_expr_t) : field_map;
+  field_access_map2_t *field_map;
+  field_map = record_already_in_map ? _type_accessor.get_from_record_field_map(addr_expr_t) : new field_access_map2_t;
 
   // UNSAFE! But it is necesseary for testing...
   // Unless there is someone who is smarter that finds another way to test this.
@@ -2905,11 +2864,11 @@ expr_accessor::_walk_ADDR_EXPR_pre (__attribute__ ((unused)) tree e)
       // Otherwise, this pointer arithmetic is invalid...
       // After the transformation
       const bool field_already_in_map
-	= field_map.find (field) != field_map.end ();
-      unsigned prev_access = field_already_in_map ? field_map[field] : Empty;
+	= field_map->get (field);
+      unsigned prev_access = field_already_in_map ? *field_map->get(field) : Empty;
 
       prev_access |= Read;
-      field_map[field] = prev_access;
+      field_map->put(field, prev_access);
       add_all_fields_in_struct (addr_expr_t);
       _type_accessor.put_in_record_field_map(addr_expr_t, field_map);
 
@@ -2944,13 +2903,13 @@ expr_accessor::_walk_COMPONENT_REF_pre (tree e)
        type_stringifier::get_field_identifier (op1).c_str());
   const bool record_already_in_map
     = _type_accessor.is_in_record_field_map (op0_t);
-  field_access_map_t field_map;
-  field_map = record_already_in_map ? _type_accessor.get_from_record_field_map(op0_t) : field_map;
-  const bool field_already_in_map = field_map.find (op1) != field_map.end ();
-  unsigned prev_access = field_already_in_map ? field_map[op1] : Empty;
+  field_access_map2_t *field_map;
+  field_map = record_already_in_map ? _type_accessor.get_from_record_field_map(op0_t) : new field_access_map2_t;
+  const bool field_already_in_map = field_map->get(op1);
+  unsigned prev_access = field_already_in_map ? *field_map->get(op1) : Empty;
 
   prev_access |= _access;
-  field_map[op1] = prev_access;
+  field_map->put(op1, prev_access);
   add_all_fields_in_struct (op0_t);
   _type_accessor.put_in_record_field_map(op0_t, field_map);
 
@@ -2986,11 +2945,11 @@ expr_accessor::_walk_COMPONENT_REF_pre (tree e)
   {
       log ("ever inside?\n");
       const bool field_already_in_map
-	= field_map.find (field) != field_map.end ();
-      unsigned prev_access = field_already_in_map ? field_map[field] : Empty;
+	= field_map->get(field);
+      unsigned prev_access = field_already_in_map ? *field_map->get(field) : Empty;
 
       prev_access |= Read;
-      field_map[field] = prev_access;
+      field_map->put(field, prev_access);
       add_all_fields_in_struct (t);
       _type_accessor.put_in_record_field_map(t, field_map);
   }
@@ -3025,15 +2984,6 @@ expr_accessor::print_accesses ()
     */
 }
 
-/* RECORD_TYPE -> (FIELD_DECL -> bitflag)
- * bitflag specifies if field is read, written or neither.
- */
-record_field_map_t
-gimple_accessor::get_map ()
-{
-  return _expr_accessor.get_map ();
-}
-
 void
 gimple_accessor::print_accesses ()
 {
diff --git a/gcc/ipa-type-escape-analysis.h b/gcc/ipa-type-escape-analysis.h
index 805e4b2a3fa..702e13e62ba 100644
--- a/gcc/ipa-type-escape-analysis.h
+++ b/gcc/ipa-type-escape-analysis.h
@@ -106,7 +106,6 @@ tree_to_tree (tree t)
 
 // TODO: Rename?
 // TSET_T stands for type set.
-typedef std::set<tree> tset_t;
 typedef hash_set<tree> tset2_t;
 
 /* Base class used for visiting tree nodes starting with root T.
@@ -1099,38 +1098,30 @@ const unsigned Read = 0x01u;
 const unsigned Write = 0x02u;
 
 // maps FIELD_DECL -> bitflag.
-typedef std::map<tree, unsigned> field_access_map_t;
 typedef hash_map<tree, unsigned> field_access_map2_t;
 
 // maps RECORD_TYPE -> (FIELD_DECL -> bitflag).
-typedef std::map<tree, field_access_map_t> record_field_map_t;
 typedef hash_map<tree, field_access_map2_t*> record_field_map4_t;
 
 // Class used to determine if a FIELD is read, written or never accessed.
 class type_accessor : public type_walker
 {
 public:
-  type_accessor () 
+  type_accessor (record_field_map4_t &map) : _map4(map)
   {};
 
   ~type_accessor()
   {
-
-    for (auto i = _map4.begin(), e = _map4.end(); i != e; ++i)
-    {
-      delete (*i).second;
-    }
   };
 
-  record_field_map_t get_map ();
   bool is_in_record_field_map(tree t);
-  field_access_map_t get_from_record_field_map(tree t);
-  void put_in_record_field_map(tree t, field_access_map_t);
+  field_access_map2_t* get_from_record_field_map(tree t);
+  void put_in_record_field_map(tree t, field_access_map2_t*);
 
 private:
 
   // maps RECORD -> (FIELD_DECL -> bitflag).
-  record_field_map4_t _map4;
+  record_field_map4_t &_map4;
 
   // set of trees which are memoized and we don't need to look into them.
   hash_set<tree> memoized_map2;
@@ -1148,7 +1139,7 @@ private:
 class expr_accessor : public expr_walker
 {
 public:
-  expr_accessor () : _type_accessor (), _stack2 (vNULL)
+  expr_accessor (record_field_map4_t &map) : _type_accessor (map), _stack2 (vNULL)
   {};
 
   // Expr E is accessed in A manner.
@@ -1160,9 +1151,6 @@ public:
   // Add all fields to map.  Initialize with empty.
   void add_all_fields_in_struct (tree t);
 
-  // Get final results.
-  record_field_map_t get_map ();
-
   // Aids expr-accessor in updating types.
   type_accessor _type_accessor;
 
@@ -1200,15 +1188,13 @@ private:
 class gimple_accessor : public gimple_walker
 {
 public:
-  gimple_accessor ()
+  gimple_accessor (record_field_map4_t &map)
+  : _expr_accessor(map)
   {};
 
   /* Print final results.  */
   void print_accesses ();
 
-  /* Get final results.  */
-  record_field_map_t get_map ();
-
 protected:
   /* Navigate expressions in gimple statements.  */
   expr_accessor _expr_accessor;
@@ -1233,8 +1219,6 @@ private:
 };
 
 typedef hash_set<int_hash <int , -1, -2>> field_offsets2_t;
-
-typedef std::map<tree, field_offsets2_t*> record_field_offset_map3_t;
 typedef hash_map<tree, field_offsets2_t*> record_field_offset_map4_t;
 
 // Partition types into escaping or non escaping sets.
@@ -1244,7 +1228,7 @@ partition_types_into_escaping_nonescaping (tpartitions2_t &p, hash_map<tree, boo
 // Compute set of not escaping unaccessed fields
 void
 obtain_nonescaping_unaccessed_fields (tpartitions2_t casting,
-				      record_field_map_t record_field_map,
+				      record_field_map4_t& record_field_map,
 				      int warning,
 				      record_field_offset_map4_t &a);