memset blacklisting about to begin

3 files changed, 93 insertions, 20 deletions

diff --git a/gcc/ipa-hello-world.c b/gcc/ipa-hello-world.c
index 594998aadbb..e9322455eca 100644
--- a/gcc/ipa-hello-world.c
+++ b/gcc/ipa-hello-world.c
@@ -184,6 +184,25 @@ count_access_for_type_in_addr_expr(const_tree expr, const record_set &non_escapi
   count_access_for_types_in_expr(op0, non_escaping_records, counter, access);
 }
 
+static inline void
+is_array_expr_p(const_tree expr)
+{
+  gcc_assert(expr);
+  const enum tree_code code = TREE_CODE(expr);
+  const bool is_addr_expr = ARRAY_REF == code;
+  gcc_assert(is_addr_expr);
+}
+
+void
+count_access_for_type_in_array_expr(const_tree expr, const record_set &non_escaping_records, field_access_counter &counter, const enum access_code access)
+{
+  is_array_expr_p(expr);
+  const_tree op0 = TREE_OPERAND(expr, 0);
+  const_tree op1 = TREE_OPERAND(expr, 1);
+  count_access_for_types_in_expr(op0, non_escaping_records, counter, READ_ACCESS);
+  count_access_for_types_in_expr(op1, non_escaping_records, counter, READ_ACCESS);
+}
+
 void
 count_access_for_types_in_expr(const_tree expr, const record_set &non_escaping_records, field_access_counter &counter, const enum access_code access)
 {
@@ -193,6 +212,7 @@ count_access_for_types_in_expr(const_tree expr, const record_set &non_escaping_r
   {
     case COMPONENT_REF: count_access_for_type_in_component_ref(expr, non_escaping_records, counter, access); break;
     case ADDR_EXPR: count_access_for_type_in_addr_expr(expr, non_escaping_records, counter, access); break;
+    case ARRAY_REF : count_access_for_type_in_array_expr(expr, non_escaping_records, counter, access); break;
     default: break;
   }
 }
diff --git a/gcc/ipa-str-reorg-dead-field-eliminate.c b/gcc/ipa-str-reorg-dead-field-eliminate.c
index 38d9c7b9182..f966af3b2b0 100644
--- a/gcc/ipa-str-reorg-dead-field-eliminate.c
+++ b/gcc/ipa-str-reorg-dead-field-eliminate.c
@@ -582,8 +582,11 @@ is_record_p(const_tree record)
   gcc_assert(is_record);
 }
 
-std::set<const_tree> interesting_records;
-std::set<const_tree> interesting_fields;
+struct cstrless {
+  bool operator()(const char* a, const char* b) { return strcmp(a, b) < 0; }
+};
+std::set<const char*, cstrless> interesting_records;
+std::set<const char*, cstrless> interesting_fields;
 
 static bool
 is_interesting_struct_escape_analysis(const_tree record)
@@ -591,16 +594,43 @@ is_interesting_struct_escape_analysis(const_tree record)
   is_record_p(record);
   const_tree main_variant = TYPE_MAIN_VARIANT(record);
   is_record_p(main_variant);
+  const char* const ob_type_name = get_type_name(main_variant);
+  const char* blacklist [5] = { "__gcov_fn_info", "__gcov_ctr_info", "__gcov_fn_info", "__gcov_info", "indirect_call_tuple" };
+  const char* whitelist [4] = { "arc", "arc_t", "network_t", "network" };
 
+  for (int i = 0; i < 5; i++)
+  {
+     const bool is_blacklisted = strcmp(blacklist[i], ob_type_name) == 0;
+     if (is_blacklisted) return false;
+  }
 
-  const bool in_set = 
+  bool is_whitelisted = false;
+  for (int i = 0; i < 4; i++)
+  {
+     is_whitelisted |= strcmp(whitelist[i], ob_type_name) == 0;
+  }
+  if (!is_whitelisted) return false;
+
+
+  bool in_set = 
 #if __cplusplus > 201703L
-          interesting_records.contains(main_variant)
+          interesting_records.contains(get_type_name(main_variant))
 #else
-	  interesting_records.find(main_variant) != interesting_records.end()
+	  interesting_records.find(get_type_name(main_variant)) != interesting_records.end()
 #endif
 	  ;
 
+  in_set |=  
+#if __cplusplus > 201703L
+          interesting_records.contains(get_type_name(record))
+#else
+	  interesting_records.find(get_type_name(record)) != interesting_records.end()
+#endif
+	  ;
+
+
+  log("is interesting struct ? %s\n", in_set ? "true" : "false");
+
   return in_set;
 
 }
@@ -643,7 +673,7 @@ is_interesting_struct_manual(const_tree record_1)
 }
 
 
-inline static bool
+inline static void
 is_field_decl_p(const_tree field)
 {
   gcc_assert(field);
@@ -679,18 +709,29 @@ static bool
 is_interesting_field_escape_analysis(const_tree field)
 {
   is_field_decl_p(field);
-  const_tree main_variant = TYPE_MAIN_VARIANT(field);
-  is_field_decl_p(main_variant);
 
+  const char* field_name = get_field_name(field);
+  /*
+  const char* whitelist [2] = { "nextin", "nextout" };
+
+  bool is_whitelisted = false;
+  for (int i = 0; i < 2; i++)
+  {
+     is_whitelisted |= strcmp(whitelist[i], field_name) == 0;
+  }
+  if (!is_whitelisted) return false;
+  */
 
   const bool in_set = 
 #if __cplusplus > 201703L
-          interesting_fields.contains(main_variant)
+          interesting_fields.contains(field_name);
 #else
-	  interesting_fields.find(main_variant) != interesting_fields.end()
+	  interesting_fields.find(field_name) != interesting_fields.end()
 #endif
 	  ;
 
+  log("is interesting field? %s\n", in_set ? "true" : "false");
+
   return in_set;
 }
 
@@ -1055,6 +1096,7 @@ get_new_type_main_variant (const_tree old, t_map *mod_type_map)
 static const_tree
 make_new_record_based_on_typedef (const_tree _typedef, t_map *mod_type_map)
 {
+  log("make_new_record_based_on_typedef\n");
   bool is_typedef = _typedef != TYPE_MAIN_VARIANT(_typedef);
   gcc_assert(is_typedef);
   tree new_main_variant = (tree) get_new_type_main_variant(_typedef, mod_type_map);
@@ -1084,6 +1126,7 @@ static const_tree
 make_new_record_based_on_old (const_tree old,
 			       t_map *mod_type_map)
 {
+  log("make_new_record_based_on_old\n %s", get_type_name(old));
   delete_info_t* info = mod_type_map->get(old);
   const_tree *new_record_ptr = info ? &(info->new_record) : NULL;
 
@@ -1105,13 +1148,12 @@ make_new_record_based_on_old (const_tree old,
        old_field = DECL_CHAIN (old_field))
     {
 
-      if (will_definitely_change)
+     const bool are_field_names_equal = is_interesting_field (old_field);
+     log("am i deleting fields ? %s\n", will_definitely_change && are_field_names_equal ? "true" : "false");
+      if (will_definitely_change && are_field_names_equal)
 	{
-          const bool are_field_names_equal = is_interesting_field (old_field);
-	  if (are_field_names_equal) {
-	    deleted_fields->add(old_field);
-	    continue;
-	  }
+	  deleted_fields->add(old_field);
+	  continue;
 	}
 
       tree new_field = make_node (FIELD_DECL);
@@ -2525,7 +2567,7 @@ compute_inverse_type_map ( t_map &mod_type_map,
 
 
 static void
-separate_set_of_pairs_into_pair_of_sets(const record_field_set &set_of_pairs, std::set<const_tree> &one, std::set<const_tree> &two)
+separate_set_of_pairs_into_pair_of_sets(const record_field_set &set_of_pairs, std::set<const char*, cstrless> &one, std::set<const char*, cstrless> &two)
 {
   
   for (auto it = set_of_pairs.cbegin(); it != set_of_pairs.cend() ; ++it)
@@ -2533,8 +2575,9 @@ separate_set_of_pairs_into_pair_of_sets(const record_field_set &set_of_pairs, st
     fields record_field_pair = *it;
     const_tree record = record_field_pair.first;
     const_tree field = record_field_pair.second;
-    one.insert(record);
-    two.insert(field);
+    one.insert(get_type_name(record));
+    one.insert(get_type_name(TYPE_MAIN_VARIANT(record)));
+    two.insert(get_field_name(field));
   }
 }
 
@@ -2544,6 +2587,14 @@ iphw_execute_escape_analysis()
   gcc_assert(!flag_ipa_typelist_struct && !flag_ipa_typelist_field);
   const record_field_set to_reorg = get_fields_to_reorg();
   separate_set_of_pairs_into_pair_of_sets(to_reorg, interesting_records, interesting_fields);
+
+  hash_set<const_tree> orig_type_map;
+  collect_orig_structs (orig_type_map);
+  t_map mod_type_map;
+  compute_modified_structs (orig_type_map, mod_type_map);
+  t_map inverse_type_map;
+  compute_inverse_type_map (mod_type_map, inverse_type_map);
+  rewrite_references_to_modified_structs (mod_type_map, inverse_type_map);
 }
 
 static void
diff --git a/gcc/ipa-type-escape-analysis.c b/gcc/ipa-type-escape-analysis.c
index a3c10302327..ff86447e869 100644
--- a/gcc/ipa-type-escape-analysis.c
+++ b/gcc/ipa-type-escape-analysis.c
@@ -259,9 +259,11 @@ collect_global(type_map &escape_map, varpool_node *vnode)
 
     tree type = TREE_TYPE(decl);
     gcc_assert(type);
+    log("collecting global type escape analysis %s\n", get_type_name(type));
     escaping_reason reason = new_escaping_reason();
     escaping_info info = { type, false, reason };
     escape_map.put (type, info);
+    //escape_map.put (TYPE_MAIN_VARIANT(type), info);
   }
 }
 
@@ -431,9 +433,9 @@ collect_types(type_map &escape_map)
   cgraph_node *cnode = NULL;
   FOR_EACH_DEFINED_FUNCTION (cnode)
   {
+    collect_parm_declarations (cnode, escape_map);
     collect_function_body (cnode, escape_map);
     collect_local_declarations (cnode, escape_map);
-    collect_parm_declarations (cnode, escape_map);
   }
 }