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. */
53 /* This object of this pass is to replace a non-addressable aggregate with a
54 set of independent variables. Most of the time, all of these variables
55 will be scalars. But a secondary objective is to break up larger
56 aggregates into smaller aggregates. In the process we may find that some
57 bits of the larger aggregate can be deleted as unreferenced.
59 This substitution is done globally. More localized substitutions would
60 be the purvey of a load-store motion pass.
62 The optimization proceeds in phases:
64 (1) Identify variables that have types that are candidates for
67 (2) Scan the function looking for the ways these variables are used.
68 In particular we're interested in the number of times a variable
69 (or member) is needed as a complete unit, and the number of times
70 a variable (or member) is copied.
72 (3) Based on the usage profile, instantiate substitution variables.
74 (4) Scan the function making replacements.
78 /* The set of aggregate variables that are candidates for scalarization. */
79 static bitmap sra_candidates
;
81 /* Set of scalarizable PARM_DECLs that need copy-in operations at the
82 beginning of the function. */
83 static bitmap needs_copy_in
;
85 /* Sets of bit pairs that cache type decomposition and instantiation. */
86 static bitmap sra_type_decomp_cache
;
87 static bitmap sra_type_inst_cache
;
89 /* One of these structures is created for each candidate aggregate
90 and each (accessed) member of such an aggregate. */
93 /* A tree of the elements. Used when we want to traverse everything. */
94 struct sra_elt
*parent
;
95 struct sra_elt
*children
;
96 struct sra_elt
*sibling
;
98 /* If this element is a root, then this is the VAR_DECL. If this is
99 a sub-element, this is some token used to identify the reference.
100 In the case of COMPONENT_REF, this is the FIELD_DECL. In the case
101 of an ARRAY_REF, this is the (constant) index. In the case of a
102 complex number, this is a zero or one. */
105 /* The type of the element. */
108 /* A VAR_DECL, for any sub-element we've decided to replace. */
111 /* The number of times the element is referenced as a whole. I.e.
112 given "a.b.c", this would be incremented for C, but not for A or B. */
115 /* The number of times the element is copied to or from another
116 scalarizable element. */
117 unsigned int n_copies
;
119 /* True if TYPE is scalar. */
122 /* True if we saw something about this element that prevents scalarization,
123 such as non-constant indexing. */
124 bool cannot_scalarize
;
126 /* True if we've decided that structure-to-structure assignment
127 should happen via memcpy and not per-element. */
130 /* A flag for use with/after random access traversals. */
134 /* Random access to the child of a parent is performed by hashing.
135 This prevents quadratic behaviour, and allows SRA to function
136 reasonably on larger records. */
137 static htab_t sra_map
;
139 /* All structures are allocated out of the following obstack. */
140 static struct obstack sra_obstack
;
142 /* Debugging functions. */
143 static void dump_sra_elt_name (FILE *, struct sra_elt
*);
144 extern void debug_sra_elt_name (struct sra_elt
*);
147 /* Return true if DECL is an SRA candidate. */
150 is_sra_candidate_decl (tree decl
)
152 return DECL_P (decl
) && bitmap_bit_p (sra_candidates
, var_ann (decl
)->uid
);
155 /* Return true if TYPE is a scalar type. */
158 is_sra_scalar_type (tree type
)
160 enum tree_code code
= TREE_CODE (type
);
161 return (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== VECTOR_TYPE
162 || code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
163 || code
== CHAR_TYPE
|| code
== POINTER_TYPE
|| code
== OFFSET_TYPE
164 || code
== REFERENCE_TYPE
);
167 /* Return true if TYPE can be decomposed into a set of independent variables.
169 Note that this doesn't imply that all elements of TYPE can be
170 instantiated, just that if we decide to break up the type into
171 separate pieces that it can be done. */
174 type_can_be_decomposed_p (tree type
)
176 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
179 /* Avoid searching the same type twice. */
180 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+0))
182 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+1))
185 /* The type must have a definite non-zero size. */
186 if (TYPE_SIZE (type
) == NULL
|| integer_zerop (TYPE_SIZE (type
)))
189 /* The type must be a non-union aggregate. */
190 switch (TREE_CODE (type
))
194 bool saw_one_field
= false;
196 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
197 if (TREE_CODE (t
) == FIELD_DECL
)
199 /* Reject incorrectly represented bit fields. */
200 if (DECL_BIT_FIELD (t
)
201 && (tree_low_cst (DECL_SIZE (t
), 1)
202 != TYPE_PRECISION (TREE_TYPE (t
))))
205 saw_one_field
= true;
208 /* Record types must have at least one field. */
215 /* Array types must have a fixed lower and upper bound. */
216 t
= TYPE_DOMAIN (type
);
219 if (TYPE_MIN_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MIN_VALUE (t
)))
221 if (TYPE_MAX_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MAX_VALUE (t
)))
232 bitmap_set_bit (sra_type_decomp_cache
, cache
+0);
236 bitmap_set_bit (sra_type_decomp_cache
, cache
+1);
240 /* Return true if DECL can be decomposed into a set of independent
241 (though not necessarily scalar) variables. */
244 decl_can_be_decomposed_p (tree var
)
246 /* Early out for scalars. */
247 if (is_sra_scalar_type (TREE_TYPE (var
)))
250 /* The variable must not be aliased. */
251 if (!is_gimple_non_addressable (var
))
253 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
255 fprintf (dump_file
, "Cannot scalarize variable ");
256 print_generic_expr (dump_file
, var
, dump_flags
);
257 fprintf (dump_file
, " because it must live in memory\n");
262 /* The variable must not be volatile. */
263 if (TREE_THIS_VOLATILE (var
))
265 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
267 fprintf (dump_file
, "Cannot scalarize variable ");
268 print_generic_expr (dump_file
, var
, dump_flags
);
269 fprintf (dump_file
, " because it is declared volatile\n");
274 /* We must be able to decompose the variable's type. */
275 if (!type_can_be_decomposed_p (TREE_TYPE (var
)))
277 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
279 fprintf (dump_file
, "Cannot scalarize variable ");
280 print_generic_expr (dump_file
, var
, dump_flags
);
281 fprintf (dump_file
, " because its type cannot be decomposed\n");
289 /* Return true if TYPE can be *completely* decomposed into scalars. */
292 type_can_instantiate_all_elements (tree type
)
294 if (is_sra_scalar_type (type
))
296 if (!type_can_be_decomposed_p (type
))
299 switch (TREE_CODE (type
))
303 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
306 if (bitmap_bit_p (sra_type_inst_cache
, cache
+0))
308 if (bitmap_bit_p (sra_type_inst_cache
, cache
+1))
311 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
312 if (TREE_CODE (f
) == FIELD_DECL
)
314 if (!type_can_instantiate_all_elements (TREE_TYPE (f
)))
316 bitmap_set_bit (sra_type_inst_cache
, cache
+1);
321 bitmap_set_bit (sra_type_inst_cache
, cache
+0);
326 return type_can_instantiate_all_elements (TREE_TYPE (type
));
336 /* Test whether ELT or some sub-element cannot be scalarized. */
339 can_completely_scalarize_p (struct sra_elt
*elt
)
343 if (elt
->cannot_scalarize
)
346 for (c
= elt
->children
; c
; c
= c
->sibling
)
347 if (!can_completely_scalarize_p (c
))
354 /* A simplified tree hashing algorithm that only handles the types of
355 trees we expect to find in sra_elt->element. */
358 sra_hash_tree (tree t
)
362 switch (TREE_CODE (t
))
371 h
= TREE_INT_CST_LOW (t
) ^ TREE_INT_CST_HIGH (t
);
375 /* We can have types that are compatible, but have different member
376 lists, so we can't hash fields by ID. Use offsets instead. */
377 h
= iterative_hash_expr (DECL_FIELD_OFFSET (t
), 0);
378 h
= iterative_hash_expr (DECL_FIELD_BIT_OFFSET (t
), h
);
388 /* Hash function for type SRA_PAIR. */
391 sra_elt_hash (const void *x
)
393 const struct sra_elt
*e
= x
;
394 const struct sra_elt
*p
;
397 h
= sra_hash_tree (e
->element
);
399 /* Take into account everything back up the chain. Given that chain
400 lengths are rarely very long, this should be acceptable. If we
401 truely identify this as a performance problem, it should work to
402 hash the pointer value "e->parent". */
403 for (p
= e
->parent
; p
; p
= p
->parent
)
404 h
= (h
* 65521) ^ sra_hash_tree (p
->element
);
409 /* Equality function for type SRA_PAIR. */
412 sra_elt_eq (const void *x
, const void *y
)
414 const struct sra_elt
*a
= x
;
415 const struct sra_elt
*b
= y
;
418 if (a
->parent
!= b
->parent
)
426 if (TREE_CODE (ae
) != TREE_CODE (be
))
429 switch (TREE_CODE (ae
))
434 /* These are all pointer unique. */
438 /* Integers are not pointer unique, so compare their values. */
439 return tree_int_cst_equal (ae
, be
);
442 /* Fields are unique within a record, but not between
443 compatible records. */
444 if (DECL_FIELD_CONTEXT (ae
) == DECL_FIELD_CONTEXT (be
))
446 return fields_compatible_p (ae
, be
);
453 /* Create or return the SRA_ELT structure for CHILD in PARENT. PARENT
454 may be null, in which case CHILD must be a DECL. */
456 static struct sra_elt
*
457 lookup_element (struct sra_elt
*parent
, tree child
, tree type
,
458 enum insert_option insert
)
460 struct sra_elt dummy
;
461 struct sra_elt
**slot
;
464 dummy
.parent
= parent
;
465 dummy
.element
= child
;
467 slot
= (struct sra_elt
**) htab_find_slot (sra_map
, &dummy
, insert
);
468 if (!slot
&& insert
== NO_INSERT
)
472 if (!elt
&& insert
== INSERT
)
474 *slot
= elt
= obstack_alloc (&sra_obstack
, sizeof (*elt
));
475 memset (elt
, 0, sizeof (*elt
));
477 elt
->parent
= parent
;
478 elt
->element
= child
;
480 elt
->is_scalar
= is_sra_scalar_type (type
);
484 elt
->sibling
= parent
->children
;
485 parent
->children
= elt
;
488 /* If this is a parameter, then if we want to scalarize, we have
489 one copy from the true function parameter. Count it now. */
490 if (TREE_CODE (child
) == PARM_DECL
)
493 bitmap_set_bit (needs_copy_in
, var_ann (child
)->uid
);
500 /* Return true if the ARRAY_REF in EXPR is a constant, in bounds access. */
503 is_valid_const_index (tree expr
)
505 tree dom
, t
, index
= TREE_OPERAND (expr
, 1);
507 if (TREE_CODE (index
) != INTEGER_CST
)
510 /* Watch out for stupid user tricks, indexing outside the array.
512 Careful, we're not called only on scalarizable types, so do not
513 assume constant array bounds. We needn't do anything with such
514 cases, since they'll be referring to objects that we should have
515 already rejected for scalarization, so returning false is fine. */
517 dom
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (expr
, 0)));
521 t
= TYPE_MIN_VALUE (dom
);
522 if (!t
|| TREE_CODE (t
) != INTEGER_CST
)
524 if (tree_int_cst_lt (index
, t
))
527 t
= TYPE_MAX_VALUE (dom
);
528 if (!t
|| TREE_CODE (t
) != INTEGER_CST
)
530 if (tree_int_cst_lt (t
, index
))
536 /* Create or return the SRA_ELT structure for EXPR if the expression
537 refers to a scalarizable variable. */
539 static struct sra_elt
*
540 maybe_lookup_element_for_expr (tree expr
)
545 switch (TREE_CODE (expr
))
550 if (is_sra_candidate_decl (expr
))
551 return lookup_element (NULL
, expr
, TREE_TYPE (expr
), INSERT
);
555 /* We can't scalarize variable array indicies. */
556 if (is_valid_const_index (expr
))
557 child
= TREE_OPERAND (expr
, 1);
563 /* Don't look through unions. */
564 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) != RECORD_TYPE
)
566 child
= TREE_OPERAND (expr
, 1);
570 child
= integer_zero_node
;
573 child
= integer_one_node
;
580 elt
= maybe_lookup_element_for_expr (TREE_OPERAND (expr
, 0));
582 return lookup_element (elt
, child
, TREE_TYPE (expr
), INSERT
);
587 /* Functions to walk just enough of the tree to see all scalarizable
588 references, and categorize them. */
590 /* A set of callbacks for phases 2 and 4. They'll be invoked for the
591 various kinds of references seen. In all cases, *BSI is an iterator
592 pointing to the statement being processed. */
595 /* Invoked when ELT is required as a unit. Note that ELT might refer to
596 a leaf node, in which case this is a simple scalar reference. *EXPR_P
597 points to the location of the expression. IS_OUTPUT is true if this
598 is a left-hand-side reference. */
599 void (*use
) (struct sra_elt
*elt
, tree
*expr_p
,
600 block_stmt_iterator
*bsi
, bool is_output
);
602 /* Invoked when we have a copy between two scalarizable references. */
603 void (*copy
) (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
604 block_stmt_iterator
*bsi
);
606 /* Invoked when ELT is initialized from a constant. VALUE may be NULL,
607 in which case it should be treated as an empty CONSTRUCTOR. */
608 void (*init
) (struct sra_elt
*elt
, tree value
, block_stmt_iterator
*bsi
);
610 /* Invoked when we have a copy between one scalarizable reference ELT
611 and one non-scalarizable reference OTHER. IS_OUTPUT is true if ELT
612 is on the left-hand side. */
613 void (*ldst
) (struct sra_elt
*elt
, tree other
,
614 block_stmt_iterator
*bsi
, bool is_output
);
616 /* True during phase 2, false during phase 4. */
617 /* ??? This is a hack. */
621 #ifdef ENABLE_CHECKING
622 /* Invoked via walk_tree, if *TP contains an candidate decl, return it. */
625 sra_find_candidate_decl (tree
*tp
, int *walk_subtrees
,
626 void *data ATTRIBUTE_UNUSED
)
629 enum tree_code code
= TREE_CODE (t
);
631 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
634 if (is_sra_candidate_decl (t
))
644 /* Walk most expressions looking for a scalarizable aggregate.
645 If we find one, invoke FNS->USE. */
648 sra_walk_expr (tree
*expr_p
, block_stmt_iterator
*bsi
, bool is_output
,
649 const struct sra_walk_fns
*fns
)
653 bool disable_scalarization
= false;
655 /* We're looking to collect a reference expression between EXPR and INNER,
656 such that INNER is a scalarizable decl and all other nodes through EXPR
657 are references that we can scalarize. If we come across something that
658 we can't scalarize, we reset EXPR. This has the effect of making it
659 appear that we're referring to the larger expression as a whole. */
662 switch (TREE_CODE (inner
))
667 /* If there is a scalarizable decl at the bottom, then process it. */
668 if (is_sra_candidate_decl (inner
))
670 struct sra_elt
*elt
= maybe_lookup_element_for_expr (expr
);
671 if (disable_scalarization
)
672 elt
->cannot_scalarize
= true;
674 fns
->use (elt
, expr_p
, bsi
, is_output
);
679 /* Non-constant index means any member may be accessed. Prevent the
680 expression from being scalarized. If we were to treat this as a
681 reference to the whole array, we can wind up with a single dynamic
682 index reference inside a loop being overridden by several constant
683 index references during loop setup. It's possible that this could
684 be avoided by using dynamic usage counts based on BB trip counts
685 (based on loop analysis or profiling), but that hardly seems worth
687 /* ??? Hack. Figure out how to push this into the scan routines
688 without duplicating too much code. */
689 if (!is_valid_const_index (inner
))
691 disable_scalarization
= true;
694 /* ??? Are we assured that non-constant bounds and stride will have
695 the same value everywhere? I don't think Fortran will... */
696 if (TREE_OPERAND (inner
, 2) || TREE_OPERAND (inner
, 3))
698 inner
= TREE_OPERAND (inner
, 0);
702 /* A reference to a union member constitutes a reference to the
704 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (inner
, 0))) != RECORD_TYPE
)
706 /* ??? See above re non-constant stride. */
707 if (TREE_OPERAND (inner
, 2))
709 inner
= TREE_OPERAND (inner
, 0);
714 inner
= TREE_OPERAND (inner
, 0);
718 /* A bit field reference (access to *multiple* fields simultaneously)
719 is not currently scalarized. Consider this an access to the
720 complete outer element, to which walk_tree will bring us next. */
723 case ARRAY_RANGE_REF
:
724 /* Similarly, an subrange reference is used to modify indexing. Which
725 means that the canonical element names that we have won't work. */
728 case VIEW_CONVERT_EXPR
:
730 /* Similarly, a view/nop explicitly wants to look at an object in a
731 type other than the one we've scalarized. */
735 /* This is a transparent wrapper. The entire inner expression really
740 expr_p
= &TREE_OPERAND (inner
, 0);
741 inner
= expr
= *expr_p
;
745 #ifdef ENABLE_CHECKING
746 /* Validate that we're not missing any references. */
747 if (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
1016 sra_walk_function (&fns
);
1018 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1022 fputs ("\nScan results:\n", dump_file
);
1023 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
,
1025 tree var
= referenced_var (i
);
1026 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1030 fputc ('\n', dump_file
);
1034 /* Phase Three: Make decisions about which variables to scalarize, if any.
1035 All elements to be scalarized have replacement variables made for them. */
1037 /* A subroutine of build_element_name. Recursively build the element
1038 name on the obstack. */
1041 build_element_name_1 (struct sra_elt
*elt
)
1048 build_element_name_1 (elt
->parent
);
1049 obstack_1grow (&sra_obstack
, '$');
1051 if (TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
1053 if (elt
->element
== integer_zero_node
)
1054 obstack_grow (&sra_obstack
, "real", 4);
1056 obstack_grow (&sra_obstack
, "imag", 4);
1062 if (TREE_CODE (t
) == INTEGER_CST
)
1064 /* ??? Eh. Don't bother doing double-wide printing. */
1065 sprintf (buffer
, HOST_WIDE_INT_PRINT_DEC
, TREE_INT_CST_LOW (t
));
1066 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1070 tree name
= DECL_NAME (t
);
1072 obstack_grow (&sra_obstack
, IDENTIFIER_POINTER (name
),
1073 IDENTIFIER_LENGTH (name
));
1076 sprintf (buffer
, "D%u", DECL_UID (t
));
1077 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1082 /* Construct a pretty variable name for an element's replacement variable.
1083 The name is built on the obstack. */
1086 build_element_name (struct sra_elt
*elt
)
1088 build_element_name_1 (elt
);
1089 obstack_1grow (&sra_obstack
, '\0');
1090 return obstack_finish (&sra_obstack
);
1093 /* Instantiate an element as an independent variable. */
1096 instantiate_element (struct sra_elt
*elt
)
1098 struct sra_elt
*base_elt
;
1101 for (base_elt
= elt
; base_elt
->parent
; base_elt
= base_elt
->parent
)
1103 base
= base_elt
->element
;
1105 elt
->replacement
= var
= make_rename_temp (elt
->type
, "SR");
1106 DECL_SOURCE_LOCATION (var
) = DECL_SOURCE_LOCATION (base
);
1107 TREE_NO_WARNING (var
) = TREE_NO_WARNING (base
);
1108 DECL_ARTIFICIAL (var
) = DECL_ARTIFICIAL (base
);
1110 if (DECL_NAME (base
) && !DECL_IGNORED_P (base
))
1112 char *pretty_name
= build_element_name (elt
);
1113 DECL_NAME (var
) = get_identifier (pretty_name
);
1114 obstack_free (&sra_obstack
, pretty_name
);
1119 fputs (" ", dump_file
);
1120 dump_sra_elt_name (dump_file
, elt
);
1121 fputs (" -> ", dump_file
);
1122 print_generic_expr (dump_file
, var
, dump_flags
);
1123 fputc ('\n', dump_file
);
1127 /* Make one pass across an element tree deciding whether or not it's
1128 profitable to instantiate individual leaf scalars.
1130 PARENT_USES and PARENT_COPIES are the sum of the N_USES and N_COPIES
1131 fields all the way up the tree. */
1134 decide_instantiation_1 (struct sra_elt
*elt
, unsigned int parent_uses
,
1135 unsigned int parent_copies
)
1137 if (dump_file
&& !elt
->parent
)
1139 fputs ("Initial instantiation for ", dump_file
);
1140 dump_sra_elt_name (dump_file
, elt
);
1141 fputc ('\n', dump_file
);
1144 if (elt
->cannot_scalarize
)
1149 /* The decision is simple: instantiate if we're used more frequently
1150 than the parent needs to be seen as a complete unit. */
1151 if (elt
->n_uses
+ elt
->n_copies
+ parent_copies
> parent_uses
)
1152 instantiate_element (elt
);
1157 unsigned int this_uses
= elt
->n_uses
+ parent_uses
;
1158 unsigned int this_copies
= elt
->n_copies
+ parent_copies
;
1160 for (c
= elt
->children
; c
; c
= c
->sibling
)
1161 decide_instantiation_1 (c
, this_uses
, this_copies
);
1165 /* Compute the size and number of all instantiated elements below ELT.
1166 We will only care about this if the size of the complete structure
1167 fits in a HOST_WIDE_INT, so we don't have to worry about overflow. */
1170 sum_instantiated_sizes (struct sra_elt
*elt
, unsigned HOST_WIDE_INT
*sizep
)
1172 if (elt
->replacement
)
1174 *sizep
+= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (elt
->type
));
1180 unsigned int count
= 0;
1182 for (c
= elt
->children
; c
; c
= c
->sibling
)
1183 count
+= sum_instantiated_sizes (c
, sizep
);
1189 /* Instantiate fields in ELT->TYPE that are not currently present as
1192 static void instantiate_missing_elements (struct sra_elt
*elt
);
1195 instantiate_missing_elements_1 (struct sra_elt
*elt
, tree child
, tree type
)
1197 struct sra_elt
*sub
= lookup_element (elt
, child
, type
, INSERT
);
1200 if (sub
->replacement
== NULL
)
1201 instantiate_element (sub
);
1204 instantiate_missing_elements (sub
);
1208 instantiate_missing_elements (struct sra_elt
*elt
)
1210 tree type
= elt
->type
;
1212 switch (TREE_CODE (type
))
1217 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
1218 if (TREE_CODE (f
) == FIELD_DECL
)
1219 instantiate_missing_elements_1 (elt
, f
, TREE_TYPE (f
));
1225 tree i
, max
, subtype
;
1227 i
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
1228 max
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
1229 subtype
= TREE_TYPE (type
);
1233 instantiate_missing_elements_1 (elt
, i
, subtype
);
1234 if (tree_int_cst_equal (i
, max
))
1236 i
= int_const_binop (PLUS_EXPR
, i
, integer_one_node
, true);
1243 type
= TREE_TYPE (type
);
1244 instantiate_missing_elements_1 (elt
, integer_zero_node
, type
);
1245 instantiate_missing_elements_1 (elt
, integer_one_node
, type
);
1253 /* Make one pass across an element tree deciding whether to perform block
1254 or element copies. If we decide on element copies, instantiate all
1255 elements. Return true if there are any instantiated sub-elements. */
1258 decide_block_copy (struct sra_elt
*elt
)
1263 /* If scalarization is disabled, respect it. */
1264 if (elt
->cannot_scalarize
)
1266 elt
->use_block_copy
= 1;
1270 fputs ("Scalarization disabled for ", dump_file
);
1271 dump_sra_elt_name (dump_file
, elt
);
1272 fputc ('\n', dump_file
);
1278 /* Don't decide if we've no uses. */
1279 if (elt
->n_uses
== 0 && elt
->n_copies
== 0)
1282 else if (!elt
->is_scalar
)
1284 tree size_tree
= TYPE_SIZE_UNIT (elt
->type
);
1285 bool use_block_copy
= true;
1287 /* Don't bother trying to figure out the rest if the structure is
1288 so large we can't do easy arithmetic. This also forces block
1289 copies for variable sized structures. */
1290 if (host_integerp (size_tree
, 1))
1292 unsigned HOST_WIDE_INT full_size
, inst_size
= 0;
1293 unsigned int inst_count
;
1295 full_size
= tree_low_cst (size_tree
, 1);
1297 /* ??? What to do here. If there are two fields, and we've only
1298 instantiated one, then instantiating the other is clearly a win.
1299 If there are a large number of fields then the size of the copy
1300 is much more of a factor. */
1302 /* If the structure is small, and we've made copies, go ahead
1303 and instantiate, hoping that the copies will go away. */
1304 if (full_size
<= (unsigned) MOVE_RATIO
* UNITS_PER_WORD
1305 && elt
->n_copies
> elt
->n_uses
)
1306 use_block_copy
= false;
1309 inst_count
= sum_instantiated_sizes (elt
, &inst_size
);
1311 if (inst_size
* 4 >= full_size
* 3)
1312 use_block_copy
= false;
1315 /* In order to avoid block copy, we have to be able to instantiate
1316 all elements of the type. See if this is possible. */
1318 && (!can_completely_scalarize_p (elt
)
1319 || !type_can_instantiate_all_elements (elt
->type
)))
1320 use_block_copy
= true;
1322 elt
->use_block_copy
= use_block_copy
;
1326 fprintf (dump_file
, "Using %s for ",
1327 use_block_copy
? "block-copy" : "element-copy");
1328 dump_sra_elt_name (dump_file
, elt
);
1329 fputc ('\n', dump_file
);
1332 if (!use_block_copy
)
1334 instantiate_missing_elements (elt
);
1339 any_inst
= elt
->replacement
!= NULL
;
1341 for (c
= elt
->children
; c
; c
= c
->sibling
)
1342 any_inst
|= decide_block_copy (c
);
1347 /* Entry point to phase 3. Instantiate scalar replacement variables. */
1350 decide_instantiations (void)
1354 struct bitmap_head_def done_head
;
1356 /* We cannot clear bits from a bitmap we're iterating over,
1357 so save up all the bits to clear until the end. */
1358 bitmap_initialize (&done_head
, 1);
1359 cleared_any
= false;
1361 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
,
1363 tree var
= referenced_var (i
);
1364 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1367 decide_instantiation_1 (elt
, 0, 0);
1368 if (!decide_block_copy (elt
))
1373 bitmap_set_bit (&done_head
, i
);
1380 bitmap_operation (sra_candidates
, sra_candidates
, &done_head
,
1382 bitmap_operation (needs_copy_in
, needs_copy_in
, &done_head
,
1385 bitmap_clear (&done_head
);
1388 fputc ('\n', dump_file
);
1392 /* Phase Four: Update the function to match the replacements created. */
1394 /* Mark all the variables in V_MAY_DEF or V_MUST_DEF operands for STMT for
1395 renaming. This becomes necessary when we modify all of a non-scalar. */
1398 mark_all_v_defs (tree stmt
)
1403 get_stmt_operands (stmt
);
1405 FOR_EACH_SSA_TREE_OPERAND (sym
, stmt
, iter
, SSA_OP_VIRTUAL_DEFS
)
1407 if (TREE_CODE (sym
) == SSA_NAME
)
1408 sym
= SSA_NAME_VAR (sym
);
1409 bitmap_set_bit (vars_to_rename
, var_ann (sym
)->uid
);
1413 /* Build a single level component reference to ELT rooted at BASE. */
1416 generate_one_element_ref (struct sra_elt
*elt
, tree base
)
1418 switch (TREE_CODE (TREE_TYPE (base
)))
1422 tree field
= elt
->element
;
1424 /* Watch out for compatible records with differing field lists. */
1425 if (DECL_FIELD_CONTEXT (field
) != TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
1426 field
= find_compatible_field (TREE_TYPE (base
), field
);
1428 return build (COMPONENT_REF
, elt
->type
, base
, field
, NULL
);
1432 return build (ARRAY_REF
, elt
->type
, base
, elt
->element
, NULL
, NULL
);
1435 if (elt
->element
== integer_zero_node
)
1436 return build (REALPART_EXPR
, elt
->type
, base
);
1438 return build (IMAGPART_EXPR
, elt
->type
, base
);
1445 /* Build a full component reference to ELT rooted at its native variable. */
1448 generate_element_ref (struct sra_elt
*elt
)
1451 return generate_one_element_ref (elt
, generate_element_ref (elt
->parent
));
1453 return elt
->element
;
1456 /* Generate a set of assignment statements in *LIST_P to copy all
1457 instantiated elements under ELT to or from the equivalent structure
1458 rooted at EXPR. COPY_OUT controls the direction of the copy, with
1459 true meaning to copy out of EXPR into ELT. */
1462 generate_copy_inout (struct sra_elt
*elt
, bool copy_out
, tree expr
,
1468 if (elt
->replacement
)
1471 t
= build (MODIFY_EXPR
, void_type_node
, elt
->replacement
, expr
);
1473 t
= build (MODIFY_EXPR
, void_type_node
, expr
, elt
->replacement
);
1474 append_to_statement_list (t
, list_p
);
1478 for (c
= elt
->children
; c
; c
= c
->sibling
)
1480 t
= generate_one_element_ref (c
, unshare_expr (expr
));
1481 generate_copy_inout (c
, copy_out
, t
, list_p
);
1486 /* Generate a set of assignment statements in *LIST_P to copy all instantiated
1487 elements under SRC to their counterparts under DST. There must be a 1-1
1488 correspondence of instantiated elements. */
1491 generate_element_copy (struct sra_elt
*dst
, struct sra_elt
*src
, tree
*list_p
)
1493 struct sra_elt
*dc
, *sc
;
1495 for (dc
= dst
->children
; dc
; dc
= dc
->sibling
)
1497 sc
= lookup_element (src
, dc
->element
, NULL
, NO_INSERT
);
1500 generate_element_copy (dc
, sc
, list_p
);
1503 if (dst
->replacement
)
1507 if (src
->replacement
== NULL
)
1510 t
= build (MODIFY_EXPR
, void_type_node
, dst
->replacement
,
1512 append_to_statement_list (t
, list_p
);
1516 /* Generate a set of assignment statements in *LIST_P to zero all instantiated
1517 elements under ELT. In addition, do not assign to elements that have been
1518 marked VISITED but do reset the visited flag; this allows easy coordination
1519 with generate_element_init. */
1522 generate_element_zero (struct sra_elt
*elt
, tree
*list_p
)
1528 elt
->visited
= false;
1532 for (c
= elt
->children
; c
; c
= c
->sibling
)
1533 generate_element_zero (c
, list_p
);
1535 if (elt
->replacement
)
1540 t
= fold_convert (elt
->type
, integer_zero_node
);
1542 /* We generated a replacement for a non-scalar? */
1545 t
= build (MODIFY_EXPR
, void_type_node
, elt
->replacement
, t
);
1546 append_to_statement_list (t
, list_p
);
1550 /* Find all variables within the gimplified statement that were not previously
1551 visible to the function and add them to the referenced variables list. */
1554 find_new_referenced_vars_1 (tree
*tp
, int *walk_subtrees
,
1555 void *data ATTRIBUTE_UNUSED
)
1559 if (TREE_CODE (t
) == VAR_DECL
&& !var_ann (t
))
1560 add_referenced_tmp_var (t
);
1562 if (DECL_P (t
) || TYPE_P (t
))
1569 find_new_referenced_vars (tree
*stmt_p
)
1571 walk_tree (stmt_p
, find_new_referenced_vars_1
, NULL
, NULL
);
1574 /* Generate an assignment VAR = INIT, where INIT may need gimplification.
1575 Add the result to *LIST_P. */
1578 generate_one_element_init (tree var
, tree init
, tree
*list_p
)
1582 /* The replacement can be almost arbitrarily complex. Gimplify. */
1583 stmt
= build (MODIFY_EXPR
, void_type_node
, var
, init
);
1584 gimplify_stmt (&stmt
);
1586 /* The replacement can expose previously unreferenced variables. */
1587 if (TREE_CODE (stmt
) == STATEMENT_LIST
)
1589 tree_stmt_iterator i
;
1590 for (i
= tsi_start (stmt
); !tsi_end_p (i
); tsi_next (&i
))
1591 find_new_referenced_vars (tsi_stmt_ptr (i
));
1594 find_new_referenced_vars (&stmt
);
1596 append_to_statement_list (stmt
, list_p
);
1599 /* Generate a set of assignment statements in *LIST_P to set all instantiated
1600 elements under ELT with the contents of the initializer INIT. In addition,
1601 mark all assigned elements VISITED; this allows easy coordination with
1602 generate_element_zero. Return false if we found a case we couldn't
1606 generate_element_init (struct sra_elt
*elt
, tree init
, tree
*list_p
)
1609 enum tree_code init_code
;
1610 struct sra_elt
*sub
;
1613 /* We can be passed DECL_INITIAL of a static variable. It might have a
1614 conversion, which we strip off here. */
1615 STRIP_USELESS_TYPE_CONVERSION (init
);
1616 init_code
= TREE_CODE (init
);
1620 if (elt
->replacement
)
1622 generate_one_element_init (elt
->replacement
, init
, list_p
);
1623 elt
->visited
= true;
1632 for (sub
= elt
->children
; sub
; sub
= sub
->sibling
)
1634 if (sub
->element
== integer_zero_node
)
1635 t
= (init_code
== COMPLEX_EXPR
1636 ? TREE_OPERAND (init
, 0) : TREE_REALPART (init
));
1638 t
= (init_code
== COMPLEX_EXPR
1639 ? TREE_OPERAND (init
, 1) : TREE_IMAGPART (init
));
1640 result
&= generate_element_init (sub
, t
, list_p
);
1645 for (t
= CONSTRUCTOR_ELTS (init
); t
; t
= TREE_CHAIN (t
))
1647 sub
= lookup_element (elt
, TREE_PURPOSE (t
), NULL
, NO_INSERT
);
1650 result
&= generate_element_init (sub
, TREE_VALUE (t
), list_p
);
1655 elt
->visited
= true;
1662 /* Insert STMT on all the outgoing edges out of BB. Note that if BB
1663 has more than one edge, STMT will be replicated for each edge. Also,
1664 abnormal edges will be ignored. */
1667 insert_edge_copies (tree stmt
, basic_block bb
)
1673 for (e
= bb
->succ
; e
; e
= e
->succ_next
)
1675 /* We don't need to insert copies on abnormal edges. The
1676 value of the scalar replacement is not guaranteed to
1677 be valid through an abnormal edge. */
1678 if (!(e
->flags
& EDGE_ABNORMAL
))
1682 bsi_insert_on_edge (e
, stmt
);
1686 bsi_insert_on_edge (e
, unsave_expr_now (stmt
));
1691 /* Helper function to insert LIST before BSI, and set up line number info. */
1694 sra_insert_before (block_stmt_iterator
*bsi
, tree list
)
1696 tree stmt
= bsi_stmt (*bsi
);
1698 if (EXPR_HAS_LOCATION (stmt
))
1699 annotate_all_with_locus (&list
, EXPR_LOCATION (stmt
));
1700 bsi_insert_before (bsi
, list
, BSI_SAME_STMT
);
1703 /* Similarly, but insert after BSI. Handles insertion onto edges as well. */
1706 sra_insert_after (block_stmt_iterator
*bsi
, tree list
)
1708 tree stmt
= bsi_stmt (*bsi
);
1710 if (EXPR_HAS_LOCATION (stmt
))
1711 annotate_all_with_locus (&list
, EXPR_LOCATION (stmt
));
1713 if (stmt_ends_bb_p (stmt
))
1714 insert_edge_copies (list
, bsi
->bb
);
1716 bsi_insert_after (bsi
, list
, BSI_SAME_STMT
);
1719 /* Similarly, but replace the statement at BSI. */
1722 sra_replace (block_stmt_iterator
*bsi
, tree list
)
1724 sra_insert_before (bsi
, list
);
1726 if (bsi_end_p (*bsi
))
1727 *bsi
= bsi_last (bsi
->bb
);
1732 /* Scalarize a USE. To recap, this is either a simple reference to ELT,
1733 if elt is scalar, or some occurrence of ELT that requires a complete
1734 aggregate. IS_OUTPUT is true if ELT is being modified. */
1737 scalarize_use (struct sra_elt
*elt
, tree
*expr_p
, block_stmt_iterator
*bsi
,
1740 tree list
= NULL
, stmt
= bsi_stmt (*bsi
);
1742 if (elt
->replacement
)
1744 /* If we have a replacement, then updating the reference is as
1745 simple as modifying the existing statement in place. */
1747 mark_all_v_defs (stmt
);
1748 *expr_p
= elt
->replacement
;
1753 /* Otherwise we need some copies. If ELT is being read, then we want
1754 to store all (modified) sub-elements back into the structure before
1755 the reference takes place. If ELT is being written, then we want to
1756 load the changed values back into our shadow variables. */
1757 /* ??? We don't check modified for reads, we just always write all of
1758 the values. We should be able to record the SSA number of the VOP
1759 for which the values were last read. If that number matches the
1760 SSA number of the VOP in the current statement, then we needn't
1761 emit an assignment. This would also eliminate double writes when
1762 a structure is passed as more than one argument to a function call.
1763 This optimization would be most effective if sra_walk_function
1764 processed the blocks in dominator order. */
1766 generate_copy_inout (elt
, is_output
, generate_element_ref (elt
), &list
);
1769 mark_all_v_defs (expr_first (list
));
1771 sra_insert_after (bsi
, list
);
1773 sra_insert_before (bsi
, list
);
1777 /* Scalarize a COPY. To recap, this is an assignment statement between
1778 two scalarizable references, LHS_ELT and RHS_ELT. */
1781 scalarize_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
1782 block_stmt_iterator
*bsi
)
1786 if (lhs_elt
->replacement
&& rhs_elt
->replacement
)
1788 /* If we have two scalar operands, modify the existing statement. */
1789 stmt
= bsi_stmt (*bsi
);
1791 #ifdef ENABLE_CHECKING
1792 /* See the commentary in sra_walk_function concerning
1793 RETURN_EXPR, and why we should never see one here. */
1794 if (TREE_CODE (stmt
) != MODIFY_EXPR
)
1798 TREE_OPERAND (stmt
, 0) = lhs_elt
->replacement
;
1799 TREE_OPERAND (stmt
, 1) = rhs_elt
->replacement
;
1802 else if (lhs_elt
->use_block_copy
|| rhs_elt
->use_block_copy
)
1804 /* If either side requires a block copy, then sync the RHS back
1805 to the original structure, leave the original assignment
1806 statement (which will perform the block copy), then load the
1807 LHS values out of its now-updated original structure. */
1808 /* ??? Could perform a modified pair-wise element copy. That
1809 would at least allow those elements that are instantiated in
1810 both structures to be optimized well. */
1813 generate_copy_inout (rhs_elt
, false,
1814 generate_element_ref (rhs_elt
), &list
);
1817 mark_all_v_defs (expr_first (list
));
1818 sra_insert_before (bsi
, list
);
1822 generate_copy_inout (lhs_elt
, true,
1823 generate_element_ref (lhs_elt
), &list
);
1825 sra_insert_after (bsi
, list
);
1829 /* Otherwise both sides must be fully instantiated. In which
1830 case perform pair-wise element assignments and replace the
1831 original block copy statement. */
1833 stmt
= bsi_stmt (*bsi
);
1834 mark_all_v_defs (stmt
);
1837 generate_element_copy (lhs_elt
, rhs_elt
, &list
);
1840 sra_replace (bsi
, list
);
1844 /* Scalarize an INIT. To recap, this is an assignment to a scalarizable
1845 reference from some form of constructor: CONSTRUCTOR, COMPLEX_CST or
1846 COMPLEX_EXPR. If RHS is NULL, it should be treated as an empty
1850 scalarize_init (struct sra_elt
*lhs_elt
, tree rhs
, block_stmt_iterator
*bsi
)
1855 /* Generate initialization statements for all members extant in the RHS. */
1858 push_gimplify_context ();
1859 result
= generate_element_init (lhs_elt
, rhs
, &list
);
1860 pop_gimplify_context (NULL
);
1863 /* CONSTRUCTOR is defined such that any member not mentioned is assigned
1864 a zero value. Initialize the rest of the instantiated elements. */
1865 generate_element_zero (lhs_elt
, &list
);
1869 /* If we failed to convert the entire initializer, then we must
1870 leave the structure assignment in place and must load values
1871 from the structure into the slots for which we did not find
1872 constants. The easiest way to do this is to generate a complete
1873 copy-out, and then follow that with the constant assignments
1874 that we were able to build. DCE will clean things up. */
1876 generate_copy_inout (lhs_elt
, true, generate_element_ref (lhs_elt
),
1878 append_to_statement_list (list
, &list0
);
1882 if (lhs_elt
->use_block_copy
|| !result
)
1884 /* Since LHS is not fully instantiated, we must leave the structure
1885 assignment in place. Treating this case differently from a USE
1886 exposes constants to later optimizations. */
1889 mark_all_v_defs (expr_first (list
));
1890 sra_insert_after (bsi
, list
);
1895 /* The LHS is fully instantiated. The list of initializations
1896 replaces the original structure assignment. */
1899 mark_all_v_defs (bsi_stmt (*bsi
));
1900 sra_replace (bsi
, list
);
1904 /* A subroutine of scalarize_ldst called via walk_tree. Set TREE_NO_TRAP
1905 on all INDIRECT_REFs. */
1908 mark_notrap (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1912 if (TREE_CODE (t
) == INDIRECT_REF
)
1914 TREE_THIS_NOTRAP (t
) = 1;
1917 else if (DECL_P (t
) || TYPE_P (t
))
1923 /* Scalarize a LDST. To recap, this is an assignment between one scalarizable
1924 reference ELT and one non-scalarizable reference OTHER. IS_OUTPUT is true
1925 if ELT is on the left-hand side. */
1928 scalarize_ldst (struct sra_elt
*elt
, tree other
,
1929 block_stmt_iterator
*bsi
, bool is_output
)
1931 /* Shouldn't have gotten called for a scalar. */
1932 if (elt
->replacement
)
1935 if (elt
->use_block_copy
)
1937 /* Since ELT is not fully instantiated, we have to leave the
1938 block copy in place. Treat this as a USE. */
1939 scalarize_use (elt
, NULL
, bsi
, is_output
);
1943 /* The interesting case is when ELT is fully instantiated. In this
1944 case we can have each element stored/loaded directly to/from the
1945 corresponding slot in OTHER. This avoids a block copy. */
1947 tree list
= NULL
, stmt
= bsi_stmt (*bsi
);
1949 mark_all_v_defs (stmt
);
1950 generate_copy_inout (elt
, is_output
, other
, &list
);
1954 /* Preserve EH semantics. */
1955 if (stmt_ends_bb_p (stmt
))
1957 tree_stmt_iterator tsi
;
1960 /* Extract the first statement from LIST. */
1961 tsi
= tsi_start (list
);
1962 first
= tsi_stmt (tsi
);
1965 /* Replace the old statement with this new representative. */
1966 bsi_replace (bsi
, first
, true);
1968 if (!tsi_end_p (tsi
))
1970 /* If any reference would trap, then they all would. And more
1971 to the point, the first would. Therefore none of the rest
1972 will trap since the first didn't. Indicate this by
1973 iterating over the remaining statements and set
1974 TREE_THIS_NOTRAP in all INDIRECT_REFs. */
1977 walk_tree (tsi_stmt_ptr (tsi
), mark_notrap
, NULL
, NULL
);
1980 while (!tsi_end_p (tsi
));
1982 insert_edge_copies (list
, bsi
->bb
);
1986 sra_replace (bsi
, list
);
1990 /* Generate initializations for all scalarizable parameters. */
1993 scalarize_parms (void)
1998 EXECUTE_IF_SET_IN_BITMAP (needs_copy_in
, 0, i
,
2000 tree var
= referenced_var (i
);
2001 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
2002 generate_copy_inout (elt
, true, var
, &list
);
2006 insert_edge_copies (list
, ENTRY_BLOCK_PTR
);
2009 /* Entry point to phase 4. Update the function to match replacements. */
2012 scalarize_function (void)
2014 static const struct sra_walk_fns fns
= {
2015 scalarize_use
, scalarize_copy
, scalarize_init
, scalarize_ldst
, false
2018 sra_walk_function (&fns
);
2020 bsi_commit_edge_inserts (NULL
);
2024 /* Debug helper function. Print ELT in a nice human-readable format. */
2027 dump_sra_elt_name (FILE *f
, struct sra_elt
*elt
)
2029 if (elt
->parent
&& TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
2031 fputs (elt
->element
== integer_zero_node
? "__real__ " : "__imag__ ", f
);
2032 dump_sra_elt_name (f
, elt
->parent
);
2037 dump_sra_elt_name (f
, elt
->parent
);
2038 if (DECL_P (elt
->element
))
2040 if (TREE_CODE (elt
->element
) == FIELD_DECL
)
2042 print_generic_expr (f
, elt
->element
, dump_flags
);
2045 fprintf (f
, "[" HOST_WIDE_INT_PRINT_DEC
"]",
2046 TREE_INT_CST_LOW (elt
->element
));
2050 /* Likewise, but callable from the debugger. */
2053 debug_sra_elt_name (struct sra_elt
*elt
)
2055 dump_sra_elt_name (stderr
, elt
);
2056 fputc ('\n', stderr
);
2059 /* Main entry point. */
2064 /* Initialize local variables. */
2065 gcc_obstack_init (&sra_obstack
);
2066 sra_candidates
= BITMAP_XMALLOC ();
2067 needs_copy_in
= BITMAP_XMALLOC ();
2068 sra_type_decomp_cache
= BITMAP_XMALLOC ();
2069 sra_type_inst_cache
= BITMAP_XMALLOC ();
2070 sra_map
= htab_create (101, sra_elt_hash
, sra_elt_eq
, NULL
);
2072 /* Scan. If we find anything, instantiate and scalarize. */
2073 if (find_candidates_for_sra ())
2076 decide_instantiations ();
2077 scalarize_function ();
2080 /* Free allocated memory. */
2081 htab_delete (sra_map
);
2083 BITMAP_XFREE (sra_candidates
);
2084 BITMAP_XFREE (needs_copy_in
);
2085 BITMAP_XFREE (sra_type_decomp_cache
);
2086 BITMAP_XFREE (sra_type_inst_cache
);
2087 obstack_free (&sra_obstack
, NULL
);
2093 return flag_tree_sra
!= 0;
2096 struct tree_opt_pass pass_sra
=
2099 gate_sra
, /* gate */
2100 tree_sra
, /* execute */
2103 0, /* static_pass_number */
2104 TV_TREE_SRA
, /* tv_id */
2105 PROP_cfg
| PROP_ssa
| PROP_alias
, /* properties_required */
2106 0, /* properties_provided */
2107 0, /* properties_destroyed */
2108 0, /* todo_flags_start */
2109 TODO_dump_func
| TODO_rename_vars
2110 | TODO_ggc_collect
| TODO_verify_ssa
/* todo_flags_finish */