re PR middle-end/21529 (code size regression (+40%) with -Os from GCC-3.4.3 to 4.1)

        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.

From-SVN: r102761

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index f5a7b3551020e10ca47c94bd120f1b882cd6d502..6662acb6f6f2840f58b4118cd52c8d4087904b3e 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+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

diff --git a/gcc/params.def b/gcc/params.def
index 7b9f97c69df8c78d3858279de302bfdcf8da909e..4fc74b5e6afeb237c25a82e82c8e7ea92b99139a 100644 (file)
--- 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 7edcb9817be5d731ca62da611e1a169f8e0a0df9..6c9f7d6cca3724101ae677b663a1a46149d46bd5 100644 (file)
--- 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 337b79777162c164e4240997a1325494e79f0d97..bd3a3c3f1f96222de2edad93b65a4a1de1bbc725 100644 (file)
--- 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.  */