PR 21529

        * params.def (PARAM_SRA_MAX_STRUCTURE_COUNT): New.
        * params.h (SRA_MAX_STRUCTURE_COUNT): New.
        * tree-sra.c (decide_block_copy): Use it.  Disable element copy
        if we'd have to instantiate too many members.


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

4 files changed, 34 insertions, 11 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index f5a7b355102..6662acb6f6f 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,13 @@
 2005-08-04  Richard Henderson  <rth@redhat.com>
 
+	PR 21529
+	* params.def (PARAM_SRA_MAX_STRUCTURE_COUNT): New.
+	* params.h (SRA_MAX_STRUCTURE_COUNT): New.
+	* tree-sra.c (decide_block_copy): Use it.  Disable element copy
+	if we'd have to instantiate too many members.
+
+2005-08-04  Richard Henderson  <rth@redhat.com>
+
 	PR 21291
 	* tree-outof-ssa.c (coalesce_asm_operands): New.
 	(coalesce_ssa_name): Use it.  Split out ...
diff --git a/gcc/params.def b/gcc/params.def
index 7b9f97c69df..4fc74b5e6af 100644
--- a/gcc/params.def
+++ b/gcc/params.def
@@ -54,14 +54,25 @@ DEFPARAM (PARAM_SALIAS_MAX_IMPLICIT_FIELDS,
    itself.  */
 DEFPARAM (PARAM_SRA_MAX_STRUCTURE_SIZE,
 	  "sra-max-structure-size",
-	  "The maximum structure size (in bytes) at which GCC will do block copies",
+	  "The maximum structure size (in bytes) for which GCC will "
+	  "use by-element copies",
+	  0, 0, 0)
+
+/* The maximum number of structure fields which the SRA pass will
+   instantiate to avoid block copies.  The default value, 0, implies
+   that GCC will select the appropriate value itself.  */
+DEFPARAM (PARAM_SRA_MAX_STRUCTURE_COUNT,
+	  "sra-max-structure-count",
+	  "The maximum number of structure fields for which GCC will "
+	  "use by-element copies",
 	  0, 0, 0)
 
 /* The ratio between instantiated fields and the complete structure
    size.  We say that if the ratio of the number of bytes in
    instantiated fields to the number of bytes in the complete
-   structure exceeds this parameter, then block copies are not used.
-   The default is 75%.  */
+   structure exceeds this parameter, or if the number of instantiated
+   fields to the total number of fields exceeds this parameter, then
+   block copies are not used.  The default is 75%.  */
 DEFPARAM (PARAM_SRA_FIELD_STRUCTURE_RATIO,
 	  "sra-field-structure-ratio",
 	  "The threshold ratio between instantiated fields and the total structure size",
diff --git a/gcc/params.h b/gcc/params.h
index 7edcb9817be..6c9f7d6cca3 100644
--- a/gcc/params.h
+++ b/gcc/params.h
@@ -93,6 +93,8 @@ typedef enum compiler_param
   PARAM_VALUE (PARAM_SALIAS_MAX_IMPLICIT_FIELDS)
 #define SRA_MAX_STRUCTURE_SIZE \
   PARAM_VALUE (PARAM_SRA_MAX_STRUCTURE_SIZE)
+#define SRA_MAX_STRUCTURE_COUNT \
+  PARAM_VALUE (PARAM_SRA_MAX_STRUCTURE_COUNT)
 #define SRA_FIELD_STRUCTURE_RATIO \
   PARAM_VALUE (PARAM_SRA_FIELD_STRUCTURE_RATIO)
 #define MAX_INLINE_INSNS_SINGLE \
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index 337b7977716..bd3a3c3f1f9 100644
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -1325,7 +1325,7 @@ decide_block_copy (struct sra_elt *elt)
       else if (host_integerp (size_tree, 1))
 	{
 	  unsigned HOST_WIDE_INT full_size, inst_size = 0;
-	  unsigned int max_size;
+	  unsigned int max_size, max_count, inst_count, full_count;
 
 	  /* If the sra-max-structure-size parameter is 0, then the
 	     user has not overridden the parameter and we can choose a
@@ -1333,8 +1333,13 @@ decide_block_copy (struct sra_elt *elt)
 	  max_size = SRA_MAX_STRUCTURE_SIZE
 	    ? SRA_MAX_STRUCTURE_SIZE
 	    : MOVE_RATIO * UNITS_PER_WORD;
+	  max_count = SRA_MAX_STRUCTURE_COUNT
+	    ? SRA_MAX_STRUCTURE_COUNT
+	    : MOVE_RATIO;
 
 	  full_size = tree_low_cst (size_tree, 1);
+	  full_count = count_type_elements (elt->type);
+	  inst_count = sum_instantiated_sizes (elt, &inst_size);
 
 	  /* ??? What to do here.  If there are two fields, and we've only
 	     instantiated one, then instantiating the other is clearly a win.
@@ -1344,15 +1349,12 @@ decide_block_copy (struct sra_elt *elt)
 	  /* If the structure is small, and we've made copies, go ahead
 	     and instantiate, hoping that the copies will go away.  */
 	  if (full_size <= max_size
+	      && (full_count - inst_count) <= max_count
 	      && elt->n_copies > elt->n_uses)
 	    use_block_copy = false;
-	  else
-	    {
-	      sum_instantiated_sizes (elt, &inst_size);
-
-	      if (inst_size * 100 >= full_size * SRA_FIELD_STRUCTURE_RATIO)
-		use_block_copy = false;
-	    }
+	  else if (inst_count * 100 >= full_count * SRA_FIELD_STRUCTURE_RATIO
+		   && inst_size * 100 >= full_size * SRA_FIELD_STRUCTURE_RATIO)
+	    use_block_copy = false;
 
 	  /* In order to avoid block copy, we have to be able to instantiate
 	     all elements of the type.  See if this is possible.  */