PR tree-optimize/46228

	* doc/invoke.texi (comdat-sharing-probability): Document.
	* ipa-inline.c (cgraph_estimate_growth): Handle COMDATs
	* params.def (PARAM_COMDAT_SHARING_PROBABILITY): New param.
	* g++.dg/tree-ssa/pr46228.C: New testcase.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@166555 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index d3b702b..dc79b88 100644 (file)
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -8343,6 +8343,11 @@ Limit of iterations of early inliner.  This basically bounds number of nested
 indirect calls early inliner can resolve.  Deeper chains are still handled by
 late inlining.
 
+@item comdat-sharing-probability
+@itemx comdat-sharing-probability
+Probability (in percent) that C++ inline function with comdat visibility
+will be shared acroess multiple compilation units.  The default value is 20.
+
 @item min-vect-loop-bound
 The minimum number of iterations under which a loop will not get vectorized
 when @option{-ftree-vectorize} is used.  The number of iterations after

diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index 61fc6b9..d4109c5 100644 (file)
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -404,6 +404,12 @@ cgraph_estimate_growth (struct cgraph_node *node)
   if (cgraph_will_be_removed_from_program_if_no_direct_calls (node)
       && !DECL_EXTERNAL (node->decl) && !self_recursive)
     growth -= node->global.size;
+  /* COMDAT functions are very often not shared across multiple units since they
+     come from various template instantiations.  Take this into account.  */
+  else  if (DECL_COMDAT (node->decl) && !self_recursive
+           && cgraph_can_remove_if_no_direct_calls_p (node))
+    growth -= (node->global.size
+              * (100 - PARAM_VALUE (PARAM_COMDAT_SHARING_PROBABILITY)) + 50) / 100;
 
   node->global.estimated_growth = growth;
   return growth;

diff --git a/gcc/params.def b/gcc/params.def
index 49a6185..6e55db6 100644 (file)
--- a/gcc/params.def
+++ b/gcc/params.def
@@ -118,6 +118,12 @@ DEFPARAM (PARAM_EARLY_INLINER_MAX_ITERATIONS,
          10, 0, 0)
 
 /* Limit on probability of entry BB.  */
+DEFPARAM (PARAM_COMDAT_SHARING_PROBABILITY,
+         "comdat-sharing-probability",
+         "Probability that COMDAT function will be shared with different compilatoin unit",
+         20, 0, 0)
+
+/* Limit on probability of entry BB.  */
 DEFPARAM (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY,
          "partial-inlining-entry-probability",
          "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen",

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index b00c673..661e55b 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2010-11-10  Jan Hubicka  <jh@suse.cz>
+
+       PR tree-optimize/46228
+       * g++.dg/tree-ssa/pr46228.C: New testcase.
+
 2010-11-10  H.J. Lu  <hongjiu.lu@intel.com>
 
        PR tree-optimization/46414

diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr46228.C b/gcc/testsuite/g++.dg/tree-ssa/pr46228.C
new file mode 100644 (file)
index 0000000..a720dbe
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tree-ssa/pr46228.C
@@ -0,0 +1,23 @@
+// { dg-options "-fdump-tree-optimized -Os" }
+#include <set>
+#include <stdio.h>
+
+int main()
+{
+  static const int array[] = { 1,2,3,4,5,6,7,8,9,10,6 };
+  std::set<int> the_set;
+  int count = 0;
+  for (unsigned i = 0; i < sizeof(array)/sizeof(*array); i++)
+  {
+    std::pair<std::set<int>::iterator, bool> result =
+      the_set.insert(array[i]);
+    if (result.second)
+      count++;
+  }
+  printf("%d unique items in array.\n", count);
+  return 0;
+}
+
+// This function is small enough to be inlined even at -Os.
+// { dg-final { scan-tree-dump-not "_ZNSt8_Rb_treeIiiSt9_IdentityIiESt4lessIiESaIiEED2Ev" "optimized" } }
+// { dg-final { cleanup-tree-dump "optimized" } }