From 460f84ed3d295f5bad049f989c355e6948d4052a Mon Sep 17 00:00:00 2001 From: Richard Henderson Date: Thu, 4 Aug 2005 19:42:06 -0700 Subject: [PATCH] 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 --- gcc/ChangeLog | 8 ++++++++ gcc/params.def | 17 ++++++++++++++--- gcc/params.h | 2 ++ gcc/tree-sra.c | 18 ++++++++++-------- 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,3 +1,11 @@ +2005-08-04 Richard Henderson + + 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 PR 21291 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. */ -- 2.30.2