type_accessor owns record_field_access_map

2 files changed, 29 insertions, 36 deletions

diff --git a/gcc/ipa-type-escape-analysis.c b/gcc/ipa-type-escape-analysis.c
index 5cc43c246b2..e9661e1751f 100644
--- a/gcc/ipa-type-escape-analysis.c
+++ b/gcc/ipa-type-escape-analysis.c
@@ -2794,11 +2794,16 @@ gimple_caster::_walk_pre_gcall (gcall *s)
   _expr_escaper.update (lhs, ret_reason);
 }
 
+record_field_map_t&
+type_accessor::get_map_ref()
+{
+  return _map;
+}
+
 bool
 type_accessor::is_memoized (tree t)
 {
   return memoized_map2.contains (t);
-  //return memoized_map.find (t) != memoized_map.end ();
 }
 
 /* Add all fields in struct to memoized map.  */
@@ -2807,7 +2812,6 @@ type_accessor::_walk_RECORD_TYPE_pre (tree t)
 {
   add_all_fields_in_struct (t);
   memoized_map2.add (t);
-  //memoized_map.insert (t);
 }
 
 /* Initialize all fields as neither read nor written.  */
@@ -2839,7 +2843,7 @@ type_accessor::add_all_fields_in_struct (tree t)
 record_field_map_t
 expr_accessor::get_map ()
 {
-  return record_field_map;
+  return _type_accessor._map;
 }
 
 void
@@ -2923,9 +2927,9 @@ expr_accessor::_walk_ADDR_EXPR_pre (__attribute__ ((unused)) tree e)
   unsigned offset_int = tree_to_uhwi (offset) % type_size_int;
   // We need to get the field that corresponds to the offset_int
   const bool record_already_in_map
-    = record_field_map.find (addr_expr_t) != record_field_map.end ();
+    = _type_accessor.get_map_ref().find (addr_expr_t) != _type_accessor.get_map_ref().end ();
   field_access_map_t field_map;
-  field_map = record_already_in_map ? record_field_map[addr_expr_t] : field_map;
+  field_map = record_already_in_map ? _type_accessor.get_map_ref()[addr_expr_t] : field_map;
 
   // UNSAFE! But it is necesseary for testing...
   // Unless there is someone who is smarter that finds another way to test this.
@@ -2954,7 +2958,7 @@ expr_accessor::_walk_ADDR_EXPR_pre (__attribute__ ((unused)) tree e)
       prev_access |= Read;
       field_map[field] = prev_access;
       add_all_fields_in_struct (addr_expr_t);
-      record_field_map[addr_expr_t] = field_map;
+      _type_accessor.get_map_ref()[addr_expr_t] = field_map;
 
       if (f_offset == offset_int)
 	break;
@@ -2986,16 +2990,16 @@ expr_accessor::_walk_COMPONENT_REF_pre (tree e)
   log ("%s.%s\n", type_stringifier::get_type_identifier (op0_t).c_str(),
        type_stringifier::get_field_identifier (op1).c_str());
   const bool record_already_in_map
-    = record_field_map.find (op0_t) != record_field_map.end ();
+    = _type_accessor.get_map_ref().find (op0_t) != _type_accessor.get_map_ref().end ();
   field_access_map_t field_map;
-  field_map = record_already_in_map ? record_field_map[op0_t] : field_map;
+  field_map = record_already_in_map ? _type_accessor.get_map_ref()[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;
 
   prev_access |= _access;
   field_map[op1] = prev_access;
   add_all_fields_in_struct (op0_t);
-  record_field_map[op0_t] = field_map;
+  _type_accessor.get_map_ref()[op0_t] = field_map;
 
   if (_stack.size () < 4)
     return;
@@ -3035,7 +3039,7 @@ expr_accessor::_walk_COMPONENT_REF_pre (tree e)
       prev_access |= Read;
       field_map[field] = prev_access;
       add_all_fields_in_struct (t);
-      record_field_map[t] = field_map;
+      _type_accessor.get_map_ref()[t] = field_map;
   }
 }
 
@@ -3044,8 +3048,8 @@ void
 expr_accessor::print_accesses ()
 {
   for (std::map<tree, field_access_map_t>::const_iterator i
-       = record_field_map.begin (),
-       e = record_field_map.end ();
+       = _type_accessor.get_map_ref().begin (),
+       e = _type_accessor.get_map_ref().end ();
        i != e; ++i)
     {
       tree record = i->first;
diff --git a/gcc/ipa-type-escape-analysis.h b/gcc/ipa-type-escape-analysis.h
index 96f726f58ba..99eed158542 100644
--- a/gcc/ipa-type-escape-analysis.h
+++ b/gcc/ipa-type-escape-analysis.h
@@ -1136,31 +1136,19 @@ typedef std::map<tree, field_access_map2_t*> record_field_map2_t;
 class type_accessor : public type_walker
 {
 public:
-  type_accessor (record_field_map_t &map) : _map (map)
-  {
-    for (auto i = map.begin(), e = map.end(); i != e; ++i)
-    {
-      field_access_map2_t *field_access_map_new = new field_access_map2_t;
-      field_access_map_t  field_access_map = i->second;
-      for (auto j = field_access_map.begin(), f = field_access_map.end(); j != f; ++j)
-      {
-        field_access_map_new->put (j->first, j->second);
-      }
-      _map2[i->first] = field_access_map_new;
-    } 
-  };
+  type_accessor () 
+  {};
+
   ~type_accessor()
   {
-    for (auto i = _map2.begin(), e = _map2.end(); i != e; ++i)
-    {
-      delete _map2.at(i->first);
-    }
   };
 
-private:
+  record_field_map_t &get_map_ref();
+
   // maps RECORD -> (FIELD_DECL -> bitflag).
-  record_field_map_t &_map;
-  record_field_map2_t _map2;
+  record_field_map_t _map;
+
+private:
 
   // set of trees which are memoized and we don't need to look into them.
   hash_set<tree> memoized_map2;
@@ -1178,7 +1166,7 @@ private:
 class expr_accessor : public expr_walker
 {
 public:
-  expr_accessor () : _type_accessor (record_field_map)
+  expr_accessor () : _type_accessor ()
   {};
 
   // Expr E is accessed in A manner.
@@ -1193,6 +1181,9 @@ public:
   // Get final results.
   record_field_map_t get_map ();
 
+  // Aids expr-accessor in updating types.
+  type_accessor _type_accessor;
+
 private:
   // Access {"Read", "Write", "Neither"} to propagate to all subexpressions.
   unsigned _access;
@@ -1201,10 +1192,8 @@ private:
   std::stack<tree> _stack;
 
   // Holds main results.
-  record_field_map_t record_field_map;
+  //record_field_map_t record_field_map;
 
-  // Aids expr-accessor in updating types.
-  type_accessor _type_accessor;
 
   // Mark FIELD_DECL as read.
   // If ADDR_EXPR is parent expression that means