1 /* Scalar Replacement of Aggregates (SRA) converts some structure
2 references into scalar references, exposing them to the scalar
4 Copyright (C) 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
6 Contributed by Diego Novillo <dnovillo@redhat.com>
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 3, or (at your option) any
15 GCC is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
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. */
150 /* 1 if the element is a field that is part of a block, 2 if the field
151 is the block itself, 0 if it's neither. */
152 char in_bitfld_block
;
155 #define IS_ELEMENT_FOR_GROUP(ELEMENT) (TREE_CODE (ELEMENT) == RANGE_EXPR)
157 #define FOR_EACH_ACTUAL_CHILD(CHILD, ELT) \
158 for ((CHILD) = (ELT)->is_group \
159 ? next_child_for_group (NULL, (ELT)) \
162 (CHILD) = (ELT)->is_group \
163 ? next_child_for_group ((CHILD), (ELT)) \
166 /* Helper function for above macro. Return next child in group. */
167 static struct sra_elt
*
168 next_child_for_group (struct sra_elt
*child
, struct sra_elt
*group
)
170 gcc_assert (group
->is_group
);
172 /* Find the next child in the parent. */
174 child
= child
->sibling
;
176 child
= group
->parent
->children
;
178 /* Skip siblings that do not belong to the group. */
181 tree g_elt
= group
->element
;
182 if (TREE_CODE (g_elt
) == RANGE_EXPR
)
184 if (!tree_int_cst_lt (child
->element
, TREE_OPERAND (g_elt
, 0))
185 && !tree_int_cst_lt (TREE_OPERAND (g_elt
, 1), child
->element
))
191 child
= child
->sibling
;
197 /* Random access to the child of a parent is performed by hashing.
198 This prevents quadratic behavior, and allows SRA to function
199 reasonably on larger records. */
200 static htab_t sra_map
;
202 /* All structures are allocated out of the following obstack. */
203 static struct obstack sra_obstack
;
205 /* Debugging functions. */
206 static void dump_sra_elt_name (FILE *, struct sra_elt
*);
207 extern void debug_sra_elt_name (struct sra_elt
*);
209 /* Forward declarations. */
210 static tree
generate_element_ref (struct sra_elt
*);
211 static tree
sra_build_assignment (tree dst
, tree src
);
212 static void mark_all_v_defs (tree list
);
215 /* Return true if DECL is an SRA candidate. */
218 is_sra_candidate_decl (tree decl
)
220 return DECL_P (decl
) && bitmap_bit_p (sra_candidates
, DECL_UID (decl
));
223 /* Return true if TYPE is a scalar type. */
226 is_sra_scalar_type (tree type
)
228 enum tree_code code
= TREE_CODE (type
);
229 return (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== VECTOR_TYPE
230 || code
== FIXED_POINT_TYPE
231 || code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
232 || code
== POINTER_TYPE
|| code
== OFFSET_TYPE
233 || code
== REFERENCE_TYPE
);
236 /* Return true if TYPE can be decomposed into a set of independent variables.
238 Note that this doesn't imply that all elements of TYPE can be
239 instantiated, just that if we decide to break up the type into
240 separate pieces that it can be done. */
243 sra_type_can_be_decomposed_p (tree type
)
245 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
248 /* Avoid searching the same type twice. */
249 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+0))
251 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+1))
254 /* The type must have a definite nonzero size. */
255 if (TYPE_SIZE (type
) == NULL
|| TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
256 || integer_zerop (TYPE_SIZE (type
)))
259 /* The type must be a non-union aggregate. */
260 switch (TREE_CODE (type
))
264 bool saw_one_field
= false;
266 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
267 if (TREE_CODE (t
) == FIELD_DECL
)
269 /* Reject incorrectly represented bit fields. */
270 if (DECL_BIT_FIELD (t
)
271 && (tree_low_cst (DECL_SIZE (t
), 1)
272 != TYPE_PRECISION (TREE_TYPE (t
))))
275 saw_one_field
= true;
278 /* Record types must have at least one field. */
285 /* Array types must have a fixed lower and upper bound. */
286 t
= TYPE_DOMAIN (type
);
289 if (TYPE_MIN_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MIN_VALUE (t
)))
291 if (TYPE_MAX_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MAX_VALUE (t
)))
302 bitmap_set_bit (sra_type_decomp_cache
, cache
+0);
306 bitmap_set_bit (sra_type_decomp_cache
, cache
+1);
310 /* Return true if DECL can be decomposed into a set of independent
311 (though not necessarily scalar) variables. */
314 decl_can_be_decomposed_p (tree var
)
316 /* Early out for scalars. */
317 if (is_sra_scalar_type (TREE_TYPE (var
)))
320 /* The variable must not be aliased. */
321 if (!is_gimple_non_addressable (var
))
323 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
325 fprintf (dump_file
, "Cannot scalarize variable ");
326 print_generic_expr (dump_file
, var
, dump_flags
);
327 fprintf (dump_file
, " because it must live in memory\n");
332 /* The variable must not be volatile. */
333 if (TREE_THIS_VOLATILE (var
))
335 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
337 fprintf (dump_file
, "Cannot scalarize variable ");
338 print_generic_expr (dump_file
, var
, dump_flags
);
339 fprintf (dump_file
, " because it is declared volatile\n");
344 /* We must be able to decompose the variable's type. */
345 if (!sra_type_can_be_decomposed_p (TREE_TYPE (var
)))
347 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
349 fprintf (dump_file
, "Cannot scalarize variable ");
350 print_generic_expr (dump_file
, var
, dump_flags
);
351 fprintf (dump_file
, " because its type cannot be decomposed\n");
356 /* HACK: if we decompose a va_list_type_node before inlining, then we'll
357 confuse tree-stdarg.c, and we won't be able to figure out which and
358 how many arguments are accessed. This really should be improved in
359 tree-stdarg.c, as the decomposition is truely a win. This could also
360 be fixed if the stdarg pass ran early, but this can't be done until
361 we've aliasing information early too. See PR 30791. */
363 && TYPE_MAIN_VARIANT (TREE_TYPE (var
))
364 == TYPE_MAIN_VARIANT (va_list_type_node
))
370 /* Return true if TYPE can be *completely* decomposed into scalars. */
373 type_can_instantiate_all_elements (tree type
)
375 if (is_sra_scalar_type (type
))
377 if (!sra_type_can_be_decomposed_p (type
))
380 switch (TREE_CODE (type
))
384 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
387 if (bitmap_bit_p (sra_type_inst_cache
, cache
+0))
389 if (bitmap_bit_p (sra_type_inst_cache
, cache
+1))
392 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
393 if (TREE_CODE (f
) == FIELD_DECL
)
395 if (!type_can_instantiate_all_elements (TREE_TYPE (f
)))
397 bitmap_set_bit (sra_type_inst_cache
, cache
+1);
402 bitmap_set_bit (sra_type_inst_cache
, cache
+0);
407 return type_can_instantiate_all_elements (TREE_TYPE (type
));
417 /* Test whether ELT or some sub-element cannot be scalarized. */
420 can_completely_scalarize_p (struct sra_elt
*elt
)
424 if (elt
->cannot_scalarize
)
427 for (c
= elt
->children
; c
; c
= c
->sibling
)
428 if (!can_completely_scalarize_p (c
))
431 for (c
= elt
->groups
; c
; c
= c
->sibling
)
432 if (!can_completely_scalarize_p (c
))
439 /* A simplified tree hashing algorithm that only handles the types of
440 trees we expect to find in sra_elt->element. */
443 sra_hash_tree (tree t
)
447 switch (TREE_CODE (t
))
456 h
= TREE_INT_CST_LOW (t
) ^ TREE_INT_CST_HIGH (t
);
460 h
= iterative_hash_expr (TREE_OPERAND (t
, 0), 0);
461 h
= iterative_hash_expr (TREE_OPERAND (t
, 1), h
);
465 /* We can have types that are compatible, but have different member
466 lists, so we can't hash fields by ID. Use offsets instead. */
467 h
= iterative_hash_expr (DECL_FIELD_OFFSET (t
), 0);
468 h
= iterative_hash_expr (DECL_FIELD_BIT_OFFSET (t
), h
);
472 /* Don't take operand 0 into account, that's our parent. */
473 h
= iterative_hash_expr (TREE_OPERAND (t
, 1), 0);
474 h
= iterative_hash_expr (TREE_OPERAND (t
, 2), h
);
484 /* Hash function for type SRA_PAIR. */
487 sra_elt_hash (const void *x
)
489 const struct sra_elt
*e
= x
;
490 const struct sra_elt
*p
;
493 h
= sra_hash_tree (e
->element
);
495 /* Take into account everything except bitfield blocks back up the
496 chain. Given that chain lengths are rarely very long, this
497 should be acceptable. If we truly identify this as a performance
498 problem, it should work to hash the pointer value
500 for (p
= e
->parent
; p
; p
= p
->parent
)
501 if (!p
->in_bitfld_block
)
502 h
= (h
* 65521) ^ sra_hash_tree (p
->element
);
507 /* Equality function for type SRA_PAIR. */
510 sra_elt_eq (const void *x
, const void *y
)
512 const struct sra_elt
*a
= x
;
513 const struct sra_elt
*b
= y
;
515 const struct sra_elt
*ap
= a
->parent
;
516 const struct sra_elt
*bp
= b
->parent
;
519 while (ap
->in_bitfld_block
)
522 while (bp
->in_bitfld_block
)
533 if (TREE_CODE (ae
) != TREE_CODE (be
))
536 switch (TREE_CODE (ae
))
541 /* These are all pointer unique. */
545 /* Integers are not pointer unique, so compare their values. */
546 return tree_int_cst_equal (ae
, be
);
550 tree_int_cst_equal (TREE_OPERAND (ae
, 0), TREE_OPERAND (be
, 0))
551 && tree_int_cst_equal (TREE_OPERAND (ae
, 1), TREE_OPERAND (be
, 1));
554 /* Fields are unique within a record, but not between
555 compatible records. */
556 if (DECL_FIELD_CONTEXT (ae
) == DECL_FIELD_CONTEXT (be
))
558 return fields_compatible_p (ae
, be
);
562 tree_int_cst_equal (TREE_OPERAND (ae
, 1), TREE_OPERAND (be
, 1))
563 && tree_int_cst_equal (TREE_OPERAND (ae
, 2), TREE_OPERAND (be
, 2));
570 /* Create or return the SRA_ELT structure for CHILD in PARENT. PARENT
571 may be null, in which case CHILD must be a DECL. */
573 static struct sra_elt
*
574 lookup_element (struct sra_elt
*parent
, tree child
, tree type
,
575 enum insert_option insert
)
577 struct sra_elt dummy
;
578 struct sra_elt
**slot
;
582 dummy
.parent
= parent
->is_group
? parent
->parent
: parent
;
585 dummy
.element
= child
;
587 slot
= (struct sra_elt
**) htab_find_slot (sra_map
, &dummy
, insert
);
588 if (!slot
&& insert
== NO_INSERT
)
592 if (!elt
&& insert
== INSERT
)
594 *slot
= elt
= obstack_alloc (&sra_obstack
, sizeof (*elt
));
595 memset (elt
, 0, sizeof (*elt
));
597 elt
->parent
= parent
;
598 elt
->element
= child
;
600 elt
->is_scalar
= is_sra_scalar_type (type
);
604 if (IS_ELEMENT_FOR_GROUP (elt
->element
))
606 elt
->is_group
= true;
607 elt
->sibling
= parent
->groups
;
608 parent
->groups
= elt
;
612 elt
->sibling
= parent
->children
;
613 parent
->children
= elt
;
617 /* If this is a parameter, then if we want to scalarize, we have
618 one copy from the true function parameter. Count it now. */
619 if (TREE_CODE (child
) == PARM_DECL
)
622 bitmap_set_bit (needs_copy_in
, DECL_UID (child
));
629 /* Create or return the SRA_ELT structure for EXPR if the expression
630 refers to a scalarizable variable. */
632 static struct sra_elt
*
633 maybe_lookup_element_for_expr (tree expr
)
638 switch (TREE_CODE (expr
))
643 if (is_sra_candidate_decl (expr
))
644 return lookup_element (NULL
, expr
, TREE_TYPE (expr
), INSERT
);
648 /* We can't scalarize variable array indices. */
649 if (in_array_bounds_p (expr
))
650 child
= TREE_OPERAND (expr
, 1);
655 case ARRAY_RANGE_REF
:
656 /* We can't scalarize variable array indices. */
657 if (range_in_array_bounds_p (expr
))
659 tree domain
= TYPE_DOMAIN (TREE_TYPE (expr
));
660 child
= build2 (RANGE_EXPR
, integer_type_node
,
661 TYPE_MIN_VALUE (domain
), TYPE_MAX_VALUE (domain
));
669 tree type
= TREE_TYPE (TREE_OPERAND (expr
, 0));
670 /* Don't look through unions. */
671 if (TREE_CODE (type
) != RECORD_TYPE
)
673 /* Neither through variable-sized records. */
674 if (TYPE_SIZE (type
) == NULL_TREE
675 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
677 child
= TREE_OPERAND (expr
, 1);
682 child
= integer_zero_node
;
685 child
= integer_one_node
;
692 elt
= maybe_lookup_element_for_expr (TREE_OPERAND (expr
, 0));
694 return lookup_element (elt
, child
, TREE_TYPE (expr
), INSERT
);
699 /* Functions to walk just enough of the tree to see all scalarizable
700 references, and categorize them. */
702 /* A set of callbacks for phases 2 and 4. They'll be invoked for the
703 various kinds of references seen. In all cases, *BSI is an iterator
704 pointing to the statement being processed. */
707 /* Invoked when ELT is required as a unit. Note that ELT might refer to
708 a leaf node, in which case this is a simple scalar reference. *EXPR_P
709 points to the location of the expression. IS_OUTPUT is true if this
710 is a left-hand-side reference. USE_ALL is true if we saw something we
711 couldn't quite identify and had to force the use of the entire object. */
712 void (*use
) (struct sra_elt
*elt
, tree
*expr_p
,
713 block_stmt_iterator
*bsi
, bool is_output
, bool use_all
);
715 /* Invoked when we have a copy between two scalarizable references. */
716 void (*copy
) (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
717 block_stmt_iterator
*bsi
);
719 /* Invoked when ELT is initialized from a constant. VALUE may be NULL,
720 in which case it should be treated as an empty CONSTRUCTOR. */
721 void (*init
) (struct sra_elt
*elt
, tree value
, block_stmt_iterator
*bsi
);
723 /* Invoked when we have a copy between one scalarizable reference ELT
724 and one non-scalarizable reference OTHER without side-effects.
725 IS_OUTPUT is true if ELT is on the left-hand side. */
726 void (*ldst
) (struct sra_elt
*elt
, tree other
,
727 block_stmt_iterator
*bsi
, bool is_output
);
729 /* True during phase 2, false during phase 4. */
730 /* ??? This is a hack. */
734 #ifdef ENABLE_CHECKING
735 /* Invoked via walk_tree, if *TP contains a candidate decl, return it. */
738 sra_find_candidate_decl (tree
*tp
, int *walk_subtrees
,
739 void *data ATTRIBUTE_UNUSED
)
742 enum tree_code code
= TREE_CODE (t
);
744 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
747 if (is_sra_candidate_decl (t
))
757 /* Walk most expressions looking for a scalarizable aggregate.
758 If we find one, invoke FNS->USE. */
761 sra_walk_expr (tree
*expr_p
, block_stmt_iterator
*bsi
, bool is_output
,
762 const struct sra_walk_fns
*fns
)
766 bool disable_scalarization
= false;
767 bool use_all_p
= false;
769 /* We're looking to collect a reference expression between EXPR and INNER,
770 such that INNER is a scalarizable decl and all other nodes through EXPR
771 are references that we can scalarize. If we come across something that
772 we can't scalarize, we reset EXPR. This has the effect of making it
773 appear that we're referring to the larger expression as a whole. */
776 switch (TREE_CODE (inner
))
781 /* If there is a scalarizable decl at the bottom, then process it. */
782 if (is_sra_candidate_decl (inner
))
784 struct sra_elt
*elt
= maybe_lookup_element_for_expr (expr
);
785 if (disable_scalarization
)
786 elt
->cannot_scalarize
= true;
788 fns
->use (elt
, expr_p
, bsi
, is_output
, use_all_p
);
793 /* Non-constant index means any member may be accessed. Prevent the
794 expression from being scalarized. If we were to treat this as a
795 reference to the whole array, we can wind up with a single dynamic
796 index reference inside a loop being overridden by several constant
797 index references during loop setup. It's possible that this could
798 be avoided by using dynamic usage counts based on BB trip counts
799 (based on loop analysis or profiling), but that hardly seems worth
801 /* ??? Hack. Figure out how to push this into the scan routines
802 without duplicating too much code. */
803 if (!in_array_bounds_p (inner
))
805 disable_scalarization
= true;
808 /* ??? Are we assured that non-constant bounds and stride will have
809 the same value everywhere? I don't think Fortran will... */
810 if (TREE_OPERAND (inner
, 2) || TREE_OPERAND (inner
, 3))
812 inner
= TREE_OPERAND (inner
, 0);
815 case ARRAY_RANGE_REF
:
816 if (!range_in_array_bounds_p (inner
))
818 disable_scalarization
= true;
821 /* ??? See above non-constant bounds and stride . */
822 if (TREE_OPERAND (inner
, 2) || TREE_OPERAND (inner
, 3))
824 inner
= TREE_OPERAND (inner
, 0);
829 tree type
= TREE_TYPE (TREE_OPERAND (inner
, 0));
830 /* Don't look through unions. */
831 if (TREE_CODE (type
) != RECORD_TYPE
)
833 /* Neither through variable-sized records. */
834 if (TYPE_SIZE (type
) == NULL_TREE
835 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
837 inner
= TREE_OPERAND (inner
, 0);
843 inner
= TREE_OPERAND (inner
, 0);
847 /* A bit field reference to a specific vector is scalarized but for
848 ones for inputs need to be marked as used on the left hand size so
849 when we scalarize it, we can mark that variable as non renamable. */
851 && TREE_CODE (TREE_TYPE (TREE_OPERAND (inner
, 0))) == VECTOR_TYPE
)
854 = maybe_lookup_element_for_expr (TREE_OPERAND (inner
, 0));
856 elt
->is_vector_lhs
= true;
858 /* A bit field reference (access to *multiple* fields simultaneously)
859 is not currently scalarized. Consider this an access to the
860 complete outer element, to which walk_tree will bring us next. */
864 case VIEW_CONVERT_EXPR
:
866 /* Similarly, a view/nop explicitly wants to look at an object in a
867 type other than the one we've scalarized. */
871 /* This is a transparent wrapper. The entire inner expression really
876 expr_p
= &TREE_OPERAND (inner
, 0);
877 inner
= expr
= *expr_p
;
882 #ifdef ENABLE_CHECKING
883 /* Validate that we're not missing any references. */
884 gcc_assert (!walk_tree (&inner
, sra_find_candidate_decl
, NULL
, NULL
));
890 /* Walk a TREE_LIST of values looking for scalarizable aggregates.
891 If we find one, invoke FNS->USE. */
894 sra_walk_tree_list (tree list
, block_stmt_iterator
*bsi
, bool is_output
,
895 const struct sra_walk_fns
*fns
)
898 for (op
= list
; op
; op
= TREE_CHAIN (op
))
899 sra_walk_expr (&TREE_VALUE (op
), bsi
, is_output
, fns
);
902 /* Walk the arguments of a CALL_EXPR looking for scalarizable aggregates.
903 If we find one, invoke FNS->USE. */
906 sra_walk_call_expr (tree expr
, block_stmt_iterator
*bsi
,
907 const struct sra_walk_fns
*fns
)
910 int nargs
= call_expr_nargs (expr
);
911 for (i
= 0; i
< nargs
; i
++)
912 sra_walk_expr (&CALL_EXPR_ARG (expr
, i
), bsi
, false, fns
);
915 /* Walk the inputs and outputs of an ASM_EXPR looking for scalarizable
916 aggregates. If we find one, invoke FNS->USE. */
919 sra_walk_asm_expr (tree expr
, block_stmt_iterator
*bsi
,
920 const struct sra_walk_fns
*fns
)
922 sra_walk_tree_list (ASM_INPUTS (expr
), bsi
, false, fns
);
923 sra_walk_tree_list (ASM_OUTPUTS (expr
), bsi
, true, fns
);
926 /* Walk a GIMPLE_MODIFY_STMT and categorize the assignment appropriately. */
929 sra_walk_gimple_modify_stmt (tree expr
, block_stmt_iterator
*bsi
,
930 const struct sra_walk_fns
*fns
)
932 struct sra_elt
*lhs_elt
, *rhs_elt
;
935 lhs
= GIMPLE_STMT_OPERAND (expr
, 0);
936 rhs
= GIMPLE_STMT_OPERAND (expr
, 1);
937 lhs_elt
= maybe_lookup_element_for_expr (lhs
);
938 rhs_elt
= maybe_lookup_element_for_expr (rhs
);
940 /* If both sides are scalarizable, this is a COPY operation. */
941 if (lhs_elt
&& rhs_elt
)
943 fns
->copy (lhs_elt
, rhs_elt
, bsi
);
947 /* If the RHS is scalarizable, handle it. There are only two cases. */
950 if (!rhs_elt
->is_scalar
&& !TREE_SIDE_EFFECTS (lhs
))
951 fns
->ldst (rhs_elt
, lhs
, bsi
, false);
953 fns
->use (rhs_elt
, &GIMPLE_STMT_OPERAND (expr
, 1), bsi
, false, false);
956 /* If it isn't scalarizable, there may be scalarizable variables within, so
957 check for a call or else walk the RHS to see if we need to do any
958 copy-in operations. We need to do it before the LHS is scalarized so
959 that the statements get inserted in the proper place, before any
960 copy-out operations. */
963 tree call
= get_call_expr_in (rhs
);
965 sra_walk_call_expr (call
, bsi
, fns
);
967 sra_walk_expr (&GIMPLE_STMT_OPERAND (expr
, 1), bsi
, false, fns
);
970 /* Likewise, handle the LHS being scalarizable. We have cases similar
971 to those above, but also want to handle RHS being constant. */
974 /* If this is an assignment from a constant, or constructor, then
975 we have access to all of the elements individually. Invoke INIT. */
976 if (TREE_CODE (rhs
) == COMPLEX_EXPR
977 || TREE_CODE (rhs
) == COMPLEX_CST
978 || TREE_CODE (rhs
) == CONSTRUCTOR
)
979 fns
->init (lhs_elt
, rhs
, bsi
);
981 /* If this is an assignment from read-only memory, treat this as if
982 we'd been passed the constructor directly. Invoke INIT. */
983 else if (TREE_CODE (rhs
) == VAR_DECL
985 && TREE_READONLY (rhs
)
986 && targetm
.binds_local_p (rhs
))
987 fns
->init (lhs_elt
, DECL_INITIAL (rhs
), bsi
);
989 /* If this is a copy from a non-scalarizable lvalue, invoke LDST.
990 The lvalue requirement prevents us from trying to directly scalarize
991 the result of a function call. Which would result in trying to call
992 the function multiple times, and other evil things. */
993 else if (!lhs_elt
->is_scalar
994 && !TREE_SIDE_EFFECTS (rhs
) && is_gimple_addressable (rhs
))
995 fns
->ldst (lhs_elt
, rhs
, bsi
, true);
997 /* Otherwise we're being used in some context that requires the
998 aggregate to be seen as a whole. Invoke USE. */
1000 fns
->use (lhs_elt
, &GIMPLE_STMT_OPERAND (expr
, 0), bsi
, true, false);
1003 /* Similarly to above, LHS_ELT being null only means that the LHS as a
1004 whole is not a scalarizable reference. There may be occurrences of
1005 scalarizable variables within, which implies a USE. */
1007 sra_walk_expr (&GIMPLE_STMT_OPERAND (expr
, 0), bsi
, true, fns
);
1010 /* Entry point to the walk functions. Search the entire function,
1011 invoking the callbacks in FNS on each of the references to
1012 scalarizable variables. */
1015 sra_walk_function (const struct sra_walk_fns
*fns
)
1018 block_stmt_iterator si
, ni
;
1020 /* ??? Phase 4 could derive some benefit to walking the function in
1021 dominator tree order. */
1024 for (si
= bsi_start (bb
); !bsi_end_p (si
); si
= ni
)
1029 stmt
= bsi_stmt (si
);
1030 ann
= stmt_ann (stmt
);
1035 /* If the statement has no virtual operands, then it doesn't
1036 make any structure references that we care about. */
1037 if (gimple_aliases_computed_p (cfun
)
1038 && ZERO_SSA_OPERANDS (stmt
, (SSA_OP_VIRTUAL_DEFS
| SSA_OP_VUSE
)))
1041 switch (TREE_CODE (stmt
))
1044 /* If we have "return <retval>" then the return value is
1045 already exposed for our pleasure. Walk it as a USE to
1046 force all the components back in place for the return.
1048 If we have an embedded assignment, then <retval> is of
1049 a type that gets returned in registers in this ABI, and
1050 we do not wish to extend their lifetimes. Treat this
1051 as a USE of the variable on the RHS of this assignment. */
1053 t
= TREE_OPERAND (stmt
, 0);
1056 else if (TREE_CODE (t
) == GIMPLE_MODIFY_STMT
)
1057 sra_walk_expr (&GIMPLE_STMT_OPERAND (t
, 1), &si
, false, fns
);
1059 sra_walk_expr (&TREE_OPERAND (stmt
, 0), &si
, false, fns
);
1062 case GIMPLE_MODIFY_STMT
:
1063 sra_walk_gimple_modify_stmt (stmt
, &si
, fns
);
1066 sra_walk_call_expr (stmt
, &si
, fns
);
1069 sra_walk_asm_expr (stmt
, &si
, fns
);
1078 /* Phase One: Scan all referenced variables in the program looking for
1079 structures that could be decomposed. */
1082 find_candidates_for_sra (void)
1084 bool any_set
= false;
1086 referenced_var_iterator rvi
;
1088 FOR_EACH_REFERENCED_VAR (var
, rvi
)
1090 if (decl_can_be_decomposed_p (var
))
1092 bitmap_set_bit (sra_candidates
, DECL_UID (var
));
1101 /* Phase Two: Scan all references to scalarizable variables. Count the
1102 number of times they are used or copied respectively. */
1104 /* Callbacks to fill in SRA_WALK_FNS. Everything but USE is
1105 considered a copy, because we can decompose the reference such that
1106 the sub-elements needn't be contiguous. */
1109 scan_use (struct sra_elt
*elt
, tree
*expr_p ATTRIBUTE_UNUSED
,
1110 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
,
1111 bool is_output ATTRIBUTE_UNUSED
, bool use_all ATTRIBUTE_UNUSED
)
1117 scan_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
1118 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
)
1120 lhs_elt
->n_copies
+= 1;
1121 rhs_elt
->n_copies
+= 1;
1125 scan_init (struct sra_elt
*lhs_elt
, tree rhs ATTRIBUTE_UNUSED
,
1126 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
)
1128 lhs_elt
->n_copies
+= 1;
1132 scan_ldst (struct sra_elt
*elt
, tree other ATTRIBUTE_UNUSED
,
1133 block_stmt_iterator
*bsi ATTRIBUTE_UNUSED
,
1134 bool is_output ATTRIBUTE_UNUSED
)
1139 /* Dump the values we collected during the scanning phase. */
1142 scan_dump (struct sra_elt
*elt
)
1146 dump_sra_elt_name (dump_file
, elt
);
1147 fprintf (dump_file
, ": n_uses=%u n_copies=%u\n", elt
->n_uses
, elt
->n_copies
);
1149 for (c
= elt
->children
; c
; c
= c
->sibling
)
1152 for (c
= elt
->groups
; c
; c
= c
->sibling
)
1156 /* Entry point to phase 2. Scan the entire function, building up
1157 scalarization data structures, recording copies and uses. */
1160 scan_function (void)
1162 static const struct sra_walk_fns fns
= {
1163 scan_use
, scan_copy
, scan_init
, scan_ldst
, true
1167 sra_walk_function (&fns
);
1169 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1173 fputs ("\nScan results:\n", dump_file
);
1174 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
, bi
)
1176 tree var
= referenced_var (i
);
1177 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1181 fputc ('\n', dump_file
);
1185 /* Phase Three: Make decisions about which variables to scalarize, if any.
1186 All elements to be scalarized have replacement variables made for them. */
1188 /* A subroutine of build_element_name. Recursively build the element
1189 name on the obstack. */
1192 build_element_name_1 (struct sra_elt
*elt
)
1199 build_element_name_1 (elt
->parent
);
1200 obstack_1grow (&sra_obstack
, '$');
1202 if (TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
1204 if (elt
->element
== integer_zero_node
)
1205 obstack_grow (&sra_obstack
, "real", 4);
1207 obstack_grow (&sra_obstack
, "imag", 4);
1213 if (TREE_CODE (t
) == INTEGER_CST
)
1215 /* ??? Eh. Don't bother doing double-wide printing. */
1216 sprintf (buffer
, HOST_WIDE_INT_PRINT_DEC
, TREE_INT_CST_LOW (t
));
1217 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1219 else if (TREE_CODE (t
) == BIT_FIELD_REF
)
1221 sprintf (buffer
, "B" HOST_WIDE_INT_PRINT_DEC
,
1222 tree_low_cst (TREE_OPERAND (t
, 2), 1));
1223 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1224 sprintf (buffer
, "F" HOST_WIDE_INT_PRINT_DEC
,
1225 tree_low_cst (TREE_OPERAND (t
, 1), 1));
1226 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1230 tree name
= DECL_NAME (t
);
1232 obstack_grow (&sra_obstack
, IDENTIFIER_POINTER (name
),
1233 IDENTIFIER_LENGTH (name
));
1236 sprintf (buffer
, "D%u", DECL_UID (t
));
1237 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1242 /* Construct a pretty variable name for an element's replacement variable.
1243 The name is built on the obstack. */
1246 build_element_name (struct sra_elt
*elt
)
1248 build_element_name_1 (elt
);
1249 obstack_1grow (&sra_obstack
, '\0');
1250 return XOBFINISH (&sra_obstack
, char *);
1253 /* Instantiate an element as an independent variable. */
1256 instantiate_element (struct sra_elt
*elt
)
1258 struct sra_elt
*base_elt
;
1260 bool nowarn
= TREE_NO_WARNING (elt
->element
);
1262 for (base_elt
= elt
; base_elt
->parent
; base_elt
= base_elt
->parent
)
1264 nowarn
= TREE_NO_WARNING (base_elt
->parent
->element
);
1265 base
= base_elt
->element
;
1267 elt
->replacement
= var
= make_rename_temp (elt
->type
, "SR");
1269 if (DECL_P (elt
->element
)
1270 && !tree_int_cst_equal (DECL_SIZE (var
), DECL_SIZE (elt
->element
)))
1272 DECL_SIZE (var
) = DECL_SIZE (elt
->element
);
1273 DECL_SIZE_UNIT (var
) = DECL_SIZE_UNIT (elt
->element
);
1275 elt
->in_bitfld_block
= 1;
1276 elt
->replacement
= build3 (BIT_FIELD_REF
, elt
->type
, var
,
1279 ? size_binop (MINUS_EXPR
,
1280 TYPE_SIZE (elt
->type
),
1283 if (!INTEGRAL_TYPE_P (elt
->type
)
1284 || TYPE_UNSIGNED (elt
->type
))
1285 BIT_FIELD_REF_UNSIGNED (elt
->replacement
) = 1;
1288 /* For vectors, if used on the left hand side with BIT_FIELD_REF,
1289 they are not a gimple register. */
1290 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
&& elt
->is_vector_lhs
)
1291 DECL_GIMPLE_REG_P (var
) = 0;
1293 DECL_SOURCE_LOCATION (var
) = DECL_SOURCE_LOCATION (base
);
1294 DECL_ARTIFICIAL (var
) = 1;
1296 if (TREE_THIS_VOLATILE (elt
->type
))
1298 TREE_THIS_VOLATILE (var
) = 1;
1299 TREE_SIDE_EFFECTS (var
) = 1;
1302 if (DECL_NAME (base
) && !DECL_IGNORED_P (base
))
1304 char *pretty_name
= build_element_name (elt
);
1305 DECL_NAME (var
) = get_identifier (pretty_name
);
1306 obstack_free (&sra_obstack
, pretty_name
);
1308 SET_DECL_DEBUG_EXPR (var
, generate_element_ref (elt
));
1309 DECL_DEBUG_EXPR_IS_FROM (var
) = 1;
1311 DECL_IGNORED_P (var
) = 0;
1312 TREE_NO_WARNING (var
) = nowarn
;
1316 DECL_IGNORED_P (var
) = 1;
1317 /* ??? We can't generate any warning that would be meaningful. */
1318 TREE_NO_WARNING (var
) = 1;
1321 /* Zero-initialize bit-field scalarization variables, to avoid
1322 triggering undefined behavior. */
1323 if (TREE_CODE (elt
->element
) == BIT_FIELD_REF
1324 || (var
!= elt
->replacement
1325 && TREE_CODE (elt
->replacement
) == BIT_FIELD_REF
))
1327 tree init
= sra_build_assignment (var
, fold_convert (TREE_TYPE (var
),
1328 integer_zero_node
));
1329 insert_edge_copies (init
, ENTRY_BLOCK_PTR
);
1330 mark_all_v_defs (init
);
1335 fputs (" ", dump_file
);
1336 dump_sra_elt_name (dump_file
, elt
);
1337 fputs (" -> ", dump_file
);
1338 print_generic_expr (dump_file
, var
, dump_flags
);
1339 fputc ('\n', dump_file
);
1343 /* Make one pass across an element tree deciding whether or not it's
1344 profitable to instantiate individual leaf scalars.
1346 PARENT_USES and PARENT_COPIES are the sum of the N_USES and N_COPIES
1347 fields all the way up the tree. */
1350 decide_instantiation_1 (struct sra_elt
*elt
, unsigned int parent_uses
,
1351 unsigned int parent_copies
)
1353 if (dump_file
&& !elt
->parent
)
1355 fputs ("Initial instantiation for ", dump_file
);
1356 dump_sra_elt_name (dump_file
, elt
);
1357 fputc ('\n', dump_file
);
1360 if (elt
->cannot_scalarize
)
1365 /* The decision is simple: instantiate if we're used more frequently
1366 than the parent needs to be seen as a complete unit. */
1367 if (elt
->n_uses
+ elt
->n_copies
+ parent_copies
> parent_uses
)
1368 instantiate_element (elt
);
1372 struct sra_elt
*c
, *group
;
1373 unsigned int this_uses
= elt
->n_uses
+ parent_uses
;
1374 unsigned int this_copies
= elt
->n_copies
+ parent_copies
;
1376 /* Consider groups of sub-elements as weighing in favour of
1377 instantiation whatever their size. */
1378 for (group
= elt
->groups
; group
; group
= group
->sibling
)
1379 FOR_EACH_ACTUAL_CHILD (c
, group
)
1381 c
->n_uses
+= group
->n_uses
;
1382 c
->n_copies
+= group
->n_copies
;
1385 for (c
= elt
->children
; c
; c
= c
->sibling
)
1386 decide_instantiation_1 (c
, this_uses
, this_copies
);
1390 /* Compute the size and number of all instantiated elements below ELT.
1391 We will only care about this if the size of the complete structure
1392 fits in a HOST_WIDE_INT, so we don't have to worry about overflow. */
1395 sum_instantiated_sizes (struct sra_elt
*elt
, unsigned HOST_WIDE_INT
*sizep
)
1397 if (elt
->replacement
)
1399 *sizep
+= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (elt
->type
));
1405 unsigned int count
= 0;
1407 for (c
= elt
->children
; c
; c
= c
->sibling
)
1408 count
+= sum_instantiated_sizes (c
, sizep
);
1414 /* Instantiate fields in ELT->TYPE that are not currently present as
1417 static void instantiate_missing_elements (struct sra_elt
*elt
);
1419 static struct sra_elt
*
1420 instantiate_missing_elements_1 (struct sra_elt
*elt
, tree child
, tree type
)
1422 struct sra_elt
*sub
= lookup_element (elt
, child
, type
, INSERT
);
1425 if (sub
->replacement
== NULL
)
1426 instantiate_element (sub
);
1429 instantiate_missing_elements (sub
);
1433 /* Obtain the canonical type for field F of ELEMENT. */
1436 canon_type_for_field (tree f
, tree element
)
1438 tree field_type
= TREE_TYPE (f
);
1440 /* canonicalize_component_ref() unwidens some bit-field types (not
1441 marked as DECL_BIT_FIELD in C++), so we must do the same, lest we
1442 may introduce type mismatches. */
1443 if (INTEGRAL_TYPE_P (field_type
)
1444 && DECL_MODE (f
) != TYPE_MODE (field_type
))
1445 field_type
= TREE_TYPE (get_unwidened (build3 (COMPONENT_REF
,
1454 /* Look for adjacent fields of ELT starting at F that we'd like to
1455 scalarize as a single variable. Return the last field of the
1459 try_instantiate_multiple_fields (struct sra_elt
*elt
, tree f
)
1462 unsigned HOST_WIDE_INT align
, bit
, size
, alchk
;
1463 enum machine_mode mode
;
1464 tree first
= f
, prev
;
1466 struct sra_elt
*block
;
1468 if (!is_sra_scalar_type (TREE_TYPE (f
))
1469 || !host_integerp (DECL_FIELD_OFFSET (f
), 1)
1470 || !host_integerp (DECL_FIELD_BIT_OFFSET (f
), 1)
1471 || !host_integerp (DECL_SIZE (f
), 1)
1472 || lookup_element (elt
, f
, NULL
, NO_INSERT
))
1477 /* For complex and array objects, there are going to be integer
1478 literals as child elements. In this case, we can't just take the
1479 alignment and mode of the decl, so we instead rely on the element
1482 ??? We could try to infer additional alignment from the full
1483 object declaration and the location of the sub-elements we're
1485 for (count
= 0; !DECL_P (block
->element
); count
++)
1486 block
= block
->parent
;
1488 align
= DECL_ALIGN (block
->element
);
1489 alchk
= GET_MODE_BITSIZE (DECL_MODE (block
->element
));
1493 type
= TREE_TYPE (block
->element
);
1495 type
= TREE_TYPE (type
);
1497 align
= TYPE_ALIGN (type
);
1498 alchk
= GET_MODE_BITSIZE (TYPE_MODE (type
));
1504 /* Coalescing wider fields is probably pointless and
1506 if (align
> BITS_PER_WORD
)
1507 align
= BITS_PER_WORD
;
1509 bit
= tree_low_cst (DECL_FIELD_OFFSET (f
), 1) * BITS_PER_UNIT
1510 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f
), 1);
1511 size
= tree_low_cst (DECL_SIZE (f
), 1);
1516 if ((bit
& alchk
) != ((bit
+ size
- 1) & alchk
))
1519 /* Find adjacent fields in the same alignment word. */
1521 for (prev
= f
, f
= TREE_CHAIN (f
);
1522 f
&& TREE_CODE (f
) == FIELD_DECL
1523 && is_sra_scalar_type (TREE_TYPE (f
))
1524 && host_integerp (DECL_FIELD_OFFSET (f
), 1)
1525 && host_integerp (DECL_FIELD_BIT_OFFSET (f
), 1)
1526 && host_integerp (DECL_SIZE (f
), 1)
1527 && !lookup_element (elt
, f
, NULL
, NO_INSERT
);
1528 prev
= f
, f
= TREE_CHAIN (f
))
1530 unsigned HOST_WIDE_INT nbit
, nsize
;
1532 nbit
= tree_low_cst (DECL_FIELD_OFFSET (f
), 1) * BITS_PER_UNIT
1533 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f
), 1);
1534 nsize
= tree_low_cst (DECL_SIZE (f
), 1);
1536 if (bit
+ size
== nbit
)
1538 if ((bit
& alchk
) != ((nbit
+ nsize
- 1) & alchk
))
1540 /* If we're at an alignment boundary, don't bother
1541 growing alignment such that we can include this next
1544 || GET_MODE_BITSIZE (DECL_MODE (f
)) <= align
)
1547 align
= GET_MODE_BITSIZE (DECL_MODE (f
));
1551 if ((bit
& alchk
) != ((nbit
+ nsize
- 1) & alchk
))
1556 else if (nbit
+ nsize
== bit
)
1558 if ((nbit
& alchk
) != ((bit
+ size
- 1) & alchk
))
1561 || GET_MODE_BITSIZE (DECL_MODE (f
)) <= align
)
1564 align
= GET_MODE_BITSIZE (DECL_MODE (f
));
1568 if ((nbit
& alchk
) != ((bit
+ size
- 1) & alchk
))
1583 gcc_assert ((bit
& alchk
) == ((bit
+ size
- 1) & alchk
));
1585 /* Try to widen the bit range so as to cover padding bits as well. */
1587 if ((bit
& ~alchk
) || size
!= align
)
1589 unsigned HOST_WIDE_INT mbit
= bit
& alchk
;
1590 unsigned HOST_WIDE_INT msize
= align
;
1592 for (f
= TYPE_FIELDS (elt
->type
);
1593 f
; f
= TREE_CHAIN (f
))
1595 unsigned HOST_WIDE_INT fbit
, fsize
;
1597 /* Skip the fields from first to prev. */
1604 if (!(TREE_CODE (f
) == FIELD_DECL
1605 && host_integerp (DECL_FIELD_OFFSET (f
), 1)
1606 && host_integerp (DECL_FIELD_BIT_OFFSET (f
), 1)))
1609 fbit
= tree_low_cst (DECL_FIELD_OFFSET (f
), 1) * BITS_PER_UNIT
1610 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f
), 1);
1612 /* If we're past the selected word, we're fine. */
1613 if ((bit
& alchk
) < (fbit
& alchk
))
1616 if (host_integerp (DECL_SIZE (f
), 1))
1617 fsize
= tree_low_cst (DECL_SIZE (f
), 1);
1619 /* Assume a variable-sized field takes up all space till
1620 the end of the word. ??? Endianness issues? */
1621 fsize
= align
- (fbit
& alchk
);
1623 if ((fbit
& alchk
) < (bit
& alchk
))
1625 /* A large field might start at a previous word and
1626 extend into the selected word. Exclude those
1627 bits. ??? Endianness issues? */
1628 HOST_WIDE_INT diff
= fbit
+ fsize
- mbit
;
1638 /* Non-overlapping, great. */
1639 if (fbit
+ fsize
<= mbit
1640 || mbit
+ msize
<= fbit
)
1645 unsigned HOST_WIDE_INT diff
= fbit
+ fsize
- mbit
;
1649 else if (fbit
> mbit
)
1650 msize
-= (mbit
+ msize
- fbit
);
1660 /* Now we know the bit range we're interested in. Find the smallest
1661 machine mode we can use to access it. */
1663 for (mode
= smallest_mode_for_size (size
, MODE_INT
);
1665 mode
= GET_MODE_WIDER_MODE (mode
))
1667 gcc_assert (mode
!= VOIDmode
);
1669 alchk
= GET_MODE_PRECISION (mode
) - 1;
1672 if ((bit
& alchk
) == ((bit
+ size
- 1) & alchk
))
1676 gcc_assert (~alchk
< align
);
1678 /* Create the field group as a single variable. */
1680 type
= lang_hooks
.types
.type_for_mode (mode
, 1);
1682 var
= build3 (BIT_FIELD_REF
, type
, NULL_TREE
,
1685 BIT_FIELD_REF_UNSIGNED (var
) = 1;
1687 block
= instantiate_missing_elements_1 (elt
, var
, type
);
1688 gcc_assert (block
&& block
->is_scalar
);
1690 var
= block
->replacement
;
1693 || (HOST_WIDE_INT
)size
!= tree_low_cst (DECL_SIZE (var
), 1))
1695 block
->replacement
= build3 (BIT_FIELD_REF
,
1696 TREE_TYPE (block
->element
), var
,
1698 bitsize_int (bit
& ~alchk
));
1699 BIT_FIELD_REF_UNSIGNED (block
->replacement
) = 1;
1702 block
->in_bitfld_block
= 2;
1704 /* Add the member fields to the group, such that they access
1705 portions of the group variable. */
1707 for (f
= first
; f
!= TREE_CHAIN (prev
); f
= TREE_CHAIN (f
))
1709 tree field_type
= canon_type_for_field (f
, elt
->element
);
1710 struct sra_elt
*fld
= lookup_element (block
, f
, field_type
, INSERT
);
1712 gcc_assert (fld
&& fld
->is_scalar
&& !fld
->replacement
);
1714 fld
->replacement
= build3 (BIT_FIELD_REF
, field_type
, var
,
1717 ((TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f
))
1720 (DECL_FIELD_BIT_OFFSET (f
))))
1722 BIT_FIELD_REF_UNSIGNED (fld
->replacement
) = TYPE_UNSIGNED (field_type
);
1723 fld
->in_bitfld_block
= 1;
1730 instantiate_missing_elements (struct sra_elt
*elt
)
1732 tree type
= elt
->type
;
1734 switch (TREE_CODE (type
))
1739 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
1740 if (TREE_CODE (f
) == FIELD_DECL
)
1742 tree last
= try_instantiate_multiple_fields (elt
, f
);
1750 instantiate_missing_elements_1 (elt
, f
,
1751 canon_type_for_field
1759 tree i
, max
, subtype
;
1761 i
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
1762 max
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
1763 subtype
= TREE_TYPE (type
);
1767 instantiate_missing_elements_1 (elt
, i
, subtype
);
1768 if (tree_int_cst_equal (i
, max
))
1770 i
= int_const_binop (PLUS_EXPR
, i
, integer_one_node
, true);
1777 type
= TREE_TYPE (type
);
1778 instantiate_missing_elements_1 (elt
, integer_zero_node
, type
);
1779 instantiate_missing_elements_1 (elt
, integer_one_node
, type
);
1787 /* Return true if there is only one non aggregate field in the record, TYPE.
1788 Return false otherwise. */
1791 single_scalar_field_in_record_p (tree type
)
1795 if (TREE_CODE (type
) != RECORD_TYPE
)
1798 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1799 if (TREE_CODE (field
) == FIELD_DECL
)
1803 if (num_fields
== 2)
1806 if (AGGREGATE_TYPE_P (TREE_TYPE (field
)))
1813 /* Make one pass across an element tree deciding whether to perform block
1814 or element copies. If we decide on element copies, instantiate all
1815 elements. Return true if there are any instantiated sub-elements. */
1818 decide_block_copy (struct sra_elt
*elt
)
1823 /* We shouldn't be invoked on groups of sub-elements as they must
1824 behave like their parent as far as block copy is concerned. */
1825 gcc_assert (!elt
->is_group
);
1827 /* If scalarization is disabled, respect it. */
1828 if (elt
->cannot_scalarize
)
1830 elt
->use_block_copy
= 1;
1834 fputs ("Scalarization disabled for ", dump_file
);
1835 dump_sra_elt_name (dump_file
, elt
);
1836 fputc ('\n', dump_file
);
1839 /* Disable scalarization of sub-elements */
1840 for (c
= elt
->children
; c
; c
= c
->sibling
)
1842 c
->cannot_scalarize
= 1;
1843 decide_block_copy (c
);
1846 /* Groups behave like their parent. */
1847 for (c
= elt
->groups
; c
; c
= c
->sibling
)
1849 c
->cannot_scalarize
= 1;
1850 c
->use_block_copy
= 1;
1856 /* Don't decide if we've no uses and no groups. */
1857 if (elt
->n_uses
== 0 && elt
->n_copies
== 0 && elt
->groups
== NULL
)
1860 else if (!elt
->is_scalar
)
1862 tree size_tree
= TYPE_SIZE_UNIT (elt
->type
);
1863 bool use_block_copy
= true;
1865 /* Tradeoffs for COMPLEX types pretty much always make it better
1866 to go ahead and split the components. */
1867 if (TREE_CODE (elt
->type
) == COMPLEX_TYPE
)
1868 use_block_copy
= false;
1870 /* Don't bother trying to figure out the rest if the structure is
1871 so large we can't do easy arithmetic. This also forces block
1872 copies for variable sized structures. */
1873 else if (host_integerp (size_tree
, 1))
1875 unsigned HOST_WIDE_INT full_size
, inst_size
= 0;
1876 unsigned int max_size
, max_count
, inst_count
, full_count
;
1878 /* If the sra-max-structure-size parameter is 0, then the
1879 user has not overridden the parameter and we can choose a
1880 sensible default. */
1881 max_size
= SRA_MAX_STRUCTURE_SIZE
1882 ? SRA_MAX_STRUCTURE_SIZE
1883 : MOVE_RATIO
* UNITS_PER_WORD
;
1884 max_count
= SRA_MAX_STRUCTURE_COUNT
1885 ? SRA_MAX_STRUCTURE_COUNT
1888 full_size
= tree_low_cst (size_tree
, 1);
1889 full_count
= count_type_elements (elt
->type
, false);
1890 inst_count
= sum_instantiated_sizes (elt
, &inst_size
);
1892 /* If there is only one scalar field in the record, don't block copy. */
1893 if (single_scalar_field_in_record_p (elt
->type
))
1894 use_block_copy
= false;
1896 /* ??? What to do here. If there are two fields, and we've only
1897 instantiated one, then instantiating the other is clearly a win.
1898 If there are a large number of fields then the size of the copy
1899 is much more of a factor. */
1901 /* If the structure is small, and we've made copies, go ahead
1902 and instantiate, hoping that the copies will go away. */
1903 if (full_size
<= max_size
1904 && (full_count
- inst_count
) <= max_count
1905 && elt
->n_copies
> elt
->n_uses
)
1906 use_block_copy
= false;
1907 else if (inst_count
* 100 >= full_count
* SRA_FIELD_STRUCTURE_RATIO
1908 && inst_size
* 100 >= full_size
* SRA_FIELD_STRUCTURE_RATIO
)
1909 use_block_copy
= false;
1911 /* In order to avoid block copy, we have to be able to instantiate
1912 all elements of the type. See if this is possible. */
1914 && (!can_completely_scalarize_p (elt
)
1915 || !type_can_instantiate_all_elements (elt
->type
)))
1916 use_block_copy
= true;
1919 elt
->use_block_copy
= use_block_copy
;
1921 /* Groups behave like their parent. */
1922 for (c
= elt
->groups
; c
; c
= c
->sibling
)
1923 c
->use_block_copy
= use_block_copy
;
1927 fprintf (dump_file
, "Using %s for ",
1928 use_block_copy
? "block-copy" : "element-copy");
1929 dump_sra_elt_name (dump_file
, elt
);
1930 fputc ('\n', dump_file
);
1933 if (!use_block_copy
)
1935 instantiate_missing_elements (elt
);
1940 any_inst
= elt
->replacement
!= NULL
;
1942 for (c
= elt
->children
; c
; c
= c
->sibling
)
1943 any_inst
|= decide_block_copy (c
);
1948 /* Entry point to phase 3. Instantiate scalar replacement variables. */
1951 decide_instantiations (void)
1955 bitmap_head done_head
;
1958 /* We cannot clear bits from a bitmap we're iterating over,
1959 so save up all the bits to clear until the end. */
1960 bitmap_initialize (&done_head
, &bitmap_default_obstack
);
1961 cleared_any
= false;
1963 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
, bi
)
1965 tree var
= referenced_var (i
);
1966 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1969 decide_instantiation_1 (elt
, 0, 0);
1970 if (!decide_block_copy (elt
))
1975 bitmap_set_bit (&done_head
, i
);
1982 bitmap_and_compl_into (sra_candidates
, &done_head
);
1983 bitmap_and_compl_into (needs_copy_in
, &done_head
);
1985 bitmap_clear (&done_head
);
1987 mark_set_for_renaming (sra_candidates
);
1990 fputc ('\n', dump_file
);
1994 /* Phase Four: Update the function to match the replacements created. */
1996 /* Mark all the variables in VDEF/VUSE operators for STMT for
1997 renaming. This becomes necessary when we modify all of a
2001 mark_all_v_defs_1 (tree stmt
)
2006 update_stmt_if_modified (stmt
);
2008 FOR_EACH_SSA_TREE_OPERAND (sym
, stmt
, iter
, SSA_OP_ALL_VIRTUALS
)
2010 if (TREE_CODE (sym
) == SSA_NAME
)
2011 sym
= SSA_NAME_VAR (sym
);
2012 mark_sym_for_renaming (sym
);
2017 /* Mark all the variables in virtual operands in all the statements in
2018 LIST for renaming. */
2021 mark_all_v_defs (tree list
)
2023 if (TREE_CODE (list
) != STATEMENT_LIST
)
2024 mark_all_v_defs_1 (list
);
2027 tree_stmt_iterator i
;
2028 for (i
= tsi_start (list
); !tsi_end_p (i
); tsi_next (&i
))
2029 mark_all_v_defs_1 (tsi_stmt (i
));
2034 /* Mark every replacement under ELT with TREE_NO_WARNING. */
2037 mark_no_warning (struct sra_elt
*elt
)
2039 if (!elt
->all_no_warning
)
2041 if (elt
->replacement
)
2042 TREE_NO_WARNING (elt
->replacement
) = 1;
2046 FOR_EACH_ACTUAL_CHILD (c
, elt
)
2047 mark_no_warning (c
);
2049 elt
->all_no_warning
= true;
2053 /* Build a single level component reference to ELT rooted at BASE. */
2056 generate_one_element_ref (struct sra_elt
*elt
, tree base
)
2058 switch (TREE_CODE (TREE_TYPE (base
)))
2062 tree field
= elt
->element
;
2064 /* We can't test elt->in_bitfld_blk here because, when this is
2065 called from instantiate_element, we haven't set this field
2067 if (TREE_CODE (field
) == BIT_FIELD_REF
)
2069 tree ret
= unshare_expr (field
);
2070 TREE_OPERAND (ret
, 0) = base
;
2074 /* Watch out for compatible records with differing field lists. */
2075 if (DECL_FIELD_CONTEXT (field
) != TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
2076 field
= find_compatible_field (TREE_TYPE (base
), field
);
2078 return build3 (COMPONENT_REF
, elt
->type
, base
, field
, NULL
);
2082 if (TREE_CODE (elt
->element
) == RANGE_EXPR
)
2083 return build4 (ARRAY_RANGE_REF
, elt
->type
, base
,
2084 TREE_OPERAND (elt
->element
, 0), NULL
, NULL
);
2086 return build4 (ARRAY_REF
, elt
->type
, base
, elt
->element
, NULL
, NULL
);
2089 if (elt
->element
== integer_zero_node
)
2090 return build1 (REALPART_EXPR
, elt
->type
, base
);
2092 return build1 (IMAGPART_EXPR
, elt
->type
, base
);
2099 /* Build a full component reference to ELT rooted at its native variable. */
2102 generate_element_ref (struct sra_elt
*elt
)
2105 return generate_one_element_ref (elt
, generate_element_ref (elt
->parent
));
2107 return elt
->element
;
2110 /* Return true if BF is a bit-field that we can handle like a scalar. */
2113 scalar_bitfield_p (tree bf
)
2115 return (TREE_CODE (bf
) == BIT_FIELD_REF
2116 && (is_gimple_reg (TREE_OPERAND (bf
, 0))
2117 || (TYPE_MODE (TREE_TYPE (TREE_OPERAND (bf
, 0))) != BLKmode
2118 && (!TREE_SIDE_EFFECTS (TREE_OPERAND (bf
, 0))
2119 || (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE
2120 (TREE_OPERAND (bf
, 0))))
2121 <= BITS_PER_WORD
)))));
2124 /* Create an assignment statement from SRC to DST. */
2127 sra_build_assignment (tree dst
, tree src
)
2129 /* Turning BIT_FIELD_REFs into bit operations enables other passes
2130 to do a much better job at optimizing the code. */
2131 if (scalar_bitfield_p (src
))
2133 tree cst
, cst2
, mask
, minshift
, maxshift
;
2134 tree tmp
, var
, utype
, stype
;
2136 bool unsignedp
= BIT_FIELD_REF_UNSIGNED (src
);
2138 var
= TREE_OPERAND (src
, 0);
2139 cst
= TREE_OPERAND (src
, 2);
2140 cst2
= size_binop (PLUS_EXPR
, TREE_OPERAND (src
, 1),
2141 TREE_OPERAND (src
, 2));
2143 if (BYTES_BIG_ENDIAN
)
2145 maxshift
= size_binop (MINUS_EXPR
, TYPE_SIZE (TREE_TYPE (var
)), cst
);
2146 minshift
= size_binop (MINUS_EXPR
, TYPE_SIZE (TREE_TYPE (var
)), cst2
);
2154 stype
= TREE_TYPE (var
);
2155 if (!INTEGRAL_TYPE_P (stype
))
2156 stype
= lang_hooks
.types
.type_for_size (TREE_INT_CST_LOW
2157 (TYPE_SIZE (stype
)), 1);
2158 else if (!TYPE_UNSIGNED (stype
))
2159 stype
= unsigned_type_for (stype
);
2161 utype
= TREE_TYPE (dst
);
2162 if (!INTEGRAL_TYPE_P (utype
))
2163 utype
= lang_hooks
.types
.type_for_size (TREE_INT_CST_LOW
2164 (TYPE_SIZE (utype
)), 1);
2165 else if (!TYPE_UNSIGNED (utype
))
2166 utype
= unsigned_type_for (utype
);
2170 cst2
= size_binop (MINUS_EXPR
, maxshift
, minshift
);
2171 if (TREE_INT_CST_LOW (cst2
) == TYPE_PRECISION (utype
))
2178 mask
= build_int_cst_wide (utype
, 1, 0);
2179 cst
= int_const_binop (LSHIFT_EXPR
, mask
, cst2
, true);
2180 mask
= int_const_binop (MINUS_EXPR
, cst
, mask
, true);
2183 tmp
= make_rename_temp (stype
, "SR");
2184 if (TYPE_MAIN_VARIANT (TREE_TYPE (var
)) != TYPE_MAIN_VARIANT (stype
))
2186 if (INTEGRAL_TYPE_P (TREE_TYPE (var
)))
2187 stmt
= build_gimple_modify_stmt (tmp
,
2188 fold_convert (stype
, var
));
2190 stmt
= build_gimple_modify_stmt (tmp
,
2191 fold_build1 (VIEW_CONVERT_EXPR
,
2193 append_to_statement_list (stmt
, &list
);
2198 if (!integer_zerop (minshift
))
2200 tmp
= make_rename_temp (stype
, "SR");
2201 stmt
= build_gimple_modify_stmt (tmp
,
2202 fold_build2 (RSHIFT_EXPR
, stype
,
2204 append_to_statement_list (stmt
, &list
);
2209 if (TYPE_MAIN_VARIANT (utype
) != TYPE_MAIN_VARIANT (stype
))
2211 if (!mask
&& unsignedp
2212 && (TYPE_MAIN_VARIANT (utype
)
2213 == TYPE_MAIN_VARIANT (TREE_TYPE (dst
))))
2216 tmp
= make_rename_temp (utype
, "SR");
2218 stmt
= build_gimple_modify_stmt (tmp
, fold_convert (utype
, var
));
2219 append_to_statement_list (stmt
, &list
);
2227 || (TYPE_MAIN_VARIANT (TREE_TYPE (dst
))
2228 != TYPE_MAIN_VARIANT (utype
)))
2229 tmp
= make_rename_temp (utype
, "SR");
2233 stmt
= build_gimple_modify_stmt (tmp
,
2234 fold_build2 (BIT_AND_EXPR
, utype
,
2236 append_to_statement_list (stmt
, &list
);
2243 tree signbit
= int_const_binop (LSHIFT_EXPR
,
2244 build_int_cst_wide (utype
, 1, 0),
2245 size_binop (MINUS_EXPR
, cst2
,
2249 tmp
= make_rename_temp (utype
, "SR");
2250 stmt
= build_gimple_modify_stmt (tmp
,
2251 fold_build2 (BIT_XOR_EXPR
, utype
,
2253 append_to_statement_list (stmt
, &list
);
2257 if (TYPE_MAIN_VARIANT (TREE_TYPE (dst
)) != TYPE_MAIN_VARIANT (utype
))
2258 tmp
= make_rename_temp (utype
, "SR");
2262 stmt
= build_gimple_modify_stmt (tmp
,
2263 fold_build2 (MINUS_EXPR
, utype
,
2265 append_to_statement_list (stmt
, &list
);
2272 if (INTEGRAL_TYPE_P (TREE_TYPE (dst
)))
2273 var
= fold_convert (TREE_TYPE (dst
), var
);
2275 var
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (dst
), var
);
2277 stmt
= build_gimple_modify_stmt (dst
, var
);
2278 append_to_statement_list (stmt
, &list
);
2284 /* It was hoped that we could perform some type sanity checking
2285 here, but since front-ends can emit accesses of fields in types
2286 different from their nominal types and copy structures containing
2287 them as a whole, we'd have to handle such differences here.
2288 Since such accesses under different types require compatibility
2289 anyway, there's little point in making tests and/or adding
2290 conversions to ensure the types of src and dst are the same.
2291 So we just assume type differences at this point are ok. */
2292 return build_gimple_modify_stmt (dst
, src
);
2295 /* BIT_FIELD_REFs must not be shared. sra_build_elt_assignment()
2296 takes care of assignments, but we must create copies for uses. */
2297 #define REPLDUP(t) (TREE_CODE (t) != BIT_FIELD_REF ? (t) : unshare_expr (t))
2299 /* Emit an assignment from SRC to DST, but if DST is a scalarizable
2300 BIT_FIELD_REF, turn it into bit operations. */
2303 sra_build_bf_assignment (tree dst
, tree src
)
2305 tree var
, type
, utype
, tmp
, tmp2
, tmp3
;
2307 tree cst
, cst2
, mask
;
2308 tree minshift
, maxshift
;
2310 if (TREE_CODE (dst
) != BIT_FIELD_REF
)
2311 return sra_build_assignment (dst
, src
);
2313 var
= TREE_OPERAND (dst
, 0);
2315 if (!scalar_bitfield_p (dst
))
2316 return sra_build_assignment (REPLDUP (dst
), src
);
2320 cst
= fold_convert (bitsizetype
, TREE_OPERAND (dst
, 2));
2321 cst2
= size_binop (PLUS_EXPR
,
2322 fold_convert (bitsizetype
, TREE_OPERAND (dst
, 1)),
2325 if (BYTES_BIG_ENDIAN
)
2327 maxshift
= size_binop (MINUS_EXPR
, TYPE_SIZE (TREE_TYPE (var
)), cst
);
2328 minshift
= size_binop (MINUS_EXPR
, TYPE_SIZE (TREE_TYPE (var
)), cst2
);
2336 type
= TREE_TYPE (var
);
2337 if (!INTEGRAL_TYPE_P (type
))
2338 type
= lang_hooks
.types
.type_for_size
2339 (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (var
))), 1);
2340 if (TYPE_UNSIGNED (type
))
2343 utype
= unsigned_type_for (type
);
2345 mask
= build_int_cst_wide (utype
, 1, 0);
2346 if (TREE_INT_CST_LOW (maxshift
) == TYPE_PRECISION (utype
))
2347 cst
= build_int_cst_wide (utype
, 0, 0);
2349 cst
= int_const_binop (LSHIFT_EXPR
, mask
, maxshift
, true);
2350 if (integer_zerop (minshift
))
2353 cst2
= int_const_binop (LSHIFT_EXPR
, mask
, minshift
, true);
2354 mask
= int_const_binop (MINUS_EXPR
, cst
, cst2
, true);
2355 mask
= fold_build1 (BIT_NOT_EXPR
, utype
, mask
);
2357 if (TYPE_MAIN_VARIANT (utype
) != TYPE_MAIN_VARIANT (TREE_TYPE (var
))
2358 && !integer_zerop (mask
))
2361 if (!is_gimple_variable (tmp
))
2362 tmp
= unshare_expr (var
);
2364 tmp2
= make_rename_temp (utype
, "SR");
2366 if (INTEGRAL_TYPE_P (TREE_TYPE (var
)))
2367 stmt
= build_gimple_modify_stmt (tmp2
, fold_convert (utype
, tmp
));
2369 stmt
= build_gimple_modify_stmt (tmp2
, fold_build1 (VIEW_CONVERT_EXPR
,
2371 append_to_statement_list (stmt
, &list
);
2376 if (!integer_zerop (mask
))
2378 tmp
= make_rename_temp (utype
, "SR");
2379 stmt
= build_gimple_modify_stmt (tmp
,
2380 fold_build2 (BIT_AND_EXPR
, utype
,
2382 append_to_statement_list (stmt
, &list
);
2387 if (is_gimple_reg (src
) && INTEGRAL_TYPE_P (TREE_TYPE (src
)))
2389 else if (INTEGRAL_TYPE_P (TREE_TYPE (src
)))
2391 tmp2
= make_rename_temp (TREE_TYPE (src
), "SR");
2392 stmt
= sra_build_assignment (tmp2
, src
);
2393 append_to_statement_list (stmt
, &list
);
2397 tmp2
= make_rename_temp
2398 (lang_hooks
.types
.type_for_size
2399 (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (src
))),
2401 stmt
= sra_build_assignment (tmp2
, fold_build1 (VIEW_CONVERT_EXPR
,
2402 TREE_TYPE (tmp2
), src
));
2403 append_to_statement_list (stmt
, &list
);
2406 if (!TYPE_UNSIGNED (TREE_TYPE (tmp2
)))
2408 tree ut
= unsigned_type_for (TREE_TYPE (tmp2
));
2409 tmp3
= make_rename_temp (ut
, "SR");
2410 tmp2
= fold_convert (ut
, tmp2
);
2411 stmt
= sra_build_assignment (tmp3
, tmp2
);
2412 append_to_statement_list (stmt
, &list
);
2414 tmp2
= fold_build1 (BIT_NOT_EXPR
, utype
, mask
);
2415 tmp2
= int_const_binop (RSHIFT_EXPR
, tmp2
, minshift
, true);
2416 tmp2
= fold_convert (ut
, tmp2
);
2417 tmp2
= fold_build2 (BIT_AND_EXPR
, ut
, tmp3
, tmp2
);
2421 tmp3
= make_rename_temp (ut
, "SR");
2422 stmt
= sra_build_assignment (tmp3
, tmp2
);
2423 append_to_statement_list (stmt
, &list
);
2429 if (TYPE_MAIN_VARIANT (TREE_TYPE (tmp2
)) != TYPE_MAIN_VARIANT (utype
))
2431 tmp3
= make_rename_temp (utype
, "SR");
2432 tmp2
= fold_convert (utype
, tmp2
);
2433 stmt
= sra_build_assignment (tmp3
, tmp2
);
2434 append_to_statement_list (stmt
, &list
);
2438 if (!integer_zerop (minshift
))
2440 tmp3
= make_rename_temp (utype
, "SR");
2441 stmt
= build_gimple_modify_stmt (tmp3
,
2442 fold_build2 (LSHIFT_EXPR
, utype
,
2444 append_to_statement_list (stmt
, &list
);
2448 if (utype
!= TREE_TYPE (var
))
2449 tmp3
= make_rename_temp (utype
, "SR");
2452 stmt
= build_gimple_modify_stmt (tmp3
,
2453 fold_build2 (BIT_IOR_EXPR
, utype
,
2455 append_to_statement_list (stmt
, &list
);
2459 if (TREE_TYPE (var
) == type
)
2460 stmt
= build_gimple_modify_stmt (var
,
2461 fold_convert (type
, tmp3
));
2463 stmt
= build_gimple_modify_stmt (var
,
2464 fold_build1 (VIEW_CONVERT_EXPR
,
2465 TREE_TYPE (var
), tmp3
));
2466 append_to_statement_list (stmt
, &list
);
2472 /* Expand an assignment of SRC to the scalarized representation of
2473 ELT. If it is a field group, try to widen the assignment to cover
2474 the full variable. */
2477 sra_build_elt_assignment (struct sra_elt
*elt
, tree src
)
2479 tree dst
= elt
->replacement
;
2480 tree var
, tmp
, cst
, cst2
, list
, stmt
;
2482 if (TREE_CODE (dst
) != BIT_FIELD_REF
2483 || !elt
->in_bitfld_block
)
2484 return sra_build_assignment (REPLDUP (dst
), src
);
2486 var
= TREE_OPERAND (dst
, 0);
2488 /* Try to widen the assignment to the entire variable.
2489 We need the source to be a BIT_FIELD_REF as well, such that, for
2490 BIT_FIELD_REF<d,sz,dp> = BIT_FIELD_REF<s,sz,sp>,
2491 by design, conditions are met such that we can turn it into
2492 d = BIT_FIELD_REF<s,dw,sp-dp>. */
2493 if (elt
->in_bitfld_block
== 2
2494 && TREE_CODE (src
) == BIT_FIELD_REF
)
2496 cst
= TYPE_SIZE (TREE_TYPE (var
));
2497 cst2
= size_binop (MINUS_EXPR
, TREE_OPERAND (src
, 2),
2498 TREE_OPERAND (dst
, 2));
2500 src
= TREE_OPERAND (src
, 0);
2502 /* Avoid full-width bit-fields. */
2503 if (integer_zerop (cst2
)
2504 && tree_int_cst_equal (cst
, TYPE_SIZE (TREE_TYPE (src
))))
2506 if (INTEGRAL_TYPE_P (TREE_TYPE (src
))
2507 && !TYPE_UNSIGNED (TREE_TYPE (src
)))
2508 src
= fold_convert (unsigned_type_for (TREE_TYPE (src
)), src
);
2510 /* If a single conversion won't do, we'll need a statement
2512 if (TYPE_MAIN_VARIANT (TREE_TYPE (var
))
2513 != TYPE_MAIN_VARIANT (TREE_TYPE (src
)))
2517 if (!INTEGRAL_TYPE_P (TREE_TYPE (src
)))
2518 src
= fold_build1 (VIEW_CONVERT_EXPR
,
2519 lang_hooks
.types
.type_for_size
2521 (TYPE_SIZE (TREE_TYPE (src
))),
2523 gcc_assert (TYPE_UNSIGNED (TREE_TYPE (src
)));
2525 tmp
= make_rename_temp (TREE_TYPE (src
), "SR");
2526 stmt
= build_gimple_modify_stmt (tmp
, src
);
2527 append_to_statement_list (stmt
, &list
);
2529 stmt
= sra_build_assignment (var
,
2530 fold_convert (TREE_TYPE (var
),
2532 append_to_statement_list (stmt
, &list
);
2537 src
= fold_convert (TREE_TYPE (var
), src
);
2541 src
= fold_build3 (BIT_FIELD_REF
, TREE_TYPE (var
), src
, cst
, cst2
);
2542 BIT_FIELD_REF_UNSIGNED (src
) = 1;
2545 return sra_build_assignment (var
, src
);
2548 return sra_build_bf_assignment (dst
, src
);
2551 /* Generate a set of assignment statements in *LIST_P to copy all
2552 instantiated elements under ELT to or from the equivalent structure
2553 rooted at EXPR. COPY_OUT controls the direction of the copy, with
2554 true meaning to copy out of EXPR into ELT. */
2557 generate_copy_inout (struct sra_elt
*elt
, bool copy_out
, tree expr
,
2563 if (!copy_out
&& TREE_CODE (expr
) == SSA_NAME
2564 && TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2568 c
= lookup_element (elt
, integer_zero_node
, NULL
, NO_INSERT
);
2570 c
= lookup_element (elt
, integer_one_node
, NULL
, NO_INSERT
);
2573 t
= build2 (COMPLEX_EXPR
, elt
->type
, r
, i
);
2574 t
= sra_build_bf_assignment (expr
, t
);
2575 SSA_NAME_DEF_STMT (expr
) = t
;
2576 append_to_statement_list (t
, list_p
);
2578 else if (elt
->replacement
)
2581 t
= sra_build_elt_assignment (elt
, expr
);
2583 t
= sra_build_bf_assignment (expr
, REPLDUP (elt
->replacement
));
2584 append_to_statement_list (t
, list_p
);
2588 FOR_EACH_ACTUAL_CHILD (c
, elt
)
2590 t
= generate_one_element_ref (c
, unshare_expr (expr
));
2591 generate_copy_inout (c
, copy_out
, t
, list_p
);
2596 /* Generate a set of assignment statements in *LIST_P to copy all instantiated
2597 elements under SRC to their counterparts under DST. There must be a 1-1
2598 correspondence of instantiated elements. */
2601 generate_element_copy (struct sra_elt
*dst
, struct sra_elt
*src
, tree
*list_p
)
2603 struct sra_elt
*dc
, *sc
;
2605 FOR_EACH_ACTUAL_CHILD (dc
, dst
)
2607 sc
= lookup_element (src
, dc
->element
, NULL
, NO_INSERT
);
2608 if (!sc
&& dc
->in_bitfld_block
== 2)
2610 struct sra_elt
*dcs
;
2612 FOR_EACH_ACTUAL_CHILD (dcs
, dc
)
2614 sc
= lookup_element (src
, dcs
->element
, NULL
, NO_INSERT
);
2616 generate_element_copy (dcs
, sc
, list_p
);
2622 generate_element_copy (dc
, sc
, list_p
);
2625 if (dst
->replacement
)
2629 gcc_assert (src
->replacement
);
2631 t
= sra_build_elt_assignment (dst
, REPLDUP (src
->replacement
));
2632 append_to_statement_list (t
, list_p
);
2636 /* Generate a set of assignment statements in *LIST_P to zero all instantiated
2637 elements under ELT. In addition, do not assign to elements that have been
2638 marked VISITED but do reset the visited flag; this allows easy coordination
2639 with generate_element_init. */
2642 generate_element_zero (struct sra_elt
*elt
, tree
*list_p
)
2648 elt
->visited
= false;
2652 if (!elt
->in_bitfld_block
)
2653 FOR_EACH_ACTUAL_CHILD (c
, elt
)
2654 generate_element_zero (c
, list_p
);
2656 if (elt
->replacement
)
2660 gcc_assert (elt
->is_scalar
);
2661 t
= fold_convert (elt
->type
, integer_zero_node
);
2663 t
= sra_build_elt_assignment (elt
, t
);
2664 append_to_statement_list (t
, list_p
);
2668 /* Generate an assignment VAR = INIT, where INIT may need gimplification.
2669 Add the result to *LIST_P. */
2672 generate_one_element_init (struct sra_elt
*elt
, tree init
, tree
*list_p
)
2674 /* The replacement can be almost arbitrarily complex. Gimplify. */
2675 tree stmt
= sra_build_elt_assignment (elt
, init
);
2676 gimplify_and_add (stmt
, list_p
);
2679 /* Generate a set of assignment statements in *LIST_P to set all instantiated
2680 elements under ELT with the contents of the initializer INIT. In addition,
2681 mark all assigned elements VISITED; this allows easy coordination with
2682 generate_element_zero. Return false if we found a case we couldn't
2686 generate_element_init_1 (struct sra_elt
*elt
, tree init
, tree
*list_p
)
2689 enum tree_code init_code
;
2690 struct sra_elt
*sub
;
2692 unsigned HOST_WIDE_INT idx
;
2693 tree value
, purpose
;
2695 /* We can be passed DECL_INITIAL of a static variable. It might have a
2696 conversion, which we strip off here. */
2697 STRIP_USELESS_TYPE_CONVERSION (init
);
2698 init_code
= TREE_CODE (init
);
2702 if (elt
->replacement
)
2704 generate_one_element_init (elt
, init
, list_p
);
2705 elt
->visited
= true;
2714 FOR_EACH_ACTUAL_CHILD (sub
, elt
)
2716 if (sub
->element
== integer_zero_node
)
2717 t
= (init_code
== COMPLEX_EXPR
2718 ? TREE_OPERAND (init
, 0) : TREE_REALPART (init
));
2720 t
= (init_code
== COMPLEX_EXPR
2721 ? TREE_OPERAND (init
, 1) : TREE_IMAGPART (init
));
2722 result
&= generate_element_init_1 (sub
, t
, list_p
);
2727 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, purpose
, value
)
2729 if (TREE_CODE (purpose
) == RANGE_EXPR
)
2731 tree lower
= TREE_OPERAND (purpose
, 0);
2732 tree upper
= TREE_OPERAND (purpose
, 1);
2736 sub
= lookup_element (elt
, lower
, NULL
, NO_INSERT
);
2738 result
&= generate_element_init_1 (sub
, value
, list_p
);
2739 if (tree_int_cst_equal (lower
, upper
))
2741 lower
= int_const_binop (PLUS_EXPR
, lower
,
2742 integer_one_node
, true);
2747 sub
= lookup_element (elt
, purpose
, NULL
, NO_INSERT
);
2749 result
&= generate_element_init_1 (sub
, value
, list_p
);
2755 elt
->visited
= true;
2762 /* A wrapper function for generate_element_init_1 that handles cleanup after
2766 generate_element_init (struct sra_elt
*elt
, tree init
, tree
*list_p
)
2770 push_gimplify_context ();
2771 ret
= generate_element_init_1 (elt
, init
, list_p
);
2772 pop_gimplify_context (NULL
);
2774 /* The replacement can expose previously unreferenced variables. */
2777 tree_stmt_iterator i
;
2779 for (i
= tsi_start (*list_p
); !tsi_end_p (i
); tsi_next (&i
))
2780 find_new_referenced_vars (tsi_stmt_ptr (i
));
2786 /* Insert STMT on all the outgoing edges out of BB. Note that if BB
2787 has more than one edge, STMT will be replicated for each edge. Also,
2788 abnormal edges will be ignored. */
2791 insert_edge_copies (tree stmt
, basic_block bb
)
2798 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2800 /* We don't need to insert copies on abnormal edges. The
2801 value of the scalar replacement is not guaranteed to
2802 be valid through an abnormal edge. */
2803 if (!(e
->flags
& EDGE_ABNORMAL
))
2807 bsi_insert_on_edge (e
, stmt
);
2811 bsi_insert_on_edge (e
, unsave_expr_now (stmt
));
2816 /* Helper function to insert LIST before BSI, and set up line number info. */
2819 sra_insert_before (block_stmt_iterator
*bsi
, tree list
)
2821 tree stmt
= bsi_stmt (*bsi
);
2823 if (EXPR_HAS_LOCATION (stmt
))
2824 annotate_all_with_locus (&list
, EXPR_LOCATION (stmt
));
2825 bsi_insert_before (bsi
, list
, BSI_SAME_STMT
);
2828 /* Similarly, but insert after BSI. Handles insertion onto edges as well. */
2831 sra_insert_after (block_stmt_iterator
*bsi
, tree list
)
2833 tree stmt
= bsi_stmt (*bsi
);
2835 if (EXPR_HAS_LOCATION (stmt
))
2836 annotate_all_with_locus (&list
, EXPR_LOCATION (stmt
));
2838 if (stmt_ends_bb_p (stmt
))
2839 insert_edge_copies (list
, bsi
->bb
);
2841 bsi_insert_after (bsi
, list
, BSI_SAME_STMT
);
2844 /* Similarly, but replace the statement at BSI. */
2847 sra_replace (block_stmt_iterator
*bsi
, tree list
)
2849 sra_insert_before (bsi
, list
);
2850 bsi_remove (bsi
, false);
2851 if (bsi_end_p (*bsi
))
2852 *bsi
= bsi_last (bsi
->bb
);
2857 /* Data structure that bitfield_overlaps_p fills in with information
2858 about the element passed in and how much of it overlaps with the
2859 bit-range passed it to. */
2861 struct bitfield_overlap_info
2863 /* The bit-length of an element. */
2866 /* The bit-position of the element in its parent. */
2869 /* The number of bits of the element that overlap with the incoming
2873 /* The first bit of the element that overlaps with the incoming bit
2878 /* Return true if a BIT_FIELD_REF<(FLD->parent), BLEN, BPOS>
2879 expression (referenced as BF below) accesses any of the bits in FLD,
2880 false if it doesn't. If DATA is non-null, its field_len and
2881 field_pos are filled in such that BIT_FIELD_REF<(FLD->parent),
2882 field_len, field_pos> (referenced as BFLD below) represents the
2883 entire field FLD->element, and BIT_FIELD_REF<BFLD, overlap_len,
2884 overlap_pos> represents the portion of the entire field that
2885 overlaps with BF. */
2888 bitfield_overlaps_p (tree blen
, tree bpos
, struct sra_elt
*fld
,
2889 struct bitfield_overlap_info
*data
)
2894 if (TREE_CODE (fld
->element
) == FIELD_DECL
)
2896 flen
= fold_convert (bitsizetype
, DECL_SIZE (fld
->element
));
2897 fpos
= fold_convert (bitsizetype
, DECL_FIELD_OFFSET (fld
->element
));
2898 fpos
= size_binop (MULT_EXPR
, fpos
, bitsize_int (BITS_PER_UNIT
));
2899 fpos
= size_binop (PLUS_EXPR
, fpos
, DECL_FIELD_BIT_OFFSET (fld
->element
));
2901 else if (TREE_CODE (fld
->element
) == BIT_FIELD_REF
)
2903 flen
= fold_convert (bitsizetype
, TREE_OPERAND (fld
->element
, 1));
2904 fpos
= fold_convert (bitsizetype
, TREE_OPERAND (fld
->element
, 2));
2906 else if (TREE_CODE (fld
->element
) == INTEGER_CST
)
2908 flen
= fold_convert (bitsizetype
, TYPE_SIZE (fld
->type
));
2909 fpos
= fold_convert (bitsizetype
, fld
->element
);
2910 fpos
= size_binop (MULT_EXPR
, flen
, fpos
);
2915 gcc_assert (host_integerp (blen
, 1)
2916 && host_integerp (bpos
, 1)
2917 && host_integerp (flen
, 1)
2918 && host_integerp (fpos
, 1));
2920 ret
= ((!tree_int_cst_lt (fpos
, bpos
)
2921 && tree_int_cst_lt (size_binop (MINUS_EXPR
, fpos
, bpos
),
2923 || (!tree_int_cst_lt (bpos
, fpos
)
2924 && tree_int_cst_lt (size_binop (MINUS_EXPR
, bpos
, fpos
),
2934 data
->field_len
= flen
;
2935 data
->field_pos
= fpos
;
2937 fend
= size_binop (PLUS_EXPR
, fpos
, flen
);
2938 bend
= size_binop (PLUS_EXPR
, bpos
, blen
);
2940 if (tree_int_cst_lt (bend
, fend
))
2941 data
->overlap_len
= size_binop (MINUS_EXPR
, bend
, fpos
);
2943 data
->overlap_len
= NULL
;
2945 if (tree_int_cst_lt (fpos
, bpos
))
2947 data
->overlap_pos
= size_binop (MINUS_EXPR
, bpos
, fpos
);
2948 data
->overlap_len
= size_binop (MINUS_EXPR
,
2955 data
->overlap_pos
= NULL
;
2961 /* Add to LISTP a sequence of statements that copies BLEN bits between
2962 VAR and the scalarized elements of ELT, starting a bit VPOS of VAR
2963 and at bit BPOS of ELT. The direction of the copy is given by
2967 sra_explode_bitfield_assignment (tree var
, tree vpos
, bool to_var
,
2968 tree
*listp
, tree blen
, tree bpos
,
2969 struct sra_elt
*elt
)
2971 struct sra_elt
*fld
;
2972 struct bitfield_overlap_info flp
;
2974 FOR_EACH_ACTUAL_CHILD (fld
, elt
)
2978 if (!bitfield_overlaps_p (blen
, bpos
, fld
, &flp
))
2981 flen
= flp
.overlap_len
? flp
.overlap_len
: flp
.field_len
;
2982 fpos
= flp
.overlap_pos
? flp
.overlap_pos
: bitsize_int (0);
2984 if (fld
->replacement
)
2986 tree infld
, invar
, st
, type
;
2988 infld
= fld
->replacement
;
2990 type
= TREE_TYPE (infld
);
2991 if (TYPE_PRECISION (type
) != TREE_INT_CST_LOW (flen
))
2992 type
= lang_hooks
.types
.type_for_size (TREE_INT_CST_LOW (flen
), 1);
2994 if (TREE_CODE (infld
) == BIT_FIELD_REF
)
2996 fpos
= size_binop (PLUS_EXPR
, fpos
, TREE_OPERAND (infld
, 2));
2997 infld
= TREE_OPERAND (infld
, 0);
2999 else if (BYTES_BIG_ENDIAN
&& DECL_P (fld
->element
)
3000 && !tree_int_cst_equal (TYPE_SIZE (TREE_TYPE (infld
)),
3001 DECL_SIZE (fld
->element
)))
3003 fpos
= size_binop (PLUS_EXPR
, fpos
,
3004 TYPE_SIZE (TREE_TYPE (infld
)));
3005 fpos
= size_binop (MINUS_EXPR
, fpos
,
3006 DECL_SIZE (fld
->element
));
3009 infld
= fold_build3 (BIT_FIELD_REF
, type
, infld
, flen
, fpos
);
3010 BIT_FIELD_REF_UNSIGNED (infld
) = 1;
3012 invar
= size_binop (MINUS_EXPR
, flp
.field_pos
, bpos
);
3013 if (flp
.overlap_pos
)
3014 invar
= size_binop (PLUS_EXPR
, invar
, flp
.overlap_pos
);
3015 invar
= size_binop (PLUS_EXPR
, invar
, vpos
);
3017 invar
= fold_build3 (BIT_FIELD_REF
, type
, var
, flen
, invar
);
3018 BIT_FIELD_REF_UNSIGNED (invar
) = 1;
3021 st
= sra_build_bf_assignment (invar
, infld
);
3023 st
= sra_build_bf_assignment (infld
, invar
);
3025 append_to_statement_list (st
, listp
);
3029 tree sub
= size_binop (MINUS_EXPR
, flp
.field_pos
, bpos
);
3030 sub
= size_binop (PLUS_EXPR
, vpos
, sub
);
3031 if (flp
.overlap_pos
)
3032 sub
= size_binop (PLUS_EXPR
, sub
, flp
.overlap_pos
);
3034 sra_explode_bitfield_assignment (var
, sub
, to_var
, listp
,
3040 /* Add to LISTBEFOREP statements that copy scalarized members of ELT
3041 that overlap with BIT_FIELD_REF<(ELT->element), BLEN, BPOS> back
3042 into the full variable, and to LISTAFTERP, if non-NULL, statements
3043 that copy the (presumably modified) overlapping portions of the
3044 full variable back to the scalarized variables. */
3047 sra_sync_for_bitfield_assignment (tree
*listbeforep
, tree
*listafterp
,
3048 tree blen
, tree bpos
,
3049 struct sra_elt
*elt
)
3051 struct sra_elt
*fld
;
3052 struct bitfield_overlap_info flp
;
3054 FOR_EACH_ACTUAL_CHILD (fld
, elt
)
3055 if (bitfield_overlaps_p (blen
, bpos
, fld
, &flp
))
3057 if (fld
->replacement
|| (!flp
.overlap_len
&& !flp
.overlap_pos
))
3059 generate_copy_inout (fld
, false, generate_element_ref (fld
),
3061 mark_no_warning (fld
);
3063 generate_copy_inout (fld
, true, generate_element_ref (fld
),
3068 tree flen
= flp
.overlap_len
? flp
.overlap_len
: flp
.field_len
;
3069 tree fpos
= flp
.overlap_pos
? flp
.overlap_pos
: bitsize_int (0);
3071 sra_sync_for_bitfield_assignment (listbeforep
, listafterp
,
3077 /* Scalarize a USE. To recap, this is either a simple reference to ELT,
3078 if elt is scalar, or some occurrence of ELT that requires a complete
3079 aggregate. IS_OUTPUT is true if ELT is being modified. */
3082 scalarize_use (struct sra_elt
*elt
, tree
*expr_p
, block_stmt_iterator
*bsi
,
3083 bool is_output
, bool use_all
)
3085 tree stmt
= bsi_stmt (*bsi
);
3088 if (elt
->replacement
)
3090 tree replacement
= elt
->replacement
;
3092 /* If we have a replacement, then updating the reference is as
3093 simple as modifying the existing statement in place. */
3095 && TREE_CODE (elt
->replacement
) == BIT_FIELD_REF
3096 && is_gimple_reg (TREE_OPERAND (elt
->replacement
, 0))
3097 && TREE_CODE (stmt
) == GIMPLE_MODIFY_STMT
3098 && &GIMPLE_STMT_OPERAND (stmt
, 0) == expr_p
)
3100 tree newstmt
= sra_build_elt_assignment
3101 (elt
, GIMPLE_STMT_OPERAND (stmt
, 1));
3102 if (TREE_CODE (newstmt
) != STATEMENT_LIST
)
3105 append_to_statement_list (newstmt
, &list
);
3108 sra_replace (bsi
, newstmt
);
3112 && TREE_CODE (elt
->replacement
) == BIT_FIELD_REF
3113 && TREE_CODE (stmt
) == GIMPLE_MODIFY_STMT
3114 && &GIMPLE_STMT_OPERAND (stmt
, 1) == expr_p
)
3116 tree tmp
= make_rename_temp
3117 (TREE_TYPE (GIMPLE_STMT_OPERAND (stmt
, 0)), "SR");
3118 tree newstmt
= sra_build_assignment (tmp
, REPLDUP (elt
->replacement
));
3120 if (TREE_CODE (newstmt
) != STATEMENT_LIST
)
3123 append_to_statement_list (newstmt
, &list
);
3126 sra_insert_before (bsi
, newstmt
);
3130 mark_all_v_defs (stmt
);
3131 *expr_p
= REPLDUP (replacement
);
3134 else if (use_all
&& is_output
3135 && TREE_CODE (stmt
) == GIMPLE_MODIFY_STMT
3136 && TREE_CODE (bfexpr
3137 = GIMPLE_STMT_OPERAND (stmt
, 0)) == BIT_FIELD_REF
3138 && &TREE_OPERAND (bfexpr
, 0) == expr_p
3139 && INTEGRAL_TYPE_P (TREE_TYPE (bfexpr
))
3140 && TREE_CODE (TREE_TYPE (*expr_p
)) == RECORD_TYPE
)
3142 tree listbefore
= NULL
, listafter
= NULL
;
3143 tree blen
= fold_convert (bitsizetype
, TREE_OPERAND (bfexpr
, 1));
3144 tree bpos
= fold_convert (bitsizetype
, TREE_OPERAND (bfexpr
, 2));
3145 bool update
= false;
3147 if (!elt
->use_block_copy
)
3149 tree type
= TREE_TYPE (bfexpr
);
3150 tree var
= make_rename_temp (type
, "SR"), tmp
, st
;
3152 GIMPLE_STMT_OPERAND (stmt
, 0) = var
;
3155 if (!TYPE_UNSIGNED (type
))
3157 type
= unsigned_type_for (type
);
3158 tmp
= make_rename_temp (type
, "SR");
3159 st
= build_gimple_modify_stmt (tmp
,
3160 fold_convert (type
, var
));
3161 append_to_statement_list (st
, &listafter
);
3165 sra_explode_bitfield_assignment
3166 (var
, bitsize_int (0), false, &listafter
, blen
, bpos
, elt
);
3169 sra_sync_for_bitfield_assignment
3170 (&listbefore
, &listafter
, blen
, bpos
, elt
);
3174 mark_all_v_defs (listbefore
);
3175 sra_insert_before (bsi
, listbefore
);
3179 mark_all_v_defs (listafter
);
3180 sra_insert_after (bsi
, listafter
);
3186 else if (use_all
&& !is_output
3187 && TREE_CODE (stmt
) == GIMPLE_MODIFY_STMT
3188 && TREE_CODE (bfexpr
3189 = GIMPLE_STMT_OPERAND (stmt
, 1)) == BIT_FIELD_REF
3190 && &TREE_OPERAND (GIMPLE_STMT_OPERAND (stmt
, 1), 0) == expr_p
3191 && INTEGRAL_TYPE_P (TREE_TYPE (bfexpr
))
3192 && TREE_CODE (TREE_TYPE (*expr_p
)) == RECORD_TYPE
)
3195 tree blen
= fold_convert (bitsizetype
, TREE_OPERAND (bfexpr
, 1));
3196 tree bpos
= fold_convert (bitsizetype
, TREE_OPERAND (bfexpr
, 2));
3197 bool update
= false;
3199 if (!elt
->use_block_copy
)
3201 tree type
= TREE_TYPE (bfexpr
);
3204 if (!TYPE_UNSIGNED (type
))
3205 type
= unsigned_type_for (type
);
3207 var
= make_rename_temp (type
, "SR");
3209 append_to_statement_list (build_gimple_modify_stmt
3210 (var
, build_int_cst_wide (type
, 0, 0)),
3213 sra_explode_bitfield_assignment
3214 (var
, bitsize_int (0), true, &list
, blen
, bpos
, elt
);
3216 GIMPLE_STMT_OPERAND (stmt
, 1) = var
;
3220 sra_sync_for_bitfield_assignment
3221 (&list
, NULL
, blen
, bpos
, elt
);
3225 mark_all_v_defs (list
);
3226 sra_insert_before (bsi
, list
);
3236 /* Otherwise we need some copies. If ELT is being read, then we
3237 want to store all (modified) sub-elements back into the
3238 structure before the reference takes place. If ELT is being
3239 written, then we want to load the changed values back into
3240 our shadow variables. */
3241 /* ??? We don't check modified for reads, we just always write all of
3242 the values. We should be able to record the SSA number of the VOP
3243 for which the values were last read. If that number matches the
3244 SSA number of the VOP in the current statement, then we needn't
3245 emit an assignment. This would also eliminate double writes when
3246 a structure is passed as more than one argument to a function call.
3247 This optimization would be most effective if sra_walk_function
3248 processed the blocks in dominator order. */
3250 generate_copy_inout (elt
, is_output
, generate_element_ref (elt
), &list
);
3253 mark_all_v_defs (list
);
3255 sra_insert_after (bsi
, list
);
3258 sra_insert_before (bsi
, list
);
3260 mark_no_warning (elt
);
3265 /* Scalarize a COPY. To recap, this is an assignment statement between
3266 two scalarizable references, LHS_ELT and RHS_ELT. */
3269 scalarize_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
3270 block_stmt_iterator
*bsi
)
3274 if (lhs_elt
->replacement
&& rhs_elt
->replacement
)
3276 /* If we have two scalar operands, modify the existing statement. */
3277 stmt
= bsi_stmt (*bsi
);
3279 /* See the commentary in sra_walk_function concerning
3280 RETURN_EXPR, and why we should never see one here. */
3281 gcc_assert (TREE_CODE (stmt
) == GIMPLE_MODIFY_STMT
);
3283 GIMPLE_STMT_OPERAND (stmt
, 0) = lhs_elt
->replacement
;
3284 GIMPLE_STMT_OPERAND (stmt
, 1) = REPLDUP (rhs_elt
->replacement
);
3287 else if (lhs_elt
->use_block_copy
|| rhs_elt
->use_block_copy
)
3289 /* If either side requires a block copy, then sync the RHS back
3290 to the original structure, leave the original assignment
3291 statement (which will perform the block copy), then load the
3292 LHS values out of its now-updated original structure. */
3293 /* ??? Could perform a modified pair-wise element copy. That
3294 would at least allow those elements that are instantiated in
3295 both structures to be optimized well. */
3298 generate_copy_inout (rhs_elt
, false,
3299 generate_element_ref (rhs_elt
), &list
);
3302 mark_all_v_defs (list
);
3303 sra_insert_before (bsi
, list
);
3307 generate_copy_inout (lhs_elt
, true,
3308 generate_element_ref (lhs_elt
), &list
);
3311 mark_all_v_defs (list
);
3312 sra_insert_after (bsi
, list
);
3317 /* Otherwise both sides must be fully instantiated. In which
3318 case perform pair-wise element assignments and replace the
3319 original block copy statement. */
3321 stmt
= bsi_stmt (*bsi
);
3322 mark_all_v_defs (stmt
);
3325 generate_element_copy (lhs_elt
, rhs_elt
, &list
);
3327 mark_all_v_defs (list
);
3328 sra_replace (bsi
, list
);
3332 /* Scalarize an INIT. To recap, this is an assignment to a scalarizable
3333 reference from some form of constructor: CONSTRUCTOR, COMPLEX_CST or
3334 COMPLEX_EXPR. If RHS is NULL, it should be treated as an empty
3338 scalarize_init (struct sra_elt
*lhs_elt
, tree rhs
, block_stmt_iterator
*bsi
)
3343 /* Generate initialization statements for all members extant in the RHS. */
3346 /* Unshare the expression just in case this is from a decl's initial. */
3347 rhs
= unshare_expr (rhs
);
3348 result
= generate_element_init (lhs_elt
, rhs
, &list
);
3351 /* CONSTRUCTOR is defined such that any member not mentioned is assigned
3352 a zero value. Initialize the rest of the instantiated elements. */
3353 generate_element_zero (lhs_elt
, &list
);
3357 /* If we failed to convert the entire initializer, then we must
3358 leave the structure assignment in place and must load values
3359 from the structure into the slots for which we did not find
3360 constants. The easiest way to do this is to generate a complete
3361 copy-out, and then follow that with the constant assignments
3362 that we were able to build. DCE will clean things up. */
3364 generate_copy_inout (lhs_elt
, true, generate_element_ref (lhs_elt
),
3366 append_to_statement_list (list
, &list0
);
3370 if (lhs_elt
->use_block_copy
|| !result
)
3372 /* Since LHS is not fully instantiated, we must leave the structure
3373 assignment in place. Treating this case differently from a USE
3374 exposes constants to later optimizations. */
3377 mark_all_v_defs (list
);
3378 sra_insert_after (bsi
, list
);
3383 /* The LHS is fully instantiated. The list of initializations
3384 replaces the original structure assignment. */
3386 mark_all_v_defs (bsi_stmt (*bsi
));
3387 mark_all_v_defs (list
);
3388 sra_replace (bsi
, list
);
3392 /* A subroutine of scalarize_ldst called via walk_tree. Set TREE_NO_TRAP
3393 on all INDIRECT_REFs. */
3396 mark_notrap (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
3400 if (TREE_CODE (t
) == INDIRECT_REF
)
3402 TREE_THIS_NOTRAP (t
) = 1;
3405 else if (IS_TYPE_OR_DECL_P (t
))
3411 /* Scalarize a LDST. To recap, this is an assignment between one scalarizable
3412 reference ELT and one non-scalarizable reference OTHER. IS_OUTPUT is true
3413 if ELT is on the left-hand side. */
3416 scalarize_ldst (struct sra_elt
*elt
, tree other
,
3417 block_stmt_iterator
*bsi
, bool is_output
)
3419 /* Shouldn't have gotten called for a scalar. */
3420 gcc_assert (!elt
->replacement
);
3422 if (elt
->use_block_copy
)
3424 /* Since ELT is not fully instantiated, we have to leave the
3425 block copy in place. Treat this as a USE. */
3426 scalarize_use (elt
, NULL
, bsi
, is_output
, false);
3430 /* The interesting case is when ELT is fully instantiated. In this
3431 case we can have each element stored/loaded directly to/from the
3432 corresponding slot in OTHER. This avoids a block copy. */
3434 tree list
= NULL
, stmt
= bsi_stmt (*bsi
);
3436 mark_all_v_defs (stmt
);
3437 generate_copy_inout (elt
, is_output
, other
, &list
);
3439 mark_all_v_defs (list
);
3441 /* Preserve EH semantics. */
3442 if (stmt_ends_bb_p (stmt
))
3444 tree_stmt_iterator tsi
;
3445 tree first
, blist
= NULL
;
3446 bool thr
= tree_could_throw_p (stmt
);
3448 /* If the last statement of this BB created an EH edge
3449 before scalarization, we have to locate the first
3450 statement that can throw in the new statement list and
3451 use that as the last statement of this BB, such that EH
3452 semantics is preserved. All statements up to this one
3453 are added to the same BB. All other statements in the
3454 list will be added to normal outgoing edges of the same
3455 BB. If they access any memory, it's the same memory, so
3456 we can assume they won't throw. */
3457 tsi
= tsi_start (list
);
3458 for (first
= tsi_stmt (tsi
);
3459 thr
&& !tsi_end_p (tsi
) && !tree_could_throw_p (first
);
3460 first
= tsi_stmt (tsi
))
3463 append_to_statement_list (first
, &blist
);
3466 /* Extract the first remaining statement from LIST, this is
3467 the EH statement if there is one. */
3471 sra_insert_before (bsi
, blist
);
3473 /* Replace the old statement with this new representative. */
3474 bsi_replace (bsi
, first
, true);
3476 if (!tsi_end_p (tsi
))
3478 /* If any reference would trap, then they all would. And more
3479 to the point, the first would. Therefore none of the rest
3480 will trap since the first didn't. Indicate this by
3481 iterating over the remaining statements and set
3482 TREE_THIS_NOTRAP in all INDIRECT_REFs. */
3485 walk_tree (tsi_stmt_ptr (tsi
), mark_notrap
, NULL
, NULL
);
3488 while (!tsi_end_p (tsi
));
3490 insert_edge_copies (list
, bsi
->bb
);
3494 sra_replace (bsi
, list
);
3498 /* Generate initializations for all scalarizable parameters. */
3501 scalarize_parms (void)
3507 EXECUTE_IF_SET_IN_BITMAP (needs_copy_in
, 0, i
, bi
)
3509 tree var
= referenced_var (i
);
3510 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
3511 generate_copy_inout (elt
, true, var
, &list
);
3516 insert_edge_copies (list
, ENTRY_BLOCK_PTR
);
3517 mark_all_v_defs (list
);
3521 /* Entry point to phase 4. Update the function to match replacements. */
3524 scalarize_function (void)
3526 static const struct sra_walk_fns fns
= {
3527 scalarize_use
, scalarize_copy
, scalarize_init
, scalarize_ldst
, false
3530 sra_walk_function (&fns
);
3532 bsi_commit_edge_inserts ();
3536 /* Debug helper function. Print ELT in a nice human-readable format. */
3539 dump_sra_elt_name (FILE *f
, struct sra_elt
*elt
)
3541 if (elt
->parent
&& TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
3543 fputs (elt
->element
== integer_zero_node
? "__real__ " : "__imag__ ", f
);
3544 dump_sra_elt_name (f
, elt
->parent
);
3549 dump_sra_elt_name (f
, elt
->parent
);
3550 if (DECL_P (elt
->element
))
3552 if (TREE_CODE (elt
->element
) == FIELD_DECL
)
3554 print_generic_expr (f
, elt
->element
, dump_flags
);
3556 else if (TREE_CODE (elt
->element
) == BIT_FIELD_REF
)
3557 fprintf (f
, "$B" HOST_WIDE_INT_PRINT_DEC
"F" HOST_WIDE_INT_PRINT_DEC
,
3558 tree_low_cst (TREE_OPERAND (elt
->element
, 2), 1),
3559 tree_low_cst (TREE_OPERAND (elt
->element
, 1), 1));
3560 else if (TREE_CODE (elt
->element
) == RANGE_EXPR
)
3561 fprintf (f
, "["HOST_WIDE_INT_PRINT_DEC
".."HOST_WIDE_INT_PRINT_DEC
"]",
3562 TREE_INT_CST_LOW (TREE_OPERAND (elt
->element
, 0)),
3563 TREE_INT_CST_LOW (TREE_OPERAND (elt
->element
, 1)));
3565 fprintf (f
, "[" HOST_WIDE_INT_PRINT_DEC
"]",
3566 TREE_INT_CST_LOW (elt
->element
));
3570 /* Likewise, but callable from the debugger. */
3573 debug_sra_elt_name (struct sra_elt
*elt
)
3575 dump_sra_elt_name (stderr
, elt
);
3576 fputc ('\n', stderr
);
3580 sra_init_cache (void)
3582 if (sra_type_decomp_cache
)
3585 sra_type_decomp_cache
= BITMAP_ALLOC (NULL
);
3586 sra_type_inst_cache
= BITMAP_ALLOC (NULL
);
3589 /* Main entry point. */
3594 /* Initialize local variables. */
3596 gcc_obstack_init (&sra_obstack
);
3597 sra_candidates
= BITMAP_ALLOC (NULL
);
3598 needs_copy_in
= BITMAP_ALLOC (NULL
);
3600 sra_map
= htab_create (101, sra_elt_hash
, sra_elt_eq
, NULL
);
3602 /* Scan. If we find anything, instantiate and scalarize. */
3603 if (find_candidates_for_sra ())
3606 decide_instantiations ();
3607 scalarize_function ();
3608 if (!bitmap_empty_p (sra_candidates
))
3609 todoflags
|= TODO_rebuild_alias
;
3612 /* Free allocated memory. */
3613 htab_delete (sra_map
);
3615 BITMAP_FREE (sra_candidates
);
3616 BITMAP_FREE (needs_copy_in
);
3617 BITMAP_FREE (sra_type_decomp_cache
);
3618 BITMAP_FREE (sra_type_inst_cache
);
3619 obstack_free (&sra_obstack
, NULL
);
3624 tree_sra_early (void)
3632 return ret
& ~TODO_rebuild_alias
;
3638 return flag_tree_sra
!= 0;
3641 struct tree_opt_pass pass_sra_early
=
3644 gate_sra
, /* gate */
3645 tree_sra_early
, /* execute */
3648 0, /* static_pass_number */
3649 TV_TREE_SRA
, /* tv_id */
3650 PROP_cfg
| PROP_ssa
, /* properties_required */
3651 0, /* properties_provided */
3652 0, /* properties_destroyed */
3653 0, /* todo_flags_start */
3657 | TODO_verify_ssa
, /* todo_flags_finish */
3661 struct tree_opt_pass pass_sra
=
3664 gate_sra
, /* gate */
3665 tree_sra
, /* execute */
3668 0, /* static_pass_number */
3669 TV_TREE_SRA
, /* tv_id */
3670 PROP_cfg
| PROP_ssa
, /* properties_required */
3671 0, /* properties_provided */
3672 0, /* properties_destroyed */
3673 0, /* todo_flags_start */
3677 | TODO_verify_ssa
, /* todo_flags_finish */