gimplify.c (gimplify_init_constructor): Revert to using < rather than <= for sparsene...

        * gimplify.c (gimplify_init_constructor): Revert to using < rather
        than <= for sparseness test.

From-SVN: r142618

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 95b8e98eb07eb4cbb9580b7a4343aa2ebf101d0c..407237718f797fef89c5a3bc06fac3c7657d62d4 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -166,6 +166,9 @@
 
 2008-12-09  Jason Merrill  <jason@redhat.com>
 
+       * gimplify.c (gimplify_init_constructor): Revert to using < rather
+       than <= for sparseness test.
+
        PR c++/38410
        * gimplify.c (gimplify_init_constructor): Don't write out a static
        copy of the CONSTRUCTOR for TREE_ADDRESSABLE types or small sparse

diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 01b2fbef6b7ea865e64941b256335ad36b51c650..607743b73f0e2f19f52c7c80b2329b67680be5a9 100644 (file)
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -3502,7 +3502,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
        struct gimplify_init_ctor_preeval_data preeval_data;
        HOST_WIDE_INT num_type_elements, num_ctor_elements;
        HOST_WIDE_INT num_nonzero_elements;
-       bool cleared, valid_const_initializer, sparse;
+       bool cleared, valid_const_initializer;
 
        /* Aggregate types must lower constructors to initialization of
           individual elements.  The exception is that a CONSTRUCTOR node
@@ -3558,9 +3558,6 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 
        num_type_elements = count_type_elements (type, true);
 
-       /* Are there significantly more zeros than non-zeros?  */
-       sparse = (num_nonzero_elements <= num_type_elements/4);
-
        /* If count_type_elements could not determine number of type elements
           for a constant-sized object, assume clearing is needed.
           Don't do this for variable-sized objects, as store_constructor
@@ -3570,7 +3567,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
        /* If there are "lots" of zeros, then block clear the object first.  */
        else if (num_type_elements - num_nonzero_elements
                 > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
-                && sparse)
+                && num_nonzero_elements < num_type_elements/4)
          cleared = true;
        /* ??? This bit ought not be needed.  For any element not present
           in the initializer, we should simply set them to zero.  Except
@@ -3585,9 +3582,12 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
           be dropped to memory, and then memcpy'd out.  Don't do this
           for sparse arrays, though, as it's more efficient to follow
           the standard CONSTRUCTOR behavior of memset followed by
-          individual element initialization.  Also don't try to do
-          bitwise copies of TREE_ADDRESSABLE types.  */
-       if (valid_const_initializer && !(cleared || sparse)
+          individual element initialization.  Also don't do this for small
+          all-zero initializers (which aren't big enough to merit
+          clearing), and don't try to make bitwise copies of
+          TREE_ADDRESSABLE types.  */
+       if (valid_const_initializer
+           && !(cleared || num_nonzero_elements == 0)
            && !TREE_ADDRESSABLE (type))
          {
            HOST_WIDE_INT size = int_size_in_bytes (type);