1 /* Scalar Replacement of Aggregates (SRA) converts some structure
2 references into scalar references, exposing them to the scalar
4 Copyright (C) 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
6 Contributed by Diego Novillo <dnovillo@redhat.com>
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option) any
15 GCC is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING. If not, write to the Free
22 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
27 #include "coretypes.h"
32 /* These RTL headers are needed for basic-block.h. */
35 #include "hard-reg-set.h"
36 #include "basic-block.h"
37 #include "diagnostic.h"
38 #include "langhooks.h"
39 #include "tree-inline.h"
40 #include "tree-flow.h"
41 #include "tree-gimple.h"
42 #include "tree-dump.h"
43 #include "tree-pass.h"
49 /* expr.h is needed for MOVE_RATIO. */
54 /* This object of this pass is to replace a non-addressable aggregate with a
55 set of independent variables. Most of the time, all of these variables
56 will be scalars. But a secondary objective is to break up larger
57 aggregates into smaller aggregates. In the process we may find that some
58 bits of the larger aggregate can be deleted as unreferenced.
60 This substitution is done globally. More localized substitutions would
61 be the purvey of a load-store motion pass.
63 The optimization proceeds in phases:
65 (1) Identify variables that have types that are candidates for
68 (2) Scan the function looking for the ways these variables are used.
69 In particular we're interested in the number of times a variable
70 (or member) is needed as a complete unit, and the number of times
71 a variable (or member) is copied.
73 (3) Based on the usage profile, instantiate substitution variables.
75 (4) Scan the function making replacements.
79 /* True if this is the "early" pass, before inlining. */
80 static bool early_sra
;
82 /* The set of todo flags to return from tree_sra. */
83 static unsigned int todoflags
;
85 /* The set of aggregate variables that are candidates for scalarization. */
86 static bitmap sra_candidates
;
88 /* Set of scalarizable PARM_DECLs that need copy-in operations at the
89 beginning of the function. */
90 static bitmap needs_copy_in
;
92 /* Sets of bit pairs that cache type decomposition and instantiation. */
93 static bitmap sra_type_decomp_cache
;
94 static bitmap sra_type_inst_cache
;
96 /* One of these structures is created for each candidate aggregate and
97 each (accessed) member or group of members of such an aggregate. */
100 /* A tree of the elements. Used when we want to traverse everything. */
101 struct sra_elt
*parent
;
102 struct sra_elt
*groups
;
103 struct sra_elt
*children
;
104 struct sra_elt
*sibling
;
106 /* If this element is a root, then this is the VAR_DECL. If this is
107 a sub-element, this is some token used to identify the reference.
108 In the case of COMPONENT_REF, this is the FIELD_DECL. In the case
109 of an ARRAY_REF, this is the (constant) index. In the case of an
110 ARRAY_RANGE_REF, this is the (constant) RANGE_EXPR. In the case
111 of a complex number, this is a zero or one. */
114 /* The type of the element. */
117 /* A VAR_DECL, for any sub-element we've decided to replace. */
120 /* The number of times the element is referenced as a whole. I.e.
121 given "a.b.c", this would be incremented for C, but not for A or B. */
124 /* The number of times the element is copied to or from another
125 scalarizable element. */
126 unsigned int n_copies
;
128 /* True if TYPE is scalar. */
131 /* True if this element is a group of members of its parent. */
134 /* True if we saw something about this element that prevents scalarization,
135 such as non-constant indexing. */
136 bool cannot_scalarize
;
138 /* True if we've decided that structure-to-structure assignment
139 should happen via memcpy and not per-element. */
142 /* True if everything under this element has been marked TREE_NO_WARNING. */
145 /* A flag for use with/after random access traversals. */
148 /* True if there is BIT_FIELD_REF on the lhs with a vector. */
152 #define IS_ELEMENT_FOR_GROUP(ELEMENT) (TREE_CODE (ELEMENT) == RANGE_EXPR)
154 #define FOR_EACH_ACTUAL_CHILD(CHILD, ELT) \
155 for ((CHILD) = (ELT)->is_group \
156 ? next_child_for_group (NULL, (ELT)) \
159 (CHILD) = (ELT)->is_group \
160 ? next_child_for_group ((CHILD), (ELT)) \
163 /* Helper function for above macro. Return next child in group. */
164 static struct sra_elt
*
165 next_child_for_group (struct sra_elt
*child
, struct sra_elt
*group
)
167 gcc_assert (group
->is_group
);
169 /* Find the next child in the parent. */
171 child
= child
->sibling
;
173 child
= group
->parent
->children
;
175 /* Skip siblings that do not belong to the group. */
178 tree g_elt
= group
->element
;
179 if (TREE_CODE (g_elt
) == RANGE_EXPR
)
181 if (!tree_int_cst_lt (child
->element
, TREE_OPERAND (g_elt
, 0))
182 && !tree_int_cst_lt (TREE_OPERAND (g_elt
, 1), child
->element
))
188 child
= child
->sibling
;
194 /* Random access to the child of a parent is performed by hashing.
195 This prevents quadratic behavior, and allows SRA to function
196 reasonably on larger records. */
197 static htab_t sra_map
;
199 /* All structures are allocated out of the following obstack. */
200 static struct obstack sra_obstack
;
202 /* Debugging functions. */
203 static void dump_sra_elt_name (FILE *, struct sra_elt
*);
204 extern void debug_sra_elt_name (struct sra_elt
*);
206 /* Forward declarations. */
207 static tree
generate_element_ref (struct sra_elt
*);
209 /* Return true if DECL is an SRA candidate. */
212 is_sra_candidate_decl (tree decl
)
214 return DECL_P (decl
) && bitmap_bit_p (sra_candidates
, DECL_UID (decl
));
217 /* Return true if TYPE is a scalar type. */
220 is_sra_scalar_type (tree type
)
222 enum tree_code code
= TREE_CODE (type
);
223 return (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== VECTOR_TYPE
224 || code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
225 || code
== POINTER_TYPE
|| code
== OFFSET_TYPE
226 || code
== REFERENCE_TYPE
);
229 /* Return true if TYPE can be decomposed into a set of independent variables.
231 Note that this doesn't imply that all elements of TYPE can be
232 instantiated, just that if we decide to break up the type into
233 separate pieces that it can be done. */
236 sra_type_can_be_decomposed_p (tree type
)
238 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
241 /* Avoid searching the same type twice. */
242 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+0))
244 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+1))
247 /* The type must have a definite nonzero size. */
248 if (TYPE_SIZE (type
) == NULL
|| TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
249 || integer_zerop (TYPE_SIZE (type
)))
252 /* The type must be a non-union aggregate. */
253 switch (TREE_CODE (type
))
257 bool saw_one_field
= false;
259 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
260 if (TREE_CODE (t
) == FIELD_DECL
)
262 /* Reject incorrectly represented bit fields. */
263 if (DECL_BIT_FIELD (t
)
264 && (tree_low_cst (DECL_SIZE (t
), 1)
265 != TYPE_PRECISION (TREE_TYPE (t
))))
268 saw_one_field
= true;
271 /* Record types must have at least one field. */
278 /* Array types must have a fixed lower and upper bound. */
279 t
= TYPE_DOMAIN (type
);
282 if (TYPE_MIN_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MIN_VALUE (t
)))
284 if (TYPE_MAX_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MAX_VALUE (t
)))
295 bitmap_set_bit (sra_type_decomp_cache
, cache
+0);
299 bitmap_set_bit (sra_type_decomp_cache
, cache
+1);
303 /* Return true if DECL can be decomposed into a set of independent
304 (though not necessarily scalar) variables. */
307 decl_can_be_decomposed_p (tree var
)
309 /* Early out for scalars. */
310 if (is_sra_scalar_type (TREE_TYPE (var
)))
313 /* The variable must not be aliased. */
314 if (!is_gimple_non_addressable (var
))
316 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
318 fprintf (dump_file
, "Cannot scalarize variable ");
319 print_generic_expr (dump_file
, var
, dump_flags
);
320 fprintf (dump_file
, " because it must live in memory\n");
325 /* The variable must not be volatile. */
326 if (TREE_THIS_VOLATILE (var
))
328 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
330 fprintf (dump_file
, "Cannot scalarize variable ");
331 print_generic_expr (dump_file
, var
, dump_flags
);
332 fprintf (dump_file
, " because it is declared volatile\n");
337 /* We must be able to decompose the variable's type. */
338 if (!sra_type_can_be_decomposed_p (TREE_TYPE (var
)))
340 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
342 fprintf (dump_file
, "Cannot scalarize variable ");
343 print_generic_expr (dump_file
, var
, dump_flags
);
344 fprintf (dump_file
, " because its type cannot be decomposed\n");
349 /* HACK: if we decompose a va_list_type_node before inlining, then we'll
350 confuse tree-stdarg.c, and we won't be able to figure out which and
351 how many arguments are accessed. This really should be improved in
352 tree-stdarg.c, as the decomposition is truely a win. This could also
353 be fixed if the stdarg pass ran early, but this can't be done until
354 we've aliasing information early too. See PR 30791. */
356 && TYPE_MAIN_VARIANT (TREE_TYPE (var
))
357 == TYPE_MAIN_VARIANT (va_list_type_node
))
363 /* Return true if TYPE can be *completely* decomposed into scalars. */
366 type_can_instantiate_all_elements (tree type
)
368 if (is_sra_scalar_type (type
))
370 if (!sra_type_can_be_decomposed_p (type
))
373 switch (TREE_CODE (type
))
377 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
380 if (bitmap_bit_p (sra_type_inst_cache
, cache
+0))
382 if (bitmap_bit_p (sra_type_inst_cache
, cache
+1))
385 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
386 if (TREE_CODE (f
) == FIELD_DECL
)
388 if (!type_can_instantiate_all_elements (TREE_TYPE (f
)))
390 bitmap_set_bit (sra_type_inst_cache
, cache
+1);
395 bitmap_set_bit (sra_type_inst_cache
, cache
+0);
400 return type_can_instantiate_all_elements (TREE_TYPE (type
));
410 /* Test whether ELT or some sub-element cannot be scalarized. */
413 can_completely_scalarize_p (struct sra_elt
*elt
)
417 if (elt
->cannot_scalarize
)
420 for (c
= elt
->children
; c
; c
= c
->sibling
)
421 if (!can_completely_scalarize_p (c
))
424 for (c
= elt
->groups
; c
; c
= c
->sibling
)
425 if (!can_completely_scalarize_p (c
))
432 /* A simplified tree hashing algorithm that only handles the types of
433 trees we expect to find in sra_elt->element. */
436 sra_hash_tree (tree t
)
440 switch (TREE_CODE (t
))
449 h
= TREE_INT_CST_LOW (t
) ^ TREE_INT_CST_HIGH (t
);
453 h
= iterative_hash_expr (TREE_OPERAND (t
, 0), 0);
454 h
= iterative_hash_expr (TREE_OPERAND (t
, 1), h
);
458 /* We can have types that are compatible, but have different member
459 lists, so we can't hash fields by ID. Use offsets instead. */
460 h
= iterative_hash_expr (DECL_FIELD_OFFSET (t
), 0);
461 h
= iterative_hash_expr (DECL_FIELD_BIT_OFFSET (t
), h
);
471 /* Hash function for type SRA_PAIR. */
474 sra_elt_hash (const void *x
)
476 const struct sra_elt
*e
= x
;
477 const struct sra_elt
*p
;
480 h
= sra_hash_tree (e
->element
);
482 /* Take into account everything back up the chain. Given that chain
483 lengths are rarely very long, this should be acceptable. If we
484 truly identify this as a performance problem, it should work to
485 hash the pointer value "e->parent". */
486 for (p
= e
->parent
; p
; p
= p
->parent
)
487 h
= (h
* 65521) ^ sra_hash_tree (p
->element
);
492 /* Equality function for type SRA_PAIR. */
495 sra_elt_eq (const void *x
, const void *y
)
497 const struct sra_elt
*a
= x
;
498 const struct sra_elt
*b
= y
;
501 if (a
->parent
!= b
->parent
)
509 if (TREE_CODE (ae
) != TREE_CODE (be
))
512 switch (TREE_CODE (ae
))
517 /* These are all pointer unique. */
521 /* Integers are not pointer unique, so compare their values. */
522 return tree_int_cst_equal (ae
, be
);
526 tree_int_cst_equal (TREE_OPERAND (ae
, 0), TREE_OPERAND (be
, 0))
527 && tree_int_cst_equal (TREE_OPERAND (ae
, 1), TREE_OPERAND (be
, 1));
530 /* Fields are unique within a record, but not between
531 compatible records. */
532 if (DECL_FIELD_CONTEXT (ae
) == DECL_FIELD_CONTEXT (be
))
534 return fields_compatible_p (ae
, be
);
541 /* Create or return the SRA_ELT structure for CHILD in PARENT. PARENT
542 may be null, in which case CHILD must be a DECL. */
544 static struct sra_elt
*
545 lookup_element (struct sra_elt
*parent
, tree child
, tree type
,
546 enum insert_option insert
)
548 struct sra_elt dummy
;
549 struct sra_elt
**slot
;
553 dummy
.parent
= parent
->is_group
? parent
->parent
: parent
;
556 dummy
.element
= child
;
558 slot
= (struct sra_elt
**) htab_find_slot (sra_map
, &dummy
, insert
);
559 if (!slot
&& insert
== NO_INSERT
)
563 if (!elt
&& insert
== INSERT
)
565 *slot
= elt
= obstack_alloc (&sra_obstack
, sizeof (*elt
));
566 memset (elt
, 0, sizeof (*elt
));
568 elt
->parent
= parent
;
569 elt
->element
= child
;
571 elt
->is_scalar
= is_sra_scalar_type (type
);
575 if (IS_ELEMENT_FOR_GROUP (elt
->element
))
577 elt
->is_group
= true;
578 elt
->sibling
= parent
->groups
;
579 parent
->groups
= elt
;
583 elt
->sibling
= parent
->children
;
584 parent
->children
= elt
;
588 /* If this is a parameter, then if we want to scalarize, we have
589 one copy from the true function parameter. Count it now. */
590 if (TREE_CODE (child
) == PARM_DECL
)
593 bitmap_set_bit (needs_copy_in
, DECL_UID (child
));
600 /* Create or return the SRA_ELT structure for EXPR if the expression
601 refers to a scalarizable variable. */
603 static struct sra_elt
*
604 maybe_lookup_element_for_expr (tree expr
)
609 switch (TREE_CODE (expr
))
614 if (is_sra_candidate_decl (expr
))
615 return lookup_element (NULL
, expr
, TREE_TYPE (expr
), INSERT
);
619 /* We can't scalarize variable array indices. */
620 if (in_array_bounds_p (expr
))
621 child
= TREE_OPERAND (expr
, 1);
626 case ARRAY_RANGE_REF
:
627 /* We can't scalarize variable array indices. */
628 if (range_in_array_bounds_p (expr
))
630 tree domain
= TYPE_DOMAIN (TREE_TYPE (expr
));
631 child
= build2 (RANGE_EXPR
, integer_type_node
,
632 TYPE_MIN_VALUE (domain
), TYPE_MAX_VALUE (domain
));
639 /* Don't look through unions. */
640 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) != RECORD_TYPE
)
642 child
= TREE_OPERAND (expr
, 1);
646 child
= integer_zero_node
;
649 child
= integer_one_node
;
656 elt
= maybe_lookup_element_for_expr (TREE_OPERAND (expr
, 0));
658 return lookup_element (elt
, child
, TREE_TYPE (expr
), INSERT
);
663 /* Functions to walk just enough of the tree to see all scalarizable
664 references, and categorize them. */
666 /* A set of callbacks for phases 2 and 4. They'll be invoked for the
667 various kinds of references seen. In all cases, *BSI is an iterator
668 pointing to the statement being processed. */
671 /* Invoked when ELT is required as a unit. Note that ELT might refer to
672 a leaf node, in which case this is a simple scalar reference. *EXPR_P
673 points to the location of the expression. IS_OUTPUT is true if this
674 is a left-hand-side reference. USE_ALL is true if we saw something we
675 couldn't quite identify and had to force the use of the entire object. */
676 void (*use
) (struct sra_elt
*elt
, tree
*expr_p
,
677 block_stmt_iterator
*bsi
, bool is_output
, bool use_all
);
679 /* Invoked when we have a copy between two scalarizable references. */
680 void (*copy
) (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
681 block_stmt_iterator
*bsi
);
683 /* Invoked when ELT is initialized from a constant. VALUE may be NULL,
684 in which case it should be treated as an empty CONSTRUCTOR. */
685 void (*init
) (struct sra_elt
*elt
, tree value
, block_stmt_iterator
*bsi
);
687 /* Invoked when we have a copy between one scalarizable reference ELT
688 and one non-scalarizable reference OTHER without side-effects.
689 IS_OUTPUT is true if ELT is on the left-hand side. */
690 void (*ldst
) (struct sra_elt
*elt
, tree other
,
691 block_stmt_iterator
*bsi
, bool is_output
);
693 /* True during phase 2, false during phase 4. */
694 /* ??? This is a hack. */
698 #ifdef ENABLE_CHECKING
699 /* Invoked via walk_tree, if *TP contains a candidate decl, return it. */
702 sra_find_candidate_decl (tree
*tp
, int *walk_subtrees
,
703 void *data ATTRIBUTE_UNUSED
)
706 enum tree_code code
= TREE_CODE (t
);
708 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
711 if (is_sra_candidate_decl (t
))
721 /* Walk most expressions looking for a scalarizable aggregate.
722 If we find one, invoke FNS->USE. */
725 sra_walk_expr (tree
*expr_p
, block_stmt_iterator
*bsi
, bool is_output
,
726 const struct sra_walk_fns
*fns
)
730 bool disable_scalarization
= false;
731 bool use_all_p
= false;
733 /* We're looking to collect a reference expression between EXPR and INNER,
734 such that INNER is a scalarizable decl and all other nodes through EXPR
735 are references that we can scalarize. If we come across something that
736 we can't scalarize, we reset EXPR. This has the effect of making it
737 appear that we're referring to the larger expression as a whole. */
740 switch (TREE_CODE (inner
))
745 /* If there is a scalarizable decl at the bottom, then process it. */
746 if (is_sra_candidate_decl (inner
))
748 struct sra_elt
*elt
= maybe_lookup_element_for_expr (expr
);
749 if (disable_scalarization
)
750 elt
->cannot_scalarize
= true;
752 fns
->use (elt
, expr_p
, bsi
, is_output
, use_all_p
);
757 /* Non-constant index means any member may be accessed. Prevent the
758 expression from being scalarized. If we were to treat this as a
759 reference to the whole array, we can wind up with a single dynamic
760 index reference inside a loop being overridden by several constant
761 index references during loop setup. It's possible that this could
762 be avoided by using dynamic usage counts based on BB trip counts
763 (based on loop analysis or profiling), but that hardly seems worth
765 /* ??? Hack. Figure out how to push this into the scan routines
766 without duplicating too much code. */
767 if (!in_array_bounds_p (inner
))
769 disable_scalarization
= true;
772 /* ??? Are we assured that non-constant bounds and stride will have
773 the same value everywhere? I don't think Fortran will... */
774 if (TREE_OPERAND (inner
, 2) || TREE_OPERAND (inner
, 3))
776 inner
= TREE_OPERAND (inner
, 0);
779 case ARRAY_RANGE_REF
:
780 if (!range_in_array_bounds_p (inner
))
782 disable_scalarization
= true;
785 /* ??? See above non-constant bounds and stride . */
786 if (TREE_OPERAND (inner
, 2) || TREE_OPERAND (inner
, 3))
788 inner
= TREE_OPERAND (inner
, 0);
792 /* A reference to a union member constitutes a reference to the
794 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (inner
, 0))) != RECORD_TYPE
)
796 /* ??? See above re non-constant stride. */
797 if (TREE_OPERAND (inner
, 2))
799 inner
= TREE_OPERAND (inner
, 0);
804 inner
= TREE_OPERAND (inner
, 0);
808 /* A bit field reference to a specific vector is scalarized but for
809 ones for inputs need to be marked as used on the left hand size so
810 when we scalarize it, we can mark that variable as non renamable. */
812 && TREE_CODE (TREE_TYPE (TREE_OPERAND (inner
, 0))) == VECTOR_TYPE
)
815 = maybe_lookup_element_for_expr (TREE_OPERAND (inner
, 0));
817 elt
->is_vector_lhs
= true;
819 /* A bit field reference (access to *multiple* fields simultaneously)
820 is not currently scalarized. Consider this an access to the
821 complete outer element, to which walk_tree will bring us next. */
825 case VIEW_CONVERT_EXPR
:
827 /* Similarly, a view/nop explicitly wants to look at an object in a
828 type other than the one we've scalarized. */
832 /* This is a transparent wrapper. The entire inner expression really
837 expr_p
= &TREE_OPERAND (inner
, 0);
838 inner
= expr
= *expr_p
;
843 #ifdef ENABLE_CHECKING
844 /* Validate that we're not missing any references. */
845 gcc_assert (!walk_tree (&inner
, sra_find_candidate_decl
, NULL
, NULL
));
851 /* Walk a TREE_LIST of values looking for scalarizable aggregates.
852 If we find one, invoke FNS->USE. */
855 sra_walk_tree_list (tree list
, block_stmt_iterator
*bsi
, bool is_output
,
856 const struct sra_walk_fns
*fns
)
859 for (op
= list
; op
; op
= TREE_CHAIN (op
))
860 sra_walk_expr (&TREE_VALUE (op
), bsi
, is_output
, fns
);
863 /* Walk the arguments of a CALL_EXPR looking for scalarizable aggregates.
864 If we find one, invoke FNS->USE. */
867 sra_walk_call_expr (tree expr
, block_stmt_iterator
*bsi
,
868 const struct sra_walk_fns
*fns
)
871 int nargs
= call_expr_nargs (expr
);
872 for (i
= 0; i
< nargs
; i
++)
873 sra_walk_expr (&CALL_EXPR_ARG (expr
, i
), bsi
, false, fns
);
876 /* Walk the inputs and outputs of an ASM_EXPR looking for scalarizable
877 aggregates. If we find one, invoke FNS->USE. */
880 sra_walk_asm_expr (tree expr
, block_stmt_iterator
*bsi
,
881 const struct sra_walk_fns
*fns
)
883 sra_walk_tree_list (ASM_INPUTS (expr
), bsi
, false, fns
);
884 sra_walk_tree_list (ASM_OUTPUTS (expr
), bsi
, true, fns
);
887 /* Walk a GIMPLE_MODIFY_STMT and categorize the assignment appropriately. */
890 sra_walk_gimple_modify_stmt (tree expr
, block_stmt_iterator
*bsi
,
891 const struct sra_walk_fns
*fns
)
893 struct sra_elt
*lhs_elt
, *rhs_elt
;
896 lhs
= GIMPLE_STMT_OPERAND (expr
, 0);
897 rhs
= GIMPLE_STMT_OPERAND (expr
, 1);
898 lhs_elt
= maybe_lookup_element_for_expr (lhs
);
899 rhs_elt
= maybe_lookup_element_for_expr (rhs
);
901 /* If both sides are scalarizable, this is a COPY operation. */
902 if (lhs_elt
&& rhs_elt
)
904 fns
->copy (lhs_elt
, rhs_elt
, bsi
);
908 /* If the RHS is scalarizable, handle it. There are only two cases. */
911 if (!rhs_elt
->is_scalar
&& !TREE_SIDE_EFFECTS (lhs
))
912 fns
->ldst (rhs_elt
, lhs
, bsi
, false);
914 fns
->use (rhs_elt
, &GIMPLE_STMT_OPERAND (expr
, 1), bsi
, false, false);
917 /* If it isn't scalarizable, there may be scalarizable variables within, so
918 check for a call or else walk the RHS to see if we need to do any
919 copy-in operations. We need to do it before the LHS is scalarized so
920 that the statements get inserted in the proper place, before any
921 copy-out operations. */
924 tree call
= get_call_expr_in (rhs
);
926 sra_walk_call_expr (call
, bsi
, fns
);
928 sra_walk_expr (&GIMPLE_STMT_OPERAND (expr
, 1), bsi
, false, fns
);
931 /* Likewise, handle the LHS being scalarizable. We have cases similar
932 to those above, but also want to handle RHS being constant. */
935 /* If this is an assignment from a constant, or constructor, then
936 we have access to all of the elements individually. Invoke INIT. */
937 if (TREE_CODE (rhs
) == COMPLEX_EXPR
938 || TREE_CODE (rhs
) == COMPLEX_CST
939 || TREE_CODE (rhs
) == CONSTRUCTOR
)
940 fns
->init (lhs_elt
, rhs
, bsi
);
942 /* If this is an assignment from read-only memory, treat this as if
943 we'd been passed the constructor directly. Invoke INIT. */
944 else if (TREE_CODE (rhs
) == VAR_DECL
946 && TREE_READONLY (rhs
)
947 && targetm
.binds_local_p (rhs
))
948 fns
->init (lhs_elt
, DECL_INITIAL (rhs
), bsi
);
950 /* If this is a copy from a non-scalarizable lvalue, invoke LDST.
951 The lvalue requirement prevents us from trying to directly scalarize
952 the result of a function call. Which would result in trying to call
953 the function multiple times, and other evil things. */
954 else if (!lhs_elt
->is_scalar
955 && !TREE_SIDE_EFFECTS (rhs
) && is_gimple_addressable (rhs
))
956 fns
->ldst (lhs_elt
, rhs
, bsi
, true);
958 /* Otherwise we're being used in some context that requires the
959 aggregate to be seen as a whole. Invoke USE. */
961 fns
->use (lhs_elt
, &GIMPLE_STMT_OPERAND (expr
, 0), bsi
, true, false);
964 /* Similarly to above, LHS_ELT being null only means that the LHS as a
965 whole is not a scalarizable reference. There may be occurrences of
966 scalarizable variables within, which implies a USE. */
968 sra_walk_expr (&GIMPLE_STMT_OPERAND (expr
, 0), bsi
, true, fns
);
971 /* Entry point to the walk functions. Search the entire function,
972 invoking the callbacks in FNS on each of the references to
973 scalarizable variables. */
976 sra_walk_function (const struct sra_walk_fns
*fns
)
979 block_stmt_iterator si
, ni
;
981 /* ??? Phase 4 could derive some benefit to walking the function in
982 dominator tree order. */
985 for (si
= bsi_start (bb
); !bsi_end_p (si
); si
= ni
)
990 stmt
= bsi_stmt (si
);
991 ann
= stmt_ann (stmt
);
996 /* If the statement has no virtual operands, then it doesn't
997 make any structure references that we care about. */
998 if (gimple_aliases_computed_p (cfun
)
999 && ZERO_SSA_OPERANDS (stmt
, (SSA_OP_VIRTUAL_DEFS
| SSA_OP_VUSE
)))
1002 switch (TREE_CODE (stmt
))
1005 /* If we have "return <retval>" then the return value is
1006 already exposed for our pleasure. Walk it as a USE to
1007 force all the components back in place for the return.
1009 If we have an embedded assignment, then <retval> is of
1010 a type that gets returned in registers in this ABI, and
1011 we do not wish to extend their lifetimes. Treat this
1012 as a USE of the variable on the RHS of this assignment. */
1014 t
= TREE_OPERAND (stmt
, 0);
1017 else if (TREE_CODE (t
) == GIMPLE_MODIFY_STMT
)
1018 sra_walk_expr (&GIMPLE_STMT_OPERAND (t
, 1), &si
, false, fns
);
1020 sra_walk_expr (&TREE_OPERAND (stmt
, 0), &si
, false, fns
);
1023 case GIMPLE_MODIFY_STMT
:
1024 sra_walk_gimple_modify_stmt (stmt
, &si
, fns
);
1027 sra_walk_call_expr (stmt
, &si
, fns
);
1030 sra_walk_asm_expr (stmt
, &si
, fns
);
1039 /* Phase One: Scan all referenced variables in the program looking for
1040 structures that could be decomposed. */
1043 find_candidates_for_sra (void)
1045 bool any_set
= false;
1047 referenced_var_iterator rvi
;
1049 FOR_EACH_REFERENCED_VAR (var
, rvi
)
1051 if (decl_can_be_decomposed_p (var
))
1053 bitmap_set_bit (sra_candidates
, DECL_UID (var
));
1062 /* Phase Two: Scan all references to scalarizable variables. Count the
1063 number of times they are used or copied respectively. */
1065 /* Callbacks to fill in SRA_WALK_FNS. Everything but USE is
1066 considered a copy, because we can decompose the reference such that
1067 the sub-elements needn't be contiguous. */
1070 scan_use (struct sra_elt
*elt
, tree
*expr_p ATTRIBUTE_UNUSED
,
1071 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
,
1072 bool is_output ATTRIBUTE_UNUSED
, bool use_all ATTRIBUTE_UNUSED
)
1078 scan_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
1079 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
)
1081 lhs_elt
->n_copies
+= 1;
1082 rhs_elt
->n_copies
+= 1;
1086 scan_init (struct sra_elt
*lhs_elt
, tree rhs ATTRIBUTE_UNUSED
,
1087 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
)
1089 lhs_elt
->n_copies
+= 1;
1093 scan_ldst (struct sra_elt
*elt
, tree other ATTRIBUTE_UNUSED
,
1094 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
,
1095 bool is_output ATTRIBUTE_UNUSED
)
1100 /* Dump the values we collected during the scanning phase. */
1103 scan_dump (struct sra_elt
*elt
)
1107 dump_sra_elt_name (dump_file
, elt
);
1108 fprintf (dump_file
, ": n_uses=%u n_copies=%u\n", elt
->n_uses
, elt
->n_copies
);
1110 for (c
= elt
->children
; c
; c
= c
->sibling
)
1113 for (c
= elt
->groups
; c
; c
= c
->sibling
)
1117 /* Entry point to phase 2. Scan the entire function, building up
1118 scalarization data structures, recording copies and uses. */
1121 scan_function (void)
1123 static const struct sra_walk_fns fns
= {
1124 scan_use
, scan_copy
, scan_init
, scan_ldst
, true
1128 sra_walk_function (&fns
);
1130 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1134 fputs ("\nScan results:\n", dump_file
);
1135 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
, bi
)
1137 tree var
= referenced_var (i
);
1138 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1142 fputc ('\n', dump_file
);
1146 /* Phase Three: Make decisions about which variables to scalarize, if any.
1147 All elements to be scalarized have replacement variables made for them. */
1149 /* A subroutine of build_element_name. Recursively build the element
1150 name on the obstack. */
1153 build_element_name_1 (struct sra_elt
*elt
)
1160 build_element_name_1 (elt
->parent
);
1161 obstack_1grow (&sra_obstack
, '$');
1163 if (TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
1165 if (elt
->element
== integer_zero_node
)
1166 obstack_grow (&sra_obstack
, "real", 4);
1168 obstack_grow (&sra_obstack
, "imag", 4);
1174 if (TREE_CODE (t
) == INTEGER_CST
)
1176 /* ??? Eh. Don't bother doing double-wide printing. */
1177 sprintf (buffer
, HOST_WIDE_INT_PRINT_DEC
, TREE_INT_CST_LOW (t
));
1178 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1182 tree name
= DECL_NAME (t
);
1184 obstack_grow (&sra_obstack
, IDENTIFIER_POINTER (name
),
1185 IDENTIFIER_LENGTH (name
));
1188 sprintf (buffer
, "D%u", DECL_UID (t
));
1189 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1194 /* Construct a pretty variable name for an element's replacement variable.
1195 The name is built on the obstack. */
1198 build_element_name (struct sra_elt
*elt
)
1200 build_element_name_1 (elt
);
1201 obstack_1grow (&sra_obstack
, '\0');
1202 return XOBFINISH (&sra_obstack
, char *);
1205 /* Instantiate an element as an independent variable. */
1208 instantiate_element (struct sra_elt
*elt
)
1210 struct sra_elt
*base_elt
;
1213 for (base_elt
= elt
; base_elt
->parent
; base_elt
= base_elt
->parent
)
1215 base
= base_elt
->element
;
1217 elt
->replacement
= var
= make_rename_temp (elt
->type
, "SR");
1219 /* For vectors, if used on the left hand side with BIT_FIELD_REF,
1220 they are not a gimple register. */
1221 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
&& elt
->is_vector_lhs
)
1222 DECL_GIMPLE_REG_P (var
) = 0;
1224 DECL_SOURCE_LOCATION (var
) = DECL_SOURCE_LOCATION (base
);
1225 DECL_ARTIFICIAL (var
) = 1;
1227 if (TREE_THIS_VOLATILE (elt
->type
))
1229 TREE_THIS_VOLATILE (var
) = 1;
1230 TREE_SIDE_EFFECTS (var
) = 1;
1233 if (DECL_NAME (base
) && !DECL_IGNORED_P (base
))
1235 char *pretty_name
= build_element_name (elt
);
1236 DECL_NAME (var
) = get_identifier (pretty_name
);
1237 obstack_free (&sra_obstack
, pretty_name
);
1239 SET_DECL_DEBUG_EXPR (var
, generate_element_ref (elt
));
1240 DECL_DEBUG_EXPR_IS_FROM (var
) = 1;
1242 DECL_IGNORED_P (var
) = 0;
1243 TREE_NO_WARNING (var
) = TREE_NO_WARNING (base
);
1244 if (elt
->element
&& TREE_NO_WARNING (elt
->element
))
1245 TREE_NO_WARNING (var
) = 1;
1249 DECL_IGNORED_P (var
) = 1;
1250 /* ??? We can't generate any warning that would be meaningful. */
1251 TREE_NO_WARNING (var
) = 1;
1256 fputs (" ", dump_file
);
1257 dump_sra_elt_name (dump_file
, elt
);
1258 fputs (" -> ", dump_file
);
1259 print_generic_expr (dump_file
, var
, dump_flags
);
1260 fputc ('\n', dump_file
);
1264 /* Make one pass across an element tree deciding whether or not it's
1265 profitable to instantiate individual leaf scalars.
1267 PARENT_USES and PARENT_COPIES are the sum of the N_USES and N_COPIES
1268 fields all the way up the tree. */
1271 decide_instantiation_1 (struct sra_elt
*elt
, unsigned int parent_uses
,
1272 unsigned int parent_copies
)
1274 if (dump_file
&& !elt
->parent
)
1276 fputs ("Initial instantiation for ", dump_file
);
1277 dump_sra_elt_name (dump_file
, elt
);
1278 fputc ('\n', dump_file
);
1281 if (elt
->cannot_scalarize
)
1286 /* The decision is simple: instantiate if we're used more frequently
1287 than the parent needs to be seen as a complete unit. */
1288 if (elt
->n_uses
+ elt
->n_copies
+ parent_copies
> parent_uses
)
1289 instantiate_element (elt
);
1293 struct sra_elt
*c
, *group
;
1294 unsigned int this_uses
= elt
->n_uses
+ parent_uses
;
1295 unsigned int this_copies
= elt
->n_copies
+ parent_copies
;
1297 /* Consider groups of sub-elements as weighing in favour of
1298 instantiation whatever their size. */
1299 for (group
= elt
->groups
; group
; group
= group
->sibling
)
1300 FOR_EACH_ACTUAL_CHILD (c
, group
)
1302 c
->n_uses
+= group
->n_uses
;
1303 c
->n_copies
+= group
->n_copies
;
1306 for (c
= elt
->children
; c
; c
= c
->sibling
)
1307 decide_instantiation_1 (c
, this_uses
, this_copies
);
1311 /* Compute the size and number of all instantiated elements below ELT.
1312 We will only care about this if the size of the complete structure
1313 fits in a HOST_WIDE_INT, so we don't have to worry about overflow. */
1316 sum_instantiated_sizes (struct sra_elt
*elt
, unsigned HOST_WIDE_INT
*sizep
)
1318 if (elt
->replacement
)
1320 *sizep
+= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (elt
->type
));
1326 unsigned int count
= 0;
1328 for (c
= elt
->children
; c
; c
= c
->sibling
)
1329 count
+= sum_instantiated_sizes (c
, sizep
);
1335 /* Instantiate fields in ELT->TYPE that are not currently present as
1338 static void instantiate_missing_elements (struct sra_elt
*elt
);
1341 instantiate_missing_elements_1 (struct sra_elt
*elt
, tree child
, tree type
)
1343 struct sra_elt
*sub
= lookup_element (elt
, child
, type
, INSERT
);
1346 if (sub
->replacement
== NULL
)
1347 instantiate_element (sub
);
1350 instantiate_missing_elements (sub
);
1354 instantiate_missing_elements (struct sra_elt
*elt
)
1356 tree type
= elt
->type
;
1358 switch (TREE_CODE (type
))
1363 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
1364 if (TREE_CODE (f
) == FIELD_DECL
)
1366 tree field_type
= TREE_TYPE (f
);
1368 /* canonicalize_component_ref() unwidens some bit-field
1369 types (not marked as DECL_BIT_FIELD in C++), so we
1370 must do the same, lest we may introduce type
1372 if (INTEGRAL_TYPE_P (field_type
)
1373 && DECL_MODE (f
) != TYPE_MODE (field_type
))
1374 field_type
= TREE_TYPE (get_unwidened (build3 (COMPONENT_REF
,
1380 instantiate_missing_elements_1 (elt
, f
, field_type
);
1387 tree i
, max
, subtype
;
1389 i
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
1390 max
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
1391 subtype
= TREE_TYPE (type
);
1395 instantiate_missing_elements_1 (elt
, i
, subtype
);
1396 if (tree_int_cst_equal (i
, max
))
1398 i
= int_const_binop (PLUS_EXPR
, i
, integer_one_node
, true);
1405 type
= TREE_TYPE (type
);
1406 instantiate_missing_elements_1 (elt
, integer_zero_node
, type
);
1407 instantiate_missing_elements_1 (elt
, integer_one_node
, type
);
1415 /* Return true if there is only one non aggregate field in the record, TYPE.
1416 Return false otherwise. */
1419 single_scalar_field_in_record_p (tree type
)
1423 if (TREE_CODE (type
) != RECORD_TYPE
)
1426 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1427 if (TREE_CODE (field
) == FIELD_DECL
)
1431 if (num_fields
== 2)
1434 if (AGGREGATE_TYPE_P (TREE_TYPE (field
)))
1441 /* Make one pass across an element tree deciding whether to perform block
1442 or element copies. If we decide on element copies, instantiate all
1443 elements. Return true if there are any instantiated sub-elements. */
1446 decide_block_copy (struct sra_elt
*elt
)
1451 /* We shouldn't be invoked on groups of sub-elements as they must
1452 behave like their parent as far as block copy is concerned. */
1453 gcc_assert (!elt
->is_group
);
1455 /* If scalarization is disabled, respect it. */
1456 if (elt
->cannot_scalarize
)
1458 elt
->use_block_copy
= 1;
1462 fputs ("Scalarization disabled for ", dump_file
);
1463 dump_sra_elt_name (dump_file
, elt
);
1464 fputc ('\n', dump_file
);
1467 /* Disable scalarization of sub-elements */
1468 for (c
= elt
->children
; c
; c
= c
->sibling
)
1470 c
->cannot_scalarize
= 1;
1471 decide_block_copy (c
);
1474 /* Groups behave like their parent. */
1475 for (c
= elt
->groups
; c
; c
= c
->sibling
)
1477 c
->cannot_scalarize
= 1;
1478 c
->use_block_copy
= 1;
1484 /* Don't decide if we've no uses. */
1485 if (elt
->n_uses
== 0 && elt
->n_copies
== 0)
1488 else if (!elt
->is_scalar
)
1490 tree size_tree
= TYPE_SIZE_UNIT (elt
->type
);
1491 bool use_block_copy
= true;
1493 /* Tradeoffs for COMPLEX types pretty much always make it better
1494 to go ahead and split the components. */
1495 if (TREE_CODE (elt
->type
) == COMPLEX_TYPE
)
1496 use_block_copy
= false;
1498 /* Don't bother trying to figure out the rest if the structure is
1499 so large we can't do easy arithmetic. This also forces block
1500 copies for variable sized structures. */
1501 else if (host_integerp (size_tree
, 1))
1503 unsigned HOST_WIDE_INT full_size
, inst_size
= 0;
1504 unsigned int max_size
, max_count
, inst_count
, full_count
;
1506 /* If the sra-max-structure-size parameter is 0, then the
1507 user has not overridden the parameter and we can choose a
1508 sensible default. */
1509 max_size
= SRA_MAX_STRUCTURE_SIZE
1510 ? SRA_MAX_STRUCTURE_SIZE
1511 : MOVE_RATIO
* UNITS_PER_WORD
;
1512 max_count
= SRA_MAX_STRUCTURE_COUNT
1513 ? SRA_MAX_STRUCTURE_COUNT
1516 full_size
= tree_low_cst (size_tree
, 1);
1517 full_count
= count_type_elements (elt
->type
, false);
1518 inst_count
= sum_instantiated_sizes (elt
, &inst_size
);
1520 /* If there is only one scalar field in the record, don't block copy. */
1521 if (single_scalar_field_in_record_p (elt
->type
))
1522 use_block_copy
= false;
1524 /* ??? What to do here. If there are two fields, and we've only
1525 instantiated one, then instantiating the other is clearly a win.
1526 If there are a large number of fields then the size of the copy
1527 is much more of a factor. */
1529 /* If the structure is small, and we've made copies, go ahead
1530 and instantiate, hoping that the copies will go away. */
1531 if (full_size
<= max_size
1532 && (full_count
- inst_count
) <= max_count
1533 && elt
->n_copies
> elt
->n_uses
)
1534 use_block_copy
= false;
1535 else if (inst_count
* 100 >= full_count
* SRA_FIELD_STRUCTURE_RATIO
1536 && inst_size
* 100 >= full_size
* SRA_FIELD_STRUCTURE_RATIO
)
1537 use_block_copy
= false;
1539 /* In order to avoid block copy, we have to be able to instantiate
1540 all elements of the type. See if this is possible. */
1542 && (!can_completely_scalarize_p (elt
)
1543 || !type_can_instantiate_all_elements (elt
->type
)))
1544 use_block_copy
= true;
1547 elt
->use_block_copy
= use_block_copy
;
1549 /* Groups behave like their parent. */
1550 for (c
= elt
->groups
; c
; c
= c
->sibling
)
1551 c
->use_block_copy
= use_block_copy
;
1555 fprintf (dump_file
, "Using %s for ",
1556 use_block_copy
? "block-copy" : "element-copy");
1557 dump_sra_elt_name (dump_file
, elt
);
1558 fputc ('\n', dump_file
);
1561 if (!use_block_copy
)
1563 instantiate_missing_elements (elt
);
1568 any_inst
= elt
->replacement
!= NULL
;
1570 for (c
= elt
->children
; c
; c
= c
->sibling
)
1571 any_inst
|= decide_block_copy (c
);
1576 /* Entry point to phase 3. Instantiate scalar replacement variables. */
1579 decide_instantiations (void)
1583 bitmap_head done_head
;
1586 /* We cannot clear bits from a bitmap we're iterating over,
1587 so save up all the bits to clear until the end. */
1588 bitmap_initialize (&done_head
, &bitmap_default_obstack
);
1589 cleared_any
= false;
1591 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
, bi
)
1593 tree var
= referenced_var (i
);
1594 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1597 decide_instantiation_1 (elt
, 0, 0);
1598 if (!decide_block_copy (elt
))
1603 bitmap_set_bit (&done_head
, i
);
1610 bitmap_and_compl_into (sra_candidates
, &done_head
);
1611 bitmap_and_compl_into (needs_copy_in
, &done_head
);
1613 bitmap_clear (&done_head
);
1615 if (!bitmap_empty_p (sra_candidates
))
1616 todoflags
|= TODO_update_smt_usage
;
1618 mark_set_for_renaming (sra_candidates
);
1621 fputc ('\n', dump_file
);
1625 /* Phase Four: Update the function to match the replacements created. */
1627 /* Mark all the variables in VDEF/VUSE operators for STMT for
1628 renaming. This becomes necessary when we modify all of a
1632 mark_all_v_defs_1 (tree stmt
)
1637 update_stmt_if_modified (stmt
);
1639 FOR_EACH_SSA_TREE_OPERAND (sym
, stmt
, iter
, SSA_OP_ALL_VIRTUALS
)
1641 if (TREE_CODE (sym
) == SSA_NAME
)
1642 sym
= SSA_NAME_VAR (sym
);
1643 mark_sym_for_renaming (sym
);
1648 /* Mark all the variables in virtual operands in all the statements in
1649 LIST for renaming. */
1652 mark_all_v_defs (tree list
)
1654 if (TREE_CODE (list
) != STATEMENT_LIST
)
1655 mark_all_v_defs_1 (list
);
1658 tree_stmt_iterator i
;
1659 for (i
= tsi_start (list
); !tsi_end_p (i
); tsi_next (&i
))
1660 mark_all_v_defs_1 (tsi_stmt (i
));
1665 /* Mark every replacement under ELT with TREE_NO_WARNING. */
1668 mark_no_warning (struct sra_elt
*elt
)
1670 if (!elt
->all_no_warning
)
1672 if (elt
->replacement
)
1673 TREE_NO_WARNING (elt
->replacement
) = 1;
1677 FOR_EACH_ACTUAL_CHILD (c
, elt
)
1678 mark_no_warning (c
);
1680 elt
->all_no_warning
= true;
1684 /* Build a single level component reference to ELT rooted at BASE. */
1687 generate_one_element_ref (struct sra_elt
*elt
, tree base
)
1689 switch (TREE_CODE (TREE_TYPE (base
)))
1693 tree field
= elt
->element
;
1695 /* Watch out for compatible records with differing field lists. */
1696 if (DECL_FIELD_CONTEXT (field
) != TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
1697 field
= find_compatible_field (TREE_TYPE (base
), field
);
1699 return build3 (COMPONENT_REF
, elt
->type
, base
, field
, NULL
);
1703 todoflags
|= TODO_update_smt_usage
;
1704 if (TREE_CODE (elt
->element
) == RANGE_EXPR
)
1705 return build4 (ARRAY_RANGE_REF
, elt
->type
, base
,
1706 TREE_OPERAND (elt
->element
, 0), NULL
, NULL
);
1708 return build4 (ARRAY_REF
, elt
->type
, base
, elt
->element
, NULL
, NULL
);
1711 if (elt
->element
== integer_zero_node
)
1712 return build1 (REALPART_EXPR
, elt
->type
, base
);
1714 return build1 (IMAGPART_EXPR
, elt
->type
, base
);
1721 /* Build a full component reference to ELT rooted at its native variable. */
1724 generate_element_ref (struct sra_elt
*elt
)
1727 return generate_one_element_ref (elt
, generate_element_ref (elt
->parent
));
1729 return elt
->element
;
1732 /* Create an assignment statement from SRC to DST. */
1735 sra_build_assignment (tree dst
, tree src
)
1737 /* It was hoped that we could perform some type sanity checking
1738 here, but since front-ends can emit accesses of fields in types
1739 different from their nominal types and copy structures containing
1740 them as a whole, we'd have to handle such differences here.
1741 Since such accesses under different types require compatibility
1742 anyway, there's little point in making tests and/or adding
1743 conversions to ensure the types of src and dst are the same.
1744 So we just assume type differences at this point are ok. */
1745 return build_gimple_modify_stmt (dst
, src
);
1748 /* Generate a set of assignment statements in *LIST_P to copy all
1749 instantiated elements under ELT to or from the equivalent structure
1750 rooted at EXPR. COPY_OUT controls the direction of the copy, with
1751 true meaning to copy out of EXPR into ELT. */
1754 generate_copy_inout (struct sra_elt
*elt
, bool copy_out
, tree expr
,
1760 if (!copy_out
&& TREE_CODE (expr
) == SSA_NAME
1761 && TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
1765 c
= lookup_element (elt
, integer_zero_node
, NULL
, NO_INSERT
);
1767 c
= lookup_element (elt
, integer_one_node
, NULL
, NO_INSERT
);
1770 t
= build2 (COMPLEX_EXPR
, elt
->type
, r
, i
);
1771 t
= sra_build_assignment (expr
, t
);
1772 SSA_NAME_DEF_STMT (expr
) = t
;
1773 append_to_statement_list (t
, list_p
);
1775 else if (elt
->replacement
)
1778 t
= sra_build_assignment (elt
->replacement
, expr
);
1780 t
= sra_build_assignment (expr
, elt
->replacement
);
1781 append_to_statement_list (t
, list_p
);
1785 FOR_EACH_ACTUAL_CHILD (c
, elt
)
1787 t
= generate_one_element_ref (c
, unshare_expr (expr
));
1788 generate_copy_inout (c
, copy_out
, t
, list_p
);
1793 /* Generate a set of assignment statements in *LIST_P to copy all instantiated
1794 elements under SRC to their counterparts under DST. There must be a 1-1
1795 correspondence of instantiated elements. */
1798 generate_element_copy (struct sra_elt
*dst
, struct sra_elt
*src
, tree
*list_p
)
1800 struct sra_elt
*dc
, *sc
;
1802 FOR_EACH_ACTUAL_CHILD (dc
, dst
)
1804 sc
= lookup_element (src
, dc
->element
, NULL
, NO_INSERT
);
1806 generate_element_copy (dc
, sc
, list_p
);
1809 if (dst
->replacement
)
1813 gcc_assert (src
->replacement
);
1815 t
= sra_build_assignment (dst
->replacement
, src
->replacement
);
1816 append_to_statement_list (t
, list_p
);
1820 /* Generate a set of assignment statements in *LIST_P to zero all instantiated
1821 elements under ELT. In addition, do not assign to elements that have been
1822 marked VISITED but do reset the visited flag; this allows easy coordination
1823 with generate_element_init. */
1826 generate_element_zero (struct sra_elt
*elt
, tree
*list_p
)
1832 elt
->visited
= false;
1836 FOR_EACH_ACTUAL_CHILD (c
, elt
)
1837 generate_element_zero (c
, list_p
);
1839 if (elt
->replacement
)
1843 gcc_assert (elt
->is_scalar
);
1844 t
= fold_convert (elt
->type
, integer_zero_node
);
1846 t
= sra_build_assignment (elt
->replacement
, t
);
1847 append_to_statement_list (t
, list_p
);
1851 /* Generate an assignment VAR = INIT, where INIT may need gimplification.
1852 Add the result to *LIST_P. */
1855 generate_one_element_init (tree var
, tree init
, tree
*list_p
)
1857 /* The replacement can be almost arbitrarily complex. Gimplify. */
1858 tree stmt
= sra_build_assignment (var
, init
);
1859 gimplify_and_add (stmt
, list_p
);
1862 /* Generate a set of assignment statements in *LIST_P to set all instantiated
1863 elements under ELT with the contents of the initializer INIT. In addition,
1864 mark all assigned elements VISITED; this allows easy coordination with
1865 generate_element_zero. Return false if we found a case we couldn't
1869 generate_element_init_1 (struct sra_elt
*elt
, tree init
, tree
*list_p
)
1872 enum tree_code init_code
;
1873 struct sra_elt
*sub
;
1875 unsigned HOST_WIDE_INT idx
;
1876 tree value
, purpose
;
1878 /* We can be passed DECL_INITIAL of a static variable. It might have a
1879 conversion, which we strip off here. */
1880 STRIP_USELESS_TYPE_CONVERSION (init
);
1881 init_code
= TREE_CODE (init
);
1885 if (elt
->replacement
)
1887 generate_one_element_init (elt
->replacement
, init
, list_p
);
1888 elt
->visited
= true;
1897 FOR_EACH_ACTUAL_CHILD (sub
, elt
)
1899 if (sub
->element
== integer_zero_node
)
1900 t
= (init_code
== COMPLEX_EXPR
1901 ? TREE_OPERAND (init
, 0) : TREE_REALPART (init
));
1903 t
= (init_code
== COMPLEX_EXPR
1904 ? TREE_OPERAND (init
, 1) : TREE_IMAGPART (init
));
1905 result
&= generate_element_init_1 (sub
, t
, list_p
);
1910 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, purpose
, value
)
1912 if (TREE_CODE (purpose
) == RANGE_EXPR
)
1914 tree lower
= TREE_OPERAND (purpose
, 0);
1915 tree upper
= TREE_OPERAND (purpose
, 1);
1919 sub
= lookup_element (elt
, lower
, NULL
, NO_INSERT
);
1921 result
&= generate_element_init_1 (sub
, value
, list_p
);
1922 if (tree_int_cst_equal (lower
, upper
))
1924 lower
= int_const_binop (PLUS_EXPR
, lower
,
1925 integer_one_node
, true);
1930 sub
= lookup_element (elt
, purpose
, NULL
, NO_INSERT
);
1932 result
&= generate_element_init_1 (sub
, value
, list_p
);
1938 elt
->visited
= true;
1945 /* A wrapper function for generate_element_init_1 that handles cleanup after
1949 generate_element_init (struct sra_elt
*elt
, tree init
, tree
*list_p
)
1953 push_gimplify_context ();
1954 ret
= generate_element_init_1 (elt
, init
, list_p
);
1955 pop_gimplify_context (NULL
);
1957 /* The replacement can expose previously unreferenced variables. */
1960 tree_stmt_iterator i
;
1962 for (i
= tsi_start (*list_p
); !tsi_end_p (i
); tsi_next (&i
))
1963 find_new_referenced_vars (tsi_stmt_ptr (i
));
1969 /* Insert STMT on all the outgoing edges out of BB. Note that if BB
1970 has more than one edge, STMT will be replicated for each edge. Also,
1971 abnormal edges will be ignored. */
1974 insert_edge_copies (tree stmt
, basic_block bb
)
1981 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1983 /* We don't need to insert copies on abnormal edges. The
1984 value of the scalar replacement is not guaranteed to
1985 be valid through an abnormal edge. */
1986 if (!(e
->flags
& EDGE_ABNORMAL
))
1990 bsi_insert_on_edge (e
, stmt
);
1994 bsi_insert_on_edge (e
, unsave_expr_now (stmt
));
1999 /* Helper function to insert LIST before BSI, and set up line number info. */
2002 sra_insert_before (block_stmt_iterator
*bsi
, tree list
)
2004 tree stmt
= bsi_stmt (*bsi
);
2006 if (EXPR_HAS_LOCATION (stmt
))
2007 annotate_all_with_locus (&list
, EXPR_LOCATION (stmt
));
2008 bsi_insert_before (bsi
, list
, BSI_SAME_STMT
);
2011 /* Similarly, but insert after BSI. Handles insertion onto edges as well. */
2014 sra_insert_after (block_stmt_iterator
*bsi
, tree list
)
2016 tree stmt
= bsi_stmt (*bsi
);
2018 if (EXPR_HAS_LOCATION (stmt
))
2019 annotate_all_with_locus (&list
, EXPR_LOCATION (stmt
));
2021 if (stmt_ends_bb_p (stmt
))
2022 insert_edge_copies (list
, bsi
->bb
);
2024 bsi_insert_after (bsi
, list
, BSI_SAME_STMT
);
2027 /* Similarly, but replace the statement at BSI. */
2030 sra_replace (block_stmt_iterator
*bsi
, tree list
)
2032 sra_insert_before (bsi
, list
);
2033 bsi_remove (bsi
, false);
2034 if (bsi_end_p (*bsi
))
2035 *bsi
= bsi_last (bsi
->bb
);
2040 /* Scalarize a USE. To recap, this is either a simple reference to ELT,
2041 if elt is scalar, or some occurrence of ELT that requires a complete
2042 aggregate. IS_OUTPUT is true if ELT is being modified. */
2045 scalarize_use (struct sra_elt
*elt
, tree
*expr_p
, block_stmt_iterator
*bsi
,
2046 bool is_output
, bool use_all
)
2048 tree list
= NULL
, stmt
= bsi_stmt (*bsi
);
2050 if (elt
->replacement
)
2052 /* If we have a replacement, then updating the reference is as
2053 simple as modifying the existing statement in place. */
2055 mark_all_v_defs (stmt
);
2056 *expr_p
= elt
->replacement
;
2061 /* Otherwise we need some copies. If ELT is being read, then we want
2062 to store all (modified) sub-elements back into the structure before
2063 the reference takes place. If ELT is being written, then we want to
2064 load the changed values back into our shadow variables. */
2065 /* ??? We don't check modified for reads, we just always write all of
2066 the values. We should be able to record the SSA number of the VOP
2067 for which the values were last read. If that number matches the
2068 SSA number of the VOP in the current statement, then we needn't
2069 emit an assignment. This would also eliminate double writes when
2070 a structure is passed as more than one argument to a function call.
2071 This optimization would be most effective if sra_walk_function
2072 processed the blocks in dominator order. */
2074 generate_copy_inout (elt
, is_output
, generate_element_ref (elt
), &list
);
2077 mark_all_v_defs (list
);
2079 sra_insert_after (bsi
, list
);
2082 sra_insert_before (bsi
, list
);
2084 mark_no_warning (elt
);
2089 /* Scalarize a COPY. To recap, this is an assignment statement between
2090 two scalarizable references, LHS_ELT and RHS_ELT. */
2093 scalarize_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
2094 block_stmt_iterator
*bsi
)
2098 if (lhs_elt
->replacement
&& rhs_elt
->replacement
)
2100 /* If we have two scalar operands, modify the existing statement. */
2101 stmt
= bsi_stmt (*bsi
);
2103 /* See the commentary in sra_walk_function concerning
2104 RETURN_EXPR, and why we should never see one here. */
2105 gcc_assert (TREE_CODE (stmt
) == GIMPLE_MODIFY_STMT
);
2107 GIMPLE_STMT_OPERAND (stmt
, 0) = lhs_elt
->replacement
;
2108 GIMPLE_STMT_OPERAND (stmt
, 1) = rhs_elt
->replacement
;
2111 else if (lhs_elt
->use_block_copy
|| rhs_elt
->use_block_copy
)
2113 /* If either side requires a block copy, then sync the RHS back
2114 to the original structure, leave the original assignment
2115 statement (which will perform the block copy), then load the
2116 LHS values out of its now-updated original structure. */
2117 /* ??? Could perform a modified pair-wise element copy. That
2118 would at least allow those elements that are instantiated in
2119 both structures to be optimized well. */
2122 generate_copy_inout (rhs_elt
, false,
2123 generate_element_ref (rhs_elt
), &list
);
2126 mark_all_v_defs (list
);
2127 sra_insert_before (bsi
, list
);
2131 generate_copy_inout (lhs_elt
, true,
2132 generate_element_ref (lhs_elt
), &list
);
2135 mark_all_v_defs (list
);
2136 sra_insert_after (bsi
, list
);
2141 /* Otherwise both sides must be fully instantiated. In which
2142 case perform pair-wise element assignments and replace the
2143 original block copy statement. */
2145 stmt
= bsi_stmt (*bsi
);
2146 mark_all_v_defs (stmt
);
2149 generate_element_copy (lhs_elt
, rhs_elt
, &list
);
2151 mark_all_v_defs (list
);
2152 sra_replace (bsi
, list
);
2156 /* Scalarize an INIT. To recap, this is an assignment to a scalarizable
2157 reference from some form of constructor: CONSTRUCTOR, COMPLEX_CST or
2158 COMPLEX_EXPR. If RHS is NULL, it should be treated as an empty
2162 scalarize_init (struct sra_elt
*lhs_elt
, tree rhs
, block_stmt_iterator
*bsi
)
2167 /* Generate initialization statements for all members extant in the RHS. */
2170 /* Unshare the expression just in case this is from a decl's initial. */
2171 rhs
= unshare_expr (rhs
);
2172 result
= generate_element_init (lhs_elt
, rhs
, &list
);
2175 /* CONSTRUCTOR is defined such that any member not mentioned is assigned
2176 a zero value. Initialize the rest of the instantiated elements. */
2177 generate_element_zero (lhs_elt
, &list
);
2181 /* If we failed to convert the entire initializer, then we must
2182 leave the structure assignment in place and must load values
2183 from the structure into the slots for which we did not find
2184 constants. The easiest way to do this is to generate a complete
2185 copy-out, and then follow that with the constant assignments
2186 that we were able to build. DCE will clean things up. */
2188 generate_copy_inout (lhs_elt
, true, generate_element_ref (lhs_elt
),
2190 append_to_statement_list (list
, &list0
);
2194 if (lhs_elt
->use_block_copy
|| !result
)
2196 /* Since LHS is not fully instantiated, we must leave the structure
2197 assignment in place. Treating this case differently from a USE
2198 exposes constants to later optimizations. */
2201 mark_all_v_defs (list
);
2202 sra_insert_after (bsi
, list
);
2207 /* The LHS is fully instantiated. The list of initializations
2208 replaces the original structure assignment. */
2210 mark_all_v_defs (bsi_stmt (*bsi
));
2211 mark_all_v_defs (list
);
2212 sra_replace (bsi
, list
);
2216 /* A subroutine of scalarize_ldst called via walk_tree. Set TREE_NO_TRAP
2217 on all INDIRECT_REFs. */
2220 mark_notrap (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2224 if (TREE_CODE (t
) == INDIRECT_REF
)
2226 TREE_THIS_NOTRAP (t
) = 1;
2229 else if (IS_TYPE_OR_DECL_P (t
))
2235 /* Scalarize a LDST. To recap, this is an assignment between one scalarizable
2236 reference ELT and one non-scalarizable reference OTHER. IS_OUTPUT is true
2237 if ELT is on the left-hand side. */
2240 scalarize_ldst (struct sra_elt
*elt
, tree other
,
2241 block_stmt_iterator
*bsi
, bool is_output
)
2243 /* Shouldn't have gotten called for a scalar. */
2244 gcc_assert (!elt
->replacement
);
2246 if (elt
->use_block_copy
)
2248 /* Since ELT is not fully instantiated, we have to leave the
2249 block copy in place. Treat this as a USE. */
2250 scalarize_use (elt
, NULL
, bsi
, is_output
, false);
2254 /* The interesting case is when ELT is fully instantiated. In this
2255 case we can have each element stored/loaded directly to/from the
2256 corresponding slot in OTHER. This avoids a block copy. */
2258 tree list
= NULL
, stmt
= bsi_stmt (*bsi
);
2260 mark_all_v_defs (stmt
);
2261 generate_copy_inout (elt
, is_output
, other
, &list
);
2262 mark_all_v_defs (list
);
2265 /* Preserve EH semantics. */
2266 if (stmt_ends_bb_p (stmt
))
2268 tree_stmt_iterator tsi
;
2271 /* Extract the first statement from LIST. */
2272 tsi
= tsi_start (list
);
2273 first
= tsi_stmt (tsi
);
2276 /* Replace the old statement with this new representative. */
2277 bsi_replace (bsi
, first
, true);
2279 if (!tsi_end_p (tsi
))
2281 /* If any reference would trap, then they all would. And more
2282 to the point, the first would. Therefore none of the rest
2283 will trap since the first didn't. Indicate this by
2284 iterating over the remaining statements and set
2285 TREE_THIS_NOTRAP in all INDIRECT_REFs. */
2288 walk_tree (tsi_stmt_ptr (tsi
), mark_notrap
, NULL
, NULL
);
2291 while (!tsi_end_p (tsi
));
2293 insert_edge_copies (list
, bsi
->bb
);
2297 sra_replace (bsi
, list
);
2301 /* Generate initializations for all scalarizable parameters. */
2304 scalarize_parms (void)
2310 EXECUTE_IF_SET_IN_BITMAP (needs_copy_in
, 0, i
, bi
)
2312 tree var
= referenced_var (i
);
2313 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
2314 generate_copy_inout (elt
, true, var
, &list
);
2319 insert_edge_copies (list
, ENTRY_BLOCK_PTR
);
2320 mark_all_v_defs (list
);
2324 /* Entry point to phase 4. Update the function to match replacements. */
2327 scalarize_function (void)
2329 static const struct sra_walk_fns fns
= {
2330 scalarize_use
, scalarize_copy
, scalarize_init
, scalarize_ldst
, false
2333 sra_walk_function (&fns
);
2335 bsi_commit_edge_inserts ();
2339 /* Debug helper function. Print ELT in a nice human-readable format. */
2342 dump_sra_elt_name (FILE *f
, struct sra_elt
*elt
)
2344 if (elt
->parent
&& TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
2346 fputs (elt
->element
== integer_zero_node
? "__real__ " : "__imag__ ", f
);
2347 dump_sra_elt_name (f
, elt
->parent
);
2352 dump_sra_elt_name (f
, elt
->parent
);
2353 if (DECL_P (elt
->element
))
2355 if (TREE_CODE (elt
->element
) == FIELD_DECL
)
2357 print_generic_expr (f
, elt
->element
, dump_flags
);
2359 else if (TREE_CODE (elt
->element
) == RANGE_EXPR
)
2360 fprintf (f
, "["HOST_WIDE_INT_PRINT_DEC
".."HOST_WIDE_INT_PRINT_DEC
"]",
2361 TREE_INT_CST_LOW (TREE_OPERAND (elt
->element
, 0)),
2362 TREE_INT_CST_LOW (TREE_OPERAND (elt
->element
, 1)));
2364 fprintf (f
, "[" HOST_WIDE_INT_PRINT_DEC
"]",
2365 TREE_INT_CST_LOW (elt
->element
));
2369 /* Likewise, but callable from the debugger. */
2372 debug_sra_elt_name (struct sra_elt
*elt
)
2374 dump_sra_elt_name (stderr
, elt
);
2375 fputc ('\n', stderr
);
2379 sra_init_cache (void)
2381 if (sra_type_decomp_cache
)
2384 sra_type_decomp_cache
= BITMAP_ALLOC (NULL
);
2385 sra_type_inst_cache
= BITMAP_ALLOC (NULL
);
2388 /* Main entry point. */
2393 /* Initialize local variables. */
2395 gcc_obstack_init (&sra_obstack
);
2396 sra_candidates
= BITMAP_ALLOC (NULL
);
2397 needs_copy_in
= BITMAP_ALLOC (NULL
);
2399 sra_map
= htab_create (101, sra_elt_hash
, sra_elt_eq
, NULL
);
2401 /* Scan. If we find anything, instantiate and scalarize. */
2402 if (find_candidates_for_sra ())
2405 decide_instantiations ();
2406 scalarize_function ();
2409 /* Free allocated memory. */
2410 htab_delete (sra_map
);
2412 BITMAP_FREE (sra_candidates
);
2413 BITMAP_FREE (needs_copy_in
);
2414 BITMAP_FREE (sra_type_decomp_cache
);
2415 BITMAP_FREE (sra_type_inst_cache
);
2416 obstack_free (&sra_obstack
, NULL
);
2421 tree_sra_early (void)
2435 return flag_tree_sra
!= 0;
2438 struct tree_opt_pass pass_sra_early
=
2441 gate_sra
, /* gate */
2442 tree_sra_early
, /* execute */
2445 0, /* static_pass_number */
2446 TV_TREE_SRA
, /* tv_id */
2447 PROP_cfg
| PROP_ssa
, /* properties_required */
2448 0, /* properties_provided */
2449 0, /* properties_destroyed */
2450 0, /* todo_flags_start */
2454 | TODO_verify_ssa
, /* todo_flags_finish */
2458 struct tree_opt_pass pass_sra
=
2461 gate_sra
, /* gate */
2462 tree_sra
, /* execute */
2465 0, /* static_pass_number */
2466 TV_TREE_SRA
, /* tv_id */
2467 PROP_cfg
| PROP_ssa
, /* properties_required */
2468 0, /* properties_provided */
2469 0, /* properties_destroyed */
2470 0, /* todo_flags_start */
2474 | TODO_verify_ssa
, /* todo_flags_finish */