1 /* Scalar Replacement of Aggregates (SRA) converts some structure
2 references into scalar references, exposing them to the scalar
4 Copyright (C) 2003, 2004, 2005, 2006 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, 51 Franklin Street, Fifth Floor, Boston, MA
26 #include "coretypes.h"
31 /* These RTL headers are needed for basic-block.h. */
34 #include "hard-reg-set.h"
35 #include "basic-block.h"
36 #include "diagnostic.h"
37 #include "langhooks.h"
38 #include "tree-inline.h"
39 #include "tree-flow.h"
40 #include "tree-gimple.h"
41 #include "tree-dump.h"
42 #include "tree-pass.h"
48 /* 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 /* True if this is the "early" pass, before inlining. */
79 static bool early_sra;
81 /* The set of todo flags to return from tree_sra. */
82 static unsigned int todoflags;
84 /* The set of aggregate variables that are candidates for scalarization. */
85 static bitmap sra_candidates;
87 /* Set of scalarizable PARM_DECLs that need copy-in operations at the
88 beginning of the function. */
89 static bitmap needs_copy_in;
91 /* Sets of bit pairs that cache type decomposition and instantiation. */
92 static bitmap sra_type_decomp_cache;
93 static bitmap sra_type_inst_cache;
95 /* One of these structures is created for each candidate aggregate and
96 each (accessed) member or group of members of such an aggregate. */
99 /* A tree of the elements. Used when we want to traverse everything. */
100 struct sra_elt *parent;
101 struct sra_elt *groups;
102 struct sra_elt *children;
103 struct sra_elt *sibling;
105 /* If this element is a root, then this is the VAR_DECL. If this is
106 a sub-element, this is some token used to identify the reference.
107 In the case of COMPONENT_REF, this is the FIELD_DECL. In the case
108 of an ARRAY_REF, this is the (constant) index. In the case of an
109 ARRAY_RANGE_REF, this is the (constant) RANGE_EXPR. In the case
110 of a complex number, this is a zero or one. */
113 /* The type of the element. */
116 /* A VAR_DECL, for any sub-element we've decided to replace. */
119 /* The number of times the element is referenced as a whole. I.e.
120 given "a.b.c", this would be incremented for C, but not for A or B. */
123 /* The number of times the element is copied to or from another
124 scalarizable element. */
125 unsigned int n_copies;
127 /* True if TYPE is scalar. */
130 /* True if this element is a group of members of its parent. */
133 /* True if we saw something about this element that prevents scalarization,
134 such as non-constant indexing. */
135 bool cannot_scalarize;
137 /* True if we've decided that structure-to-structure assignment
138 should happen via memcpy and not per-element. */
141 /* True if everything under this element has been marked TREE_NO_WARNING. */
144 /* A flag for use with/after random access traversals. */
147 /* True if there is BIT_FIELD_REF on the lhs with a vector. */
151 #define IS_ELEMENT_FOR_GROUP(ELEMENT) (TREE_CODE (ELEMENT) == RANGE_EXPR)
153 #define FOR_EACH_ACTUAL_CHILD(CHILD, ELT) \
154 for ((CHILD) = (ELT)->is_group \
155 ? next_child_for_group (NULL, (ELT)) \
158 (CHILD) = (ELT)->is_group \
159 ? next_child_for_group ((CHILD), (ELT)) \
162 /* Helper function for above macro. Return next child in group. */
163 static struct sra_elt *
164 next_child_for_group (struct sra_elt *child, struct sra_elt *group)
166 gcc_assert (group->is_group);
168 /* Find the next child in the parent. */
170 child = child->sibling;
172 child = group->parent->children;
174 /* Skip siblings that do not belong to the group. */
177 tree g_elt = group->element;
178 if (TREE_CODE (g_elt) == RANGE_EXPR)
180 if (!tree_int_cst_lt (child->element, TREE_OPERAND (g_elt, 0))
181 && !tree_int_cst_lt (TREE_OPERAND (g_elt, 1), child->element))
187 child = child->sibling;
193 /* Random access to the child of a parent is performed by hashing.
194 This prevents quadratic behavior, and allows SRA to function
195 reasonably on larger records. */
196 static htab_t sra_map;
198 /* All structures are allocated out of the following obstack. */
199 static struct obstack sra_obstack;
201 /* Debugging functions. */
202 static void dump_sra_elt_name (FILE *, struct sra_elt *);
203 extern void debug_sra_elt_name (struct sra_elt *);
205 /* Forward declarations. */
206 static tree generate_element_ref (struct sra_elt *);
208 /* Return true if DECL is an SRA candidate. */
211 is_sra_candidate_decl (tree decl)
213 return DECL_P (decl) && bitmap_bit_p (sra_candidates, DECL_UID (decl));
216 /* Return true if TYPE is a scalar type. */
219 is_sra_scalar_type (tree type)
221 enum tree_code code = TREE_CODE (type);
222 return (code == INTEGER_TYPE || code == REAL_TYPE || code == VECTOR_TYPE
223 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE
224 || code == POINTER_TYPE || code == OFFSET_TYPE
225 || code == REFERENCE_TYPE);
228 /* Return true if TYPE can be decomposed into a set of independent variables.
230 Note that this doesn't imply that all elements of TYPE can be
231 instantiated, just that if we decide to break up the type into
232 separate pieces that it can be done. */
235 sra_type_can_be_decomposed_p (tree type)
237 unsigned int cache = TYPE_UID (TYPE_MAIN_VARIANT (type)) * 2;
240 /* Avoid searching the same type twice. */
241 if (bitmap_bit_p (sra_type_decomp_cache, cache+0))
243 if (bitmap_bit_p (sra_type_decomp_cache, cache+1))
246 /* The type must have a definite nonzero size. */
247 if (TYPE_SIZE (type) == NULL || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
248 || integer_zerop (TYPE_SIZE (type)))
251 /* The type must be a non-union aggregate. */
252 switch (TREE_CODE (type))
256 bool saw_one_field = false;
258 for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
259 if (TREE_CODE (t) == FIELD_DECL)
261 /* Reject incorrectly represented bit fields. */
262 if (DECL_BIT_FIELD (t)
263 && (tree_low_cst (DECL_SIZE (t), 1)
264 != TYPE_PRECISION (TREE_TYPE (t))))
267 saw_one_field = true;
270 /* Record types must have at least one field. */
277 /* Array types must have a fixed lower and upper bound. */
278 t = TYPE_DOMAIN (type);
281 if (TYPE_MIN_VALUE (t) == NULL || !TREE_CONSTANT (TYPE_MIN_VALUE (t)))
283 if (TYPE_MAX_VALUE (t) == NULL || !TREE_CONSTANT (TYPE_MAX_VALUE (t)))
294 bitmap_set_bit (sra_type_decomp_cache, cache+0);
298 bitmap_set_bit (sra_type_decomp_cache, cache+1);
302 /* Return true if DECL can be decomposed into a set of independent
303 (though not necessarily scalar) variables. */
306 decl_can_be_decomposed_p (tree var)
308 /* Early out for scalars. */
309 if (is_sra_scalar_type (TREE_TYPE (var)))
312 /* The variable must not be aliased. */
313 if (!is_gimple_non_addressable (var))
315 if (dump_file && (dump_flags & TDF_DETAILS))
317 fprintf (dump_file, "Cannot scalarize variable ");
318 print_generic_expr (dump_file, var, dump_flags);
319 fprintf (dump_file, " because it must live in memory\n");
324 /* The variable must not be volatile. */
325 if (TREE_THIS_VOLATILE (var))
327 if (dump_file && (dump_flags & TDF_DETAILS))
329 fprintf (dump_file, "Cannot scalarize variable ");
330 print_generic_expr (dump_file, var, dump_flags);
331 fprintf (dump_file, " because it is declared volatile\n");
336 /* We must be able to decompose the variable's type. */
337 if (!sra_type_can_be_decomposed_p (TREE_TYPE (var)))
339 if (dump_file && (dump_flags & TDF_DETAILS))
341 fprintf (dump_file, "Cannot scalarize variable ");
342 print_generic_expr (dump_file, var, dump_flags);
343 fprintf (dump_file, " because its type cannot be decomposed\n");
348 /* HACK: if we decompose a va_list_type_node before inlining, then we'll
349 confuse tree-stdarg.c, and we won't be able to figure out which and
350 how many arguments are accessed. This really should be improved in
351 tree-stdarg.c, as the decomposition is truely a win. This could also
352 be fixed if the stdarg pass ran early, but this can't be done until
353 we've aliasing information early too. See PR 30791. */
355 && TYPE_MAIN_VARIANT (TREE_TYPE (var))
356 == TYPE_MAIN_VARIANT (va_list_type_node))
362 /* Return true if TYPE can be *completely* decomposed into scalars. */
365 type_can_instantiate_all_elements (tree type)
367 if (is_sra_scalar_type (type))
369 if (!sra_type_can_be_decomposed_p (type))
372 switch (TREE_CODE (type))
376 unsigned int cache = TYPE_UID (TYPE_MAIN_VARIANT (type)) * 2;
379 if (bitmap_bit_p (sra_type_inst_cache, cache+0))
381 if (bitmap_bit_p (sra_type_inst_cache, cache+1))
384 for (f = TYPE_FIELDS (type); f ; f = TREE_CHAIN (f))
385 if (TREE_CODE (f) == FIELD_DECL)
387 if (!type_can_instantiate_all_elements (TREE_TYPE (f)))
389 bitmap_set_bit (sra_type_inst_cache, cache+1);
394 bitmap_set_bit (sra_type_inst_cache, cache+0);
399 return type_can_instantiate_all_elements (TREE_TYPE (type));
409 /* Test whether ELT or some sub-element cannot be scalarized. */
412 can_completely_scalarize_p (struct sra_elt *elt)
416 if (elt->cannot_scalarize)
419 for (c = elt->children; c; c = c->sibling)
420 if (!can_completely_scalarize_p (c))
423 for (c = elt->groups; c; c = c->sibling)
424 if (!can_completely_scalarize_p (c))
431 /* A simplified tree hashing algorithm that only handles the types of
432 trees we expect to find in sra_elt->element. */
435 sra_hash_tree (tree t)
439 switch (TREE_CODE (t))
448 h = TREE_INT_CST_LOW (t) ^ TREE_INT_CST_HIGH (t);
452 h = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
453 h = iterative_hash_expr (TREE_OPERAND (t, 1), h);
457 /* We can have types that are compatible, but have different member
458 lists, so we can't hash fields by ID. Use offsets instead. */
459 h = iterative_hash_expr (DECL_FIELD_OFFSET (t), 0);
460 h = iterative_hash_expr (DECL_FIELD_BIT_OFFSET (t), h);
470 /* Hash function for type SRA_PAIR. */
473 sra_elt_hash (const void *x)
475 const struct sra_elt *e = x;
476 const struct sra_elt *p;
479 h = sra_hash_tree (e->element);
481 /* Take into account everything back up the chain. Given that chain
482 lengths are rarely very long, this should be acceptable. If we
483 truly identify this as a performance problem, it should work to
484 hash the pointer value "e->parent". */
485 for (p = e->parent; p ; p = p->parent)
486 h = (h * 65521) ^ sra_hash_tree (p->element);
491 /* Equality function for type SRA_PAIR. */
494 sra_elt_eq (const void *x, const void *y)
496 const struct sra_elt *a = x;
497 const struct sra_elt *b = y;
500 if (a->parent != b->parent)
508 if (TREE_CODE (ae) != TREE_CODE (be))
511 switch (TREE_CODE (ae))
516 /* These are all pointer unique. */
520 /* Integers are not pointer unique, so compare their values. */
521 return tree_int_cst_equal (ae, be);
525 tree_int_cst_equal (TREE_OPERAND (ae, 0), TREE_OPERAND (be, 0))
526 && tree_int_cst_equal (TREE_OPERAND (ae, 1), TREE_OPERAND (be, 1));
529 /* Fields are unique within a record, but not between
530 compatible records. */
531 if (DECL_FIELD_CONTEXT (ae) == DECL_FIELD_CONTEXT (be))
533 return fields_compatible_p (ae, be);
540 /* Create or return the SRA_ELT structure for CHILD in PARENT. PARENT
541 may be null, in which case CHILD must be a DECL. */
543 static struct sra_elt *
544 lookup_element (struct sra_elt *parent, tree child, tree type,
545 enum insert_option insert)
547 struct sra_elt dummy;
548 struct sra_elt **slot;
552 dummy.parent = parent->is_group ? parent->parent : parent;
555 dummy.element = child;
557 slot = (struct sra_elt **) htab_find_slot (sra_map, &dummy, insert);
558 if (!slot && insert == NO_INSERT)
562 if (!elt && insert == INSERT)
564 *slot = elt = obstack_alloc (&sra_obstack, sizeof (*elt));
565 memset (elt, 0, sizeof (*elt));
567 elt->parent = parent;
568 elt->element = child;
570 elt->is_scalar = is_sra_scalar_type (type);
574 if (IS_ELEMENT_FOR_GROUP (elt->element))
576 elt->is_group = true;
577 elt->sibling = parent->groups;
578 parent->groups = elt;
582 elt->sibling = parent->children;
583 parent->children = elt;
587 /* If this is a parameter, then if we want to scalarize, we have
588 one copy from the true function parameter. Count it now. */
589 if (TREE_CODE (child) == PARM_DECL)
592 bitmap_set_bit (needs_copy_in, DECL_UID (child));
599 /* Create or return the SRA_ELT structure for EXPR if the expression
600 refers to a scalarizable variable. */
602 static struct sra_elt *
603 maybe_lookup_element_for_expr (tree expr)
608 switch (TREE_CODE (expr))
613 if (is_sra_candidate_decl (expr))
614 return lookup_element (NULL, expr, TREE_TYPE (expr), INSERT);
618 /* We can't scalarize variable array indices. */
619 if (in_array_bounds_p (expr))
620 child = TREE_OPERAND (expr, 1);
625 case ARRAY_RANGE_REF:
626 /* We can't scalarize variable array indices. */
627 if (range_in_array_bounds_p (expr))
629 tree domain = TYPE_DOMAIN (TREE_TYPE (expr));
630 child = build2 (RANGE_EXPR, integer_type_node,
631 TYPE_MIN_VALUE (domain), TYPE_MAX_VALUE (domain));
638 /* Don't look through unions. */
639 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) != RECORD_TYPE)
641 child = TREE_OPERAND (expr, 1);
645 child = integer_zero_node;
648 child = integer_one_node;
655 elt = maybe_lookup_element_for_expr (TREE_OPERAND (expr, 0));
657 return lookup_element (elt, child, TREE_TYPE (expr), INSERT);
662 /* Functions to walk just enough of the tree to see all scalarizable
663 references, and categorize them. */
665 /* A set of callbacks for phases 2 and 4. They'll be invoked for the
666 various kinds of references seen. In all cases, *BSI is an iterator
667 pointing to the statement being processed. */
670 /* Invoked when ELT is required as a unit. Note that ELT might refer to
671 a leaf node, in which case this is a simple scalar reference. *EXPR_P
672 points to the location of the expression. IS_OUTPUT is true if this
673 is a left-hand-side reference. USE_ALL is true if we saw something we
674 couldn't quite identify and had to force the use of the entire object. */
675 void (*use) (struct sra_elt *elt, tree *expr_p,
676 block_stmt_iterator *bsi, bool is_output, bool use_all);
678 /* Invoked when we have a copy between two scalarizable references. */
679 void (*copy) (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
680 block_stmt_iterator *bsi);
682 /* Invoked when ELT is initialized from a constant. VALUE may be NULL,
683 in which case it should be treated as an empty CONSTRUCTOR. */
684 void (*init) (struct sra_elt *elt, tree value, block_stmt_iterator *bsi);
686 /* Invoked when we have a copy between one scalarizable reference ELT
687 and one non-scalarizable reference OTHER. IS_OUTPUT is true if ELT
688 is on the left-hand side. */
689 void (*ldst) (struct sra_elt *elt, tree other,
690 block_stmt_iterator *bsi, bool is_output);
692 /* True during phase 2, false during phase 4. */
693 /* ??? This is a hack. */
697 #ifdef ENABLE_CHECKING
698 /* Invoked via walk_tree, if *TP contains a candidate decl, return it. */
701 sra_find_candidate_decl (tree *tp, int *walk_subtrees,
702 void *data ATTRIBUTE_UNUSED)
705 enum tree_code code = TREE_CODE (t);
707 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
710 if (is_sra_candidate_decl (t))
720 /* Walk most expressions looking for a scalarizable aggregate.
721 If we find one, invoke FNS->USE. */
724 sra_walk_expr (tree *expr_p, block_stmt_iterator *bsi, bool is_output,
725 const struct sra_walk_fns *fns)
729 bool disable_scalarization = false;
730 bool use_all_p = false;
732 /* We're looking to collect a reference expression between EXPR and INNER,
733 such that INNER is a scalarizable decl and all other nodes through EXPR
734 are references that we can scalarize. If we come across something that
735 we can't scalarize, we reset EXPR. This has the effect of making it
736 appear that we're referring to the larger expression as a whole. */
739 switch (TREE_CODE (inner))
744 /* If there is a scalarizable decl at the bottom, then process it. */
745 if (is_sra_candidate_decl (inner))
747 struct sra_elt *elt = maybe_lookup_element_for_expr (expr);
748 if (disable_scalarization)
749 elt->cannot_scalarize = true;
751 fns->use (elt, expr_p, bsi, is_output, use_all_p);
756 /* Non-constant index means any member may be accessed. Prevent the
757 expression from being scalarized. If we were to treat this as a
758 reference to the whole array, we can wind up with a single dynamic
759 index reference inside a loop being overridden by several constant
760 index references during loop setup. It's possible that this could
761 be avoided by using dynamic usage counts based on BB trip counts
762 (based on loop analysis or profiling), but that hardly seems worth
764 /* ??? Hack. Figure out how to push this into the scan routines
765 without duplicating too much code. */
766 if (!in_array_bounds_p (inner))
768 disable_scalarization = true;
771 /* ??? Are we assured that non-constant bounds and stride will have
772 the same value everywhere? I don't think Fortran will... */
773 if (TREE_OPERAND (inner, 2) || TREE_OPERAND (inner, 3))
775 inner = TREE_OPERAND (inner, 0);
778 case ARRAY_RANGE_REF:
779 if (!range_in_array_bounds_p (inner))
781 disable_scalarization = true;
784 /* ??? See above non-constant bounds and stride . */
785 if (TREE_OPERAND (inner, 2) || TREE_OPERAND (inner, 3))
787 inner = TREE_OPERAND (inner, 0);
791 /* A reference to a union member constitutes a reference to the
793 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (inner, 0))) != RECORD_TYPE)
795 /* ??? See above re non-constant stride. */
796 if (TREE_OPERAND (inner, 2))
798 inner = TREE_OPERAND (inner, 0);
803 inner = TREE_OPERAND (inner, 0);
807 /* A bit field reference to a specific vector is scalarized but for
808 ones for inputs need to be marked as used on the left hand size so
809 when we scalarize it, we can mark that variable as non renamable. */
811 && TREE_CODE (TREE_TYPE (TREE_OPERAND (inner, 0))) == VECTOR_TYPE)
814 = maybe_lookup_element_for_expr (TREE_OPERAND (inner, 0));
816 elt->is_vector_lhs = true;
818 /* A bit field reference (access to *multiple* fields simultaneously)
819 is not currently scalarized. Consider this an access to the
820 complete outer element, to which walk_tree will bring us next. */
824 case VIEW_CONVERT_EXPR:
826 /* Similarly, a view/nop explicitly wants to look at an object in a
827 type other than the one we've scalarized. */
831 /* This is a transparent wrapper. The entire inner expression really
836 expr_p = &TREE_OPERAND (inner, 0);
837 inner = expr = *expr_p;
842 #ifdef ENABLE_CHECKING
843 /* Validate that we're not missing any references. */
844 gcc_assert (!walk_tree (&inner, sra_find_candidate_decl, NULL, NULL));
850 /* Walk a TREE_LIST of values looking for scalarizable aggregates.
851 If we find one, invoke FNS->USE. */
854 sra_walk_tree_list (tree list, block_stmt_iterator *bsi, bool is_output,
855 const struct sra_walk_fns *fns)
858 for (op = list; op ; op = TREE_CHAIN (op))
859 sra_walk_expr (&TREE_VALUE (op), bsi, is_output, fns);
862 /* Walk the arguments of a CALL_EXPR looking for scalarizable aggregates.
863 If we find one, invoke FNS->USE. */
866 sra_walk_call_expr (tree expr, block_stmt_iterator *bsi,
867 const struct sra_walk_fns *fns)
869 sra_walk_tree_list (TREE_OPERAND (expr, 1), bsi, false, fns);
872 /* Walk the inputs and outputs of an ASM_EXPR looking for scalarizable
873 aggregates. If we find one, invoke FNS->USE. */
876 sra_walk_asm_expr (tree expr, block_stmt_iterator *bsi,
877 const struct sra_walk_fns *fns)
879 sra_walk_tree_list (ASM_INPUTS (expr), bsi, false, fns);
880 sra_walk_tree_list (ASM_OUTPUTS (expr), bsi, true, fns);
883 /* Walk a GIMPLE_MODIFY_STMT and categorize the assignment appropriately. */
886 sra_walk_gimple_modify_stmt (tree expr, block_stmt_iterator *bsi,
887 const struct sra_walk_fns *fns)
889 struct sra_elt *lhs_elt, *rhs_elt;
892 lhs = GIMPLE_STMT_OPERAND (expr, 0);
893 rhs = GIMPLE_STMT_OPERAND (expr, 1);
894 lhs_elt = maybe_lookup_element_for_expr (lhs);
895 rhs_elt = maybe_lookup_element_for_expr (rhs);
897 /* If both sides are scalarizable, this is a COPY operation. */
898 if (lhs_elt && rhs_elt)
900 fns->copy (lhs_elt, rhs_elt, bsi);
904 /* If the RHS is scalarizable, handle it. There are only two cases. */
907 if (!rhs_elt->is_scalar)
908 fns->ldst (rhs_elt, lhs, bsi, false);
910 fns->use (rhs_elt, &GIMPLE_STMT_OPERAND (expr, 1), bsi, false, false);
913 /* If it isn't scalarizable, there may be scalarizable variables within, so
914 check for a call or else walk the RHS to see if we need to do any
915 copy-in operations. We need to do it before the LHS is scalarized so
916 that the statements get inserted in the proper place, before any
917 copy-out operations. */
920 tree call = get_call_expr_in (rhs);
922 sra_walk_call_expr (call, bsi, fns);
924 sra_walk_expr (&GIMPLE_STMT_OPERAND (expr, 1), bsi, false, fns);
927 /* Likewise, handle the LHS being scalarizable. We have cases similar
928 to those above, but also want to handle RHS being constant. */
931 /* If this is an assignment from a constant, or constructor, then
932 we have access to all of the elements individually. Invoke INIT. */
933 if (TREE_CODE (rhs) == COMPLEX_EXPR
934 || TREE_CODE (rhs) == COMPLEX_CST
935 || TREE_CODE (rhs) == CONSTRUCTOR)
936 fns->init (lhs_elt, rhs, bsi);
938 /* If this is an assignment from read-only memory, treat this as if
939 we'd been passed the constructor directly. Invoke INIT. */
940 else if (TREE_CODE (rhs) == VAR_DECL
942 && TREE_READONLY (rhs)
943 && targetm.binds_local_p (rhs))
944 fns->init (lhs_elt, DECL_INITIAL (rhs), bsi);
946 /* If this is a copy from a non-scalarizable lvalue, invoke LDST.
947 The lvalue requirement prevents us from trying to directly scalarize
948 the result of a function call. Which would result in trying to call
949 the function multiple times, and other evil things. */
950 else if (!lhs_elt->is_scalar && is_gimple_addressable (rhs))
951 fns->ldst (lhs_elt, rhs, bsi, true);
953 /* Otherwise we're being used in some context that requires the
954 aggregate to be seen as a whole. Invoke USE. */
956 fns->use (lhs_elt, &GIMPLE_STMT_OPERAND (expr, 0), bsi, true, false);
959 /* Similarly to above, LHS_ELT being null only means that the LHS as a
960 whole is not a scalarizable reference. There may be occurrences of
961 scalarizable variables within, which implies a USE. */
963 sra_walk_expr (&GIMPLE_STMT_OPERAND (expr, 0), bsi, true, fns);
966 /* Entry point to the walk functions. Search the entire function,
967 invoking the callbacks in FNS on each of the references to
968 scalarizable variables. */
971 sra_walk_function (const struct sra_walk_fns *fns)
974 block_stmt_iterator si, ni;
976 /* ??? Phase 4 could derive some benefit to walking the function in
977 dominator tree order. */
980 for (si = bsi_start (bb); !bsi_end_p (si); si = ni)
985 stmt = bsi_stmt (si);
986 ann = stmt_ann (stmt);
991 /* If the statement has no virtual operands, then it doesn't
992 make any structure references that we care about. */
993 if (gimple_aliases_computed_p (cfun)
994 && ZERO_SSA_OPERANDS (stmt, (SSA_OP_VIRTUAL_DEFS | SSA_OP_VUSE)))
997 switch (TREE_CODE (stmt))
1000 /* If we have "return <retval>" then the return value is
1001 already exposed for our pleasure. Walk it as a USE to
1002 force all the components back in place for the return.
1004 If we have an embedded assignment, then <retval> is of
1005 a type that gets returned in registers in this ABI, and
1006 we do not wish to extend their lifetimes. Treat this
1007 as a USE of the variable on the RHS of this assignment. */
1009 t = TREE_OPERAND (stmt, 0);
1012 else if (TREE_CODE (t) == GIMPLE_MODIFY_STMT)
1013 sra_walk_expr (&GIMPLE_STMT_OPERAND (t, 1), &si, false, fns);
1015 sra_walk_expr (&TREE_OPERAND (stmt, 0), &si, false, fns);
1018 case GIMPLE_MODIFY_STMT:
1019 sra_walk_gimple_modify_stmt (stmt, &si, fns);
1022 sra_walk_call_expr (stmt, &si, fns);
1025 sra_walk_asm_expr (stmt, &si, fns);
1034 /* Phase One: Scan all referenced variables in the program looking for
1035 structures that could be decomposed. */
1038 find_candidates_for_sra (void)
1040 bool any_set = false;
1042 referenced_var_iterator rvi;
1044 FOR_EACH_REFERENCED_VAR (var, rvi)
1046 if (decl_can_be_decomposed_p (var))
1048 bitmap_set_bit (sra_candidates, DECL_UID (var));
1057 /* Phase Two: Scan all references to scalarizable variables. Count the
1058 number of times they are used or copied respectively. */
1060 /* Callbacks to fill in SRA_WALK_FNS. Everything but USE is
1061 considered a copy, because we can decompose the reference such that
1062 the sub-elements needn't be contiguous. */
1065 scan_use (struct sra_elt *elt, tree *expr_p ATTRIBUTE_UNUSED,
1066 block_stmt_iterator *bsi ATTRIBUTE_UNUSED,
1067 bool is_output ATTRIBUTE_UNUSED, bool use_all ATTRIBUTE_UNUSED)
1073 scan_copy (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
1074 block_stmt_iterator *bsi ATTRIBUTE_UNUSED)
1076 lhs_elt->n_copies += 1;
1077 rhs_elt->n_copies += 1;
1081 scan_init (struct sra_elt *lhs_elt, tree rhs ATTRIBUTE_UNUSED,
1082 block_stmt_iterator *bsi ATTRIBUTE_UNUSED)
1084 lhs_elt->n_copies += 1;
1088 scan_ldst (struct sra_elt *elt, tree other ATTRIBUTE_UNUSED,
1089 block_stmt_iterator *bsi ATTRIBUTE_UNUSED,
1090 bool is_output ATTRIBUTE_UNUSED)
1095 /* Dump the values we collected during the scanning phase. */
1098 scan_dump (struct sra_elt *elt)
1102 dump_sra_elt_name (dump_file, elt);
1103 fprintf (dump_file, ": n_uses=%u n_copies=%u\n", elt->n_uses, elt->n_copies);
1105 for (c = elt->children; c ; c = c->sibling)
1108 for (c = elt->groups; c ; c = c->sibling)
1112 /* Entry point to phase 2. Scan the entire function, building up
1113 scalarization data structures, recording copies and uses. */
1116 scan_function (void)
1118 static const struct sra_walk_fns fns = {
1119 scan_use, scan_copy, scan_init, scan_ldst, true
1123 sra_walk_function (&fns);
1125 if (dump_file && (dump_flags & TDF_DETAILS))
1129 fputs ("\nScan results:\n", dump_file);
1130 EXECUTE_IF_SET_IN_BITMAP (sra_candidates, 0, i, bi)
1132 tree var = referenced_var (i);
1133 struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
1137 fputc ('\n', dump_file);
1141 /* Phase Three: Make decisions about which variables to scalarize, if any.
1142 All elements to be scalarized have replacement variables made for them. */
1144 /* A subroutine of build_element_name. Recursively build the element
1145 name on the obstack. */
1148 build_element_name_1 (struct sra_elt *elt)
1155 build_element_name_1 (elt->parent);
1156 obstack_1grow (&sra_obstack, '$');
1158 if (TREE_CODE (elt->parent->type) == COMPLEX_TYPE)
1160 if (elt->element == integer_zero_node)
1161 obstack_grow (&sra_obstack, "real", 4);
1163 obstack_grow (&sra_obstack, "imag", 4);
1169 if (TREE_CODE (t) == INTEGER_CST)
1171 /* ??? Eh. Don't bother doing double-wide printing. */
1172 sprintf (buffer, HOST_WIDE_INT_PRINT_DEC, TREE_INT_CST_LOW (t));
1173 obstack_grow (&sra_obstack, buffer, strlen (buffer));
1177 tree name = DECL_NAME (t);
1179 obstack_grow (&sra_obstack, IDENTIFIER_POINTER (name),
1180 IDENTIFIER_LENGTH (name));
1183 sprintf (buffer, "D%u", DECL_UID (t));
1184 obstack_grow (&sra_obstack, buffer, strlen (buffer));
1189 /* Construct a pretty variable name for an element's replacement variable.
1190 The name is built on the obstack. */
1193 build_element_name (struct sra_elt *elt)
1195 build_element_name_1 (elt);
1196 obstack_1grow (&sra_obstack, '\0');
1197 return XOBFINISH (&sra_obstack, char *);
1200 /* Instantiate an element as an independent variable. */
1203 instantiate_element (struct sra_elt *elt)
1205 struct sra_elt *base_elt;
1208 for (base_elt = elt; base_elt->parent; base_elt = base_elt->parent)
1210 base = base_elt->element;
1212 elt->replacement = var = make_rename_temp (elt->type, "SR");
1214 /* For vectors, if used on the left hand side with BIT_FIELD_REF,
1215 they are not a gimple register. */
1216 if (TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE && elt->is_vector_lhs)
1217 DECL_GIMPLE_REG_P (var) = 0;
1219 DECL_SOURCE_LOCATION (var) = DECL_SOURCE_LOCATION (base);
1220 DECL_ARTIFICIAL (var) = 1;
1222 if (TREE_THIS_VOLATILE (elt->type))
1224 TREE_THIS_VOLATILE (var) = 1;
1225 TREE_SIDE_EFFECTS (var) = 1;
1228 if (DECL_NAME (base) && !DECL_IGNORED_P (base))
1230 char *pretty_name = build_element_name (elt);
1231 DECL_NAME (var) = get_identifier (pretty_name);
1232 obstack_free (&sra_obstack, pretty_name);
1234 SET_DECL_DEBUG_EXPR (var, generate_element_ref (elt));
1235 DECL_DEBUG_EXPR_IS_FROM (var) = 1;
1237 DECL_IGNORED_P (var) = 0;
1238 TREE_NO_WARNING (var) = TREE_NO_WARNING (base);
1242 DECL_IGNORED_P (var) = 1;
1243 /* ??? We can't generate any warning that would be meaningful. */
1244 TREE_NO_WARNING (var) = 1;
1249 fputs (" ", dump_file);
1250 dump_sra_elt_name (dump_file, elt);
1251 fputs (" -> ", dump_file);
1252 print_generic_expr (dump_file, var, dump_flags);
1253 fputc ('\n', dump_file);
1257 /* Make one pass across an element tree deciding whether or not it's
1258 profitable to instantiate individual leaf scalars.
1260 PARENT_USES and PARENT_COPIES are the sum of the N_USES and N_COPIES
1261 fields all the way up the tree. */
1264 decide_instantiation_1 (struct sra_elt *elt, unsigned int parent_uses,
1265 unsigned int parent_copies)
1267 if (dump_file && !elt->parent)
1269 fputs ("Initial instantiation for ", dump_file);
1270 dump_sra_elt_name (dump_file, elt);
1271 fputc ('\n', dump_file);
1274 if (elt->cannot_scalarize)
1279 /* The decision is simple: instantiate if we're used more frequently
1280 than the parent needs to be seen as a complete unit. */
1281 if (elt->n_uses + elt->n_copies + parent_copies > parent_uses)
1282 instantiate_element (elt);
1286 struct sra_elt *c, *group;
1287 unsigned int this_uses = elt->n_uses + parent_uses;
1288 unsigned int this_copies = elt->n_copies + parent_copies;
1290 /* Consider groups of sub-elements as weighing in favour of
1291 instantiation whatever their size. */
1292 for (group = elt->groups; group ; group = group->sibling)
1293 FOR_EACH_ACTUAL_CHILD (c, group)
1295 c->n_uses += group->n_uses;
1296 c->n_copies += group->n_copies;
1299 for (c = elt->children; c ; c = c->sibling)
1300 decide_instantiation_1 (c, this_uses, this_copies);
1304 /* Compute the size and number of all instantiated elements below ELT.
1305 We will only care about this if the size of the complete structure
1306 fits in a HOST_WIDE_INT, so we don't have to worry about overflow. */
1309 sum_instantiated_sizes (struct sra_elt *elt, unsigned HOST_WIDE_INT *sizep)
1311 if (elt->replacement)
1313 *sizep += TREE_INT_CST_LOW (TYPE_SIZE_UNIT (elt->type));
1319 unsigned int count = 0;
1321 for (c = elt->children; c ; c = c->sibling)
1322 count += sum_instantiated_sizes (c, sizep);
1328 /* Instantiate fields in ELT->TYPE that are not currently present as
1331 static void instantiate_missing_elements (struct sra_elt *elt);
1334 instantiate_missing_elements_1 (struct sra_elt *elt, tree child, tree type)
1336 struct sra_elt *sub = lookup_element (elt, child, type, INSERT);
1339 if (sub->replacement == NULL)
1340 instantiate_element (sub);
1343 instantiate_missing_elements (sub);
1347 instantiate_missing_elements (struct sra_elt *elt)
1349 tree type = elt->type;
1351 switch (TREE_CODE (type))
1356 for (f = TYPE_FIELDS (type); f ; f = TREE_CHAIN (f))
1357 if (TREE_CODE (f) == FIELD_DECL)
1358 instantiate_missing_elements_1 (elt, f, TREE_TYPE (f));
1364 tree i, max, subtype;
1366 i = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
1367 max = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
1368 subtype = TREE_TYPE (type);
1372 instantiate_missing_elements_1 (elt, i, subtype);
1373 if (tree_int_cst_equal (i, max))
1375 i = int_const_binop (PLUS_EXPR, i, integer_one_node, true);
1382 type = TREE_TYPE (type);
1383 instantiate_missing_elements_1 (elt, integer_zero_node, type);
1384 instantiate_missing_elements_1 (elt, integer_one_node, type);
1392 /* Return true if there is only one non aggregate field in the record, TYPE.
1393 Return false otherwise. */
1396 single_scalar_field_in_record_p (tree type)
1400 if (TREE_CODE (type) != RECORD_TYPE)
1403 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1404 if (TREE_CODE (field) == FIELD_DECL)
1408 if (num_fields == 2)
1411 if (AGGREGATE_TYPE_P (TREE_TYPE (field)))
1418 /* Make one pass across an element tree deciding whether to perform block
1419 or element copies. If we decide on element copies, instantiate all
1420 elements. Return true if there are any instantiated sub-elements. */
1423 decide_block_copy (struct sra_elt *elt)
1428 /* We shouldn't be invoked on groups of sub-elements as they must
1429 behave like their parent as far as block copy is concerned. */
1430 gcc_assert (!elt->is_group);
1432 /* If scalarization is disabled, respect it. */
1433 if (elt->cannot_scalarize)
1435 elt->use_block_copy = 1;
1439 fputs ("Scalarization disabled for ", dump_file);
1440 dump_sra_elt_name (dump_file, elt);
1441 fputc ('\n', dump_file);
1444 /* Disable scalarization of sub-elements */
1445 for (c = elt->children; c; c = c->sibling)
1447 c->cannot_scalarize = 1;
1448 decide_block_copy (c);
1451 /* Groups behave like their parent. */
1452 for (c = elt->groups; c; c = c->sibling)
1454 c->cannot_scalarize = 1;
1455 c->use_block_copy = 1;
1461 /* Don't decide if we've no uses. */
1462 if (elt->n_uses == 0 && elt->n_copies == 0)
1465 else if (!elt->is_scalar)
1467 tree size_tree = TYPE_SIZE_UNIT (elt->type);
1468 bool use_block_copy = true;
1470 /* Tradeoffs for COMPLEX types pretty much always make it better
1471 to go ahead and split the components. */
1472 if (TREE_CODE (elt->type) == COMPLEX_TYPE)
1473 use_block_copy = false;
1475 /* Don't bother trying to figure out the rest if the structure is
1476 so large we can't do easy arithmetic. This also forces block
1477 copies for variable sized structures. */
1478 else if (host_integerp (size_tree, 1))
1480 unsigned HOST_WIDE_INT full_size, inst_size = 0;
1481 unsigned int max_size, max_count, inst_count, full_count;
1483 /* If the sra-max-structure-size parameter is 0, then the
1484 user has not overridden the parameter and we can choose a
1485 sensible default. */
1486 max_size = SRA_MAX_STRUCTURE_SIZE
1487 ? SRA_MAX_STRUCTURE_SIZE
1488 : MOVE_RATIO * UNITS_PER_WORD;
1489 max_count = SRA_MAX_STRUCTURE_COUNT
1490 ? SRA_MAX_STRUCTURE_COUNT
1493 full_size = tree_low_cst (size_tree, 1);
1494 full_count = count_type_elements (elt->type, false);
1495 inst_count = sum_instantiated_sizes (elt, &inst_size);
1497 /* If there is only one scalar field in the record, don't block copy. */
1498 if (single_scalar_field_in_record_p (elt->type))
1499 use_block_copy = false;
1501 /* ??? What to do here. If there are two fields, and we've only
1502 instantiated one, then instantiating the other is clearly a win.
1503 If there are a large number of fields then the size of the copy
1504 is much more of a factor. */
1506 /* If the structure is small, and we've made copies, go ahead
1507 and instantiate, hoping that the copies will go away. */
1508 if (full_size <= max_size
1509 && (full_count - inst_count) <= max_count
1510 && elt->n_copies > elt->n_uses)
1511 use_block_copy = false;
1512 else if (inst_count * 100 >= full_count * SRA_FIELD_STRUCTURE_RATIO
1513 && inst_size * 100 >= full_size * SRA_FIELD_STRUCTURE_RATIO)
1514 use_block_copy = false;
1516 /* In order to avoid block copy, we have to be able to instantiate
1517 all elements of the type. See if this is possible. */
1519 && (!can_completely_scalarize_p (elt)
1520 || !type_can_instantiate_all_elements (elt->type)))
1521 use_block_copy = true;
1524 elt->use_block_copy = use_block_copy;
1526 /* Groups behave like their parent. */
1527 for (c = elt->groups; c; c = c->sibling)
1528 c->use_block_copy = use_block_copy;
1532 fprintf (dump_file, "Using %s for ",
1533 use_block_copy ? "block-copy" : "element-copy");
1534 dump_sra_elt_name (dump_file, elt);
1535 fputc ('\n', dump_file);
1538 if (!use_block_copy)
1540 instantiate_missing_elements (elt);
1545 any_inst = elt->replacement != NULL;
1547 for (c = elt->children; c ; c = c->sibling)
1548 any_inst |= decide_block_copy (c);
1553 /* Entry point to phase 3. Instantiate scalar replacement variables. */
1556 decide_instantiations (void)
1560 bitmap_head done_head;
1563 /* We cannot clear bits from a bitmap we're iterating over,
1564 so save up all the bits to clear until the end. */
1565 bitmap_initialize (&done_head, &bitmap_default_obstack);
1566 cleared_any = false;
1568 EXECUTE_IF_SET_IN_BITMAP (sra_candidates, 0, i, bi)
1570 tree var = referenced_var (i);
1571 struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
1574 decide_instantiation_1 (elt, 0, 0);
1575 if (!decide_block_copy (elt))
1580 bitmap_set_bit (&done_head, i);
1587 bitmap_and_compl_into (sra_candidates, &done_head);
1588 bitmap_and_compl_into (needs_copy_in, &done_head);
1590 bitmap_clear (&done_head);
1592 if (!bitmap_empty_p (sra_candidates))
1593 todoflags |= TODO_update_smt_usage;
1595 mark_set_for_renaming (sra_candidates);
1598 fputc ('\n', dump_file);
1602 /* Phase Four: Update the function to match the replacements created. */
1604 /* Mark all the variables in VDEF/VUSE operators for STMT for
1605 renaming. This becomes necessary when we modify all of a
1609 mark_all_v_defs_1 (tree stmt)
1614 update_stmt_if_modified (stmt);
1616 FOR_EACH_SSA_TREE_OPERAND (sym, stmt, iter, SSA_OP_ALL_VIRTUALS)
1618 if (TREE_CODE (sym) == SSA_NAME)
1619 sym = SSA_NAME_VAR (sym);
1620 mark_sym_for_renaming (sym);
1625 /* Mark all the variables in virtual operands in all the statements in
1626 LIST for renaming. */
1629 mark_all_v_defs (tree list)
1631 if (TREE_CODE (list) != STATEMENT_LIST)
1632 mark_all_v_defs_1 (list);
1635 tree_stmt_iterator i;
1636 for (i = tsi_start (list); !tsi_end_p (i); tsi_next (&i))
1637 mark_all_v_defs_1 (tsi_stmt (i));
1642 /* Mark every replacement under ELT with TREE_NO_WARNING. */
1645 mark_no_warning (struct sra_elt *elt)
1647 if (!elt->all_no_warning)
1649 if (elt->replacement)
1650 TREE_NO_WARNING (elt->replacement) = 1;
1654 FOR_EACH_ACTUAL_CHILD (c, elt)
1655 mark_no_warning (c);
1657 elt->all_no_warning = true;
1661 /* Build a single level component reference to ELT rooted at BASE. */
1664 generate_one_element_ref (struct sra_elt *elt, tree base)
1666 switch (TREE_CODE (TREE_TYPE (base)))
1670 tree field = elt->element;
1672 /* Watch out for compatible records with differing field lists. */
1673 if (DECL_FIELD_CONTEXT (field) != TYPE_MAIN_VARIANT (TREE_TYPE (base)))
1674 field = find_compatible_field (TREE_TYPE (base), field);
1676 return build3 (COMPONENT_REF, elt->type, base, field, NULL);
1680 todoflags |= TODO_update_smt_usage;
1681 if (TREE_CODE (elt->element) == RANGE_EXPR)
1682 return build4 (ARRAY_RANGE_REF, elt->type, base,
1683 TREE_OPERAND (elt->element, 0), NULL, NULL);
1685 return build4 (ARRAY_REF, elt->type, base, elt->element, NULL, NULL);
1688 if (elt->element == integer_zero_node)
1689 return build1 (REALPART_EXPR, elt->type, base);
1691 return build1 (IMAGPART_EXPR, elt->type, base);
1698 /* Build a full component reference to ELT rooted at its native variable. */
1701 generate_element_ref (struct sra_elt *elt)
1704 return generate_one_element_ref (elt, generate_element_ref (elt->parent));
1706 return elt->element;
1709 /* Generate a set of assignment statements in *LIST_P to copy all
1710 instantiated elements under ELT to or from the equivalent structure
1711 rooted at EXPR. COPY_OUT controls the direction of the copy, with
1712 true meaning to copy out of EXPR into ELT. */
1715 generate_copy_inout (struct sra_elt *elt, bool copy_out, tree expr,
1721 if (!copy_out && TREE_CODE (expr) == SSA_NAME
1722 && TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
1726 c = lookup_element (elt, integer_zero_node, NULL, NO_INSERT);
1728 c = lookup_element (elt, integer_one_node, NULL, NO_INSERT);
1731 t = build2 (COMPLEX_EXPR, elt->type, r, i);
1732 t = build2 (GIMPLE_MODIFY_STMT, void_type_node, expr, t);
1733 SSA_NAME_DEF_STMT (expr) = t;
1734 append_to_statement_list (t, list_p);
1736 else if (elt->replacement)
1739 t = build2 (GIMPLE_MODIFY_STMT, void_type_node, elt->replacement, expr);
1741 t = build2 (GIMPLE_MODIFY_STMT, void_type_node, expr, elt->replacement);
1742 append_to_statement_list (t, list_p);
1746 FOR_EACH_ACTUAL_CHILD (c, elt)
1748 t = generate_one_element_ref (c, unshare_expr (expr));
1749 generate_copy_inout (c, copy_out, t, list_p);
1754 /* Generate a set of assignment statements in *LIST_P to copy all instantiated
1755 elements under SRC to their counterparts under DST. There must be a 1-1
1756 correspondence of instantiated elements. */
1759 generate_element_copy (struct sra_elt *dst, struct sra_elt *src, tree *list_p)
1761 struct sra_elt *dc, *sc;
1763 FOR_EACH_ACTUAL_CHILD (dc, dst)
1765 sc = lookup_element (src, dc->element, NULL, NO_INSERT);
1767 generate_element_copy (dc, sc, list_p);
1770 if (dst->replacement)
1774 gcc_assert (src->replacement);
1776 t = build2 (GIMPLE_MODIFY_STMT, void_type_node, dst->replacement,
1778 append_to_statement_list (t, list_p);
1782 /* Generate a set of assignment statements in *LIST_P to zero all instantiated
1783 elements under ELT. In addition, do not assign to elements that have been
1784 marked VISITED but do reset the visited flag; this allows easy coordination
1785 with generate_element_init. */
1788 generate_element_zero (struct sra_elt *elt, tree *list_p)
1794 elt->visited = false;
1798 FOR_EACH_ACTUAL_CHILD (c, elt)
1799 generate_element_zero (c, list_p);
1801 if (elt->replacement)
1805 gcc_assert (elt->is_scalar);
1806 t = fold_convert (elt->type, integer_zero_node);
1808 t = build2 (GIMPLE_MODIFY_STMT, void_type_node, elt->replacement, t);
1809 append_to_statement_list (t, list_p);
1813 /* Generate an assignment VAR = INIT, where INIT may need gimplification.
1814 Add the result to *LIST_P. */
1817 generate_one_element_init (tree var, tree init, tree *list_p)
1819 /* The replacement can be almost arbitrarily complex. Gimplify. */
1820 tree stmt = build2 (GIMPLE_MODIFY_STMT, void_type_node, var, init);
1821 gimplify_and_add (stmt, list_p);
1824 /* Generate a set of assignment statements in *LIST_P to set all instantiated
1825 elements under ELT with the contents of the initializer INIT. In addition,
1826 mark all assigned elements VISITED; this allows easy coordination with
1827 generate_element_zero. Return false if we found a case we couldn't
1831 generate_element_init_1 (struct sra_elt *elt, tree init, tree *list_p)
1834 enum tree_code init_code;
1835 struct sra_elt *sub;
1837 unsigned HOST_WIDE_INT idx;
1838 tree value, purpose;
1840 /* We can be passed DECL_INITIAL of a static variable. It might have a
1841 conversion, which we strip off here. */
1842 STRIP_USELESS_TYPE_CONVERSION (init);
1843 init_code = TREE_CODE (init);
1847 if (elt->replacement)
1849 generate_one_element_init (elt->replacement, init, list_p);
1850 elt->visited = true;
1859 FOR_EACH_ACTUAL_CHILD (sub, elt)
1861 if (sub->element == integer_zero_node)
1862 t = (init_code == COMPLEX_EXPR
1863 ? TREE_OPERAND (init, 0) : TREE_REALPART (init));
1865 t = (init_code == COMPLEX_EXPR
1866 ? TREE_OPERAND (init, 1) : TREE_IMAGPART (init));
1867 result &= generate_element_init_1 (sub, t, list_p);
1872 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, purpose, value)
1874 if (TREE_CODE (purpose) == RANGE_EXPR)
1876 tree lower = TREE_OPERAND (purpose, 0);
1877 tree upper = TREE_OPERAND (purpose, 1);
1881 sub = lookup_element (elt, lower, NULL, NO_INSERT);
1883 result &= generate_element_init_1 (sub, value, list_p);
1884 if (tree_int_cst_equal (lower, upper))
1886 lower = int_const_binop (PLUS_EXPR, lower,
1887 integer_one_node, true);
1892 sub = lookup_element (elt, purpose, NULL, NO_INSERT);
1894 result &= generate_element_init_1 (sub, value, list_p);
1900 elt->visited = true;
1907 /* A wrapper function for generate_element_init_1 that handles cleanup after
1911 generate_element_init (struct sra_elt *elt, tree init, tree *list_p)
1915 push_gimplify_context ();
1916 ret = generate_element_init_1 (elt, init, list_p);
1917 pop_gimplify_context (NULL);
1919 /* The replacement can expose previously unreferenced variables. */
1922 tree_stmt_iterator i;
1924 for (i = tsi_start (*list_p); !tsi_end_p (i); tsi_next (&i))
1925 find_new_referenced_vars (tsi_stmt_ptr (i));
1931 /* Insert STMT on all the outgoing edges out of BB. Note that if BB
1932 has more than one edge, STMT will be replicated for each edge. Also,
1933 abnormal edges will be ignored. */
1936 insert_edge_copies (tree stmt, basic_block bb)
1943 FOR_EACH_EDGE (e, ei, bb->succs)
1945 /* We don't need to insert copies on abnormal edges. The
1946 value of the scalar replacement is not guaranteed to
1947 be valid through an abnormal edge. */
1948 if (!(e->flags & EDGE_ABNORMAL))
1952 bsi_insert_on_edge (e, stmt);
1956 bsi_insert_on_edge (e, unsave_expr_now (stmt));
1961 /* Helper function to insert LIST before BSI, and set up line number info. */
1964 sra_insert_before (block_stmt_iterator *bsi, tree list)
1966 tree stmt = bsi_stmt (*bsi);
1968 if (EXPR_HAS_LOCATION (stmt))
1969 annotate_all_with_locus (&list, EXPR_LOCATION (stmt));
1970 bsi_insert_before (bsi, list, BSI_SAME_STMT);
1973 /* Similarly, but insert after BSI. Handles insertion onto edges as well. */
1976 sra_insert_after (block_stmt_iterator *bsi, tree list)
1978 tree stmt = bsi_stmt (*bsi);
1980 if (EXPR_HAS_LOCATION (stmt))
1981 annotate_all_with_locus (&list, EXPR_LOCATION (stmt));
1983 if (stmt_ends_bb_p (stmt))
1984 insert_edge_copies (list, bsi->bb);
1986 bsi_insert_after (bsi, list, BSI_SAME_STMT);
1989 /* Similarly, but replace the statement at BSI. */
1992 sra_replace (block_stmt_iterator *bsi, tree list)
1994 sra_insert_before (bsi, list);
1995 bsi_remove (bsi, false);
1996 if (bsi_end_p (*bsi))
1997 *bsi = bsi_last (bsi->bb);
2002 /* Scalarize a USE. To recap, this is either a simple reference to ELT,
2003 if elt is scalar, or some occurrence of ELT that requires a complete
2004 aggregate. IS_OUTPUT is true if ELT is being modified. */
2007 scalarize_use (struct sra_elt *elt, tree *expr_p, block_stmt_iterator *bsi,
2008 bool is_output, bool use_all)
2010 tree list = NULL, stmt = bsi_stmt (*bsi);
2012 if (elt->replacement)
2014 /* If we have a replacement, then updating the reference is as
2015 simple as modifying the existing statement in place. */
2017 mark_all_v_defs (stmt);
2018 *expr_p = elt->replacement;
2023 /* Otherwise we need some copies. If ELT is being read, then we want
2024 to store all (modified) sub-elements back into the structure before
2025 the reference takes place. If ELT is being written, then we want to
2026 load the changed values back into our shadow variables. */
2027 /* ??? We don't check modified for reads, we just always write all of
2028 the values. We should be able to record the SSA number of the VOP
2029 for which the values were last read. If that number matches the
2030 SSA number of the VOP in the current statement, then we needn't
2031 emit an assignment. This would also eliminate double writes when
2032 a structure is passed as more than one argument to a function call.
2033 This optimization would be most effective if sra_walk_function
2034 processed the blocks in dominator order. */
2036 generate_copy_inout (elt, is_output, generate_element_ref (elt), &list);
2039 mark_all_v_defs (list);
2041 sra_insert_after (bsi, list);
2044 sra_insert_before (bsi, list);
2046 mark_no_warning (elt);
2051 /* Scalarize a COPY. To recap, this is an assignment statement between
2052 two scalarizable references, LHS_ELT and RHS_ELT. */
2055 scalarize_copy (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
2056 block_stmt_iterator *bsi)
2060 if (lhs_elt->replacement && rhs_elt->replacement)
2062 /* If we have two scalar operands, modify the existing statement. */
2063 stmt = bsi_stmt (*bsi);
2065 /* See the commentary in sra_walk_function concerning
2066 RETURN_EXPR, and why we should never see one here. */
2067 gcc_assert (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT);
2069 GIMPLE_STMT_OPERAND (stmt, 0) = lhs_elt->replacement;
2070 GIMPLE_STMT_OPERAND (stmt, 1) = rhs_elt->replacement;
2073 else if (lhs_elt->use_block_copy || rhs_elt->use_block_copy)
2075 /* If either side requires a block copy, then sync the RHS back
2076 to the original structure, leave the original assignment
2077 statement (which will perform the block copy), then load the
2078 LHS values out of its now-updated original structure. */
2079 /* ??? Could perform a modified pair-wise element copy. That
2080 would at least allow those elements that are instantiated in
2081 both structures to be optimized well. */
2084 generate_copy_inout (rhs_elt, false,
2085 generate_element_ref (rhs_elt), &list);
2088 mark_all_v_defs (list);
2089 sra_insert_before (bsi, list);
2093 generate_copy_inout (lhs_elt, true,
2094 generate_element_ref (lhs_elt), &list);
2097 mark_all_v_defs (list);
2098 sra_insert_after (bsi, list);
2103 /* Otherwise both sides must be fully instantiated. In which
2104 case perform pair-wise element assignments and replace the
2105 original block copy statement. */
2107 stmt = bsi_stmt (*bsi);
2108 mark_all_v_defs (stmt);
2111 generate_element_copy (lhs_elt, rhs_elt, &list);
2113 mark_all_v_defs (list);
2114 sra_replace (bsi, list);
2118 /* Scalarize an INIT. To recap, this is an assignment to a scalarizable
2119 reference from some form of constructor: CONSTRUCTOR, COMPLEX_CST or
2120 COMPLEX_EXPR. If RHS is NULL, it should be treated as an empty
2124 scalarize_init (struct sra_elt *lhs_elt, tree rhs, block_stmt_iterator *bsi)
2129 /* Generate initialization statements for all members extant in the RHS. */
2132 /* Unshare the expression just in case this is from a decl's initial. */
2133 rhs = unshare_expr (rhs);
2134 result = generate_element_init (lhs_elt, rhs, &list);
2137 /* CONSTRUCTOR is defined such that any member not mentioned is assigned
2138 a zero value. Initialize the rest of the instantiated elements. */
2139 generate_element_zero (lhs_elt, &list);
2143 /* If we failed to convert the entire initializer, then we must
2144 leave the structure assignment in place and must load values
2145 from the structure into the slots for which we did not find
2146 constants. The easiest way to do this is to generate a complete
2147 copy-out, and then follow that with the constant assignments
2148 that we were able to build. DCE will clean things up. */
2150 generate_copy_inout (lhs_elt, true, generate_element_ref (lhs_elt),
2152 append_to_statement_list (list, &list0);
2156 if (lhs_elt->use_block_copy || !result)
2158 /* Since LHS is not fully instantiated, we must leave the structure
2159 assignment in place. Treating this case differently from a USE
2160 exposes constants to later optimizations. */
2163 mark_all_v_defs (list);
2164 sra_insert_after (bsi, list);
2169 /* The LHS is fully instantiated. The list of initializations
2170 replaces the original structure assignment. */
2172 mark_all_v_defs (bsi_stmt (*bsi));
2173 mark_all_v_defs (list);
2174 sra_replace (bsi, list);
2178 /* A subroutine of scalarize_ldst called via walk_tree. Set TREE_NO_TRAP
2179 on all INDIRECT_REFs. */
2182 mark_notrap (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
2186 if (TREE_CODE (t) == INDIRECT_REF)
2188 TREE_THIS_NOTRAP (t) = 1;
2191 else if (IS_TYPE_OR_DECL_P (t))
2197 /* Scalarize a LDST. To recap, this is an assignment between one scalarizable
2198 reference ELT and one non-scalarizable reference OTHER. IS_OUTPUT is true
2199 if ELT is on the left-hand side. */
2202 scalarize_ldst (struct sra_elt *elt, tree other,
2203 block_stmt_iterator *bsi, bool is_output)
2205 /* Shouldn't have gotten called for a scalar. */
2206 gcc_assert (!elt->replacement);
2208 if (elt->use_block_copy)
2210 /* Since ELT is not fully instantiated, we have to leave the
2211 block copy in place. Treat this as a USE. */
2212 scalarize_use (elt, NULL, bsi, is_output, false);
2216 /* The interesting case is when ELT is fully instantiated. In this
2217 case we can have each element stored/loaded directly to/from the
2218 corresponding slot in OTHER. This avoids a block copy. */
2220 tree list = NULL, stmt = bsi_stmt (*bsi);
2222 mark_all_v_defs (stmt);
2223 generate_copy_inout (elt, is_output, other, &list);
2224 mark_all_v_defs (list);
2227 /* Preserve EH semantics. */
2228 if (stmt_ends_bb_p (stmt))
2230 tree_stmt_iterator tsi;
2233 /* Extract the first statement from LIST. */
2234 tsi = tsi_start (list);
2235 first = tsi_stmt (tsi);
2238 /* Replace the old statement with this new representative. */
2239 bsi_replace (bsi, first, true);
2241 if (!tsi_end_p (tsi))
2243 /* If any reference would trap, then they all would. And more
2244 to the point, the first would. Therefore none of the rest
2245 will trap since the first didn't. Indicate this by
2246 iterating over the remaining statements and set
2247 TREE_THIS_NOTRAP in all INDIRECT_REFs. */
2250 walk_tree (tsi_stmt_ptr (tsi), mark_notrap, NULL, NULL);
2253 while (!tsi_end_p (tsi));
2255 insert_edge_copies (list, bsi->bb);
2259 sra_replace (bsi, list);
2263 /* Generate initializations for all scalarizable parameters. */
2266 scalarize_parms (void)
2272 EXECUTE_IF_SET_IN_BITMAP (needs_copy_in, 0, i, bi)
2274 tree var = referenced_var (i);
2275 struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
2276 generate_copy_inout (elt, true, var, &list);
2281 insert_edge_copies (list, ENTRY_BLOCK_PTR);
2282 mark_all_v_defs (list);
2286 /* Entry point to phase 4. Update the function to match replacements. */
2289 scalarize_function (void)
2291 static const struct sra_walk_fns fns = {
2292 scalarize_use, scalarize_copy, scalarize_init, scalarize_ldst, false
2295 sra_walk_function (&fns);
2297 bsi_commit_edge_inserts ();
2301 /* Debug helper function. Print ELT in a nice human-readable format. */
2304 dump_sra_elt_name (FILE *f, struct sra_elt *elt)
2306 if (elt->parent && TREE_CODE (elt->parent->type) == COMPLEX_TYPE)
2308 fputs (elt->element == integer_zero_node ? "__real__ " : "__imag__ ", f);
2309 dump_sra_elt_name (f, elt->parent);
2314 dump_sra_elt_name (f, elt->parent);
2315 if (DECL_P (elt->element))
2317 if (TREE_CODE (elt->element) == FIELD_DECL)
2319 print_generic_expr (f, elt->element, dump_flags);
2321 else if (TREE_CODE (elt->element) == RANGE_EXPR)
2322 fprintf (f, "["HOST_WIDE_INT_PRINT_DEC".."HOST_WIDE_INT_PRINT_DEC"]",
2323 TREE_INT_CST_LOW (TREE_OPERAND (elt->element, 0)),
2324 TREE_INT_CST_LOW (TREE_OPERAND (elt->element, 1)));
2326 fprintf (f, "[" HOST_WIDE_INT_PRINT_DEC "]",
2327 TREE_INT_CST_LOW (elt->element));
2331 /* Likewise, but callable from the debugger. */
2334 debug_sra_elt_name (struct sra_elt *elt)
2336 dump_sra_elt_name (stderr, elt);
2337 fputc ('\n', stderr);
2341 sra_init_cache (void)
2343 if (sra_type_decomp_cache)
2346 sra_type_decomp_cache = BITMAP_ALLOC (NULL);
2347 sra_type_inst_cache = BITMAP_ALLOC (NULL);
2350 /* Main entry point. */
2355 /* Initialize local variables. */
2357 gcc_obstack_init (&sra_obstack);
2358 sra_candidates = BITMAP_ALLOC (NULL);
2359 needs_copy_in = BITMAP_ALLOC (NULL);
2361 sra_map = htab_create (101, sra_elt_hash, sra_elt_eq, NULL);
2363 /* Scan. If we find anything, instantiate and scalarize. */
2364 if (find_candidates_for_sra ())
2367 decide_instantiations ();
2368 scalarize_function ();
2371 /* Free allocated memory. */
2372 htab_delete (sra_map);
2374 BITMAP_FREE (sra_candidates);
2375 BITMAP_FREE (needs_copy_in);
2376 BITMAP_FREE (sra_type_decomp_cache);
2377 BITMAP_FREE (sra_type_inst_cache);
2378 obstack_free (&sra_obstack, NULL);
2383 tree_sra_early (void)
2397 return flag_tree_sra != 0;
2400 struct tree_opt_pass pass_sra_early =
2403 gate_sra, /* gate */
2404 tree_sra_early, /* execute */
2407 0, /* static_pass_number */
2408 TV_TREE_SRA, /* tv_id */
2409 PROP_cfg | PROP_ssa, /* properties_required */
2410 0, /* properties_provided */
2411 0, /* properties_destroyed */
2412 0, /* todo_flags_start */
2416 | TODO_verify_ssa, /* todo_flags_finish */
2420 struct tree_opt_pass pass_sra =
2423 gate_sra, /* gate */
2424 tree_sra, /* execute */
2427 0, /* static_pass_number */
2428 TV_TREE_SRA, /* tv_id */
2429 PROP_cfg | PROP_ssa, /* properties_required */
2430 0, /* properties_provided */
2431 0, /* properties_destroyed */
2432 0, /* todo_flags_start */
2436 | TODO_verify_ssa, /* todo_flags_finish */