CbC/CbC_gcc: gcc/ipa-devirt.c comparison

comparison gcc/ipa-devirt.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Basic IPA utilities for type inheritance graph construction and
 devirtualization.
-Copyright (C) 2013-2017 Free Software Foundation, Inc.
+Copyright (C) 2013-2018 Free Software Foundation, Inc.
 Contributed by Jan Hubicka
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 TYPE_BINFO (type) = binfo;
 else
 gcc_assert (!TYPE_BINFO (type));
 }
-/* Compare T2 and T2 based on name or structure.  */
+/* Compare T1 and T2 based on name or structure.  */
 static bool
 odr_subtypes_equivalent_p (tree t1, tree t2,
 			   hash_set<type_pair> *visited,
 			   location_t loc1, location_t loc2)
 if ((type_with_linkage_p (t1) && type_in_anonymous_namespace_p (t1))
 || (type_with_linkage_p (t2) && type_in_anonymous_namespace_p (t2)))
 return false;
 /* For ODR types be sure to compare their names.
-To support -wno-odr-type-merging we allow one type to be non-ODR
+To support -Wno-odr-type-merging we allow one type to be non-ODR
 and other ODR even though it is a violation.  */
 if (types_odr_comparable (t1, t2, true))
 {
 if (!types_same_for_odr (t1, t2, true))
 return false;
 /* Limit recursion: If subtypes are ODR types and we know
-that they are same, be happy.  */
+	 that they are same, be happy.  */
 if (!odr_type_p (t1) || !get_odr_type (t1, true)->odr_violated)
 return true;
 }
 /* Component types, builtins and possibly violating ODR types
 	{
 	  varpool_node *tmp = prevailing;
 	  prevailing = vtable;
 	  vtable = tmp;
 	}
+auto_diagnostic_group d;
 if (warning_at (DECL_SOURCE_LOCATION
 			(TYPE_NAME (DECL_CONTEXT (vtable->decl))),
 		      OPT_Wodr,
 		      "virtual table of type %qD violates one definition rule",
 		      DECL_CONTEXT (vtable->decl)))
 	         || (methods_equal_p (ref1->referred->decl,
 				      ref2->referred->decl)
 	             && TREE_CODE (ref1->referred->decl) == FUNCTION_DECL))
 	     && TREE_CODE (ref2->referred->decl) != FUNCTION_DECL)
 	{
-	  if (!class_type->rtti_broken
+	  if (!class_type->rtti_broken)
-	      && warning_at (DECL_SOURCE_LOCATION
-			      (TYPE_NAME (DECL_CONTEXT (vtable->decl))),
-			     OPT_Wodr,
-			     "virtual table of type %qD contains RTTI "
-			     "information",
-			     DECL_CONTEXT (vtable->decl)))
 	    {
-	      inform (DECL_SOURCE_LOCATION
+	      auto_diagnostic_group d;
-			(TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
+	      if (warning_at (DECL_SOURCE_LOCATION
-		      "but is prevailed by one without from other translation "
+				  (TYPE_NAME (DECL_CONTEXT (vtable->decl))),
-		      "unit");
+				OPT_Wodr,
-	      inform (DECL_SOURCE_LOCATION
+				"virtual table of type %qD contains RTTI "
-			(TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
+				"information",
-		      "RTTI will not work on this type");
+				DECL_CONTEXT (vtable->decl)))
-	      class_type->rtti_broken = true;
+		{
+		  inform (DECL_SOURCE_LOCATION
+			      (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
+			    "but is prevailed by one without from other"
+			    " translation unit");
+		  inform (DECL_SOURCE_LOCATION
+			      (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
+			    "RTTI will not work on this type");
+		  class_type->rtti_broken = true;
+		}
 	    }
 	  n2++;
 end2 = !vtable->iterate_reference (n2, ref2);
 	}
 while (!end1
 	     Do this as very last check so the not very informative error
 	     is not output too often.  */
 	  if (DECL_SIZE (prevailing->decl) != DECL_SIZE (vtable->decl))
 	    {
 	      class_type->odr_violated = true;
+	      auto_diagnostic_group d;
 	      if (warning_at (DECL_SOURCE_LOCATION
 				(TYPE_NAME (DECL_CONTEXT (vtable->decl))),
 			      OPT_Wodr,
 			      "virtual table of type %qD violates "
 			      "one definition rule  ",
 	  /* If the loops above stopped on non-virtual pointer, we have
 	     mismatch in RTTI information mangling.  */
 	  if (TREE_CODE (ref1->referred->decl) != FUNCTION_DECL
 	      && TREE_CODE (ref2->referred->decl) != FUNCTION_DECL)
 	    {
+	      auto_diagnostic_group d;
 	      if (warning_at (DECL_SOURCE_LOCATION
 				(TYPE_NAME (DECL_CONTEXT (vtable->decl))),
 			      OPT_Wodr,
 			      "virtual table of type %qD violates "
 			      "one definition rule  ",
 	      varpool_node *tmp = prevailing;
 	      prevailing = vtable;
 	      vtable = tmp;
 	      ref1 = ref2;
 	    }
+	  auto_diagnostic_group d;
 	  if (warning_at (DECL_SOURCE_LOCATION
 			    (TYPE_NAME (DECL_CONTEXT (vtable->decl))),
 			  OPT_Wodr,
 			  "virtual table of type %qD violates "
 			  "one definition rule",
 	  return;
 	}
 /* And in the last case we have either mistmatch in between two virtual
 	 methods or two virtual table pointers.  */
+auto_diagnostic_group d;
 if (warning_at (DECL_SOURCE_LOCATION
 			(TYPE_NAME (DECL_CONTEXT (vtable->decl))), OPT_Wodr,
 		      "virtual table of type %qD violates "
 		      "one definition rule  ",
 		      DECL_CONTEXT (vtable->decl)))
 /* ODR warnings are output druing LTO streaming; we must apply location
 cache for potential warnings to be output correctly.  */
 if (lto_location_cache::current_cache)
 lto_location_cache::current_cache->apply_location_cache ();
+auto_diagnostic_group d;
 if (!warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (t1)), OPT_Wodr,
 		   "type %qT violates the C++ One Definition Rule",
 		   t1))
 return;
 if (!st1 && !st2)
 		    warn_odr (t1, t2, f1, f2, warn, warned,
 			      G_("fields have different layout "
 				 "in another translation unit"));
 		    return false;
 		  }
-		gcc_assert (DECL_NONADDRESSABLE_P (f1)
+		if (DECL_BIT_FIELD (f1) != DECL_BIT_FIELD (f2))
-			    == DECL_NONADDRESSABLE_P (f2));
+		  {
+		    warn_odr (t1, t2, f1, f2, warn, warned,
+			      G_("one field is bitfield while other is not"));
+		    return false;
+		  }
+		else
+		  gcc_assert (DECL_NONADDRESSABLE_P (f1)
+			      == DECL_NONADDRESSABLE_P (f2));
 	      }
 	    /* If one aggregate has more fields than the other, they
 	       are not the same.  */
 	    if (f1 || f2)
 	      putc ('\n',symtab->dump_file);
 	    }
 	}
 }
-/* Next compare memory layout.  */
+/* Next compare memory layout.
+The DECL_SOURCE_LOCATIONs in this invocation came from LTO streaming.
+We must apply the location cache to ensure that they are valid
+before we can pass them to odr_types_equivalent_p (PR lto/83121).  */
+if (lto_location_cache::current_cache)
+lto_location_cache::current_cache->apply_location_cache ();
 if (!odr_types_equivalent_p (val->type, type,
 			       !flag_ltrans && !val->odr_violated && !warned,
 			       &warned, &visited,
 			       DECL_SOURCE_LOCATION (TYPE_NAME (val->type)),
 			       DECL_SOURCE_LOCATION (TYPE_NAME (type))))
 delete cached_polymorphic_call_targets;
 cached_polymorphic_call_targets = NULL;
 }
 }
+/* Force rebuilding type inheritance graph from scratch.
+This is use to make sure that we do not keep references to types
+which was not visible to free_lang_data.  */
+void
+rebuild_type_inheritance_graph ()
+{
+if (!odr_hash)
+return;
+delete odr_hash;
+if (in_lto_p)
+delete odr_vtable_hash;
+odr_hash = NULL;
+odr_vtable_hash = NULL;
+odr_types_ptr = NULL;
+free_polymorphic_call_targets_hash ();
+}
 /* When virtual function is removed, we may need to flush the cache.  */
 static void
 devirt_node_removal_hook (struct cgraph_node *n, void *d ATTRIBUTE_UNUSED)
 {
 /* Information about type and decl warnings.  */
 struct final_warning_record
 {
+/* If needed grow type_warnings vector and initialize new decl_warn_count
+to have dyn_count set to profile_count::zero ().  */
+void grow_type_warnings (unsigned newlen);
 profile_count dyn_count;
 auto_vec<odr_type_warn_count> type_warnings;
 hash_map<tree, decl_warn_count> decl_warnings;
 };
+void
+final_warning_record::grow_type_warnings (unsigned newlen)
+{
+unsigned len = type_warnings.length ();
+if (newlen > len)
+{
+type_warnings.safe_grow_cleared (newlen);
+for (unsigned i = len; i < newlen; i++)
+	type_warnings[i].dyn_count = profile_count::zero ();
+}
+}
 struct final_warning_record *final_warning_records;
 /* Return vector containing possible targets of polymorphic call of type
 OTR_TYPE calling method OTR_TOKEN within type of OTR_OUTER_TYPE and OFFSET.
 If INCLUDE_BASES is true, walk also base types of OUTER_TYPES containing
 		{
 		  if (complete
 		      && warn_suggest_final_types
 		      && !outer_type->derived_types.length ())
 		    {
-		      if (outer_type->id >= (int)final_warning_records->type_warnings.length ())
+		      final_warning_records->grow_type_warnings
-			final_warning_records->type_warnings.safe_grow_cleared
+			(outer_type->id);
-			  (odr_types.length ());
 		      final_warning_records->type_warnings[outer_type->id].count++;
 		      if (!final_warning_records->type_warnings
 				[outer_type->id].dyn_count.initialized_p ())
 			final_warning_records->type_warnings
 			   [outer_type->id].dyn_count = profile_count::zero ();
 entries.  */
 if (warn_suggest_final_methods || warn_suggest_final_types)
 {
 final_warning_records = new (final_warning_record);
 final_warning_records->dyn_count = profile_count::zero ();
-final_warning_records->type_warnings.safe_grow_cleared
+final_warning_records->grow_type_warnings (odr_types.length ());
-						 (odr_types.length ());
 free_polymorphic_call_targets_hash ();
 }
 FOR_EACH_DEFINED_FUNCTION (n)
 {
 	    struct cgraph_node *likely_target = NULL;
 	    void *cache_token;
 	    bool final;
 	    if (final_warning_records)
-	      final_warning_records->dyn_count = e->count;
+	      final_warning_records->dyn_count = e->count.ipa ();
 	    vec <cgraph_node *>targets
 	       = possible_polymorphic_call_targets
 		    (e, &final, &cache_token, true);
 	    unsigned int i;
 	      }
 	    else if (dbg_cnt (devirt))
 	      {
 		if (dump_enabled_p ())
 {
-location_t locus = gimple_location_safe (e->call_stmt);
+dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, e->call_stmt,
-dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, locus,
 				     "speculatively devirtualizing call "
 				     "in %s to %s\n",
 				     n->dump_name (),
 				     likely_target->dump_name ());
 }
 		      likely_target = alias;
 		  }
 		nconverted++;
 		update = true;
 		e->make_speculative
-		  (likely_target, e->count.apply_scale (8, 10),
+		  (likely_target, e->count.apply_scale (8, 10));
-		   e->frequency * 8 / 10);
 	      }
 	  }
 if (update)
 	ipa_update_overall_fn_summary (n);
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ipa-devirt.c @ 131:84e7813d76e9