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 Free Software Foundation, Inc.
5 Contributed by Diego Novillo <dnovillo@redhat.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 GCC is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to the Free
21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
26 #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 /* The set of aggregate variables that are candidates for scalarization. */
80 static bitmap sra_candidates
;
82 /* Set of scalarizable PARM_DECLs that need copy-in operations at the
83 beginning of the function. */
84 static bitmap needs_copy_in
;
86 /* Sets of bit pairs that cache type decomposition and instantiation. */
87 static bitmap sra_type_decomp_cache
;
88 static bitmap sra_type_inst_cache
;
90 /* One of these structures is created for each candidate aggregate
91 and each (accessed) member of such an aggregate. */
94 /* A tree of the elements. Used when we want to traverse everything. */
95 struct sra_elt
*parent
;
96 struct sra_elt
*children
;
97 struct sra_elt
*sibling
;
99 /* If this element is a root, then this is the VAR_DECL. If this is
100 a sub-element, this is some token used to identify the reference.
101 In the case of COMPONENT_REF, this is the FIELD_DECL. In the case
102 of an ARRAY_REF, this is the (constant) index. In the case of a
103 complex number, this is a zero or one. */
106 /* The type of the element. */
109 /* A VAR_DECL, for any sub-element we've decided to replace. */
112 /* The number of times the element is referenced as a whole. I.e.
113 given "a.b.c", this would be incremented for C, but not for A or B. */
116 /* The number of times the element is copied to or from another
117 scalarizable element. */
118 unsigned int n_copies
;
120 /* True if TYPE is scalar. */
123 /* True if we saw something about this element that prevents scalarization,
124 such as non-constant indexing. */
125 bool cannot_scalarize
;
127 /* True if we've decided that structure-to-structure assignment
128 should happen via memcpy and not per-element. */
131 /* A flag for use with/after random access traversals. */
135 /* Random access to the child of a parent is performed by hashing.
136 This prevents quadratic behavior, and allows SRA to function
137 reasonably on larger records. */
138 static htab_t sra_map
;
140 /* All structures are allocated out of the following obstack. */
141 static struct obstack sra_obstack
;
143 /* Debugging functions. */
144 static void dump_sra_elt_name (FILE *, struct sra_elt
*);
145 extern void debug_sra_elt_name (struct sra_elt
*);
147 /* Forward declarations. */
148 static tree
generate_element_ref (struct sra_elt
*);
150 /* Return true if DECL is an SRA candidate. */
153 is_sra_candidate_decl (tree decl
)
155 return DECL_P (decl
) && bitmap_bit_p (sra_candidates
, var_ann (decl
)->uid
);
158 /* Return true if TYPE is a scalar type. */
161 is_sra_scalar_type (tree type
)
163 enum tree_code code
= TREE_CODE (type
);
164 return (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== VECTOR_TYPE
165 || code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
166 || code
== CHAR_TYPE
|| code
== POINTER_TYPE
|| code
== OFFSET_TYPE
167 || code
== REFERENCE_TYPE
);
170 /* Return true if TYPE can be decomposed into a set of independent variables.
172 Note that this doesn't imply that all elements of TYPE can be
173 instantiated, just that if we decide to break up the type into
174 separate pieces that it can be done. */
177 type_can_be_decomposed_p (tree type
)
179 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
182 /* Avoid searching the same type twice. */
183 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+0))
185 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+1))
188 /* The type must have a definite nonzero size. */
189 if (TYPE_SIZE (type
) == NULL
|| TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
190 || integer_zerop (TYPE_SIZE (type
)))
193 /* The type must be a non-union aggregate. */
194 switch (TREE_CODE (type
))
198 bool saw_one_field
= false;
200 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
201 if (TREE_CODE (t
) == FIELD_DECL
)
203 /* Reject incorrectly represented bit fields. */
204 if (DECL_BIT_FIELD (t
)
205 && (tree_low_cst (DECL_SIZE (t
), 1)
206 != TYPE_PRECISION (TREE_TYPE (t
))))
209 saw_one_field
= true;
212 /* Record types must have at least one field. */
219 /* Array types must have a fixed lower and upper bound. */
220 t
= TYPE_DOMAIN (type
);
223 if (TYPE_MIN_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MIN_VALUE (t
)))
225 if (TYPE_MAX_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MAX_VALUE (t
)))
236 bitmap_set_bit (sra_type_decomp_cache
, cache
+0);
240 bitmap_set_bit (sra_type_decomp_cache
, cache
+1);
244 /* Return true if DECL can be decomposed into a set of independent
245 (though not necessarily scalar) variables. */
248 decl_can_be_decomposed_p (tree var
)
250 /* Early out for scalars. */
251 if (is_sra_scalar_type (TREE_TYPE (var
)))
254 /* The variable must not be aliased. */
255 if (!is_gimple_non_addressable (var
))
257 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
259 fprintf (dump_file
, "Cannot scalarize variable ");
260 print_generic_expr (dump_file
, var
, dump_flags
);
261 fprintf (dump_file
, " because it must live in memory\n");
266 /* The variable must not be volatile. */
267 if (TREE_THIS_VOLATILE (var
))
269 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
271 fprintf (dump_file
, "Cannot scalarize variable ");
272 print_generic_expr (dump_file
, var
, dump_flags
);
273 fprintf (dump_file
, " because it is declared volatile\n");
278 /* We must be able to decompose the variable's type. */
279 if (!type_can_be_decomposed_p (TREE_TYPE (var
)))
281 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
283 fprintf (dump_file
, "Cannot scalarize variable ");
284 print_generic_expr (dump_file
, var
, dump_flags
);
285 fprintf (dump_file
, " because its type cannot be decomposed\n");
293 /* Return true if TYPE can be *completely* decomposed into scalars. */
296 type_can_instantiate_all_elements (tree type
)
298 if (is_sra_scalar_type (type
))
300 if (!type_can_be_decomposed_p (type
))
303 switch (TREE_CODE (type
))
307 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
310 if (bitmap_bit_p (sra_type_inst_cache
, cache
+0))
312 if (bitmap_bit_p (sra_type_inst_cache
, cache
+1))
315 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
316 if (TREE_CODE (f
) == FIELD_DECL
)
318 if (!type_can_instantiate_all_elements (TREE_TYPE (f
)))
320 bitmap_set_bit (sra_type_inst_cache
, cache
+1);
325 bitmap_set_bit (sra_type_inst_cache
, cache
+0);
330 return type_can_instantiate_all_elements (TREE_TYPE (type
));
340 /* Test whether ELT or some sub-element cannot be scalarized. */
343 can_completely_scalarize_p (struct sra_elt
*elt
)
347 if (elt
->cannot_scalarize
)
350 for (c
= elt
->children
; c
; c
= c
->sibling
)
351 if (!can_completely_scalarize_p (c
))
358 /* A simplified tree hashing algorithm that only handles the types of
359 trees we expect to find in sra_elt->element. */
362 sra_hash_tree (tree t
)
366 switch (TREE_CODE (t
))
375 h
= TREE_INT_CST_LOW (t
) ^ TREE_INT_CST_HIGH (t
);
379 /* We can have types that are compatible, but have different member
380 lists, so we can't hash fields by ID. Use offsets instead. */
381 h
= iterative_hash_expr (DECL_FIELD_OFFSET (t
), 0);
382 h
= iterative_hash_expr (DECL_FIELD_BIT_OFFSET (t
), h
);
392 /* Hash function for type SRA_PAIR. */
395 sra_elt_hash (const void *x
)
397 const struct sra_elt
*e
= x
;
398 const struct sra_elt
*p
;
401 h
= sra_hash_tree (e
->element
);
403 /* Take into account everything back up the chain. Given that chain
404 lengths are rarely very long, this should be acceptable. If we
405 truly identify this as a performance problem, it should work to
406 hash the pointer value "e->parent". */
407 for (p
= e
->parent
; p
; p
= p
->parent
)
408 h
= (h
* 65521) ^ sra_hash_tree (p
->element
);
413 /* Equality function for type SRA_PAIR. */
416 sra_elt_eq (const void *x
, const void *y
)
418 const struct sra_elt
*a
= x
;
419 const struct sra_elt
*b
= y
;
422 if (a
->parent
!= b
->parent
)
430 if (TREE_CODE (ae
) != TREE_CODE (be
))
433 switch (TREE_CODE (ae
))
438 /* These are all pointer unique. */
442 /* Integers are not pointer unique, so compare their values. */
443 return tree_int_cst_equal (ae
, be
);
446 /* Fields are unique within a record, but not between
447 compatible records. */
448 if (DECL_FIELD_CONTEXT (ae
) == DECL_FIELD_CONTEXT (be
))
450 return fields_compatible_p (ae
, be
);
457 /* Create or return the SRA_ELT structure for CHILD in PARENT. PARENT
458 may be null, in which case CHILD must be a DECL. */
460 static struct sra_elt
*
461 lookup_element (struct sra_elt
*parent
, tree child
, tree type
,
462 enum insert_option insert
)
464 struct sra_elt dummy
;
465 struct sra_elt
**slot
;
468 dummy
.parent
= parent
;
469 dummy
.element
= child
;
471 slot
= (struct sra_elt
**) htab_find_slot (sra_map
, &dummy
, insert
);
472 if (!slot
&& insert
== NO_INSERT
)
476 if (!elt
&& insert
== INSERT
)
478 *slot
= elt
= obstack_alloc (&sra_obstack
, sizeof (*elt
));
479 memset (elt
, 0, sizeof (*elt
));
481 elt
->parent
= parent
;
482 elt
->element
= child
;
484 elt
->is_scalar
= is_sra_scalar_type (type
);
488 elt
->sibling
= parent
->children
;
489 parent
->children
= elt
;
492 /* If this is a parameter, then if we want to scalarize, we have
493 one copy from the true function parameter. Count it now. */
494 if (TREE_CODE (child
) == PARM_DECL
)
497 bitmap_set_bit (needs_copy_in
, var_ann (child
)->uid
);
504 /* Return true if the ARRAY_REF in EXPR is a constant, in bounds access. */
507 is_valid_const_index (tree expr
)
509 tree dom
, t
, index
= TREE_OPERAND (expr
, 1);
511 if (TREE_CODE (index
) != INTEGER_CST
)
514 /* Watch out for stupid user tricks, indexing outside the array.
516 Careful, we're not called only on scalarizable types, so do not
517 assume constant array bounds. We needn't do anything with such
518 cases, since they'll be referring to objects that we should have
519 already rejected for scalarization, so returning false is fine. */
521 dom
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (expr
, 0)));
525 t
= TYPE_MIN_VALUE (dom
);
526 if (!t
|| TREE_CODE (t
) != INTEGER_CST
)
528 if (tree_int_cst_lt (index
, t
))
531 t
= TYPE_MAX_VALUE (dom
);
532 if (!t
|| TREE_CODE (t
) != INTEGER_CST
)
534 if (tree_int_cst_lt (t
, index
))
540 /* Create or return the SRA_ELT structure for EXPR if the expression
541 refers to a scalarizable variable. */
543 static struct sra_elt
*
544 maybe_lookup_element_for_expr (tree expr
)
549 switch (TREE_CODE (expr
))
554 if (is_sra_candidate_decl (expr
))
555 return lookup_element (NULL
, expr
, TREE_TYPE (expr
), INSERT
);
559 /* We can't scalarize variable array indicies. */
560 if (is_valid_const_index (expr
))
561 child
= TREE_OPERAND (expr
, 1);
567 /* Don't look through unions. */
568 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) != RECORD_TYPE
)
570 child
= TREE_OPERAND (expr
, 1);
574 child
= integer_zero_node
;
577 child
= integer_one_node
;
584 elt
= maybe_lookup_element_for_expr (TREE_OPERAND (expr
, 0));
586 return lookup_element (elt
, child
, TREE_TYPE (expr
), INSERT
);
591 /* Functions to walk just enough of the tree to see all scalarizable
592 references, and categorize them. */
594 /* A set of callbacks for phases 2 and 4. They'll be invoked for the
595 various kinds of references seen. In all cases, *BSI is an iterator
596 pointing to the statement being processed. */
599 /* Invoked when ELT is required as a unit. Note that ELT might refer to
600 a leaf node, in which case this is a simple scalar reference. *EXPR_P
601 points to the location of the expression. IS_OUTPUT is true if this
602 is a left-hand-side reference. */
603 void (*use
) (struct sra_elt
*elt
, tree
*expr_p
,
604 block_stmt_iterator
*bsi
, bool is_output
);
606 /* Invoked when we have a copy between two scalarizable references. */
607 void (*copy
) (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
608 block_stmt_iterator
*bsi
);
610 /* Invoked when ELT is initialized from a constant. VALUE may be NULL,
611 in which case it should be treated as an empty CONSTRUCTOR. */
612 void (*init
) (struct sra_elt
*elt
, tree value
, block_stmt_iterator
*bsi
);
614 /* Invoked when we have a copy between one scalarizable reference ELT
615 and one non-scalarizable reference OTHER. IS_OUTPUT is true if ELT
616 is on the left-hand side. */
617 void (*ldst
) (struct sra_elt
*elt
, tree other
,
618 block_stmt_iterator
*bsi
, bool is_output
);
620 /* True during phase 2, false during phase 4. */
621 /* ??? This is a hack. */
625 #ifdef ENABLE_CHECKING
626 /* Invoked via walk_tree, if *TP contains a candidate decl, return it. */
629 sra_find_candidate_decl (tree
*tp
, int *walk_subtrees
,
630 void *data ATTRIBUTE_UNUSED
)
633 enum tree_code code
= TREE_CODE (t
);
635 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
638 if (is_sra_candidate_decl (t
))
648 /* Walk most expressions looking for a scalarizable aggregate.
649 If we find one, invoke FNS->USE. */
652 sra_walk_expr (tree
*expr_p
, block_stmt_iterator
*bsi
, bool is_output
,
653 const struct sra_walk_fns
*fns
)
657 bool disable_scalarization
= false;
659 /* We're looking to collect a reference expression between EXPR and INNER,
660 such that INNER is a scalarizable decl and all other nodes through EXPR
661 are references that we can scalarize. If we come across something that
662 we can't scalarize, we reset EXPR. This has the effect of making it
663 appear that we're referring to the larger expression as a whole. */
666 switch (TREE_CODE (inner
))
671 /* If there is a scalarizable decl at the bottom, then process it. */
672 if (is_sra_candidate_decl (inner
))
674 struct sra_elt
*elt
= maybe_lookup_element_for_expr (expr
);
675 if (disable_scalarization
)
676 elt
->cannot_scalarize
= true;
678 fns
->use (elt
, expr_p
, bsi
, is_output
);
683 /* Non-constant index means any member may be accessed. Prevent the
684 expression from being scalarized. If we were to treat this as a
685 reference to the whole array, we can wind up with a single dynamic
686 index reference inside a loop being overridden by several constant
687 index references during loop setup. It's possible that this could
688 be avoided by using dynamic usage counts based on BB trip counts
689 (based on loop analysis or profiling), but that hardly seems worth
691 /* ??? Hack. Figure out how to push this into the scan routines
692 without duplicating too much code. */
693 if (!is_valid_const_index (inner
))
695 disable_scalarization
= true;
698 /* ??? Are we assured that non-constant bounds and stride will have
699 the same value everywhere? I don't think Fortran will... */
700 if (TREE_OPERAND (inner
, 2) || TREE_OPERAND (inner
, 3))
702 inner
= TREE_OPERAND (inner
, 0);
706 /* A reference to a union member constitutes a reference to the
708 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (inner
, 0))) != RECORD_TYPE
)
710 /* ??? See above re non-constant stride. */
711 if (TREE_OPERAND (inner
, 2))
713 inner
= TREE_OPERAND (inner
, 0);
718 inner
= TREE_OPERAND (inner
, 0);
722 /* A bit field reference (access to *multiple* fields simultaneously)
723 is not currently scalarized. Consider this an access to the
724 complete outer element, to which walk_tree will bring us next. */
727 case ARRAY_RANGE_REF
:
728 /* Similarly, an subrange reference is used to modify indexing. Which
729 means that the canonical element names that we have won't work. */
732 case VIEW_CONVERT_EXPR
:
734 /* Similarly, a view/nop explicitly wants to look at an object in a
735 type other than the one we've scalarized. */
739 /* This is a transparent wrapper. The entire inner expression really
744 expr_p
= &TREE_OPERAND (inner
, 0);
745 inner
= expr
= *expr_p
;
749 #ifdef ENABLE_CHECKING
750 /* Validate that we're not missing any references. */
751 gcc_assert (!walk_tree (&inner
, sra_find_candidate_decl
, NULL
, NULL
));
757 /* Walk a TREE_LIST of values looking for scalarizable aggregates.
758 If we find one, invoke FNS->USE. */
761 sra_walk_tree_list (tree list
, block_stmt_iterator
*bsi
, bool is_output
,
762 const struct sra_walk_fns
*fns
)
765 for (op
= list
; op
; op
= TREE_CHAIN (op
))
766 sra_walk_expr (&TREE_VALUE (op
), bsi
, is_output
, fns
);
769 /* Walk the arguments of a CALL_EXPR looking for scalarizable aggregates.
770 If we find one, invoke FNS->USE. */
773 sra_walk_call_expr (tree expr
, block_stmt_iterator
*bsi
,
774 const struct sra_walk_fns
*fns
)
776 sra_walk_tree_list (TREE_OPERAND (expr
, 1), bsi
, false, fns
);
779 /* Walk the inputs and outputs of an ASM_EXPR looking for scalarizable
780 aggregates. If we find one, invoke FNS->USE. */
783 sra_walk_asm_expr (tree expr
, block_stmt_iterator
*bsi
,
784 const struct sra_walk_fns
*fns
)
786 sra_walk_tree_list (ASM_INPUTS (expr
), bsi
, false, fns
);
787 sra_walk_tree_list (ASM_OUTPUTS (expr
), bsi
, true, fns
);
790 /* Walk a MODIFY_EXPR and categorize the assignment appropriately. */
793 sra_walk_modify_expr (tree expr
, block_stmt_iterator
*bsi
,
794 const struct sra_walk_fns
*fns
)
796 struct sra_elt
*lhs_elt
, *rhs_elt
;
799 lhs
= TREE_OPERAND (expr
, 0);
800 rhs
= TREE_OPERAND (expr
, 1);
801 lhs_elt
= maybe_lookup_element_for_expr (lhs
);
802 rhs_elt
= maybe_lookup_element_for_expr (rhs
);
804 /* If both sides are scalarizable, this is a COPY operation. */
805 if (lhs_elt
&& rhs_elt
)
807 fns
->copy (lhs_elt
, rhs_elt
, bsi
);
811 /* If the RHS is scalarizable, handle it. There are only two cases. */
814 if (!rhs_elt
->is_scalar
)
815 fns
->ldst (rhs_elt
, lhs
, bsi
, false);
817 fns
->use (rhs_elt
, &TREE_OPERAND (expr
, 1), bsi
, false);
820 /* If it isn't scalarizable, there may be scalarizable variables within, so
821 check for a call or else walk the RHS to see if we need to do any
822 copy-in operations. We need to do it before the LHS is scalarized so
823 that the statements get inserted in the proper place, before any
824 copy-out operations. */
827 tree call
= get_call_expr_in (rhs
);
829 sra_walk_call_expr (call
, bsi
, fns
);
831 sra_walk_expr (&TREE_OPERAND (expr
, 1), bsi
, false, fns
);
834 /* Likewise, handle the LHS being scalarizable. We have cases similar
835 to those above, but also want to handle RHS being constant. */
838 /* If this is an assignment from a constant, or constructor, then
839 we have access to all of the elements individually. Invoke INIT. */
840 if (TREE_CODE (rhs
) == COMPLEX_EXPR
841 || TREE_CODE (rhs
) == COMPLEX_CST
842 || TREE_CODE (rhs
) == CONSTRUCTOR
)
843 fns
->init (lhs_elt
, rhs
, bsi
);
845 /* If this is an assignment from read-only memory, treat this as if
846 we'd been passed the constructor directly. Invoke INIT. */
847 else if (TREE_CODE (rhs
) == VAR_DECL
849 && TREE_READONLY (rhs
)
850 && targetm
.binds_local_p (rhs
))
851 fns
->init (lhs_elt
, DECL_INITIAL (rhs
), bsi
);
853 /* If this is a copy from a non-scalarizable lvalue, invoke LDST.
854 The lvalue requirement prevents us from trying to directly scalarize
855 the result of a function call. Which would result in trying to call
856 the function multiple times, and other evil things. */
857 else if (!lhs_elt
->is_scalar
&& is_gimple_addressable (rhs
))
858 fns
->ldst (lhs_elt
, rhs
, bsi
, true);
860 /* Otherwise we're being used in some context that requires the
861 aggregate to be seen as a whole. Invoke USE. */
863 fns
->use (lhs_elt
, &TREE_OPERAND (expr
, 0), bsi
, true);
866 /* Similarly to above, LHS_ELT being null only means that the LHS as a
867 whole is not a scalarizable reference. There may be occurrences of
868 scalarizable variables within, which implies a USE. */
870 sra_walk_expr (&TREE_OPERAND (expr
, 0), bsi
, true, fns
);
873 /* Entry point to the walk functions. Search the entire function,
874 invoking the callbacks in FNS on each of the references to
875 scalarizable variables. */
878 sra_walk_function (const struct sra_walk_fns
*fns
)
881 block_stmt_iterator si
, ni
;
883 /* ??? Phase 4 could derive some benefit to walking the function in
884 dominator tree order. */
887 for (si
= bsi_start (bb
); !bsi_end_p (si
); si
= ni
)
892 stmt
= bsi_stmt (si
);
893 ann
= stmt_ann (stmt
);
898 /* If the statement has no virtual operands, then it doesn't
899 make any structure references that we care about. */
900 if (ZERO_SSA_OPERANDS (stmt
, (SSA_OP_VIRTUAL_DEFS
| SSA_OP_VUSE
)))
903 switch (TREE_CODE (stmt
))
906 /* If we have "return <retval>" then the return value is
907 already exposed for our pleasure. Walk it as a USE to
908 force all the components back in place for the return.
910 If we have an embedded assignment, then <retval> is of
911 a type that gets returned in registers in this ABI, and
912 we do not wish to extend their lifetimes. Treat this
913 as a USE of the variable on the RHS of this assignment. */
915 t
= TREE_OPERAND (stmt
, 0);
916 if (TREE_CODE (t
) == MODIFY_EXPR
)
917 sra_walk_expr (&TREE_OPERAND (t
, 1), &si
, false, fns
);
919 sra_walk_expr (&TREE_OPERAND (stmt
, 0), &si
, false, fns
);
923 sra_walk_modify_expr (stmt
, &si
, fns
);
926 sra_walk_call_expr (stmt
, &si
, fns
);
929 sra_walk_asm_expr (stmt
, &si
, fns
);
938 /* Phase One: Scan all referenced variables in the program looking for
939 structures that could be decomposed. */
942 find_candidates_for_sra (void)
945 bool any_set
= false;
947 for (i
= 0; i
< num_referenced_vars
; i
++)
949 tree var
= referenced_var (i
);
950 if (decl_can_be_decomposed_p (var
))
952 bitmap_set_bit (sra_candidates
, var_ann (var
)->uid
);
961 /* Phase Two: Scan all references to scalarizable variables. Count the
962 number of times they are used or copied respectively. */
964 /* Callbacks to fill in SRA_WALK_FNS. Everything but USE is
965 considered a copy, because we can decompose the reference such that
966 the sub-elements needn't be contiguous. */
969 scan_use (struct sra_elt
*elt
, tree
*expr_p ATTRIBUTE_UNUSED
,
970 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
,
971 bool is_output ATTRIBUTE_UNUSED
)
977 scan_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
978 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
)
980 lhs_elt
->n_copies
+= 1;
981 rhs_elt
->n_copies
+= 1;
985 scan_init (struct sra_elt
*lhs_elt
, tree rhs ATTRIBUTE_UNUSED
,
986 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
)
988 lhs_elt
->n_copies
+= 1;
992 scan_ldst (struct sra_elt
*elt
, tree other ATTRIBUTE_UNUSED
,
993 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
,
994 bool is_output ATTRIBUTE_UNUSED
)
999 /* Dump the values we collected during the scanning phase. */
1002 scan_dump (struct sra_elt
*elt
)
1006 dump_sra_elt_name (dump_file
, elt
);
1007 fprintf (dump_file
, ": n_uses=%u n_copies=%u\n", elt
->n_uses
, elt
->n_copies
);
1009 for (c
= elt
->children
; c
; c
= c
->sibling
)
1013 /* Entry point to phase 2. Scan the entire function, building up
1014 scalarization data structures, recording copies and uses. */
1017 scan_function (void)
1019 static const struct sra_walk_fns fns
= {
1020 scan_use
, scan_copy
, scan_init
, scan_ldst
, true
1024 sra_walk_function (&fns
);
1026 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1030 fputs ("\nScan results:\n", dump_file
);
1031 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
, bi
)
1033 tree var
= referenced_var (i
);
1034 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1038 fputc ('\n', dump_file
);
1042 /* Phase Three: Make decisions about which variables to scalarize, if any.
1043 All elements to be scalarized have replacement variables made for them. */
1045 /* A subroutine of build_element_name. Recursively build the element
1046 name on the obstack. */
1049 build_element_name_1 (struct sra_elt
*elt
)
1056 build_element_name_1 (elt
->parent
);
1057 obstack_1grow (&sra_obstack
, '$');
1059 if (TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
1061 if (elt
->element
== integer_zero_node
)
1062 obstack_grow (&sra_obstack
, "real", 4);
1064 obstack_grow (&sra_obstack
, "imag", 4);
1070 if (TREE_CODE (t
) == INTEGER_CST
)
1072 /* ??? Eh. Don't bother doing double-wide printing. */
1073 sprintf (buffer
, HOST_WIDE_INT_PRINT_DEC
, TREE_INT_CST_LOW (t
));
1074 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1078 tree name
= DECL_NAME (t
);
1080 obstack_grow (&sra_obstack
, IDENTIFIER_POINTER (name
),
1081 IDENTIFIER_LENGTH (name
));
1084 sprintf (buffer
, "D%u", DECL_UID (t
));
1085 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1090 /* Construct a pretty variable name for an element's replacement variable.
1091 The name is built on the obstack. */
1094 build_element_name (struct sra_elt
*elt
)
1096 build_element_name_1 (elt
);
1097 obstack_1grow (&sra_obstack
, '\0');
1098 return obstack_finish (&sra_obstack
);
1101 /* Instantiate an element as an independent variable. */
1104 instantiate_element (struct sra_elt
*elt
)
1106 struct sra_elt
*base_elt
;
1109 for (base_elt
= elt
; base_elt
->parent
; base_elt
= base_elt
->parent
)
1111 base
= base_elt
->element
;
1113 elt
->replacement
= var
= make_rename_temp (elt
->type
, "SR");
1114 DECL_SOURCE_LOCATION (var
) = DECL_SOURCE_LOCATION (base
);
1115 DECL_ARTIFICIAL (var
) = 1;
1117 if (TREE_THIS_VOLATILE (elt
->type
))
1119 TREE_THIS_VOLATILE (var
) = 1;
1120 TREE_SIDE_EFFECTS (var
) = 1;
1123 if (DECL_NAME (base
) && !DECL_IGNORED_P (base
))
1125 char *pretty_name
= build_element_name (elt
);
1126 DECL_NAME (var
) = get_identifier (pretty_name
);
1127 obstack_free (&sra_obstack
, pretty_name
);
1129 DECL_DEBUG_EXPR (var
) = generate_element_ref (elt
);
1130 DECL_DEBUG_EXPR_IS_FROM (var
) = 1;
1132 DECL_IGNORED_P (var
) = 0;
1133 TREE_NO_WARNING (var
) = TREE_NO_WARNING (base
);
1137 DECL_IGNORED_P (var
) = 1;
1138 /* ??? We can't generate any warning that would be meaningful. */
1139 TREE_NO_WARNING (var
) = 1;
1144 fputs (" ", dump_file
);
1145 dump_sra_elt_name (dump_file
, elt
);
1146 fputs (" -> ", dump_file
);
1147 print_generic_expr (dump_file
, var
, dump_flags
);
1148 fputc ('\n', dump_file
);
1152 /* Make one pass across an element tree deciding whether or not it's
1153 profitable to instantiate individual leaf scalars.
1155 PARENT_USES and PARENT_COPIES are the sum of the N_USES and N_COPIES
1156 fields all the way up the tree. */
1159 decide_instantiation_1 (struct sra_elt
*elt
, unsigned int parent_uses
,
1160 unsigned int parent_copies
)
1162 if (dump_file
&& !elt
->parent
)
1164 fputs ("Initial instantiation for ", dump_file
);
1165 dump_sra_elt_name (dump_file
, elt
);
1166 fputc ('\n', dump_file
);
1169 if (elt
->cannot_scalarize
)
1174 /* The decision is simple: instantiate if we're used more frequently
1175 than the parent needs to be seen as a complete unit. */
1176 if (elt
->n_uses
+ elt
->n_copies
+ parent_copies
> parent_uses
)
1177 instantiate_element (elt
);
1182 unsigned int this_uses
= elt
->n_uses
+ parent_uses
;
1183 unsigned int this_copies
= elt
->n_copies
+ parent_copies
;
1185 for (c
= elt
->children
; c
; c
= c
->sibling
)
1186 decide_instantiation_1 (c
, this_uses
, this_copies
);
1190 /* Compute the size and number of all instantiated elements below ELT.
1191 We will only care about this if the size of the complete structure
1192 fits in a HOST_WIDE_INT, so we don't have to worry about overflow. */
1195 sum_instantiated_sizes (struct sra_elt
*elt
, unsigned HOST_WIDE_INT
*sizep
)
1197 if (elt
->replacement
)
1199 *sizep
+= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (elt
->type
));
1205 unsigned int count
= 0;
1207 for (c
= elt
->children
; c
; c
= c
->sibling
)
1208 count
+= sum_instantiated_sizes (c
, sizep
);
1214 /* Instantiate fields in ELT->TYPE that are not currently present as
1217 static void instantiate_missing_elements (struct sra_elt
*elt
);
1220 instantiate_missing_elements_1 (struct sra_elt
*elt
, tree child
, tree type
)
1222 struct sra_elt
*sub
= lookup_element (elt
, child
, type
, INSERT
);
1225 if (sub
->replacement
== NULL
)
1226 instantiate_element (sub
);
1229 instantiate_missing_elements (sub
);
1233 instantiate_missing_elements (struct sra_elt
*elt
)
1235 tree type
= elt
->type
;
1237 switch (TREE_CODE (type
))
1242 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
1243 if (TREE_CODE (f
) == FIELD_DECL
)
1244 instantiate_missing_elements_1 (elt
, f
, TREE_TYPE (f
));
1250 tree i
, max
, subtype
;
1252 i
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
1253 max
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
1254 subtype
= TREE_TYPE (type
);
1258 instantiate_missing_elements_1 (elt
, i
, subtype
);
1259 if (tree_int_cst_equal (i
, max
))
1261 i
= int_const_binop (PLUS_EXPR
, i
, integer_one_node
, true);
1268 type
= TREE_TYPE (type
);
1269 instantiate_missing_elements_1 (elt
, integer_zero_node
, type
);
1270 instantiate_missing_elements_1 (elt
, integer_one_node
, type
);
1278 /* Make one pass across an element tree deciding whether to perform block
1279 or element copies. If we decide on element copies, instantiate all
1280 elements. Return true if there are any instantiated sub-elements. */
1283 decide_block_copy (struct sra_elt
*elt
)
1288 /* If scalarization is disabled, respect it. */
1289 if (elt
->cannot_scalarize
)
1291 elt
->use_block_copy
= 1;
1295 fputs ("Scalarization disabled for ", dump_file
);
1296 dump_sra_elt_name (dump_file
, elt
);
1297 fputc ('\n', dump_file
);
1300 /* Disable scalarization of sub-elements */
1301 for (c
= elt
->children
; c
; c
= c
->sibling
)
1303 c
->cannot_scalarize
= 1;
1304 decide_block_copy (c
);
1309 /* Don't decide if we've no uses. */
1310 if (elt
->n_uses
== 0 && elt
->n_copies
== 0)
1313 else if (!elt
->is_scalar
)
1315 tree size_tree
= TYPE_SIZE_UNIT (elt
->type
);
1316 bool use_block_copy
= true;
1318 /* Tradeoffs for COMPLEX types pretty much always make it better
1319 to go ahead and split the components. */
1320 if (TREE_CODE (elt
->type
) == COMPLEX_TYPE
)
1321 use_block_copy
= false;
1323 /* Don't bother trying to figure out the rest if the structure is
1324 so large we can't do easy arithmetic. This also forces block
1325 copies for variable sized structures. */
1326 else if (host_integerp (size_tree
, 1))
1328 unsigned HOST_WIDE_INT full_size
, inst_size
= 0;
1329 unsigned int max_size
;
1331 /* If the sra-max-structure-size parameter is 0, then the
1332 user has not overridden the parameter and we can choose a
1333 sensible default. */
1334 max_size
= SRA_MAX_STRUCTURE_SIZE
1335 ? SRA_MAX_STRUCTURE_SIZE
1336 : MOVE_RATIO
* UNITS_PER_WORD
;
1338 full_size
= tree_low_cst (size_tree
, 1);
1340 /* ??? What to do here. If there are two fields, and we've only
1341 instantiated one, then instantiating the other is clearly a win.
1342 If there are a large number of fields then the size of the copy
1343 is much more of a factor. */
1345 /* If the structure is small, and we've made copies, go ahead
1346 and instantiate, hoping that the copies will go away. */
1347 if (full_size
<= max_size
1348 && elt
->n_copies
> elt
->n_uses
)
1349 use_block_copy
= false;
1352 sum_instantiated_sizes (elt
, &inst_size
);
1354 if (inst_size
* 100 >= full_size
* SRA_FIELD_STRUCTURE_RATIO
)
1355 use_block_copy
= false;
1358 /* In order to avoid block copy, we have to be able to instantiate
1359 all elements of the type. See if this is possible. */
1361 && (!can_completely_scalarize_p (elt
)
1362 || !type_can_instantiate_all_elements (elt
->type
)))
1363 use_block_copy
= true;
1365 elt
->use_block_copy
= use_block_copy
;
1369 fprintf (dump_file
, "Using %s for ",
1370 use_block_copy
? "block-copy" : "element-copy");
1371 dump_sra_elt_name (dump_file
, elt
);
1372 fputc ('\n', dump_file
);
1375 if (!use_block_copy
)
1377 instantiate_missing_elements (elt
);
1382 any_inst
= elt
->replacement
!= NULL
;
1384 for (c
= elt
->children
; c
; c
= c
->sibling
)
1385 any_inst
|= decide_block_copy (c
);
1390 /* Entry point to phase 3. Instantiate scalar replacement variables. */
1393 decide_instantiations (void)
1397 bitmap_head done_head
;
1400 /* We cannot clear bits from a bitmap we're iterating over,
1401 so save up all the bits to clear until the end. */
1402 bitmap_initialize (&done_head
, &bitmap_default_obstack
);
1403 cleared_any
= false;
1405 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
, bi
)
1407 tree var
= referenced_var (i
);
1408 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1411 decide_instantiation_1 (elt
, 0, 0);
1412 if (!decide_block_copy (elt
))
1417 bitmap_set_bit (&done_head
, i
);
1424 bitmap_and_compl_into (sra_candidates
, &done_head
);
1425 bitmap_and_compl_into (needs_copy_in
, &done_head
);
1427 bitmap_clear (&done_head
);
1429 mark_set_for_renaming (sra_candidates
);
1432 fputc ('\n', dump_file
);
1436 /* Phase Four: Update the function to match the replacements created. */
1438 /* Mark all the variables in V_MAY_DEF or V_MUST_DEF operands for STMT for
1439 renaming. This becomes necessary when we modify all of a non-scalar. */
1442 mark_all_v_defs_1 (tree stmt
)
1447 update_stmt_if_modified (stmt
);
1449 FOR_EACH_SSA_TREE_OPERAND (sym
, stmt
, iter
, SSA_OP_ALL_VIRTUALS
)
1451 if (TREE_CODE (sym
) == SSA_NAME
)
1452 sym
= SSA_NAME_VAR (sym
);
1453 mark_sym_for_renaming (sym
);
1458 /* Mark all the variables in virtual operands in all the statements in
1459 LIST for renaming. */
1462 mark_all_v_defs (tree list
)
1464 if (TREE_CODE (list
) != STATEMENT_LIST
)
1465 mark_all_v_defs_1 (list
);
1468 tree_stmt_iterator i
;
1469 for (i
= tsi_start (list
); !tsi_end_p (i
); tsi_next (&i
))
1470 mark_all_v_defs_1 (tsi_stmt (i
));
1475 /* Build a single level component reference to ELT rooted at BASE. */
1478 generate_one_element_ref (struct sra_elt
*elt
, tree base
)
1480 switch (TREE_CODE (TREE_TYPE (base
)))
1484 tree field
= elt
->element
;
1486 /* Watch out for compatible records with differing field lists. */
1487 if (DECL_FIELD_CONTEXT (field
) != TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
1488 field
= find_compatible_field (TREE_TYPE (base
), field
);
1490 return build (COMPONENT_REF
, elt
->type
, base
, field
, NULL
);
1494 return build (ARRAY_REF
, elt
->type
, base
, elt
->element
, NULL
, NULL
);
1497 if (elt
->element
== integer_zero_node
)
1498 return build (REALPART_EXPR
, elt
->type
, base
);
1500 return build (IMAGPART_EXPR
, elt
->type
, base
);
1507 /* Build a full component reference to ELT rooted at its native variable. */
1510 generate_element_ref (struct sra_elt
*elt
)
1513 return generate_one_element_ref (elt
, generate_element_ref (elt
->parent
));
1515 return elt
->element
;
1518 /* Generate a set of assignment statements in *LIST_P to copy all
1519 instantiated elements under ELT to or from the equivalent structure
1520 rooted at EXPR. COPY_OUT controls the direction of the copy, with
1521 true meaning to copy out of EXPR into ELT. */
1524 generate_copy_inout (struct sra_elt
*elt
, bool copy_out
, tree expr
,
1530 if (elt
->replacement
)
1533 t
= build (MODIFY_EXPR
, void_type_node
, elt
->replacement
, expr
);
1535 t
= build (MODIFY_EXPR
, void_type_node
, expr
, elt
->replacement
);
1536 append_to_statement_list (t
, list_p
);
1540 for (c
= elt
->children
; c
; c
= c
->sibling
)
1542 t
= generate_one_element_ref (c
, unshare_expr (expr
));
1543 generate_copy_inout (c
, copy_out
, t
, list_p
);
1548 /* Generate a set of assignment statements in *LIST_P to copy all instantiated
1549 elements under SRC to their counterparts under DST. There must be a 1-1
1550 correspondence of instantiated elements. */
1553 generate_element_copy (struct sra_elt
*dst
, struct sra_elt
*src
, tree
*list_p
)
1555 struct sra_elt
*dc
, *sc
;
1557 for (dc
= dst
->children
; dc
; dc
= dc
->sibling
)
1559 sc
= lookup_element (src
, dc
->element
, NULL
, NO_INSERT
);
1561 generate_element_copy (dc
, sc
, list_p
);
1564 if (dst
->replacement
)
1568 gcc_assert (src
->replacement
);
1570 t
= build (MODIFY_EXPR
, void_type_node
, dst
->replacement
,
1572 append_to_statement_list (t
, list_p
);
1576 /* Generate a set of assignment statements in *LIST_P to zero all instantiated
1577 elements under ELT. In addition, do not assign to elements that have been
1578 marked VISITED but do reset the visited flag; this allows easy coordination
1579 with generate_element_init. */
1582 generate_element_zero (struct sra_elt
*elt
, tree
*list_p
)
1588 elt
->visited
= false;
1592 for (c
= elt
->children
; c
; c
= c
->sibling
)
1593 generate_element_zero (c
, list_p
);
1595 if (elt
->replacement
)
1599 gcc_assert (elt
->is_scalar
);
1600 t
= fold_convert (elt
->type
, integer_zero_node
);
1602 t
= build (MODIFY_EXPR
, void_type_node
, elt
->replacement
, t
);
1603 append_to_statement_list (t
, list_p
);
1607 /* Generate an assignment VAR = INIT, where INIT may need gimplification.
1608 Add the result to *LIST_P. */
1611 generate_one_element_init (tree var
, tree init
, tree
*list_p
)
1613 /* The replacement can be almost arbitrarily complex. Gimplify. */
1614 tree stmt
= build (MODIFY_EXPR
, void_type_node
, var
, init
);
1615 gimplify_and_add (stmt
, list_p
);
1618 /* Generate a set of assignment statements in *LIST_P to set all instantiated
1619 elements under ELT with the contents of the initializer INIT. In addition,
1620 mark all assigned elements VISITED; this allows easy coordination with
1621 generate_element_zero. Return false if we found a case we couldn't
1625 generate_element_init_1 (struct sra_elt
*elt
, tree init
, tree
*list_p
)
1628 enum tree_code init_code
;
1629 struct sra_elt
*sub
;
1632 /* We can be passed DECL_INITIAL of a static variable. It might have a
1633 conversion, which we strip off here. */
1634 STRIP_USELESS_TYPE_CONVERSION (init
);
1635 init_code
= TREE_CODE (init
);
1639 if (elt
->replacement
)
1641 generate_one_element_init (elt
->replacement
, init
, list_p
);
1642 elt
->visited
= true;
1651 for (sub
= elt
->children
; sub
; sub
= sub
->sibling
)
1653 if (sub
->element
== integer_zero_node
)
1654 t
= (init_code
== COMPLEX_EXPR
1655 ? TREE_OPERAND (init
, 0) : TREE_REALPART (init
));
1657 t
= (init_code
== COMPLEX_EXPR
1658 ? TREE_OPERAND (init
, 1) : TREE_IMAGPART (init
));
1659 result
&= generate_element_init_1 (sub
, t
, list_p
);
1664 for (t
= CONSTRUCTOR_ELTS (init
); t
; t
= TREE_CHAIN (t
))
1666 tree purpose
= TREE_PURPOSE (t
);
1667 tree value
= TREE_VALUE (t
);
1669 if (TREE_CODE (purpose
) == RANGE_EXPR
)
1671 tree lower
= TREE_OPERAND (purpose
, 0);
1672 tree upper
= TREE_OPERAND (purpose
, 1);
1676 sub
= lookup_element (elt
, lower
, NULL
, NO_INSERT
);
1678 result
&= generate_element_init_1 (sub
, value
, list_p
);
1679 if (tree_int_cst_equal (lower
, upper
))
1681 lower
= int_const_binop (PLUS_EXPR
, lower
,
1682 integer_one_node
, true);
1687 sub
= lookup_element (elt
, purpose
, NULL
, NO_INSERT
);
1689 result
&= generate_element_init_1 (sub
, value
, list_p
);
1695 elt
->visited
= true;
1702 /* A wrapper function for generate_element_init_1 that handles cleanup after
1706 generate_element_init (struct sra_elt
*elt
, tree init
, tree
*list_p
)
1710 push_gimplify_context ();
1711 ret
= generate_element_init_1 (elt
, init
, list_p
);
1712 pop_gimplify_context (NULL
);
1714 /* The replacement can expose previously unreferenced variables. */
1717 tree_stmt_iterator i
;
1720 old
= num_referenced_vars
;
1722 for (i
= tsi_start (*list_p
); !tsi_end_p (i
); tsi_next (&i
))
1723 find_new_referenced_vars (tsi_stmt_ptr (i
));
1725 new = num_referenced_vars
;
1726 for (j
= old
; j
< new; ++j
)
1727 mark_sym_for_renaming (referenced_var (j
));
1733 /* Insert STMT on all the outgoing edges out of BB. Note that if BB
1734 has more than one edge, STMT will be replicated for each edge. Also,
1735 abnormal edges will be ignored. */
1738 insert_edge_copies (tree stmt
, basic_block bb
)
1745 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1747 /* We don't need to insert copies on abnormal edges. The
1748 value of the scalar replacement is not guaranteed to
1749 be valid through an abnormal edge. */
1750 if (!(e
->flags
& EDGE_ABNORMAL
))
1754 bsi_insert_on_edge (e
, stmt
);
1758 bsi_insert_on_edge (e
, unsave_expr_now (stmt
));
1763 /* Helper function to insert LIST before BSI, and set up line number info. */
1766 sra_insert_before (block_stmt_iterator
*bsi
, tree list
)
1768 tree stmt
= bsi_stmt (*bsi
);
1770 if (EXPR_HAS_LOCATION (stmt
))
1771 annotate_all_with_locus (&list
, EXPR_LOCATION (stmt
));
1772 bsi_insert_before (bsi
, list
, BSI_SAME_STMT
);
1775 /* Similarly, but insert after BSI. Handles insertion onto edges as well. */
1778 sra_insert_after (block_stmt_iterator
*bsi
, tree list
)
1780 tree stmt
= bsi_stmt (*bsi
);
1782 if (EXPR_HAS_LOCATION (stmt
))
1783 annotate_all_with_locus (&list
, EXPR_LOCATION (stmt
));
1785 if (stmt_ends_bb_p (stmt
))
1786 insert_edge_copies (list
, bsi
->bb
);
1788 bsi_insert_after (bsi
, list
, BSI_SAME_STMT
);
1791 /* Similarly, but replace the statement at BSI. */
1794 sra_replace (block_stmt_iterator
*bsi
, tree list
)
1796 sra_insert_before (bsi
, list
);
1798 if (bsi_end_p (*bsi
))
1799 *bsi
= bsi_last (bsi
->bb
);
1804 /* Scalarize a USE. To recap, this is either a simple reference to ELT,
1805 if elt is scalar, or some occurrence of ELT that requires a complete
1806 aggregate. IS_OUTPUT is true if ELT is being modified. */
1809 scalarize_use (struct sra_elt
*elt
, tree
*expr_p
, block_stmt_iterator
*bsi
,
1812 tree list
= NULL
, stmt
= bsi_stmt (*bsi
);
1814 if (elt
->replacement
)
1816 /* If we have a replacement, then updating the reference is as
1817 simple as modifying the existing statement in place. */
1819 mark_all_v_defs (stmt
);
1820 *expr_p
= elt
->replacement
;
1825 /* Otherwise we need some copies. If ELT is being read, then we want
1826 to store all (modified) sub-elements back into the structure before
1827 the reference takes place. If ELT is being written, then we want to
1828 load the changed values back into our shadow variables. */
1829 /* ??? We don't check modified for reads, we just always write all of
1830 the values. We should be able to record the SSA number of the VOP
1831 for which the values were last read. If that number matches the
1832 SSA number of the VOP in the current statement, then we needn't
1833 emit an assignment. This would also eliminate double writes when
1834 a structure is passed as more than one argument to a function call.
1835 This optimization would be most effective if sra_walk_function
1836 processed the blocks in dominator order. */
1838 generate_copy_inout (elt
, is_output
, generate_element_ref (elt
), &list
);
1841 mark_all_v_defs (list
);
1843 sra_insert_after (bsi
, list
);
1845 sra_insert_before (bsi
, list
);
1849 /* Scalarize a COPY. To recap, this is an assignment statement between
1850 two scalarizable references, LHS_ELT and RHS_ELT. */
1853 scalarize_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
1854 block_stmt_iterator
*bsi
)
1858 if (lhs_elt
->replacement
&& rhs_elt
->replacement
)
1860 /* If we have two scalar operands, modify the existing statement. */
1861 stmt
= bsi_stmt (*bsi
);
1863 /* See the commentary in sra_walk_function concerning
1864 RETURN_EXPR, and why we should never see one here. */
1865 gcc_assert (TREE_CODE (stmt
) == MODIFY_EXPR
);
1867 TREE_OPERAND (stmt
, 0) = lhs_elt
->replacement
;
1868 TREE_OPERAND (stmt
, 1) = rhs_elt
->replacement
;
1871 else if (lhs_elt
->use_block_copy
|| rhs_elt
->use_block_copy
)
1873 /* If either side requires a block copy, then sync the RHS back
1874 to the original structure, leave the original assignment
1875 statement (which will perform the block copy), then load the
1876 LHS values out of its now-updated original structure. */
1877 /* ??? Could perform a modified pair-wise element copy. That
1878 would at least allow those elements that are instantiated in
1879 both structures to be optimized well. */
1882 generate_copy_inout (rhs_elt
, false,
1883 generate_element_ref (rhs_elt
), &list
);
1886 mark_all_v_defs (list
);
1887 sra_insert_before (bsi
, list
);
1891 generate_copy_inout (lhs_elt
, true,
1892 generate_element_ref (lhs_elt
), &list
);
1895 mark_all_v_defs (list
);
1896 sra_insert_after (bsi
, list
);
1901 /* Otherwise both sides must be fully instantiated. In which
1902 case perform pair-wise element assignments and replace the
1903 original block copy statement. */
1905 stmt
= bsi_stmt (*bsi
);
1906 mark_all_v_defs (stmt
);
1909 generate_element_copy (lhs_elt
, rhs_elt
, &list
);
1911 mark_all_v_defs (list
);
1912 sra_replace (bsi
, list
);
1916 /* Scalarize an INIT. To recap, this is an assignment to a scalarizable
1917 reference from some form of constructor: CONSTRUCTOR, COMPLEX_CST or
1918 COMPLEX_EXPR. If RHS is NULL, it should be treated as an empty
1922 scalarize_init (struct sra_elt
*lhs_elt
, tree rhs
, block_stmt_iterator
*bsi
)
1927 /* Generate initialization statements for all members extant in the RHS. */
1930 /* Unshare the expression just in case this is from a decl's initial. */
1931 rhs
= unshare_expr (rhs
);
1932 result
= generate_element_init (lhs_elt
, rhs
, &list
);
1935 /* CONSTRUCTOR is defined such that any member not mentioned is assigned
1936 a zero value. Initialize the rest of the instantiated elements. */
1937 generate_element_zero (lhs_elt
, &list
);
1941 /* If we failed to convert the entire initializer, then we must
1942 leave the structure assignment in place and must load values
1943 from the structure into the slots for which we did not find
1944 constants. The easiest way to do this is to generate a complete
1945 copy-out, and then follow that with the constant assignments
1946 that we were able to build. DCE will clean things up. */
1948 generate_copy_inout (lhs_elt
, true, generate_element_ref (lhs_elt
),
1950 append_to_statement_list (list
, &list0
);
1954 if (lhs_elt
->use_block_copy
|| !result
)
1956 /* Since LHS is not fully instantiated, we must leave the structure
1957 assignment in place. Treating this case differently from a USE
1958 exposes constants to later optimizations. */
1961 mark_all_v_defs (list
);
1962 sra_insert_after (bsi
, list
);
1967 /* The LHS is fully instantiated. The list of initializations
1968 replaces the original structure assignment. */
1970 mark_all_v_defs (bsi_stmt (*bsi
));
1971 mark_all_v_defs (list
);
1972 sra_replace (bsi
, list
);
1976 /* A subroutine of scalarize_ldst called via walk_tree. Set TREE_NO_TRAP
1977 on all INDIRECT_REFs. */
1980 mark_notrap (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1984 if (TREE_CODE (t
) == INDIRECT_REF
)
1986 TREE_THIS_NOTRAP (t
) = 1;
1989 else if (IS_TYPE_OR_DECL_P (t
))
1995 /* Scalarize a LDST. To recap, this is an assignment between one scalarizable
1996 reference ELT and one non-scalarizable reference OTHER. IS_OUTPUT is true
1997 if ELT is on the left-hand side. */
2000 scalarize_ldst (struct sra_elt
*elt
, tree other
,
2001 block_stmt_iterator
*bsi
, bool is_output
)
2003 /* Shouldn't have gotten called for a scalar. */
2004 gcc_assert (!elt
->replacement
);
2006 if (elt
->use_block_copy
)
2008 /* Since ELT is not fully instantiated, we have to leave the
2009 block copy in place. Treat this as a USE. */
2010 scalarize_use (elt
, NULL
, bsi
, is_output
);
2014 /* The interesting case is when ELT is fully instantiated. In this
2015 case we can have each element stored/loaded directly to/from the
2016 corresponding slot in OTHER. This avoids a block copy. */
2018 tree list
= NULL
, stmt
= bsi_stmt (*bsi
);
2020 mark_all_v_defs (stmt
);
2021 generate_copy_inout (elt
, is_output
, other
, &list
);
2022 mark_all_v_defs (list
);
2025 /* Preserve EH semantics. */
2026 if (stmt_ends_bb_p (stmt
))
2028 tree_stmt_iterator tsi
;
2031 /* Extract the first statement from LIST. */
2032 tsi
= tsi_start (list
);
2033 first
= tsi_stmt (tsi
);
2036 /* Replace the old statement with this new representative. */
2037 bsi_replace (bsi
, first
, true);
2039 if (!tsi_end_p (tsi
))
2041 /* If any reference would trap, then they all would. And more
2042 to the point, the first would. Therefore none of the rest
2043 will trap since the first didn't. Indicate this by
2044 iterating over the remaining statements and set
2045 TREE_THIS_NOTRAP in all INDIRECT_REFs. */
2048 walk_tree (tsi_stmt_ptr (tsi
), mark_notrap
, NULL
, NULL
);
2051 while (!tsi_end_p (tsi
));
2053 insert_edge_copies (list
, bsi
->bb
);
2057 sra_replace (bsi
, list
);
2061 /* Generate initializations for all scalarizable parameters. */
2064 scalarize_parms (void)
2070 EXECUTE_IF_SET_IN_BITMAP (needs_copy_in
, 0, i
, bi
)
2072 tree var
= referenced_var (i
);
2073 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
2074 generate_copy_inout (elt
, true, var
, &list
);
2079 insert_edge_copies (list
, ENTRY_BLOCK_PTR
);
2080 mark_all_v_defs (list
);
2084 /* Entry point to phase 4. Update the function to match replacements. */
2087 scalarize_function (void)
2089 static const struct sra_walk_fns fns
= {
2090 scalarize_use
, scalarize_copy
, scalarize_init
, scalarize_ldst
, false
2093 sra_walk_function (&fns
);
2095 bsi_commit_edge_inserts ();
2099 /* Debug helper function. Print ELT in a nice human-readable format. */
2102 dump_sra_elt_name (FILE *f
, struct sra_elt
*elt
)
2104 if (elt
->parent
&& TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
2106 fputs (elt
->element
== integer_zero_node
? "__real__ " : "__imag__ ", f
);
2107 dump_sra_elt_name (f
, elt
->parent
);
2112 dump_sra_elt_name (f
, elt
->parent
);
2113 if (DECL_P (elt
->element
))
2115 if (TREE_CODE (elt
->element
) == FIELD_DECL
)
2117 print_generic_expr (f
, elt
->element
, dump_flags
);
2120 fprintf (f
, "[" HOST_WIDE_INT_PRINT_DEC
"]",
2121 TREE_INT_CST_LOW (elt
->element
));
2125 /* Likewise, but callable from the debugger. */
2128 debug_sra_elt_name (struct sra_elt
*elt
)
2130 dump_sra_elt_name (stderr
, elt
);
2131 fputc ('\n', stderr
);
2134 /* Main entry point. */
2139 /* Initialize local variables. */
2140 gcc_obstack_init (&sra_obstack
);
2141 sra_candidates
= BITMAP_ALLOC (NULL
);
2142 needs_copy_in
= BITMAP_ALLOC (NULL
);
2143 sra_type_decomp_cache
= BITMAP_ALLOC (NULL
);
2144 sra_type_inst_cache
= BITMAP_ALLOC (NULL
);
2145 sra_map
= htab_create (101, sra_elt_hash
, sra_elt_eq
, NULL
);
2147 /* Scan. If we find anything, instantiate and scalarize. */
2148 if (find_candidates_for_sra ())
2151 decide_instantiations ();
2152 scalarize_function ();
2155 /* Free allocated memory. */
2156 htab_delete (sra_map
);
2158 BITMAP_FREE (sra_candidates
);
2159 BITMAP_FREE (needs_copy_in
);
2160 BITMAP_FREE (sra_type_decomp_cache
);
2161 BITMAP_FREE (sra_type_inst_cache
);
2162 obstack_free (&sra_obstack
, NULL
);
2168 return flag_tree_sra
!= 0;
2171 struct tree_opt_pass pass_sra
=
2174 gate_sra
, /* gate */
2175 tree_sra
, /* execute */
2178 0, /* static_pass_number */
2179 TV_TREE_SRA
, /* tv_id */
2180 PROP_cfg
| PROP_ssa
| PROP_alias
, /* properties_required */
2181 0, /* properties_provided */
2182 0, /* properties_destroyed */
2183 0, /* todo_flags_start */
2184 TODO_dump_func
| TODO_update_ssa
2185 | TODO_ggc_collect
| TODO_verify_ssa
, /* todo_flags_finish */