1 /* Scalar Replacement of Aggregates (SRA) converts some structure
2 references into scalar references, exposing them to the scalar
4 Copyright (C) 2003, 2004 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
*);
148 /* Return true if DECL is an SRA candidate. */
151 is_sra_candidate_decl (tree decl
)
153 return DECL_P (decl
) && bitmap_bit_p (sra_candidates
, var_ann (decl
)->uid
);
156 /* Return true if TYPE is a scalar type. */
159 is_sra_scalar_type (tree type
)
161 enum tree_code code
= TREE_CODE (type
);
162 return (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== VECTOR_TYPE
163 || code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
164 || code
== CHAR_TYPE
|| code
== POINTER_TYPE
|| code
== OFFSET_TYPE
165 || code
== REFERENCE_TYPE
);
168 /* Return true if TYPE can be decomposed into a set of independent variables.
170 Note that this doesn't imply that all elements of TYPE can be
171 instantiated, just that if we decide to break up the type into
172 separate pieces that it can be done. */
175 type_can_be_decomposed_p (tree type
)
177 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
180 /* Avoid searching the same type twice. */
181 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+0))
183 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+1))
186 /* The type must have a definite nonzero size. */
187 if (TYPE_SIZE (type
) == NULL
|| integer_zerop (TYPE_SIZE (type
)))
190 /* The type must be a non-union aggregate. */
191 switch (TREE_CODE (type
))
195 bool saw_one_field
= false;
197 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
198 if (TREE_CODE (t
) == FIELD_DECL
)
200 /* Reject incorrectly represented bit fields. */
201 if (DECL_BIT_FIELD (t
)
202 && (tree_low_cst (DECL_SIZE (t
), 1)
203 != TYPE_PRECISION (TREE_TYPE (t
))))
206 saw_one_field
= true;
209 /* Record types must have at least one field. */
216 /* Array types must have a fixed lower and upper bound. */
217 t
= TYPE_DOMAIN (type
);
220 if (TYPE_MIN_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MIN_VALUE (t
)))
222 if (TYPE_MAX_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MAX_VALUE (t
)))
233 bitmap_set_bit (sra_type_decomp_cache
, cache
+0);
237 bitmap_set_bit (sra_type_decomp_cache
, cache
+1);
241 /* Return true if DECL can be decomposed into a set of independent
242 (though not necessarily scalar) variables. */
245 decl_can_be_decomposed_p (tree var
)
247 /* Early out for scalars. */
248 if (is_sra_scalar_type (TREE_TYPE (var
)))
251 /* The variable must not be aliased. */
252 if (!is_gimple_non_addressable (var
))
254 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
256 fprintf (dump_file
, "Cannot scalarize variable ");
257 print_generic_expr (dump_file
, var
, dump_flags
);
258 fprintf (dump_file
, " because it must live in memory\n");
263 /* The variable must not be volatile. */
264 if (TREE_THIS_VOLATILE (var
))
266 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
268 fprintf (dump_file
, "Cannot scalarize variable ");
269 print_generic_expr (dump_file
, var
, dump_flags
);
270 fprintf (dump_file
, " because it is declared volatile\n");
275 /* We must be able to decompose the variable's type. */
276 if (!type_can_be_decomposed_p (TREE_TYPE (var
)))
278 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
280 fprintf (dump_file
, "Cannot scalarize variable ");
281 print_generic_expr (dump_file
, var
, dump_flags
);
282 fprintf (dump_file
, " because its type cannot be decomposed\n");
290 /* Return true if TYPE can be *completely* decomposed into scalars. */
293 type_can_instantiate_all_elements (tree type
)
295 if (is_sra_scalar_type (type
))
297 if (!type_can_be_decomposed_p (type
))
300 switch (TREE_CODE (type
))
304 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
307 if (bitmap_bit_p (sra_type_inst_cache
, cache
+0))
309 if (bitmap_bit_p (sra_type_inst_cache
, cache
+1))
312 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
313 if (TREE_CODE (f
) == FIELD_DECL
)
315 if (!type_can_instantiate_all_elements (TREE_TYPE (f
)))
317 bitmap_set_bit (sra_type_inst_cache
, cache
+1);
322 bitmap_set_bit (sra_type_inst_cache
, cache
+0);
327 return type_can_instantiate_all_elements (TREE_TYPE (type
));
337 /* Test whether ELT or some sub-element cannot be scalarized. */
340 can_completely_scalarize_p (struct sra_elt
*elt
)
344 if (elt
->cannot_scalarize
)
347 for (c
= elt
->children
; c
; c
= c
->sibling
)
348 if (!can_completely_scalarize_p (c
))
355 /* A simplified tree hashing algorithm that only handles the types of
356 trees we expect to find in sra_elt->element. */
359 sra_hash_tree (tree t
)
363 switch (TREE_CODE (t
))
372 h
= TREE_INT_CST_LOW (t
) ^ TREE_INT_CST_HIGH (t
);
376 /* We can have types that are compatible, but have different member
377 lists, so we can't hash fields by ID. Use offsets instead. */
378 h
= iterative_hash_expr (DECL_FIELD_OFFSET (t
), 0);
379 h
= iterative_hash_expr (DECL_FIELD_BIT_OFFSET (t
), h
);
389 /* Hash function for type SRA_PAIR. */
392 sra_elt_hash (const void *x
)
394 const struct sra_elt
*e
= x
;
395 const struct sra_elt
*p
;
398 h
= sra_hash_tree (e
->element
);
400 /* Take into account everything back up the chain. Given that chain
401 lengths are rarely very long, this should be acceptable. If we
402 truly identify this as a performance problem, it should work to
403 hash the pointer value "e->parent". */
404 for (p
= e
->parent
; p
; p
= p
->parent
)
405 h
= (h
* 65521) ^ sra_hash_tree (p
->element
);
410 /* Equality function for type SRA_PAIR. */
413 sra_elt_eq (const void *x
, const void *y
)
415 const struct sra_elt
*a
= x
;
416 const struct sra_elt
*b
= y
;
419 if (a
->parent
!= b
->parent
)
427 if (TREE_CODE (ae
) != TREE_CODE (be
))
430 switch (TREE_CODE (ae
))
435 /* These are all pointer unique. */
439 /* Integers are not pointer unique, so compare their values. */
440 return tree_int_cst_equal (ae
, be
);
443 /* Fields are unique within a record, but not between
444 compatible records. */
445 if (DECL_FIELD_CONTEXT (ae
) == DECL_FIELD_CONTEXT (be
))
447 return fields_compatible_p (ae
, be
);
454 /* Create or return the SRA_ELT structure for CHILD in PARENT. PARENT
455 may be null, in which case CHILD must be a DECL. */
457 static struct sra_elt
*
458 lookup_element (struct sra_elt
*parent
, tree child
, tree type
,
459 enum insert_option insert
)
461 struct sra_elt dummy
;
462 struct sra_elt
**slot
;
465 dummy
.parent
= parent
;
466 dummy
.element
= child
;
468 slot
= (struct sra_elt
**) htab_find_slot (sra_map
, &dummy
, insert
);
469 if (!slot
&& insert
== NO_INSERT
)
473 if (!elt
&& insert
== INSERT
)
475 *slot
= elt
= obstack_alloc (&sra_obstack
, sizeof (*elt
));
476 memset (elt
, 0, sizeof (*elt
));
478 elt
->parent
= parent
;
479 elt
->element
= child
;
481 elt
->is_scalar
= is_sra_scalar_type (type
);
485 elt
->sibling
= parent
->children
;
486 parent
->children
= elt
;
489 /* If this is a parameter, then if we want to scalarize, we have
490 one copy from the true function parameter. Count it now. */
491 if (TREE_CODE (child
) == PARM_DECL
)
494 bitmap_set_bit (needs_copy_in
, var_ann (child
)->uid
);
501 /* Return true if the ARRAY_REF in EXPR is a constant, in bounds access. */
504 is_valid_const_index (tree expr
)
506 tree dom
, t
, index
= TREE_OPERAND (expr
, 1);
508 if (TREE_CODE (index
) != INTEGER_CST
)
511 /* Watch out for stupid user tricks, indexing outside the array.
513 Careful, we're not called only on scalarizable types, so do not
514 assume constant array bounds. We needn't do anything with such
515 cases, since they'll be referring to objects that we should have
516 already rejected for scalarization, so returning false is fine. */
518 dom
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (expr
, 0)));
522 t
= TYPE_MIN_VALUE (dom
);
523 if (!t
|| TREE_CODE (t
) != INTEGER_CST
)
525 if (tree_int_cst_lt (index
, t
))
528 t
= TYPE_MAX_VALUE (dom
);
529 if (!t
|| TREE_CODE (t
) != INTEGER_CST
)
531 if (tree_int_cst_lt (t
, index
))
537 /* Create or return the SRA_ELT structure for EXPR if the expression
538 refers to a scalarizable variable. */
540 static struct sra_elt
*
541 maybe_lookup_element_for_expr (tree expr
)
546 switch (TREE_CODE (expr
))
551 if (is_sra_candidate_decl (expr
))
552 return lookup_element (NULL
, expr
, TREE_TYPE (expr
), INSERT
);
556 /* We can't scalarize variable array indicies. */
557 if (is_valid_const_index (expr
))
558 child
= TREE_OPERAND (expr
, 1);
564 /* Don't look through unions. */
565 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) != RECORD_TYPE
)
567 child
= TREE_OPERAND (expr
, 1);
571 child
= integer_zero_node
;
574 child
= integer_one_node
;
581 elt
= maybe_lookup_element_for_expr (TREE_OPERAND (expr
, 0));
583 return lookup_element (elt
, child
, TREE_TYPE (expr
), INSERT
);
588 /* Functions to walk just enough of the tree to see all scalarizable
589 references, and categorize them. */
591 /* A set of callbacks for phases 2 and 4. They'll be invoked for the
592 various kinds of references seen. In all cases, *BSI is an iterator
593 pointing to the statement being processed. */
596 /* Invoked when ELT is required as a unit. Note that ELT might refer to
597 a leaf node, in which case this is a simple scalar reference. *EXPR_P
598 points to the location of the expression. IS_OUTPUT is true if this
599 is a left-hand-side reference. */
600 void (*use
) (struct sra_elt
*elt
, tree
*expr_p
,
601 block_stmt_iterator
*bsi
, bool is_output
);
603 /* Invoked when we have a copy between two scalarizable references. */
604 void (*copy
) (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
605 block_stmt_iterator
*bsi
);
607 /* Invoked when ELT is initialized from a constant. VALUE may be NULL,
608 in which case it should be treated as an empty CONSTRUCTOR. */
609 void (*init
) (struct sra_elt
*elt
, tree value
, block_stmt_iterator
*bsi
);
611 /* Invoked when we have a copy between one scalarizable reference ELT
612 and one non-scalarizable reference OTHER. IS_OUTPUT is true if ELT
613 is on the left-hand side. */
614 void (*ldst
) (struct sra_elt
*elt
, tree other
,
615 block_stmt_iterator
*bsi
, bool is_output
);
617 /* True during phase 2, false during phase 4. */
618 /* ??? This is a hack. */
622 #ifdef ENABLE_CHECKING
623 /* Invoked via walk_tree, if *TP contains an candidate decl, return it. */
626 sra_find_candidate_decl (tree
*tp
, int *walk_subtrees
,
627 void *data ATTRIBUTE_UNUSED
)
630 enum tree_code code
= TREE_CODE (t
);
632 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
635 if (is_sra_candidate_decl (t
))
645 /* Walk most expressions looking for a scalarizable aggregate.
646 If we find one, invoke FNS->USE. */
649 sra_walk_expr (tree
*expr_p
, block_stmt_iterator
*bsi
, bool is_output
,
650 const struct sra_walk_fns
*fns
)
654 bool disable_scalarization
= false;
656 /* We're looking to collect a reference expression between EXPR and INNER,
657 such that INNER is a scalarizable decl and all other nodes through EXPR
658 are references that we can scalarize. If we come across something that
659 we can't scalarize, we reset EXPR. This has the effect of making it
660 appear that we're referring to the larger expression as a whole. */
663 switch (TREE_CODE (inner
))
668 /* If there is a scalarizable decl at the bottom, then process it. */
669 if (is_sra_candidate_decl (inner
))
671 struct sra_elt
*elt
= maybe_lookup_element_for_expr (expr
);
672 if (disable_scalarization
)
673 elt
->cannot_scalarize
= true;
675 fns
->use (elt
, expr_p
, bsi
, is_output
);
680 /* Non-constant index means any member may be accessed. Prevent the
681 expression from being scalarized. If we were to treat this as a
682 reference to the whole array, we can wind up with a single dynamic
683 index reference inside a loop being overridden by several constant
684 index references during loop setup. It's possible that this could
685 be avoided by using dynamic usage counts based on BB trip counts
686 (based on loop analysis or profiling), but that hardly seems worth
688 /* ??? Hack. Figure out how to push this into the scan routines
689 without duplicating too much code. */
690 if (!is_valid_const_index (inner
))
692 disable_scalarization
= true;
695 /* ??? Are we assured that non-constant bounds and stride will have
696 the same value everywhere? I don't think Fortran will... */
697 if (TREE_OPERAND (inner
, 2) || TREE_OPERAND (inner
, 3))
699 inner
= TREE_OPERAND (inner
, 0);
703 /* A reference to a union member constitutes a reference to the
705 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (inner
, 0))) != RECORD_TYPE
)
707 /* ??? See above re non-constant stride. */
708 if (TREE_OPERAND (inner
, 2))
710 inner
= TREE_OPERAND (inner
, 0);
715 inner
= TREE_OPERAND (inner
, 0);
719 /* A bit field reference (access to *multiple* fields simultaneously)
720 is not currently scalarized. Consider this an access to the
721 complete outer element, to which walk_tree will bring us next. */
724 case ARRAY_RANGE_REF
:
725 /* Similarly, an subrange reference is used to modify indexing. Which
726 means that the canonical element names that we have won't work. */
729 case VIEW_CONVERT_EXPR
:
731 /* Similarly, a view/nop explicitly wants to look at an object in a
732 type other than the one we've scalarized. */
736 /* This is a transparent wrapper. The entire inner expression really
741 expr_p
= &TREE_OPERAND (inner
, 0);
742 inner
= expr
= *expr_p
;
746 #ifdef ENABLE_CHECKING
747 /* Validate that we're not missing any references. */
748 gcc_assert (!walk_tree (&inner
, sra_find_candidate_decl
, NULL
, NULL
));
754 /* Walk a TREE_LIST of values looking for scalarizable aggregates.
755 If we find one, invoke FNS->USE. */
758 sra_walk_tree_list (tree list
, block_stmt_iterator
*bsi
, bool is_output
,
759 const struct sra_walk_fns
*fns
)
762 for (op
= list
; op
; op
= TREE_CHAIN (op
))
763 sra_walk_expr (&TREE_VALUE (op
), bsi
, is_output
, fns
);
766 /* Walk the arguments of a CALL_EXPR looking for scalarizable aggregates.
767 If we find one, invoke FNS->USE. */
770 sra_walk_call_expr (tree expr
, block_stmt_iterator
*bsi
,
771 const struct sra_walk_fns
*fns
)
773 sra_walk_tree_list (TREE_OPERAND (expr
, 1), bsi
, false, fns
);
776 /* Walk the inputs and outputs of an ASM_EXPR looking for scalarizable
777 aggregates. If we find one, invoke FNS->USE. */
780 sra_walk_asm_expr (tree expr
, block_stmt_iterator
*bsi
,
781 const struct sra_walk_fns
*fns
)
783 sra_walk_tree_list (ASM_INPUTS (expr
), bsi
, false, fns
);
784 sra_walk_tree_list (ASM_OUTPUTS (expr
), bsi
, true, fns
);
787 /* Walk a MODIFY_EXPR and categorize the assignment appropriately. */
790 sra_walk_modify_expr (tree expr
, block_stmt_iterator
*bsi
,
791 const struct sra_walk_fns
*fns
)
793 struct sra_elt
*lhs_elt
, *rhs_elt
;
796 lhs
= TREE_OPERAND (expr
, 0);
797 rhs
= TREE_OPERAND (expr
, 1);
798 lhs_elt
= maybe_lookup_element_for_expr (lhs
);
799 rhs_elt
= maybe_lookup_element_for_expr (rhs
);
801 /* If both sides are scalarizable, this is a COPY operation. */
802 if (lhs_elt
&& rhs_elt
)
804 fns
->copy (lhs_elt
, rhs_elt
, bsi
);
810 /* If this is an assignment from a constant, or constructor, then
811 we have access to all of the elements individually. Invoke INIT. */
812 if (TREE_CODE (rhs
) == COMPLEX_EXPR
813 || TREE_CODE (rhs
) == COMPLEX_CST
814 || TREE_CODE (rhs
) == CONSTRUCTOR
)
815 fns
->init (lhs_elt
, rhs
, bsi
);
817 /* If this is an assignment from read-only memory, treat this as if
818 we'd been passed the constructor directly. Invoke INIT. */
819 else if (TREE_CODE (rhs
) == VAR_DECL
821 && TREE_READONLY (rhs
)
822 && targetm
.binds_local_p (rhs
))
823 fns
->init (lhs_elt
, DECL_INITIAL (rhs
), bsi
);
825 /* If this is a copy from a non-scalarizable lvalue, invoke LDST.
826 The lvalue requirement prevents us from trying to directly scalarize
827 the result of a function call. Which would result in trying to call
828 the function multiple times, and other evil things. */
829 else if (!lhs_elt
->is_scalar
&& is_gimple_addressable (rhs
))
830 fns
->ldst (lhs_elt
, rhs
, bsi
, true);
832 /* Otherwise we're being used in some context that requires the
833 aggregate to be seen as a whole. Invoke USE. */
835 fns
->use (lhs_elt
, &TREE_OPERAND (expr
, 0), bsi
, true);
839 /* LHS_ELT being null only means that the LHS as a whole is not a
840 scalarizable reference. There may be occurrences of scalarizable
841 variables within, which implies a USE. */
842 sra_walk_expr (&TREE_OPERAND (expr
, 0), bsi
, true, fns
);
845 /* Likewise for the right-hand side. The only difference here is that
846 we don't have to handle constants, and the RHS may be a call. */
849 if (!rhs_elt
->is_scalar
)
850 fns
->ldst (rhs_elt
, lhs
, bsi
, false);
852 fns
->use (rhs_elt
, &TREE_OPERAND (expr
, 1), bsi
, false);
856 tree call
= get_call_expr_in (rhs
);
858 sra_walk_call_expr (call
, bsi
, fns
);
860 sra_walk_expr (&TREE_OPERAND (expr
, 1), bsi
, false, fns
);
864 /* Entry point to the walk functions. Search the entire function,
865 invoking the callbacks in FNS on each of the references to
866 scalarizable variables. */
869 sra_walk_function (const struct sra_walk_fns
*fns
)
872 block_stmt_iterator si
, ni
;
874 /* ??? Phase 4 could derive some benefit to walking the function in
875 dominator tree order. */
878 for (si
= bsi_start (bb
); !bsi_end_p (si
); si
= ni
)
883 stmt
= bsi_stmt (si
);
884 ann
= stmt_ann (stmt
);
889 /* If the statement has no virtual operands, then it doesn't
890 make any structure references that we care about. */
891 if (NUM_V_MAY_DEFS (V_MAY_DEF_OPS (ann
)) == 0
892 && NUM_VUSES (VUSE_OPS (ann
)) == 0
893 && NUM_V_MUST_DEFS (V_MUST_DEF_OPS (ann
)) == 0)
896 switch (TREE_CODE (stmt
))
899 /* If we have "return <retval>" then the return value is
900 already exposed for our pleasure. Walk it as a USE to
901 force all the components back in place for the return.
903 If we have an embedded assignment, then <retval> is of
904 a type that gets returned in registers in this ABI, and
905 we do not wish to extend their lifetimes. Treat this
906 as a USE of the variable on the RHS of this assignment. */
908 t
= TREE_OPERAND (stmt
, 0);
909 if (TREE_CODE (t
) == MODIFY_EXPR
)
910 sra_walk_expr (&TREE_OPERAND (t
, 1), &si
, false, fns
);
912 sra_walk_expr (&TREE_OPERAND (stmt
, 0), &si
, false, fns
);
916 sra_walk_modify_expr (stmt
, &si
, fns
);
919 sra_walk_call_expr (stmt
, &si
, fns
);
922 sra_walk_asm_expr (stmt
, &si
, fns
);
931 /* Phase One: Scan all referenced variables in the program looking for
932 structures that could be decomposed. */
935 find_candidates_for_sra (void)
938 bool any_set
= false;
940 for (i
= 0; i
< num_referenced_vars
; i
++)
942 tree var
= referenced_var (i
);
943 if (decl_can_be_decomposed_p (var
))
945 bitmap_set_bit (sra_candidates
, var_ann (var
)->uid
);
954 /* Phase Two: Scan all references to scalarizable variables. Count the
955 number of times they are used or copied respectively. */
957 /* Callbacks to fill in SRA_WALK_FNS. Everything but USE is
958 considered a copy, because we can decompose the reference such that
959 the sub-elements needn't be contiguous. */
962 scan_use (struct sra_elt
*elt
, tree
*expr_p ATTRIBUTE_UNUSED
,
963 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
,
964 bool is_output ATTRIBUTE_UNUSED
)
970 scan_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
971 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
)
973 lhs_elt
->n_copies
+= 1;
974 rhs_elt
->n_copies
+= 1;
978 scan_init (struct sra_elt
*lhs_elt
, tree rhs ATTRIBUTE_UNUSED
,
979 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
)
981 lhs_elt
->n_copies
+= 1;
985 scan_ldst (struct sra_elt
*elt
, tree other ATTRIBUTE_UNUSED
,
986 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
,
987 bool is_output ATTRIBUTE_UNUSED
)
992 /* Dump the values we collected during the scanning phase. */
995 scan_dump (struct sra_elt
*elt
)
999 dump_sra_elt_name (dump_file
, elt
);
1000 fprintf (dump_file
, ": n_uses=%u n_copies=%u\n", elt
->n_uses
, elt
->n_copies
);
1002 for (c
= elt
->children
; c
; c
= c
->sibling
)
1006 /* Entry point to phase 2. Scan the entire function, building up
1007 scalarization data structures, recording copies and uses. */
1010 scan_function (void)
1012 static const struct sra_walk_fns fns
= {
1013 scan_use
, scan_copy
, scan_init
, scan_ldst
, true
1017 sra_walk_function (&fns
);
1019 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1023 fputs ("\nScan results:\n", dump_file
);
1024 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
, bi
)
1026 tree var
= referenced_var (i
);
1027 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1031 fputc ('\n', dump_file
);
1035 /* Phase Three: Make decisions about which variables to scalarize, if any.
1036 All elements to be scalarized have replacement variables made for them. */
1038 /* A subroutine of build_element_name. Recursively build the element
1039 name on the obstack. */
1042 build_element_name_1 (struct sra_elt
*elt
)
1049 build_element_name_1 (elt
->parent
);
1050 obstack_1grow (&sra_obstack
, '$');
1052 if (TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
1054 if (elt
->element
== integer_zero_node
)
1055 obstack_grow (&sra_obstack
, "real", 4);
1057 obstack_grow (&sra_obstack
, "imag", 4);
1063 if (TREE_CODE (t
) == INTEGER_CST
)
1065 /* ??? Eh. Don't bother doing double-wide printing. */
1066 sprintf (buffer
, HOST_WIDE_INT_PRINT_DEC
, TREE_INT_CST_LOW (t
));
1067 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1071 tree name
= DECL_NAME (t
);
1073 obstack_grow (&sra_obstack
, IDENTIFIER_POINTER (name
),
1074 IDENTIFIER_LENGTH (name
));
1077 sprintf (buffer
, "D%u", DECL_UID (t
));
1078 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1083 /* Construct a pretty variable name for an element's replacement variable.
1084 The name is built on the obstack. */
1087 build_element_name (struct sra_elt
*elt
)
1089 build_element_name_1 (elt
);
1090 obstack_1grow (&sra_obstack
, '\0');
1091 return obstack_finish (&sra_obstack
);
1094 /* Instantiate an element as an independent variable. */
1097 instantiate_element (struct sra_elt
*elt
)
1099 struct sra_elt
*base_elt
;
1102 for (base_elt
= elt
; base_elt
->parent
; base_elt
= base_elt
->parent
)
1104 base
= base_elt
->element
;
1106 elt
->replacement
= var
= make_rename_temp (elt
->type
, "SR");
1107 DECL_SOURCE_LOCATION (var
) = DECL_SOURCE_LOCATION (base
);
1108 TREE_NO_WARNING (var
) = TREE_NO_WARNING (base
);
1109 DECL_ARTIFICIAL (var
) = DECL_ARTIFICIAL (base
);
1110 DECL_IGNORED_P (var
) = DECL_IGNORED_P (base
);
1112 if (DECL_NAME (base
) && !DECL_IGNORED_P (base
))
1114 char *pretty_name
= build_element_name (elt
);
1115 DECL_NAME (var
) = get_identifier (pretty_name
);
1116 obstack_free (&sra_obstack
, pretty_name
);
1121 fputs (" ", dump_file
);
1122 dump_sra_elt_name (dump_file
, elt
);
1123 fputs (" -> ", dump_file
);
1124 print_generic_expr (dump_file
, var
, dump_flags
);
1125 fputc ('\n', dump_file
);
1129 /* Make one pass across an element tree deciding whether or not it's
1130 profitable to instantiate individual leaf scalars.
1132 PARENT_USES and PARENT_COPIES are the sum of the N_USES and N_COPIES
1133 fields all the way up the tree. */
1136 decide_instantiation_1 (struct sra_elt
*elt
, unsigned int parent_uses
,
1137 unsigned int parent_copies
)
1139 if (dump_file
&& !elt
->parent
)
1141 fputs ("Initial instantiation for ", dump_file
);
1142 dump_sra_elt_name (dump_file
, elt
);
1143 fputc ('\n', dump_file
);
1146 if (elt
->cannot_scalarize
)
1151 /* The decision is simple: instantiate if we're used more frequently
1152 than the parent needs to be seen as a complete unit. */
1153 if (elt
->n_uses
+ elt
->n_copies
+ parent_copies
> parent_uses
)
1154 instantiate_element (elt
);
1159 unsigned int this_uses
= elt
->n_uses
+ parent_uses
;
1160 unsigned int this_copies
= elt
->n_copies
+ parent_copies
;
1162 for (c
= elt
->children
; c
; c
= c
->sibling
)
1163 decide_instantiation_1 (c
, this_uses
, this_copies
);
1167 /* Compute the size and number of all instantiated elements below ELT.
1168 We will only care about this if the size of the complete structure
1169 fits in a HOST_WIDE_INT, so we don't have to worry about overflow. */
1172 sum_instantiated_sizes (struct sra_elt
*elt
, unsigned HOST_WIDE_INT
*sizep
)
1174 if (elt
->replacement
)
1176 *sizep
+= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (elt
->type
));
1182 unsigned int count
= 0;
1184 for (c
= elt
->children
; c
; c
= c
->sibling
)
1185 count
+= sum_instantiated_sizes (c
, sizep
);
1191 /* Instantiate fields in ELT->TYPE that are not currently present as
1194 static void instantiate_missing_elements (struct sra_elt
*elt
);
1197 instantiate_missing_elements_1 (struct sra_elt
*elt
, tree child
, tree type
)
1199 struct sra_elt
*sub
= lookup_element (elt
, child
, type
, INSERT
);
1202 if (sub
->replacement
== NULL
)
1203 instantiate_element (sub
);
1206 instantiate_missing_elements (sub
);
1210 instantiate_missing_elements (struct sra_elt
*elt
)
1212 tree type
= elt
->type
;
1214 switch (TREE_CODE (type
))
1219 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
1220 if (TREE_CODE (f
) == FIELD_DECL
)
1221 instantiate_missing_elements_1 (elt
, f
, TREE_TYPE (f
));
1227 tree i
, max
, subtype
;
1229 i
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
1230 max
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
1231 subtype
= TREE_TYPE (type
);
1235 instantiate_missing_elements_1 (elt
, i
, subtype
);
1236 if (tree_int_cst_equal (i
, max
))
1238 i
= int_const_binop (PLUS_EXPR
, i
, integer_one_node
, true);
1245 type
= TREE_TYPE (type
);
1246 instantiate_missing_elements_1 (elt
, integer_zero_node
, type
);
1247 instantiate_missing_elements_1 (elt
, integer_one_node
, type
);
1255 /* Make one pass across an element tree deciding whether to perform block
1256 or element copies. If we decide on element copies, instantiate all
1257 elements. Return true if there are any instantiated sub-elements. */
1260 decide_block_copy (struct sra_elt
*elt
)
1265 /* If scalarization is disabled, respect it. */
1266 if (elt
->cannot_scalarize
)
1268 elt
->use_block_copy
= 1;
1272 fputs ("Scalarization disabled for ", dump_file
);
1273 dump_sra_elt_name (dump_file
, elt
);
1274 fputc ('\n', dump_file
);
1280 /* Don't decide if we've no uses. */
1281 if (elt
->n_uses
== 0 && elt
->n_copies
== 0)
1284 else if (!elt
->is_scalar
)
1286 tree size_tree
= TYPE_SIZE_UNIT (elt
->type
);
1287 bool use_block_copy
= true;
1289 /* Don't bother trying to figure out the rest if the structure is
1290 so large we can't do easy arithmetic. This also forces block
1291 copies for variable sized structures. */
1292 if (host_integerp (size_tree
, 1))
1294 unsigned HOST_WIDE_INT full_size
, inst_size
= 0;
1295 unsigned int inst_count
;
1296 unsigned int max_size
;
1298 /* If the sra-max-structure-size parameter is 0, then the
1299 user has not overridden the parameter and we can choose a
1300 sensible default. */
1301 max_size
= SRA_MAX_STRUCTURE_SIZE
1302 ? SRA_MAX_STRUCTURE_SIZE
1303 : MOVE_RATIO
* UNITS_PER_WORD
;
1305 full_size
= tree_low_cst (size_tree
, 1);
1307 /* ??? What to do here. If there are two fields, and we've only
1308 instantiated one, then instantiating the other is clearly a win.
1309 If there are a large number of fields then the size of the copy
1310 is much more of a factor. */
1312 /* If the structure is small, and we've made copies, go ahead
1313 and instantiate, hoping that the copies will go away. */
1314 if (full_size
<= max_size
1315 && elt
->n_copies
> elt
->n_uses
)
1316 use_block_copy
= false;
1319 inst_count
= sum_instantiated_sizes (elt
, &inst_size
);
1321 if (inst_size
* 100 >= full_size
* SRA_FIELD_STRUCTURE_RATIO
)
1322 use_block_copy
= false;
1325 /* In order to avoid block copy, we have to be able to instantiate
1326 all elements of the type. See if this is possible. */
1328 && (!can_completely_scalarize_p (elt
)
1329 || !type_can_instantiate_all_elements (elt
->type
)))
1330 use_block_copy
= true;
1332 elt
->use_block_copy
= use_block_copy
;
1336 fprintf (dump_file
, "Using %s for ",
1337 use_block_copy
? "block-copy" : "element-copy");
1338 dump_sra_elt_name (dump_file
, elt
);
1339 fputc ('\n', dump_file
);
1342 if (!use_block_copy
)
1344 instantiate_missing_elements (elt
);
1349 any_inst
= elt
->replacement
!= NULL
;
1351 for (c
= elt
->children
; c
; c
= c
->sibling
)
1352 any_inst
|= decide_block_copy (c
);
1357 /* Entry point to phase 3. Instantiate scalar replacement variables. */
1360 decide_instantiations (void)
1364 struct bitmap_head_def done_head
;
1367 /* We cannot clear bits from a bitmap we're iterating over,
1368 so save up all the bits to clear until the end. */
1369 bitmap_initialize (&done_head
, 1);
1370 cleared_any
= false;
1372 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
, bi
)
1374 tree var
= referenced_var (i
);
1375 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1378 decide_instantiation_1 (elt
, 0, 0);
1379 if (!decide_block_copy (elt
))
1384 bitmap_set_bit (&done_head
, i
);
1391 bitmap_and_compl_into (sra_candidates
, &done_head
);
1392 bitmap_and_compl_into (needs_copy_in
, &done_head
);
1394 bitmap_clear (&done_head
);
1397 fputc ('\n', dump_file
);
1401 /* Phase Four: Update the function to match the replacements created. */
1403 /* Mark all the variables in V_MAY_DEF or V_MUST_DEF operands for STMT for
1404 renaming. This becomes necessary when we modify all of a non-scalar. */
1407 mark_all_v_defs (tree stmt
)
1412 get_stmt_operands (stmt
);
1414 FOR_EACH_SSA_TREE_OPERAND (sym
, stmt
, iter
, SSA_OP_VIRTUAL_DEFS
)
1416 if (TREE_CODE (sym
) == SSA_NAME
)
1417 sym
= SSA_NAME_VAR (sym
);
1418 bitmap_set_bit (vars_to_rename
, var_ann (sym
)->uid
);
1422 /* Build a single level component reference to ELT rooted at BASE. */
1425 generate_one_element_ref (struct sra_elt
*elt
, tree base
)
1427 switch (TREE_CODE (TREE_TYPE (base
)))
1431 tree field
= elt
->element
;
1433 /* Watch out for compatible records with differing field lists. */
1434 if (DECL_FIELD_CONTEXT (field
) != TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
1435 field
= find_compatible_field (TREE_TYPE (base
), field
);
1437 return build (COMPONENT_REF
, elt
->type
, base
, field
, NULL
);
1441 return build (ARRAY_REF
, elt
->type
, base
, elt
->element
, NULL
, NULL
);
1444 if (elt
->element
== integer_zero_node
)
1445 return build (REALPART_EXPR
, elt
->type
, base
);
1447 return build (IMAGPART_EXPR
, elt
->type
, base
);
1454 /* Build a full component reference to ELT rooted at its native variable. */
1457 generate_element_ref (struct sra_elt
*elt
)
1460 return generate_one_element_ref (elt
, generate_element_ref (elt
->parent
));
1462 return elt
->element
;
1465 /* Generate a set of assignment statements in *LIST_P to copy all
1466 instantiated elements under ELT to or from the equivalent structure
1467 rooted at EXPR. COPY_OUT controls the direction of the copy, with
1468 true meaning to copy out of EXPR into ELT. */
1471 generate_copy_inout (struct sra_elt
*elt
, bool copy_out
, tree expr
,
1477 if (elt
->replacement
)
1480 t
= build (MODIFY_EXPR
, void_type_node
, elt
->replacement
, expr
);
1482 t
= build (MODIFY_EXPR
, void_type_node
, expr
, elt
->replacement
);
1483 append_to_statement_list (t
, list_p
);
1487 for (c
= elt
->children
; c
; c
= c
->sibling
)
1489 t
= generate_one_element_ref (c
, unshare_expr (expr
));
1490 generate_copy_inout (c
, copy_out
, t
, list_p
);
1495 /* Generate a set of assignment statements in *LIST_P to copy all instantiated
1496 elements under SRC to their counterparts under DST. There must be a 1-1
1497 correspondence of instantiated elements. */
1500 generate_element_copy (struct sra_elt
*dst
, struct sra_elt
*src
, tree
*list_p
)
1502 struct sra_elt
*dc
, *sc
;
1504 for (dc
= dst
->children
; dc
; dc
= dc
->sibling
)
1506 sc
= lookup_element (src
, dc
->element
, NULL
, NO_INSERT
);
1508 generate_element_copy (dc
, sc
, list_p
);
1511 if (dst
->replacement
)
1515 gcc_assert (src
->replacement
);
1517 t
= build (MODIFY_EXPR
, void_type_node
, dst
->replacement
,
1519 append_to_statement_list (t
, list_p
);
1523 /* Generate a set of assignment statements in *LIST_P to zero all instantiated
1524 elements under ELT. In addition, do not assign to elements that have been
1525 marked VISITED but do reset the visited flag; this allows easy coordination
1526 with generate_element_init. */
1529 generate_element_zero (struct sra_elt
*elt
, tree
*list_p
)
1535 elt
->visited
= false;
1539 for (c
= elt
->children
; c
; c
= c
->sibling
)
1540 generate_element_zero (c
, list_p
);
1542 if (elt
->replacement
)
1546 gcc_assert (elt
->is_scalar
);
1547 t
= fold_convert (elt
->type
, integer_zero_node
);
1549 t
= build (MODIFY_EXPR
, void_type_node
, elt
->replacement
, t
);
1550 append_to_statement_list (t
, list_p
);
1554 /* Generate an assignment VAR = INIT, where INIT may need gimplification.
1555 Add the result to *LIST_P. */
1558 generate_one_element_init (tree var
, tree init
, tree
*list_p
)
1562 /* The replacement can be almost arbitrarily complex. Gimplify. */
1563 stmt
= build (MODIFY_EXPR
, void_type_node
, var
, init
);
1564 gimplify_stmt (&stmt
);
1566 /* The replacement can expose previously unreferenced variables. */
1567 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
1569 tree_stmt_iterator i
;
1570 for (i
= tsi_start (stmt
); !tsi_end_p (i
); tsi_next (&i
))
1571 find_new_referenced_vars (tsi_stmt_ptr (i
));
1574 find_new_referenced_vars (&stmt
);
1576 append_to_statement_list (stmt
, list_p
);
1579 /* Generate a set of assignment statements in *LIST_P to set all instantiated
1580 elements under ELT with the contents of the initializer INIT. In addition,
1581 mark all assigned elements VISITED; this allows easy coordination with
1582 generate_element_zero. Return false if we found a case we couldn't
1586 generate_element_init (struct sra_elt
*elt
, tree init
, tree
*list_p
)
1589 enum tree_code init_code
;
1590 struct sra_elt
*sub
;
1593 /* We can be passed DECL_INITIAL of a static variable. It might have a
1594 conversion, which we strip off here. */
1595 STRIP_USELESS_TYPE_CONVERSION (init
);
1596 init_code
= TREE_CODE (init
);
1600 if (elt
->replacement
)
1602 generate_one_element_init (elt
->replacement
, init
, list_p
);
1603 elt
->visited
= true;
1612 for (sub
= elt
->children
; sub
; sub
= sub
->sibling
)
1614 if (sub
->element
== integer_zero_node
)
1615 t
= (init_code
== COMPLEX_EXPR
1616 ? TREE_OPERAND (init
, 0) : TREE_REALPART (init
));
1618 t
= (init_code
== COMPLEX_EXPR
1619 ? TREE_OPERAND (init
, 1) : TREE_IMAGPART (init
));
1620 result
&= generate_element_init (sub
, t
, list_p
);
1625 for (t
= CONSTRUCTOR_ELTS (init
); t
; t
= TREE_CHAIN (t
))
1627 sub
= lookup_element (elt
, TREE_PURPOSE (t
), NULL
, NO_INSERT
);
1630 result
&= generate_element_init (sub
, TREE_VALUE (t
), list_p
);
1635 elt
->visited
= true;
1642 /* Insert STMT on all the outgoing edges out of BB. Note that if BB
1643 has more than one edge, STMT will be replicated for each edge. Also,
1644 abnormal edges will be ignored. */
1647 insert_edge_copies (tree stmt
, basic_block bb
)
1654 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1656 /* We don't need to insert copies on abnormal edges. The
1657 value of the scalar replacement is not guaranteed to
1658 be valid through an abnormal edge. */
1659 if (!(e
->flags
& EDGE_ABNORMAL
))
1663 bsi_insert_on_edge (e
, stmt
);
1667 bsi_insert_on_edge (e
, unsave_expr_now (stmt
));
1672 /* Helper function to insert LIST before BSI, and set up line number info. */
1675 sra_insert_before (block_stmt_iterator
*bsi
, tree list
)
1677 tree stmt
= bsi_stmt (*bsi
);
1679 if (EXPR_HAS_LOCATION (stmt
))
1680 annotate_all_with_locus (&list
, EXPR_LOCATION (stmt
));
1681 bsi_insert_before (bsi
, list
, BSI_SAME_STMT
);
1684 /* Similarly, but insert after BSI. Handles insertion onto edges as well. */
1687 sra_insert_after (block_stmt_iterator
*bsi
, tree list
)
1689 tree stmt
= bsi_stmt (*bsi
);
1691 if (EXPR_HAS_LOCATION (stmt
))
1692 annotate_all_with_locus (&list
, EXPR_LOCATION (stmt
));
1694 if (stmt_ends_bb_p (stmt
))
1695 insert_edge_copies (list
, bsi
->bb
);
1697 bsi_insert_after (bsi
, list
, BSI_SAME_STMT
);
1700 /* Similarly, but replace the statement at BSI. */
1703 sra_replace (block_stmt_iterator
*bsi
, tree list
)
1705 sra_insert_before (bsi
, list
);
1707 if (bsi_end_p (*bsi
))
1708 *bsi
= bsi_last (bsi
->bb
);
1713 /* Scalarize a USE. To recap, this is either a simple reference to ELT,
1714 if elt is scalar, or some occurrence of ELT that requires a complete
1715 aggregate. IS_OUTPUT is true if ELT is being modified. */
1718 scalarize_use (struct sra_elt
*elt
, tree
*expr_p
, block_stmt_iterator
*bsi
,
1721 tree list
= NULL
, stmt
= bsi_stmt (*bsi
);
1723 if (elt
->replacement
)
1725 /* If we have a replacement, then updating the reference is as
1726 simple as modifying the existing statement in place. */
1728 mark_all_v_defs (stmt
);
1729 *expr_p
= elt
->replacement
;
1734 /* Otherwise we need some copies. If ELT is being read, then we want
1735 to store all (modified) sub-elements back into the structure before
1736 the reference takes place. If ELT is being written, then we want to
1737 load the changed values back into our shadow variables. */
1738 /* ??? We don't check modified for reads, we just always write all of
1739 the values. We should be able to record the SSA number of the VOP
1740 for which the values were last read. If that number matches the
1741 SSA number of the VOP in the current statement, then we needn't
1742 emit an assignment. This would also eliminate double writes when
1743 a structure is passed as more than one argument to a function call.
1744 This optimization would be most effective if sra_walk_function
1745 processed the blocks in dominator order. */
1747 generate_copy_inout (elt
, is_output
, generate_element_ref (elt
), &list
);
1750 mark_all_v_defs (expr_first (list
));
1752 sra_insert_after (bsi
, list
);
1754 sra_insert_before (bsi
, list
);
1758 /* Scalarize a COPY. To recap, this is an assignment statement between
1759 two scalarizable references, LHS_ELT and RHS_ELT. */
1762 scalarize_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
1763 block_stmt_iterator
*bsi
)
1767 if (lhs_elt
->replacement
&& rhs_elt
->replacement
)
1769 /* If we have two scalar operands, modify the existing statement. */
1770 stmt
= bsi_stmt (*bsi
);
1772 /* See the commentary in sra_walk_function concerning
1773 RETURN_EXPR, and why we should never see one here. */
1774 gcc_assert (TREE_CODE (stmt
) == MODIFY_EXPR
);
1776 TREE_OPERAND (stmt
, 0) = lhs_elt
->replacement
;
1777 TREE_OPERAND (stmt
, 1) = rhs_elt
->replacement
;
1780 else if (lhs_elt
->use_block_copy
|| rhs_elt
->use_block_copy
)
1782 /* If either side requires a block copy, then sync the RHS back
1783 to the original structure, leave the original assignment
1784 statement (which will perform the block copy), then load the
1785 LHS values out of its now-updated original structure. */
1786 /* ??? Could perform a modified pair-wise element copy. That
1787 would at least allow those elements that are instantiated in
1788 both structures to be optimized well. */
1791 generate_copy_inout (rhs_elt
, false,
1792 generate_element_ref (rhs_elt
), &list
);
1795 mark_all_v_defs (expr_first (list
));
1796 sra_insert_before (bsi
, list
);
1800 generate_copy_inout (lhs_elt
, true,
1801 generate_element_ref (lhs_elt
), &list
);
1803 sra_insert_after (bsi
, list
);
1807 /* Otherwise both sides must be fully instantiated. In which
1808 case perform pair-wise element assignments and replace the
1809 original block copy statement. */
1811 stmt
= bsi_stmt (*bsi
);
1812 mark_all_v_defs (stmt
);
1815 generate_element_copy (lhs_elt
, rhs_elt
, &list
);
1817 sra_replace (bsi
, list
);
1821 /* Scalarize an INIT. To recap, this is an assignment to a scalarizable
1822 reference from some form of constructor: CONSTRUCTOR, COMPLEX_CST or
1823 COMPLEX_EXPR. If RHS is NULL, it should be treated as an empty
1827 scalarize_init (struct sra_elt
*lhs_elt
, tree rhs
, block_stmt_iterator
*bsi
)
1832 /* Generate initialization statements for all members extant in the RHS. */
1835 push_gimplify_context ();
1836 result
= generate_element_init (lhs_elt
, rhs
, &list
);
1837 pop_gimplify_context (NULL
);
1840 /* CONSTRUCTOR is defined such that any member not mentioned is assigned
1841 a zero value. Initialize the rest of the instantiated elements. */
1842 generate_element_zero (lhs_elt
, &list
);
1846 /* If we failed to convert the entire initializer, then we must
1847 leave the structure assignment in place and must load values
1848 from the structure into the slots for which we did not find
1849 constants. The easiest way to do this is to generate a complete
1850 copy-out, and then follow that with the constant assignments
1851 that we were able to build. DCE will clean things up. */
1853 generate_copy_inout (lhs_elt
, true, generate_element_ref (lhs_elt
),
1855 append_to_statement_list (list
, &list0
);
1859 if (lhs_elt
->use_block_copy
|| !result
)
1861 /* Since LHS is not fully instantiated, we must leave the structure
1862 assignment in place. Treating this case differently from a USE
1863 exposes constants to later optimizations. */
1866 mark_all_v_defs (expr_first (list
));
1867 sra_insert_after (bsi
, list
);
1872 /* The LHS is fully instantiated. The list of initializations
1873 replaces the original structure assignment. */
1875 mark_all_v_defs (bsi_stmt (*bsi
));
1876 sra_replace (bsi
, list
);
1880 /* A subroutine of scalarize_ldst called via walk_tree. Set TREE_NO_TRAP
1881 on all INDIRECT_REFs. */
1884 mark_notrap (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1888 if (TREE_CODE (t
) == INDIRECT_REF
)
1890 TREE_THIS_NOTRAP (t
) = 1;
1893 else if (IS_TYPE_OR_DECL_P (t
))
1899 /* Scalarize a LDST. To recap, this is an assignment between one scalarizable
1900 reference ELT and one non-scalarizable reference OTHER. IS_OUTPUT is true
1901 if ELT is on the left-hand side. */
1904 scalarize_ldst (struct sra_elt
*elt
, tree other
,
1905 block_stmt_iterator
*bsi
, bool is_output
)
1907 /* Shouldn't have gotten called for a scalar. */
1908 gcc_assert (!elt
->replacement
);
1910 if (elt
->use_block_copy
)
1912 /* Since ELT is not fully instantiated, we have to leave the
1913 block copy in place. Treat this as a USE. */
1914 scalarize_use (elt
, NULL
, bsi
, is_output
);
1918 /* The interesting case is when ELT is fully instantiated. In this
1919 case we can have each element stored/loaded directly to/from the
1920 corresponding slot in OTHER. This avoids a block copy. */
1922 tree list
= NULL
, stmt
= bsi_stmt (*bsi
);
1924 mark_all_v_defs (stmt
);
1925 generate_copy_inout (elt
, is_output
, other
, &list
);
1928 /* Preserve EH semantics. */
1929 if (stmt_ends_bb_p (stmt
))
1931 tree_stmt_iterator tsi
;
1934 /* Extract the first statement from LIST. */
1935 tsi
= tsi_start (list
);
1936 first
= tsi_stmt (tsi
);
1939 /* Replace the old statement with this new representative. */
1940 bsi_replace (bsi
, first
, true);
1942 if (!tsi_end_p (tsi
))
1944 /* If any reference would trap, then they all would. And more
1945 to the point, the first would. Therefore none of the rest
1946 will trap since the first didn't. Indicate this by
1947 iterating over the remaining statements and set
1948 TREE_THIS_NOTRAP in all INDIRECT_REFs. */
1951 walk_tree (tsi_stmt_ptr (tsi
), mark_notrap
, NULL
, NULL
);
1954 while (!tsi_end_p (tsi
));
1956 insert_edge_copies (list
, bsi
->bb
);
1960 sra_replace (bsi
, list
);
1964 /* Generate initializations for all scalarizable parameters. */
1967 scalarize_parms (void)
1973 EXECUTE_IF_SET_IN_BITMAP (needs_copy_in
, 0, i
, bi
)
1975 tree var
= referenced_var (i
);
1976 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1977 generate_copy_inout (elt
, true, var
, &list
);
1981 insert_edge_copies (list
, ENTRY_BLOCK_PTR
);
1984 /* Entry point to phase 4. Update the function to match replacements. */
1987 scalarize_function (void)
1989 static const struct sra_walk_fns fns
= {
1990 scalarize_use
, scalarize_copy
, scalarize_init
, scalarize_ldst
, false
1993 sra_walk_function (&fns
);
1995 bsi_commit_edge_inserts (NULL
);
1999 /* Debug helper function. Print ELT in a nice human-readable format. */
2002 dump_sra_elt_name (FILE *f
, struct sra_elt
*elt
)
2004 if (elt
->parent
&& TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
2006 fputs (elt
->element
== integer_zero_node
? "__real__ " : "__imag__ ", f
);
2007 dump_sra_elt_name (f
, elt
->parent
);
2012 dump_sra_elt_name (f
, elt
->parent
);
2013 if (DECL_P (elt
->element
))
2015 if (TREE_CODE (elt
->element
) == FIELD_DECL
)
2017 print_generic_expr (f
, elt
->element
, dump_flags
);
2020 fprintf (f
, "[" HOST_WIDE_INT_PRINT_DEC
"]",
2021 TREE_INT_CST_LOW (elt
->element
));
2025 /* Likewise, but callable from the debugger. */
2028 debug_sra_elt_name (struct sra_elt
*elt
)
2030 dump_sra_elt_name (stderr
, elt
);
2031 fputc ('\n', stderr
);
2034 /* Main entry point. */
2039 /* Initialize local variables. */
2040 gcc_obstack_init (&sra_obstack
);
2041 sra_candidates
= BITMAP_XMALLOC ();
2042 needs_copy_in
= BITMAP_XMALLOC ();
2043 sra_type_decomp_cache
= BITMAP_XMALLOC ();
2044 sra_type_inst_cache
= BITMAP_XMALLOC ();
2045 sra_map
= htab_create (101, sra_elt_hash
, sra_elt_eq
, NULL
);
2047 /* Scan. If we find anything, instantiate and scalarize. */
2048 if (find_candidates_for_sra ())
2051 decide_instantiations ();
2052 scalarize_function ();
2055 /* Free allocated memory. */
2056 htab_delete (sra_map
);
2058 BITMAP_XFREE (sra_candidates
);
2059 BITMAP_XFREE (needs_copy_in
);
2060 BITMAP_XFREE (sra_type_decomp_cache
);
2061 BITMAP_XFREE (sra_type_inst_cache
);
2062 obstack_free (&sra_obstack
, NULL
);
2068 return flag_tree_sra
!= 0;
2071 struct tree_opt_pass pass_sra
=
2074 gate_sra
, /* gate */
2075 tree_sra
, /* execute */
2078 0, /* static_pass_number */
2079 TV_TREE_SRA
, /* tv_id */
2080 PROP_cfg
| PROP_ssa
| PROP_alias
, /* properties_required */
2081 0, /* properties_provided */
2082 0, /* properties_destroyed */
2083 0, /* todo_flags_start */
2084 TODO_dump_func
| TODO_rename_vars
2085 | TODO_ggc_collect
| TODO_verify_ssa
, /* todo_flags_finish */