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, 2008
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"
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 gimple_seq
sra_build_assignment (tree dst
, tree src
);
212 static void mark_all_v_defs_seq (gimple_seq
);
213 static void mark_all_v_defs_stmt (gimple
);
216 /* Return true if DECL is an SRA candidate. */
219 is_sra_candidate_decl (tree decl
)
221 return DECL_P (decl
) && bitmap_bit_p (sra_candidates
, DECL_UID (decl
));
224 /* Return true if TYPE is a scalar type. */
227 is_sra_scalar_type (tree type
)
229 enum tree_code code
= TREE_CODE (type
);
230 return (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== VECTOR_TYPE
231 || code
== FIXED_POINT_TYPE
232 || code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
233 || code
== POINTER_TYPE
|| code
== OFFSET_TYPE
234 || code
== REFERENCE_TYPE
);
237 /* Return true if TYPE can be decomposed into a set of independent variables.
239 Note that this doesn't imply that all elements of TYPE can be
240 instantiated, just that if we decide to break up the type into
241 separate pieces that it can be done. */
244 sra_type_can_be_decomposed_p (tree type
)
246 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
249 /* Avoid searching the same type twice. */
250 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+0))
252 if (bitmap_bit_p (sra_type_decomp_cache
, cache
+1))
255 /* The type must have a definite nonzero size. */
256 if (TYPE_SIZE (type
) == NULL
|| TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
257 || integer_zerop (TYPE_SIZE (type
)))
260 /* The type must be a non-union aggregate. */
261 switch (TREE_CODE (type
))
265 bool saw_one_field
= false;
267 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
268 if (TREE_CODE (t
) == FIELD_DECL
)
270 /* Reject incorrectly represented bit fields. */
271 if (DECL_BIT_FIELD (t
)
272 && INTEGRAL_TYPE_P (TREE_TYPE (t
))
273 && (tree_low_cst (DECL_SIZE (t
), 1)
274 != TYPE_PRECISION (TREE_TYPE (t
))))
277 saw_one_field
= true;
280 /* Record types must have at least one field. */
287 /* Array types must have a fixed lower and upper bound. */
288 t
= TYPE_DOMAIN (type
);
291 if (TYPE_MIN_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MIN_VALUE (t
)))
293 if (TYPE_MAX_VALUE (t
) == NULL
|| !TREE_CONSTANT (TYPE_MAX_VALUE (t
)))
304 bitmap_set_bit (sra_type_decomp_cache
, cache
+0);
308 bitmap_set_bit (sra_type_decomp_cache
, cache
+1);
312 /* Returns true if the TYPE is one of the available va_list types.
313 Otherwise it returns false.
314 Note, that for multiple calling conventions there can be more
315 than just one va_list type present. */
318 is_va_list_type (tree type
)
322 if (type
== NULL_TREE
)
324 h
= targetm
.canonical_va_list_type (type
);
327 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (h
))
332 /* Return true if DECL can be decomposed into a set of independent
333 (though not necessarily scalar) variables. */
336 decl_can_be_decomposed_p (tree var
)
338 /* Early out for scalars. */
339 if (is_sra_scalar_type (TREE_TYPE (var
)))
342 /* The variable must not be aliased. */
343 if (!is_gimple_non_addressable (var
))
345 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
347 fprintf (dump_file
, "Cannot scalarize variable ");
348 print_generic_expr (dump_file
, var
, dump_flags
);
349 fprintf (dump_file
, " because it must live in memory\n");
354 /* The variable must not be volatile. */
355 if (TREE_THIS_VOLATILE (var
))
357 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
359 fprintf (dump_file
, "Cannot scalarize variable ");
360 print_generic_expr (dump_file
, var
, dump_flags
);
361 fprintf (dump_file
, " because it is declared volatile\n");
366 /* We must be able to decompose the variable's type. */
367 if (!sra_type_can_be_decomposed_p (TREE_TYPE (var
)))
369 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
371 fprintf (dump_file
, "Cannot scalarize variable ");
372 print_generic_expr (dump_file
, var
, dump_flags
);
373 fprintf (dump_file
, " because its type cannot be decomposed\n");
378 /* HACK: if we decompose a va_list_type_node before inlining, then we'll
379 confuse tree-stdarg.c, and we won't be able to figure out which and
380 how many arguments are accessed. This really should be improved in
381 tree-stdarg.c, as the decomposition is truly a win. This could also
382 be fixed if the stdarg pass ran early, but this can't be done until
383 we've aliasing information early too. See PR 30791. */
384 if (early_sra
&& is_va_list_type (TREE_TYPE (var
)))
390 /* Return true if TYPE can be *completely* decomposed into scalars. */
393 type_can_instantiate_all_elements (tree type
)
395 if (is_sra_scalar_type (type
))
397 if (!sra_type_can_be_decomposed_p (type
))
400 switch (TREE_CODE (type
))
404 unsigned int cache
= TYPE_UID (TYPE_MAIN_VARIANT (type
)) * 2;
407 if (bitmap_bit_p (sra_type_inst_cache
, cache
+0))
409 if (bitmap_bit_p (sra_type_inst_cache
, cache
+1))
412 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
413 if (TREE_CODE (f
) == FIELD_DECL
)
415 if (!type_can_instantiate_all_elements (TREE_TYPE (f
)))
417 bitmap_set_bit (sra_type_inst_cache
, cache
+1);
422 bitmap_set_bit (sra_type_inst_cache
, cache
+0);
427 return type_can_instantiate_all_elements (TREE_TYPE (type
));
437 /* Test whether ELT or some sub-element cannot be scalarized. */
440 can_completely_scalarize_p (struct sra_elt
*elt
)
444 if (elt
->cannot_scalarize
)
447 for (c
= elt
->children
; c
; c
= c
->sibling
)
448 if (!can_completely_scalarize_p (c
))
451 for (c
= elt
->groups
; c
; c
= c
->sibling
)
452 if (!can_completely_scalarize_p (c
))
459 /* A simplified tree hashing algorithm that only handles the types of
460 trees we expect to find in sra_elt->element. */
463 sra_hash_tree (tree t
)
467 switch (TREE_CODE (t
))
476 h
= TREE_INT_CST_LOW (t
) ^ TREE_INT_CST_HIGH (t
);
480 h
= iterative_hash_expr (TREE_OPERAND (t
, 0), 0);
481 h
= iterative_hash_expr (TREE_OPERAND (t
, 1), h
);
485 /* We can have types that are compatible, but have different member
486 lists, so we can't hash fields by ID. Use offsets instead. */
487 h
= iterative_hash_expr (DECL_FIELD_OFFSET (t
), 0);
488 h
= iterative_hash_expr (DECL_FIELD_BIT_OFFSET (t
), h
);
492 /* Don't take operand 0 into account, that's our parent. */
493 h
= iterative_hash_expr (TREE_OPERAND (t
, 1), 0);
494 h
= iterative_hash_expr (TREE_OPERAND (t
, 2), h
);
504 /* Hash function for type SRA_PAIR. */
507 sra_elt_hash (const void *x
)
509 const struct sra_elt
*const e
= (const struct sra_elt
*) x
;
510 const struct sra_elt
*p
;
513 h
= sra_hash_tree (e
->element
);
515 /* Take into account everything except bitfield blocks back up the
516 chain. Given that chain lengths are rarely very long, this
517 should be acceptable. If we truly identify this as a performance
518 problem, it should work to hash the pointer value
520 for (p
= e
->parent
; p
; p
= p
->parent
)
521 if (!p
->in_bitfld_block
)
522 h
= (h
* 65521) ^ sra_hash_tree (p
->element
);
527 /* Equality function for type SRA_PAIR. */
530 sra_elt_eq (const void *x
, const void *y
)
532 const struct sra_elt
*const a
= (const struct sra_elt
*) x
;
533 const struct sra_elt
*const b
= (const struct sra_elt
*) y
;
535 const struct sra_elt
*ap
= a
->parent
;
536 const struct sra_elt
*bp
= b
->parent
;
539 while (ap
->in_bitfld_block
)
542 while (bp
->in_bitfld_block
)
553 if (TREE_CODE (ae
) != TREE_CODE (be
))
556 switch (TREE_CODE (ae
))
561 /* These are all pointer unique. */
565 /* Integers are not pointer unique, so compare their values. */
566 return tree_int_cst_equal (ae
, be
);
570 tree_int_cst_equal (TREE_OPERAND (ae
, 0), TREE_OPERAND (be
, 0))
571 && tree_int_cst_equal (TREE_OPERAND (ae
, 1), TREE_OPERAND (be
, 1));
574 /* Fields are unique within a record, but not between
575 compatible records. */
576 if (DECL_FIELD_CONTEXT (ae
) == DECL_FIELD_CONTEXT (be
))
578 return fields_compatible_p (ae
, be
);
582 tree_int_cst_equal (TREE_OPERAND (ae
, 1), TREE_OPERAND (be
, 1))
583 && tree_int_cst_equal (TREE_OPERAND (ae
, 2), TREE_OPERAND (be
, 2));
590 /* Create or return the SRA_ELT structure for CHILD in PARENT. PARENT
591 may be null, in which case CHILD must be a DECL. */
593 static struct sra_elt
*
594 lookup_element (struct sra_elt
*parent
, tree child
, tree type
,
595 enum insert_option insert
)
597 struct sra_elt dummy
;
598 struct sra_elt
**slot
;
602 dummy
.parent
= parent
->is_group
? parent
->parent
: parent
;
605 dummy
.element
= child
;
607 slot
= (struct sra_elt
**) htab_find_slot (sra_map
, &dummy
, insert
);
608 if (!slot
&& insert
== NO_INSERT
)
612 if (!elt
&& insert
== INSERT
)
614 *slot
= elt
= XOBNEW (&sra_obstack
, struct sra_elt
);
615 memset (elt
, 0, sizeof (*elt
));
617 elt
->parent
= parent
;
618 elt
->element
= child
;
620 elt
->is_scalar
= is_sra_scalar_type (type
);
624 if (IS_ELEMENT_FOR_GROUP (elt
->element
))
626 elt
->is_group
= true;
627 elt
->sibling
= parent
->groups
;
628 parent
->groups
= elt
;
632 elt
->sibling
= parent
->children
;
633 parent
->children
= elt
;
637 /* If this is a parameter, then if we want to scalarize, we have
638 one copy from the true function parameter. Count it now. */
639 if (TREE_CODE (child
) == PARM_DECL
)
642 bitmap_set_bit (needs_copy_in
, DECL_UID (child
));
649 /* Create or return the SRA_ELT structure for EXPR if the expression
650 refers to a scalarizable variable. */
652 static struct sra_elt
*
653 maybe_lookup_element_for_expr (tree expr
)
658 switch (TREE_CODE (expr
))
663 if (is_sra_candidate_decl (expr
))
664 return lookup_element (NULL
, expr
, TREE_TYPE (expr
), INSERT
);
668 /* We can't scalarize variable array indices. */
669 if (in_array_bounds_p (expr
))
670 child
= TREE_OPERAND (expr
, 1);
675 case ARRAY_RANGE_REF
:
676 /* We can't scalarize variable array indices. */
677 if (range_in_array_bounds_p (expr
))
679 tree domain
= TYPE_DOMAIN (TREE_TYPE (expr
));
680 child
= build2 (RANGE_EXPR
, integer_type_node
,
681 TYPE_MIN_VALUE (domain
), TYPE_MAX_VALUE (domain
));
689 tree type
= TREE_TYPE (TREE_OPERAND (expr
, 0));
690 /* Don't look through unions. */
691 if (TREE_CODE (type
) != RECORD_TYPE
)
693 /* Neither through variable-sized records. */
694 if (TYPE_SIZE (type
) == NULL_TREE
695 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
697 child
= TREE_OPERAND (expr
, 1);
702 child
= integer_zero_node
;
705 child
= integer_one_node
;
712 elt
= maybe_lookup_element_for_expr (TREE_OPERAND (expr
, 0));
714 return lookup_element (elt
, child
, TREE_TYPE (expr
), INSERT
);
719 /* Functions to walk just enough of the tree to see all scalarizable
720 references, and categorize them. */
722 /* A set of callbacks for phases 2 and 4. They'll be invoked for the
723 various kinds of references seen. In all cases, *GSI is an iterator
724 pointing to the statement being processed. */
727 /* Invoked when ELT is required as a unit. Note that ELT might refer to
728 a leaf node, in which case this is a simple scalar reference. *EXPR_P
729 points to the location of the expression. IS_OUTPUT is true if this
730 is a left-hand-side reference. USE_ALL is true if we saw something we
731 couldn't quite identify and had to force the use of the entire object. */
732 void (*use
) (struct sra_elt
*elt
, tree
*expr_p
,
733 gimple_stmt_iterator
*gsi
, bool is_output
, bool use_all
);
735 /* Invoked when we have a copy between two scalarizable references. */
736 void (*copy
) (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
737 gimple_stmt_iterator
*gsi
);
739 /* Invoked when ELT is initialized from a constant. VALUE may be NULL,
740 in which case it should be treated as an empty CONSTRUCTOR. */
741 void (*init
) (struct sra_elt
*elt
, tree value
, gimple_stmt_iterator
*gsi
);
743 /* Invoked when we have a copy between one scalarizable reference ELT
744 and one non-scalarizable reference OTHER without side-effects.
745 IS_OUTPUT is true if ELT is on the left-hand side. */
746 void (*ldst
) (struct sra_elt
*elt
, tree other
,
747 gimple_stmt_iterator
*gsi
, bool is_output
);
749 /* True during phase 2, false during phase 4. */
750 /* ??? This is a hack. */
754 #ifdef ENABLE_CHECKING
755 /* Invoked via walk_tree, if *TP contains a candidate decl, return it. */
758 sra_find_candidate_decl (tree
*tp
, int *walk_subtrees
,
759 void *data ATTRIBUTE_UNUSED
)
762 enum tree_code code
= TREE_CODE (t
);
764 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
767 if (is_sra_candidate_decl (t
))
777 /* Walk most expressions looking for a scalarizable aggregate.
778 If we find one, invoke FNS->USE. */
781 sra_walk_expr (tree
*expr_p
, gimple_stmt_iterator
*gsi
, bool is_output
,
782 const struct sra_walk_fns
*fns
)
786 bool disable_scalarization
= false;
787 bool use_all_p
= false;
789 /* We're looking to collect a reference expression between EXPR and INNER,
790 such that INNER is a scalarizable decl and all other nodes through EXPR
791 are references that we can scalarize. If we come across something that
792 we can't scalarize, we reset EXPR. This has the effect of making it
793 appear that we're referring to the larger expression as a whole. */
796 switch (TREE_CODE (inner
))
801 /* If there is a scalarizable decl at the bottom, then process it. */
802 if (is_sra_candidate_decl (inner
))
804 struct sra_elt
*elt
= maybe_lookup_element_for_expr (expr
);
805 if (disable_scalarization
)
806 elt
->cannot_scalarize
= true;
808 fns
->use (elt
, expr_p
, gsi
, is_output
, use_all_p
);
813 /* Non-constant index means any member may be accessed. Prevent the
814 expression from being scalarized. If we were to treat this as a
815 reference to the whole array, we can wind up with a single dynamic
816 index reference inside a loop being overridden by several constant
817 index references during loop setup. It's possible that this could
818 be avoided by using dynamic usage counts based on BB trip counts
819 (based on loop analysis or profiling), but that hardly seems worth
821 /* ??? Hack. Figure out how to push this into the scan routines
822 without duplicating too much code. */
823 if (!in_array_bounds_p (inner
))
825 disable_scalarization
= true;
828 /* ??? Are we assured that non-constant bounds and stride will have
829 the same value everywhere? I don't think Fortran will... */
830 if (TREE_OPERAND (inner
, 2) || TREE_OPERAND (inner
, 3))
832 inner
= TREE_OPERAND (inner
, 0);
835 case ARRAY_RANGE_REF
:
836 if (!range_in_array_bounds_p (inner
))
838 disable_scalarization
= true;
841 /* ??? See above non-constant bounds and stride . */
842 if (TREE_OPERAND (inner
, 2) || TREE_OPERAND (inner
, 3))
844 inner
= TREE_OPERAND (inner
, 0);
849 tree type
= TREE_TYPE (TREE_OPERAND (inner
, 0));
850 /* Don't look through unions. */
851 if (TREE_CODE (type
) != RECORD_TYPE
)
853 /* Neither through variable-sized records. */
854 if (TYPE_SIZE (type
) == NULL_TREE
855 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
857 inner
= TREE_OPERAND (inner
, 0);
863 inner
= TREE_OPERAND (inner
, 0);
867 /* A bit field reference to a specific vector is scalarized but for
868 ones for inputs need to be marked as used on the left hand size so
869 when we scalarize it, we can mark that variable as non renamable. */
871 && TREE_CODE (TREE_TYPE (TREE_OPERAND (inner
, 0))) == VECTOR_TYPE
)
874 = maybe_lookup_element_for_expr (TREE_OPERAND (inner
, 0));
876 elt
->is_vector_lhs
= true;
879 /* A bit field reference (access to *multiple* fields simultaneously)
880 is not currently scalarized. Consider this an access to the full
881 outer element, to which walk_tree will bring us next. */
885 /* Similarly, a nop explicitly wants to look at an object in a
886 type other than the one we've scalarized. */
889 case VIEW_CONVERT_EXPR
:
890 /* Likewise for a view conversion, but with an additional twist:
891 it can be on the LHS and, in this case, an access to the full
892 outer element would mean a killing def. So we need to punt
893 if we haven't already a full access to the current element,
894 because we cannot pretend to have a killing def if we only
895 have a partial access at some level. */
896 if (is_output
&& !use_all_p
&& inner
!= expr
)
897 disable_scalarization
= true;
901 /* This is a transparent wrapper. The entire inner expression really
906 expr_p
= &TREE_OPERAND (inner
, 0);
907 inner
= expr
= *expr_p
;
912 #ifdef ENABLE_CHECKING
913 /* Validate that we're not missing any references. */
914 gcc_assert (!walk_tree (&inner
, sra_find_candidate_decl
, NULL
, NULL
));
920 /* Walk the arguments of a GIMPLE_CALL looking for scalarizable aggregates.
921 If we find one, invoke FNS->USE. */
924 sra_walk_gimple_call (gimple stmt
, gimple_stmt_iterator
*gsi
,
925 const struct sra_walk_fns
*fns
)
928 int nargs
= gimple_call_num_args (stmt
);
930 for (i
= 0; i
< nargs
; i
++)
931 sra_walk_expr (gimple_call_arg_ptr (stmt
, i
), gsi
, false, fns
);
933 if (gimple_call_lhs (stmt
))
934 sra_walk_expr (gimple_call_lhs_ptr (stmt
), gsi
, true, fns
);
937 /* Walk the inputs and outputs of a GIMPLE_ASM looking for scalarizable
938 aggregates. If we find one, invoke FNS->USE. */
941 sra_walk_gimple_asm (gimple stmt
, gimple_stmt_iterator
*gsi
,
942 const struct sra_walk_fns
*fns
)
945 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
946 sra_walk_expr (&TREE_VALUE (gimple_asm_input_op (stmt
, i
)), gsi
, false, fns
);
947 for (i
= 0; i
< gimple_asm_noutputs (stmt
); i
++)
948 sra_walk_expr (&TREE_VALUE (gimple_asm_output_op (stmt
, i
)), gsi
, true, fns
);
951 /* Walk a GIMPLE_ASSIGN and categorize the assignment appropriately. */
954 sra_walk_gimple_assign (gimple stmt
, gimple_stmt_iterator
*gsi
,
955 const struct sra_walk_fns
*fns
)
957 struct sra_elt
*lhs_elt
= NULL
, *rhs_elt
= NULL
;
960 /* If there is more than 1 element on the RHS, only walk the lhs. */
961 if (!gimple_assign_single_p (stmt
))
963 sra_walk_expr (gimple_assign_lhs_ptr (stmt
), gsi
, true, fns
);
967 lhs
= gimple_assign_lhs (stmt
);
968 rhs
= gimple_assign_rhs1 (stmt
);
969 lhs_elt
= maybe_lookup_element_for_expr (lhs
);
970 rhs_elt
= maybe_lookup_element_for_expr (rhs
);
972 /* If both sides are scalarizable, this is a COPY operation. */
973 if (lhs_elt
&& rhs_elt
)
975 fns
->copy (lhs_elt
, rhs_elt
, gsi
);
979 /* If the RHS is scalarizable, handle it. There are only two cases. */
982 if (!rhs_elt
->is_scalar
&& !TREE_SIDE_EFFECTS (lhs
))
983 fns
->ldst (rhs_elt
, lhs
, gsi
, false);
985 fns
->use (rhs_elt
, gimple_assign_rhs1_ptr (stmt
), gsi
, false, false);
988 /* If it isn't scalarizable, there may be scalarizable variables within, so
989 check for a call or else walk the RHS to see if we need to do any
990 copy-in operations. We need to do it before the LHS is scalarized so
991 that the statements get inserted in the proper place, before any
992 copy-out operations. */
994 sra_walk_expr (gimple_assign_rhs1_ptr (stmt
), gsi
, false, fns
);
996 /* Likewise, handle the LHS being scalarizable. We have cases similar
997 to those above, but also want to handle RHS being constant. */
1000 /* If this is an assignment from a constant, or constructor, then
1001 we have access to all of the elements individually. Invoke INIT. */
1002 if (TREE_CODE (rhs
) == COMPLEX_EXPR
1003 || TREE_CODE (rhs
) == COMPLEX_CST
1004 || TREE_CODE (rhs
) == CONSTRUCTOR
)
1005 fns
->init (lhs_elt
, rhs
, gsi
);
1007 /* If this is an assignment from read-only memory, treat this as if
1008 we'd been passed the constructor directly. Invoke INIT. */
1009 else if (TREE_CODE (rhs
) == VAR_DECL
1010 && TREE_STATIC (rhs
)
1011 && TREE_READONLY (rhs
)
1012 && targetm
.binds_local_p (rhs
))
1013 fns
->init (lhs_elt
, DECL_INITIAL (rhs
), gsi
);
1015 /* If this is a copy from a non-scalarizable lvalue, invoke LDST.
1016 The lvalue requirement prevents us from trying to directly scalarize
1017 the result of a function call. Which would result in trying to call
1018 the function multiple times, and other evil things. */
1019 else if (!lhs_elt
->is_scalar
1020 && !TREE_SIDE_EFFECTS (rhs
) && is_gimple_addressable (rhs
))
1021 fns
->ldst (lhs_elt
, rhs
, gsi
, true);
1023 /* Otherwise we're being used in some context that requires the
1024 aggregate to be seen as a whole. Invoke USE. */
1026 fns
->use (lhs_elt
, gimple_assign_lhs_ptr (stmt
), gsi
, true, false);
1029 /* Similarly to above, LHS_ELT being null only means that the LHS as a
1030 whole is not a scalarizable reference. There may be occurrences of
1031 scalarizable variables within, which implies a USE. */
1033 sra_walk_expr (gimple_assign_lhs_ptr (stmt
), gsi
, true, fns
);
1036 /* Entry point to the walk functions. Search the entire function,
1037 invoking the callbacks in FNS on each of the references to
1038 scalarizable variables. */
1041 sra_walk_function (const struct sra_walk_fns
*fns
)
1044 gimple_stmt_iterator si
, ni
;
1046 /* ??? Phase 4 could derive some benefit to walking the function in
1047 dominator tree order. */
1050 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); si
= ni
)
1054 stmt
= gsi_stmt (si
);
1059 /* If the statement has no virtual operands, then it doesn't
1060 make any structure references that we care about. */
1061 if (gimple_aliases_computed_p (cfun
)
1062 && ZERO_SSA_OPERANDS (stmt
, (SSA_OP_VIRTUAL_DEFS
| SSA_OP_VUSE
)))
1065 switch (gimple_code (stmt
))
1068 /* If we have "return <retval>" then the return value is
1069 already exposed for our pleasure. Walk it as a USE to
1070 force all the components back in place for the return.
1072 if (gimple_return_retval (stmt
) == NULL_TREE
)
1075 sra_walk_expr (gimple_return_retval_ptr (stmt
), &si
, false,
1080 sra_walk_gimple_assign (stmt
, &si
, fns
);
1083 sra_walk_gimple_call (stmt
, &si
, fns
);
1086 sra_walk_gimple_asm (stmt
, &si
, fns
);
1095 /* Phase One: Scan all referenced variables in the program looking for
1096 structures that could be decomposed. */
1099 find_candidates_for_sra (void)
1101 bool any_set
= false;
1103 referenced_var_iterator rvi
;
1105 FOR_EACH_REFERENCED_VAR (var
, rvi
)
1107 if (decl_can_be_decomposed_p (var
))
1109 bitmap_set_bit (sra_candidates
, DECL_UID (var
));
1118 /* Phase Two: Scan all references to scalarizable variables. Count the
1119 number of times they are used or copied respectively. */
1121 /* Callbacks to fill in SRA_WALK_FNS. Everything but USE is
1122 considered a copy, because we can decompose the reference such that
1123 the sub-elements needn't be contiguous. */
1126 scan_use (struct sra_elt
*elt
, tree
*expr_p ATTRIBUTE_UNUSED
,
1127 gimple_stmt_iterator
*gsi ATTRIBUTE_UNUSED
,
1128 bool is_output ATTRIBUTE_UNUSED
, bool use_all ATTRIBUTE_UNUSED
)
1134 scan_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
1135 gimple_stmt_iterator
*gsi ATTRIBUTE_UNUSED
)
1137 lhs_elt
->n_copies
+= 1;
1138 rhs_elt
->n_copies
+= 1;
1142 scan_init (struct sra_elt
*lhs_elt
, tree rhs ATTRIBUTE_UNUSED
,
1143 gimple_stmt_iterator
*gsi ATTRIBUTE_UNUSED
)
1145 lhs_elt
->n_copies
+= 1;
1149 scan_ldst (struct sra_elt
*elt
, tree other ATTRIBUTE_UNUSED
,
1150 gimple_stmt_iterator
*gsi ATTRIBUTE_UNUSED
,
1151 bool is_output ATTRIBUTE_UNUSED
)
1156 /* Dump the values we collected during the scanning phase. */
1159 scan_dump (struct sra_elt
*elt
)
1163 dump_sra_elt_name (dump_file
, elt
);
1164 fprintf (dump_file
, ": n_uses=%u n_copies=%u\n", elt
->n_uses
, elt
->n_copies
);
1166 for (c
= elt
->children
; c
; c
= c
->sibling
)
1169 for (c
= elt
->groups
; c
; c
= c
->sibling
)
1173 /* Entry point to phase 2. Scan the entire function, building up
1174 scalarization data structures, recording copies and uses. */
1177 scan_function (void)
1179 static const struct sra_walk_fns fns
= {
1180 scan_use
, scan_copy
, scan_init
, scan_ldst
, true
1184 sra_walk_function (&fns
);
1186 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1190 fputs ("\nScan results:\n", dump_file
);
1191 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
, bi
)
1193 tree var
= referenced_var (i
);
1194 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1198 fputc ('\n', dump_file
);
1202 /* Phase Three: Make decisions about which variables to scalarize, if any.
1203 All elements to be scalarized have replacement variables made for them. */
1205 /* A subroutine of build_element_name. Recursively build the element
1206 name on the obstack. */
1209 build_element_name_1 (struct sra_elt
*elt
)
1216 build_element_name_1 (elt
->parent
);
1217 obstack_1grow (&sra_obstack
, '$');
1219 if (TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
1221 if (elt
->element
== integer_zero_node
)
1222 obstack_grow (&sra_obstack
, "real", 4);
1224 obstack_grow (&sra_obstack
, "imag", 4);
1230 if (TREE_CODE (t
) == INTEGER_CST
)
1232 /* ??? Eh. Don't bother doing double-wide printing. */
1233 sprintf (buffer
, HOST_WIDE_INT_PRINT_DEC
, TREE_INT_CST_LOW (t
));
1234 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1236 else if (TREE_CODE (t
) == BIT_FIELD_REF
)
1238 sprintf (buffer
, "B" HOST_WIDE_INT_PRINT_DEC
,
1239 tree_low_cst (TREE_OPERAND (t
, 2), 1));
1240 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1241 sprintf (buffer
, "F" HOST_WIDE_INT_PRINT_DEC
,
1242 tree_low_cst (TREE_OPERAND (t
, 1), 1));
1243 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1247 tree name
= DECL_NAME (t
);
1249 obstack_grow (&sra_obstack
, IDENTIFIER_POINTER (name
),
1250 IDENTIFIER_LENGTH (name
));
1253 sprintf (buffer
, "D%u", DECL_UID (t
));
1254 obstack_grow (&sra_obstack
, buffer
, strlen (buffer
));
1259 /* Construct a pretty variable name for an element's replacement variable.
1260 The name is built on the obstack. */
1263 build_element_name (struct sra_elt
*elt
)
1265 build_element_name_1 (elt
);
1266 obstack_1grow (&sra_obstack
, '\0');
1267 return XOBFINISH (&sra_obstack
, char *);
1270 /* Instantiate an element as an independent variable. */
1273 instantiate_element (struct sra_elt
*elt
)
1275 struct sra_elt
*base_elt
;
1277 bool nowarn
= TREE_NO_WARNING (elt
->element
);
1279 for (base_elt
= elt
; base_elt
->parent
; base_elt
= base_elt
->parent
)
1281 nowarn
= TREE_NO_WARNING (base_elt
->parent
->element
);
1282 base
= base_elt
->element
;
1284 elt
->replacement
= var
= make_rename_temp (elt
->type
, "SR");
1286 if (DECL_P (elt
->element
)
1287 && !tree_int_cst_equal (DECL_SIZE (var
), DECL_SIZE (elt
->element
)))
1289 DECL_SIZE (var
) = DECL_SIZE (elt
->element
);
1290 DECL_SIZE_UNIT (var
) = DECL_SIZE_UNIT (elt
->element
);
1292 elt
->in_bitfld_block
= 1;
1293 elt
->replacement
= fold_build3 (BIT_FIELD_REF
, elt
->type
, var
,
1296 ? size_binop (MINUS_EXPR
,
1297 TYPE_SIZE (elt
->type
),
1302 /* For vectors, if used on the left hand side with BIT_FIELD_REF,
1303 they are not a gimple register. */
1304 if (TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
&& elt
->is_vector_lhs
)
1305 DECL_GIMPLE_REG_P (var
) = 0;
1307 DECL_SOURCE_LOCATION (var
) = DECL_SOURCE_LOCATION (base
);
1308 DECL_ARTIFICIAL (var
) = 1;
1310 if (TREE_THIS_VOLATILE (elt
->type
))
1312 TREE_THIS_VOLATILE (var
) = 1;
1313 TREE_SIDE_EFFECTS (var
) = 1;
1316 if (DECL_NAME (base
) && !DECL_IGNORED_P (base
))
1318 char *pretty_name
= build_element_name (elt
);
1319 DECL_NAME (var
) = get_identifier (pretty_name
);
1320 obstack_free (&sra_obstack
, pretty_name
);
1322 SET_DECL_DEBUG_EXPR (var
, generate_element_ref (elt
));
1323 DECL_DEBUG_EXPR_IS_FROM (var
) = 1;
1325 DECL_IGNORED_P (var
) = 0;
1326 TREE_NO_WARNING (var
) = nowarn
;
1330 DECL_IGNORED_P (var
) = 1;
1331 /* ??? We can't generate any warning that would be meaningful. */
1332 TREE_NO_WARNING (var
) = 1;
1335 /* Zero-initialize bit-field scalarization variables, to avoid
1336 triggering undefined behavior. */
1337 if (TREE_CODE (elt
->element
) == BIT_FIELD_REF
1338 || (var
!= elt
->replacement
1339 && TREE_CODE (elt
->replacement
) == BIT_FIELD_REF
))
1341 gimple_seq init
= sra_build_assignment (var
,
1342 fold_convert (TREE_TYPE (var
),
1345 insert_edge_copies_seq (init
, ENTRY_BLOCK_PTR
);
1346 mark_all_v_defs_seq (init
);
1351 fputs (" ", dump_file
);
1352 dump_sra_elt_name (dump_file
, elt
);
1353 fputs (" -> ", dump_file
);
1354 print_generic_expr (dump_file
, var
, dump_flags
);
1355 fputc ('\n', dump_file
);
1359 /* Make one pass across an element tree deciding whether or not it's
1360 profitable to instantiate individual leaf scalars.
1362 PARENT_USES and PARENT_COPIES are the sum of the N_USES and N_COPIES
1363 fields all the way up the tree. */
1366 decide_instantiation_1 (struct sra_elt
*elt
, unsigned int parent_uses
,
1367 unsigned int parent_copies
)
1369 if (dump_file
&& !elt
->parent
)
1371 fputs ("Initial instantiation for ", dump_file
);
1372 dump_sra_elt_name (dump_file
, elt
);
1373 fputc ('\n', dump_file
);
1376 if (elt
->cannot_scalarize
)
1381 /* The decision is simple: instantiate if we're used more frequently
1382 than the parent needs to be seen as a complete unit. */
1383 if (elt
->n_uses
+ elt
->n_copies
+ parent_copies
> parent_uses
)
1384 instantiate_element (elt
);
1388 struct sra_elt
*c
, *group
;
1389 unsigned int this_uses
= elt
->n_uses
+ parent_uses
;
1390 unsigned int this_copies
= elt
->n_copies
+ parent_copies
;
1392 /* Consider groups of sub-elements as weighing in favour of
1393 instantiation whatever their size. */
1394 for (group
= elt
->groups
; group
; group
= group
->sibling
)
1395 FOR_EACH_ACTUAL_CHILD (c
, group
)
1397 c
->n_uses
+= group
->n_uses
;
1398 c
->n_copies
+= group
->n_copies
;
1401 for (c
= elt
->children
; c
; c
= c
->sibling
)
1402 decide_instantiation_1 (c
, this_uses
, this_copies
);
1406 /* Compute the size and number of all instantiated elements below ELT.
1407 We will only care about this if the size of the complete structure
1408 fits in a HOST_WIDE_INT, so we don't have to worry about overflow. */
1411 sum_instantiated_sizes (struct sra_elt
*elt
, unsigned HOST_WIDE_INT
*sizep
)
1413 if (elt
->replacement
)
1415 *sizep
+= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (elt
->type
));
1421 unsigned int count
= 0;
1423 for (c
= elt
->children
; c
; c
= c
->sibling
)
1424 count
+= sum_instantiated_sizes (c
, sizep
);
1430 /* Instantiate fields in ELT->TYPE that are not currently present as
1433 static void instantiate_missing_elements (struct sra_elt
*elt
);
1435 static struct sra_elt
*
1436 instantiate_missing_elements_1 (struct sra_elt
*elt
, tree child
, tree type
)
1438 struct sra_elt
*sub
= lookup_element (elt
, child
, type
, INSERT
);
1441 if (sub
->replacement
== NULL
)
1442 instantiate_element (sub
);
1445 instantiate_missing_elements (sub
);
1449 /* Obtain the canonical type for field F of ELEMENT. */
1452 canon_type_for_field (tree f
, tree element
)
1454 tree field_type
= TREE_TYPE (f
);
1456 /* canonicalize_component_ref() unwidens some bit-field types (not
1457 marked as DECL_BIT_FIELD in C++), so we must do the same, lest we
1458 may introduce type mismatches. */
1459 if (INTEGRAL_TYPE_P (field_type
)
1460 && DECL_MODE (f
) != TYPE_MODE (field_type
))
1461 field_type
= TREE_TYPE (get_unwidened (build3 (COMPONENT_REF
,
1470 /* Look for adjacent fields of ELT starting at F that we'd like to
1471 scalarize as a single variable. Return the last field of the
1475 try_instantiate_multiple_fields (struct sra_elt
*elt
, tree f
)
1478 unsigned HOST_WIDE_INT align
, bit
, size
, alchk
;
1479 enum machine_mode mode
;
1480 tree first
= f
, prev
;
1482 struct sra_elt
*block
;
1484 /* Point fields are typically best handled as standalone entities. */
1485 if (POINTER_TYPE_P (TREE_TYPE (f
)))
1488 if (!is_sra_scalar_type (TREE_TYPE (f
))
1489 || !host_integerp (DECL_FIELD_OFFSET (f
), 1)
1490 || !host_integerp (DECL_FIELD_BIT_OFFSET (f
), 1)
1491 || !host_integerp (DECL_SIZE (f
), 1)
1492 || lookup_element (elt
, f
, NULL
, NO_INSERT
))
1497 /* For complex and array objects, there are going to be integer
1498 literals as child elements. In this case, we can't just take the
1499 alignment and mode of the decl, so we instead rely on the element
1502 ??? We could try to infer additional alignment from the full
1503 object declaration and the location of the sub-elements we're
1505 for (count
= 0; !DECL_P (block
->element
); count
++)
1506 block
= block
->parent
;
1508 align
= DECL_ALIGN (block
->element
);
1509 alchk
= GET_MODE_BITSIZE (DECL_MODE (block
->element
));
1513 type
= TREE_TYPE (block
->element
);
1515 type
= TREE_TYPE (type
);
1517 align
= TYPE_ALIGN (type
);
1518 alchk
= GET_MODE_BITSIZE (TYPE_MODE (type
));
1524 /* Coalescing wider fields is probably pointless and
1526 if (align
> BITS_PER_WORD
)
1527 align
= BITS_PER_WORD
;
1529 bit
= tree_low_cst (DECL_FIELD_OFFSET (f
), 1) * BITS_PER_UNIT
1530 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f
), 1);
1531 size
= tree_low_cst (DECL_SIZE (f
), 1);
1536 if ((bit
& alchk
) != ((bit
+ size
- 1) & alchk
))
1539 /* Find adjacent fields in the same alignment word. */
1541 for (prev
= f
, f
= TREE_CHAIN (f
);
1542 f
&& TREE_CODE (f
) == FIELD_DECL
1543 && is_sra_scalar_type (TREE_TYPE (f
))
1544 && host_integerp (DECL_FIELD_OFFSET (f
), 1)
1545 && host_integerp (DECL_FIELD_BIT_OFFSET (f
), 1)
1546 && host_integerp (DECL_SIZE (f
), 1)
1547 && !lookup_element (elt
, f
, NULL
, NO_INSERT
);
1548 prev
= f
, f
= TREE_CHAIN (f
))
1550 unsigned HOST_WIDE_INT nbit
, nsize
;
1552 nbit
= tree_low_cst (DECL_FIELD_OFFSET (f
), 1) * BITS_PER_UNIT
1553 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f
), 1);
1554 nsize
= tree_low_cst (DECL_SIZE (f
), 1);
1556 if (bit
+ size
== nbit
)
1558 if ((bit
& alchk
) != ((nbit
+ nsize
- 1) & alchk
))
1560 /* If we're at an alignment boundary, don't bother
1561 growing alignment such that we can include this next
1564 || GET_MODE_BITSIZE (DECL_MODE (f
)) <= align
)
1567 align
= GET_MODE_BITSIZE (DECL_MODE (f
));
1571 if ((bit
& alchk
) != ((nbit
+ nsize
- 1) & alchk
))
1576 else if (nbit
+ nsize
== bit
)
1578 if ((nbit
& alchk
) != ((bit
+ size
- 1) & alchk
))
1581 || GET_MODE_BITSIZE (DECL_MODE (f
)) <= align
)
1584 align
= GET_MODE_BITSIZE (DECL_MODE (f
));
1588 if ((nbit
& alchk
) != ((bit
+ size
- 1) & alchk
))
1603 gcc_assert ((bit
& alchk
) == ((bit
+ size
- 1) & alchk
));
1605 /* Try to widen the bit range so as to cover padding bits as well. */
1607 if ((bit
& ~alchk
) || size
!= align
)
1609 unsigned HOST_WIDE_INT mbit
= bit
& alchk
;
1610 unsigned HOST_WIDE_INT msize
= align
;
1612 for (f
= TYPE_FIELDS (elt
->type
);
1613 f
; f
= TREE_CHAIN (f
))
1615 unsigned HOST_WIDE_INT fbit
, fsize
;
1617 /* Skip the fields from first to prev. */
1624 if (!(TREE_CODE (f
) == FIELD_DECL
1625 && host_integerp (DECL_FIELD_OFFSET (f
), 1)
1626 && host_integerp (DECL_FIELD_BIT_OFFSET (f
), 1)))
1629 fbit
= tree_low_cst (DECL_FIELD_OFFSET (f
), 1) * BITS_PER_UNIT
1630 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f
), 1);
1632 /* If we're past the selected word, we're fine. */
1633 if ((bit
& alchk
) < (fbit
& alchk
))
1636 if (host_integerp (DECL_SIZE (f
), 1))
1637 fsize
= tree_low_cst (DECL_SIZE (f
), 1);
1639 /* Assume a variable-sized field takes up all space till
1640 the end of the word. ??? Endianness issues? */
1641 fsize
= align
- (fbit
& alchk
);
1643 if ((fbit
& alchk
) < (bit
& alchk
))
1645 /* A large field might start at a previous word and
1646 extend into the selected word. Exclude those
1647 bits. ??? Endianness issues? */
1648 HOST_WIDE_INT diff
= fbit
+ fsize
- mbit
;
1658 /* Non-overlapping, great. */
1659 if (fbit
+ fsize
<= mbit
1660 || mbit
+ msize
<= fbit
)
1665 unsigned HOST_WIDE_INT diff
= fbit
+ fsize
- mbit
;
1669 else if (fbit
> mbit
)
1670 msize
-= (mbit
+ msize
- fbit
);
1680 /* Now we know the bit range we're interested in. Find the smallest
1681 machine mode we can use to access it. */
1683 for (mode
= smallest_mode_for_size (size
, MODE_INT
);
1685 mode
= GET_MODE_WIDER_MODE (mode
))
1687 gcc_assert (mode
!= VOIDmode
);
1689 alchk
= GET_MODE_PRECISION (mode
) - 1;
1692 if ((bit
& alchk
) == ((bit
+ size
- 1) & alchk
))
1696 gcc_assert (~alchk
< align
);
1698 /* Create the field group as a single variable. */
1700 /* We used to create a type for the mode above, but size turns
1701 to be out not of mode-size. As we need a matching type
1702 to build a BIT_FIELD_REF, use a nonstandard integer type as
1704 type
= lang_hooks
.types
.type_for_size (size
, 1);
1705 if (!type
|| TYPE_PRECISION (type
) != size
)
1706 type
= build_nonstandard_integer_type (size
, 1);
1708 var
= build3 (BIT_FIELD_REF
, type
, NULL_TREE
,
1709 bitsize_int (size
), bitsize_int (bit
));
1711 block
= instantiate_missing_elements_1 (elt
, var
, type
);
1712 gcc_assert (block
&& block
->is_scalar
);
1714 var
= block
->replacement
;
1717 || (HOST_WIDE_INT
)size
!= tree_low_cst (DECL_SIZE (var
), 1))
1719 block
->replacement
= fold_build3 (BIT_FIELD_REF
,
1720 TREE_TYPE (block
->element
), var
,
1722 bitsize_int (bit
& ~alchk
));
1725 block
->in_bitfld_block
= 2;
1727 /* Add the member fields to the group, such that they access
1728 portions of the group variable. */
1730 for (f
= first
; f
!= TREE_CHAIN (prev
); f
= TREE_CHAIN (f
))
1732 tree field_type
= canon_type_for_field (f
, elt
->element
);
1733 struct sra_elt
*fld
= lookup_element (block
, f
, field_type
, INSERT
);
1735 gcc_assert (fld
&& fld
->is_scalar
&& !fld
->replacement
);
1737 fld
->replacement
= fold_build3 (BIT_FIELD_REF
, field_type
, var
,
1740 ((TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f
))
1743 (DECL_FIELD_BIT_OFFSET (f
))))
1745 fld
->in_bitfld_block
= 1;
1752 instantiate_missing_elements (struct sra_elt
*elt
)
1754 tree type
= elt
->type
;
1756 switch (TREE_CODE (type
))
1761 for (f
= TYPE_FIELDS (type
); f
; f
= TREE_CHAIN (f
))
1762 if (TREE_CODE (f
) == FIELD_DECL
)
1764 tree last
= try_instantiate_multiple_fields (elt
, f
);
1772 instantiate_missing_elements_1 (elt
, f
,
1773 canon_type_for_field
1781 tree i
, max
, subtype
;
1783 i
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
1784 max
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
1785 subtype
= TREE_TYPE (type
);
1789 instantiate_missing_elements_1 (elt
, i
, subtype
);
1790 if (tree_int_cst_equal (i
, max
))
1792 i
= int_const_binop (PLUS_EXPR
, i
, integer_one_node
, true);
1799 type
= TREE_TYPE (type
);
1800 instantiate_missing_elements_1 (elt
, integer_zero_node
, type
);
1801 instantiate_missing_elements_1 (elt
, integer_one_node
, type
);
1809 /* Return true if there is only one non aggregate field in the record, TYPE.
1810 Return false otherwise. */
1813 single_scalar_field_in_record_p (tree type
)
1817 if (TREE_CODE (type
) != RECORD_TYPE
)
1820 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1821 if (TREE_CODE (field
) == FIELD_DECL
)
1825 if (num_fields
== 2)
1828 if (AGGREGATE_TYPE_P (TREE_TYPE (field
)))
1835 /* Make one pass across an element tree deciding whether to perform block
1836 or element copies. If we decide on element copies, instantiate all
1837 elements. Return true if there are any instantiated sub-elements. */
1840 decide_block_copy (struct sra_elt
*elt
)
1845 /* We shouldn't be invoked on groups of sub-elements as they must
1846 behave like their parent as far as block copy is concerned. */
1847 gcc_assert (!elt
->is_group
);
1849 /* If scalarization is disabled, respect it. */
1850 if (elt
->cannot_scalarize
)
1852 elt
->use_block_copy
= 1;
1856 fputs ("Scalarization disabled for ", dump_file
);
1857 dump_sra_elt_name (dump_file
, elt
);
1858 fputc ('\n', dump_file
);
1861 /* Disable scalarization of sub-elements */
1862 for (c
= elt
->children
; c
; c
= c
->sibling
)
1864 c
->cannot_scalarize
= 1;
1865 decide_block_copy (c
);
1868 /* Groups behave like their parent. */
1869 for (c
= elt
->groups
; c
; c
= c
->sibling
)
1871 c
->cannot_scalarize
= 1;
1872 c
->use_block_copy
= 1;
1878 /* Don't decide if we've no uses and no groups. */
1879 if (elt
->n_uses
== 0 && elt
->n_copies
== 0 && elt
->groups
== NULL
)
1882 else if (!elt
->is_scalar
)
1884 tree size_tree
= TYPE_SIZE_UNIT (elt
->type
);
1885 bool use_block_copy
= true;
1887 /* Tradeoffs for COMPLEX types pretty much always make it better
1888 to go ahead and split the components. */
1889 if (TREE_CODE (elt
->type
) == COMPLEX_TYPE
)
1890 use_block_copy
= false;
1892 /* Don't bother trying to figure out the rest if the structure is
1893 so large we can't do easy arithmetic. This also forces block
1894 copies for variable sized structures. */
1895 else if (host_integerp (size_tree
, 1))
1897 unsigned HOST_WIDE_INT full_size
, inst_size
= 0;
1898 unsigned int max_size
, max_count
, inst_count
, full_count
;
1900 /* If the sra-max-structure-size parameter is 0, then the
1901 user has not overridden the parameter and we can choose a
1902 sensible default. */
1903 max_size
= SRA_MAX_STRUCTURE_SIZE
1904 ? SRA_MAX_STRUCTURE_SIZE
1905 : MOVE_RATIO (optimize_function_for_speed_p (cfun
)) * UNITS_PER_WORD
;
1906 max_count
= SRA_MAX_STRUCTURE_COUNT
1907 ? SRA_MAX_STRUCTURE_COUNT
1908 : MOVE_RATIO (optimize_function_for_speed_p (cfun
));
1910 full_size
= tree_low_cst (size_tree
, 1);
1911 full_count
= count_type_elements (elt
->type
, false);
1912 inst_count
= sum_instantiated_sizes (elt
, &inst_size
);
1914 /* If there is only one scalar field in the record, don't block copy. */
1915 if (single_scalar_field_in_record_p (elt
->type
))
1916 use_block_copy
= false;
1918 /* ??? What to do here. If there are two fields, and we've only
1919 instantiated one, then instantiating the other is clearly a win.
1920 If there are a large number of fields then the size of the copy
1921 is much more of a factor. */
1923 /* If the structure is small, and we've made copies, go ahead
1924 and instantiate, hoping that the copies will go away. */
1925 if (full_size
<= max_size
1926 && (full_count
- inst_count
) <= max_count
1927 && elt
->n_copies
> elt
->n_uses
)
1928 use_block_copy
= false;
1929 else if (inst_count
* 100 >= full_count
* SRA_FIELD_STRUCTURE_RATIO
1930 && inst_size
* 100 >= full_size
* SRA_FIELD_STRUCTURE_RATIO
)
1931 use_block_copy
= false;
1933 /* In order to avoid block copy, we have to be able to instantiate
1934 all elements of the type. See if this is possible. */
1936 && (!can_completely_scalarize_p (elt
)
1937 || !type_can_instantiate_all_elements (elt
->type
)))
1938 use_block_copy
= true;
1941 elt
->use_block_copy
= use_block_copy
;
1943 /* Groups behave like their parent. */
1944 for (c
= elt
->groups
; c
; c
= c
->sibling
)
1945 c
->use_block_copy
= use_block_copy
;
1949 fprintf (dump_file
, "Using %s for ",
1950 use_block_copy
? "block-copy" : "element-copy");
1951 dump_sra_elt_name (dump_file
, elt
);
1952 fputc ('\n', dump_file
);
1955 if (!use_block_copy
)
1957 instantiate_missing_elements (elt
);
1962 any_inst
= elt
->replacement
!= NULL
;
1964 for (c
= elt
->children
; c
; c
= c
->sibling
)
1965 any_inst
|= decide_block_copy (c
);
1970 /* Entry point to phase 3. Instantiate scalar replacement variables. */
1973 decide_instantiations (void)
1977 bitmap_head done_head
;
1980 /* We cannot clear bits from a bitmap we're iterating over,
1981 so save up all the bits to clear until the end. */
1982 bitmap_initialize (&done_head
, &bitmap_default_obstack
);
1983 cleared_any
= false;
1985 EXECUTE_IF_SET_IN_BITMAP (sra_candidates
, 0, i
, bi
)
1987 tree var
= referenced_var (i
);
1988 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
1991 decide_instantiation_1 (elt
, 0, 0);
1992 if (!decide_block_copy (elt
))
1997 bitmap_set_bit (&done_head
, i
);
2004 bitmap_and_compl_into (sra_candidates
, &done_head
);
2005 bitmap_and_compl_into (needs_copy_in
, &done_head
);
2007 bitmap_clear (&done_head
);
2009 mark_set_for_renaming (sra_candidates
);
2012 fputc ('\n', dump_file
);
2016 /* Phase Four: Update the function to match the replacements created. */
2018 /* Mark all the variables in VDEF/VUSE operators for STMT for
2019 renaming. This becomes necessary when we modify all of a
2023 mark_all_v_defs_stmt (gimple stmt
)
2028 update_stmt_if_modified (stmt
);
2030 FOR_EACH_SSA_TREE_OPERAND (sym
, stmt
, iter
, SSA_OP_ALL_VIRTUALS
)
2032 if (TREE_CODE (sym
) == SSA_NAME
)
2033 sym
= SSA_NAME_VAR (sym
);
2034 mark_sym_for_renaming (sym
);
2039 /* Mark all the variables in virtual operands in all the statements in
2040 LIST for renaming. */
2043 mark_all_v_defs_seq (gimple_seq seq
)
2045 gimple_stmt_iterator gsi
;
2047 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2048 mark_all_v_defs_stmt (gsi_stmt (gsi
));
2051 /* Mark every replacement under ELT with TREE_NO_WARNING. */
2054 mark_no_warning (struct sra_elt
*elt
)
2056 if (!elt
->all_no_warning
)
2058 if (elt
->replacement
)
2059 TREE_NO_WARNING (elt
->replacement
) = 1;
2063 FOR_EACH_ACTUAL_CHILD (c
, elt
)
2064 mark_no_warning (c
);
2066 elt
->all_no_warning
= true;
2070 /* Build a single level component reference to ELT rooted at BASE. */
2073 generate_one_element_ref (struct sra_elt
*elt
, tree base
)
2075 switch (TREE_CODE (TREE_TYPE (base
)))
2079 tree field
= elt
->element
;
2081 /* We can't test elt->in_bitfld_block here because, when this is
2082 called from instantiate_element, we haven't set this field
2084 if (TREE_CODE (field
) == BIT_FIELD_REF
)
2086 tree ret
= unshare_expr (field
);
2087 TREE_OPERAND (ret
, 0) = base
;
2091 /* Watch out for compatible records with differing field lists. */
2092 if (DECL_FIELD_CONTEXT (field
) != TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
2093 field
= find_compatible_field (TREE_TYPE (base
), field
);
2095 return build3 (COMPONENT_REF
, elt
->type
, base
, field
, NULL
);
2099 if (TREE_CODE (elt
->element
) == RANGE_EXPR
)
2100 return build4 (ARRAY_RANGE_REF
, elt
->type
, base
,
2101 TREE_OPERAND (elt
->element
, 0), NULL
, NULL
);
2103 return build4 (ARRAY_REF
, elt
->type
, base
, elt
->element
, NULL
, NULL
);
2106 if (elt
->element
== integer_zero_node
)
2107 return build1 (REALPART_EXPR
, elt
->type
, base
);
2109 return build1 (IMAGPART_EXPR
, elt
->type
, base
);
2116 /* Build a full component reference to ELT rooted at its native variable. */
2119 generate_element_ref (struct sra_elt
*elt
)
2122 return generate_one_element_ref (elt
, generate_element_ref (elt
->parent
));
2124 return elt
->element
;
2127 /* Return true if BF is a bit-field that we can handle like a scalar. */
2130 scalar_bitfield_p (tree bf
)
2132 return (TREE_CODE (bf
) == BIT_FIELD_REF
2133 && (is_gimple_reg (TREE_OPERAND (bf
, 0))
2134 || (TYPE_MODE (TREE_TYPE (TREE_OPERAND (bf
, 0))) != BLKmode
2135 && (!TREE_SIDE_EFFECTS (TREE_OPERAND (bf
, 0))
2136 || (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE
2137 (TREE_OPERAND (bf
, 0))))
2138 <= BITS_PER_WORD
)))));
2141 /* Create an assignment statement from SRC to DST. */
2144 sra_build_assignment (tree dst
, tree src
)
2147 gimple_seq seq
= NULL
, seq2
= NULL
;
2148 /* Turning BIT_FIELD_REFs into bit operations enables other passes
2149 to do a much better job at optimizing the code.
2150 From dst = BIT_FIELD_REF <var, sz, off> we produce
2152 SR.1 = (scalar type) var;
2154 SR.3 = SR.2 & ((1 << sz) - 1);
2155 ... possible sign extension of SR.3 ...
2156 dst = (destination type) SR.3;
2158 if (scalar_bitfield_p (src
))
2160 tree var
, shift
, width
;
2161 tree utype
, stype
, stmp
, utmp
, dtmp
;
2162 bool unsignedp
= (INTEGRAL_TYPE_P (TREE_TYPE (src
))
2163 ? TYPE_UNSIGNED (TREE_TYPE (src
)) : true);
2165 var
= TREE_OPERAND (src
, 0);
2166 width
= TREE_OPERAND (src
, 1);
2167 /* The offset needs to be adjusted to a right shift quantity
2168 depending on the endianness. */
2169 if (BYTES_BIG_ENDIAN
)
2171 tree tmp
= size_binop (PLUS_EXPR
, width
, TREE_OPERAND (src
, 2));
2172 shift
= size_binop (MINUS_EXPR
, TYPE_SIZE (TREE_TYPE (var
)), tmp
);
2175 shift
= TREE_OPERAND (src
, 2);
2177 /* In weird cases we have non-integral types for the source or
2179 ??? For unknown reasons we also want an unsigned scalar type. */
2180 stype
= TREE_TYPE (var
);
2181 if (!INTEGRAL_TYPE_P (stype
))
2182 stype
= lang_hooks
.types
.type_for_size (TREE_INT_CST_LOW
2183 (TYPE_SIZE (stype
)), 1);
2184 else if (!TYPE_UNSIGNED (stype
))
2185 stype
= unsigned_type_for (stype
);
2187 utype
= TREE_TYPE (dst
);
2188 if (!INTEGRAL_TYPE_P (utype
))
2189 utype
= lang_hooks
.types
.type_for_size (TREE_INT_CST_LOW
2190 (TYPE_SIZE (utype
)), 1);
2191 else if (!TYPE_UNSIGNED (utype
))
2192 utype
= unsigned_type_for (utype
);
2194 stmp
= make_rename_temp (stype
, "SR");
2196 /* Convert the base var of the BIT_FIELD_REF to the scalar type
2197 we use for computation if we cannot use it directly. */
2198 if (!useless_type_conversion_p (stype
, TREE_TYPE (var
)))
2200 if (INTEGRAL_TYPE_P (TREE_TYPE (var
)))
2201 stmt
= gimple_build_assign (stmp
, fold_convert (stype
, var
));
2203 stmt
= gimple_build_assign (stmp
, fold_build1 (VIEW_CONVERT_EXPR
,
2205 gimple_seq_add_stmt (&seq
, stmt
);
2209 if (!integer_zerop (shift
))
2211 stmt
= gimple_build_assign (stmp
, fold_build2 (RSHIFT_EXPR
, stype
,
2213 gimple_seq_add_stmt (&seq
, stmt
);
2217 /* If we need a masking operation, produce one. */
2218 if (TREE_INT_CST_LOW (width
) == TYPE_PRECISION (stype
))
2222 tree one
= build_int_cst_wide (stype
, 1, 0);
2223 tree mask
= int_const_binop (LSHIFT_EXPR
, one
, width
, 0);
2224 mask
= int_const_binop (MINUS_EXPR
, mask
, one
, 0);
2226 stmt
= gimple_build_assign (stmp
, fold_build2 (BIT_AND_EXPR
, stype
,
2228 gimple_seq_add_stmt (&seq
, stmt
);
2232 /* After shifting and masking, convert to the target type. */
2234 if (!useless_type_conversion_p (utype
, stype
))
2236 utmp
= make_rename_temp (utype
, "SR");
2238 stmt
= gimple_build_assign (utmp
, fold_convert (utype
, var
));
2239 gimple_seq_add_stmt (&seq
, stmt
);
2244 /* Perform sign extension, if required.
2245 ??? This should never be necessary. */
2248 tree signbit
= int_const_binop (LSHIFT_EXPR
,
2249 build_int_cst_wide (utype
, 1, 0),
2250 size_binop (MINUS_EXPR
, width
,
2251 bitsize_int (1)), 0);
2253 stmt
= gimple_build_assign (utmp
, fold_build2 (BIT_XOR_EXPR
, utype
,
2255 gimple_seq_add_stmt (&seq
, stmt
);
2257 stmt
= gimple_build_assign (utmp
, fold_build2 (MINUS_EXPR
, utype
,
2259 gimple_seq_add_stmt (&seq
, stmt
);
2264 /* fold_build3 (BIT_FIELD_REF, ...) sometimes returns a cast. */
2267 /* Finally, move and convert to the destination. */
2268 if (!useless_type_conversion_p (TREE_TYPE (dst
), TREE_TYPE (var
)))
2270 if (INTEGRAL_TYPE_P (TREE_TYPE (dst
)))
2271 var
= fold_convert (TREE_TYPE (dst
), var
);
2273 var
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (dst
), var
);
2275 /* If the destination is not a register the conversion needs
2276 to be a separate statement. */
2277 if (!is_gimple_reg (dst
))
2279 dtmp
= make_rename_temp (TREE_TYPE (dst
), "SR");
2280 stmt
= gimple_build_assign (dtmp
, var
);
2281 gimple_seq_add_stmt (&seq
, stmt
);
2285 stmt
= gimple_build_assign (dst
, var
);
2286 gimple_seq_add_stmt (&seq
, stmt
);
2291 /* fold_build3 (BIT_FIELD_REF, ...) sometimes returns a cast. */
2292 if (CONVERT_EXPR_P (dst
))
2295 src
= fold_convert (TREE_TYPE (dst
), src
);
2297 /* It was hoped that we could perform some type sanity checking
2298 here, but since front-ends can emit accesses of fields in types
2299 different from their nominal types and copy structures containing
2300 them as a whole, we'd have to handle such differences here.
2301 Since such accesses under different types require compatibility
2302 anyway, there's little point in making tests and/or adding
2303 conversions to ensure the types of src and dst are the same.
2304 So we just assume type differences at this point are ok.
2305 The only exception we make here are pointer types, which can be different
2306 in e.g. structurally equal, but non-identical RECORD_TYPEs. */
2307 else if (POINTER_TYPE_P (TREE_TYPE (dst
))
2308 && !useless_type_conversion_p (TREE_TYPE (dst
), TREE_TYPE (src
)))
2309 src
= fold_convert (TREE_TYPE (dst
), src
);
2311 /* ??? Only call the gimplifier if we need to. Otherwise we may
2312 end up substituting with DECL_VALUE_EXPR - see PR37380. */
2313 if (!handled_component_p (src
)
2314 && !SSA_VAR_P (src
))
2316 src
= force_gimple_operand (src
, &seq2
, false, NULL_TREE
);
2317 gimple_seq_add_seq (&seq
, seq2
);
2319 stmt
= gimple_build_assign (dst
, src
);
2320 gimple_seq_add_stmt (&seq
, stmt
);
2324 /* BIT_FIELD_REFs must not be shared. sra_build_elt_assignment()
2325 takes care of assignments, but we must create copies for uses. */
2326 #define REPLDUP(t) (TREE_CODE (t) != BIT_FIELD_REF ? (t) : unshare_expr (t))
2328 /* Emit an assignment from SRC to DST, but if DST is a scalarizable
2329 BIT_FIELD_REF, turn it into bit operations. */
2332 sra_build_bf_assignment (tree dst
, tree src
)
2334 tree var
, type
, utype
, tmp
, tmp2
, tmp3
;
2337 tree cst
, cst2
, mask
;
2338 tree minshift
, maxshift
;
2340 if (TREE_CODE (dst
) != BIT_FIELD_REF
)
2341 return sra_build_assignment (dst
, src
);
2343 var
= TREE_OPERAND (dst
, 0);
2345 if (!scalar_bitfield_p (dst
))
2346 return sra_build_assignment (REPLDUP (dst
), src
);
2350 cst
= fold_convert (bitsizetype
, TREE_OPERAND (dst
, 2));
2351 cst2
= size_binop (PLUS_EXPR
,
2352 fold_convert (bitsizetype
, TREE_OPERAND (dst
, 1)),
2355 if (BYTES_BIG_ENDIAN
)
2357 maxshift
= size_binop (MINUS_EXPR
, TYPE_SIZE (TREE_TYPE (var
)), cst
);
2358 minshift
= size_binop (MINUS_EXPR
, TYPE_SIZE (TREE_TYPE (var
)), cst2
);
2366 type
= TREE_TYPE (var
);
2367 if (!INTEGRAL_TYPE_P (type
))
2368 type
= lang_hooks
.types
.type_for_size
2369 (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (var
))), 1);
2370 if (TYPE_UNSIGNED (type
))
2373 utype
= unsigned_type_for (type
);
2375 mask
= build_int_cst_wide (utype
, 1, 0);
2376 if (TREE_INT_CST_LOW (maxshift
) == TYPE_PRECISION (utype
))
2377 cst
= build_int_cst_wide (utype
, 0, 0);
2379 cst
= int_const_binop (LSHIFT_EXPR
, mask
, maxshift
, true);
2380 if (integer_zerop (minshift
))
2383 cst2
= int_const_binop (LSHIFT_EXPR
, mask
, minshift
, true);
2384 mask
= int_const_binop (MINUS_EXPR
, cst
, cst2
, true);
2385 mask
= fold_build1 (BIT_NOT_EXPR
, utype
, mask
);
2387 if (TYPE_MAIN_VARIANT (utype
) != TYPE_MAIN_VARIANT (TREE_TYPE (var
))
2388 && !integer_zerop (mask
))
2391 if (!is_gimple_variable (tmp
))
2392 tmp
= unshare_expr (var
);
2394 tmp2
= make_rename_temp (utype
, "SR");
2396 if (INTEGRAL_TYPE_P (TREE_TYPE (var
)))
2397 stmt
= gimple_build_assign (tmp2
, fold_convert (utype
, tmp
));
2399 stmt
= gimple_build_assign (tmp2
, fold_build1 (VIEW_CONVERT_EXPR
,
2401 gimple_seq_add_stmt (&seq
, stmt
);
2406 if (!integer_zerop (mask
))
2408 tmp
= make_rename_temp (utype
, "SR");
2409 stmt
= gimple_build_assign (tmp
, fold_build2 (BIT_AND_EXPR
, utype
,
2411 gimple_seq_add_stmt (&seq
, stmt
);
2416 if (is_gimple_reg (src
) && INTEGRAL_TYPE_P (TREE_TYPE (src
)))
2418 else if (INTEGRAL_TYPE_P (TREE_TYPE (src
)))
2421 tmp2
= make_rename_temp (TREE_TYPE (src
), "SR");
2422 tmp_seq
= sra_build_assignment (tmp2
, src
);
2423 gimple_seq_add_seq (&seq
, tmp_seq
);
2428 tmp2
= make_rename_temp
2429 (lang_hooks
.types
.type_for_size
2430 (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (src
))),
2432 tmp_seq
= sra_build_assignment (tmp2
, fold_build1 (VIEW_CONVERT_EXPR
,
2433 TREE_TYPE (tmp2
), src
));
2434 gimple_seq_add_seq (&seq
, tmp_seq
);
2437 if (!TYPE_UNSIGNED (TREE_TYPE (tmp2
)))
2440 tree ut
= unsigned_type_for (TREE_TYPE (tmp2
));
2441 tmp3
= make_rename_temp (ut
, "SR");
2442 tmp2
= fold_convert (ut
, tmp2
);
2443 tmp_seq
= sra_build_assignment (tmp3
, tmp2
);
2444 gimple_seq_add_seq (&seq
, tmp_seq
);
2446 tmp2
= fold_build1 (BIT_NOT_EXPR
, utype
, mask
);
2447 tmp2
= int_const_binop (RSHIFT_EXPR
, tmp2
, minshift
, true);
2448 tmp2
= fold_convert (ut
, tmp2
);
2449 tmp2
= fold_build2 (BIT_AND_EXPR
, ut
, tmp3
, tmp2
);
2453 tmp3
= make_rename_temp (ut
, "SR");
2454 tmp_seq
= sra_build_assignment (tmp3
, tmp2
);
2455 gimple_seq_add_seq (&seq
, tmp_seq
);
2461 if (TYPE_MAIN_VARIANT (TREE_TYPE (tmp2
)) != TYPE_MAIN_VARIANT (utype
))
2464 tmp3
= make_rename_temp (utype
, "SR");
2465 tmp2
= fold_convert (utype
, tmp2
);
2466 tmp_seq
= sra_build_assignment (tmp3
, tmp2
);
2467 gimple_seq_add_seq (&seq
, tmp_seq
);
2471 if (!integer_zerop (minshift
))
2473 tmp3
= make_rename_temp (utype
, "SR");
2474 stmt
= gimple_build_assign (tmp3
, fold_build2 (LSHIFT_EXPR
, utype
,
2476 gimple_seq_add_stmt (&seq
, stmt
);
2480 if (utype
!= TREE_TYPE (var
))
2481 tmp3
= make_rename_temp (utype
, "SR");
2484 stmt
= gimple_build_assign (tmp3
, fold_build2 (BIT_IOR_EXPR
, utype
,
2486 gimple_seq_add_stmt (&seq
, stmt
);
2490 if (TREE_TYPE (var
) == type
)
2491 stmt
= gimple_build_assign (var
, fold_convert (type
, tmp3
));
2493 stmt
= gimple_build_assign (var
, fold_build1 (VIEW_CONVERT_EXPR
,
2494 TREE_TYPE (var
), tmp3
));
2495 gimple_seq_add_stmt (&seq
, stmt
);
2501 /* Expand an assignment of SRC to the scalarized representation of
2502 ELT. If it is a field group, try to widen the assignment to cover
2503 the full variable. */
2506 sra_build_elt_assignment (struct sra_elt
*elt
, tree src
)
2508 tree dst
= elt
->replacement
;
2509 tree var
, tmp
, cst
, cst2
;
2513 if (TREE_CODE (dst
) != BIT_FIELD_REF
2514 || !elt
->in_bitfld_block
)
2515 return sra_build_assignment (REPLDUP (dst
), src
);
2517 var
= TREE_OPERAND (dst
, 0);
2519 /* Try to widen the assignment to the entire variable.
2520 We need the source to be a BIT_FIELD_REF as well, such that, for
2521 BIT_FIELD_REF<d,sz,dp> = BIT_FIELD_REF<s,sz,sp>,
2522 by design, conditions are met such that we can turn it into
2523 d = BIT_FIELD_REF<s,dw,sp-dp>. */
2524 if (elt
->in_bitfld_block
== 2
2525 && TREE_CODE (src
) == BIT_FIELD_REF
)
2528 cst
= TYPE_SIZE (TREE_TYPE (var
));
2529 cst2
= size_binop (MINUS_EXPR
, TREE_OPERAND (src
, 2),
2530 TREE_OPERAND (dst
, 2));
2532 src
= TREE_OPERAND (src
, 0);
2534 /* Avoid full-width bit-fields. */
2535 if (integer_zerop (cst2
)
2536 && tree_int_cst_equal (cst
, TYPE_SIZE (TREE_TYPE (src
))))
2538 if (INTEGRAL_TYPE_P (TREE_TYPE (src
))
2539 && !TYPE_UNSIGNED (TREE_TYPE (src
)))
2540 src
= fold_convert (unsigned_type_for (TREE_TYPE (src
)), src
);
2542 /* If a single conversion won't do, we'll need a statement
2544 if (TYPE_MAIN_VARIANT (TREE_TYPE (var
))
2545 != TYPE_MAIN_VARIANT (TREE_TYPE (src
)))
2550 if (!INTEGRAL_TYPE_P (TREE_TYPE (src
)))
2551 src
= fold_build1 (VIEW_CONVERT_EXPR
,
2552 lang_hooks
.types
.type_for_size
2554 (TYPE_SIZE (TREE_TYPE (src
))),
2556 gcc_assert (TYPE_UNSIGNED (TREE_TYPE (src
)));
2558 tmp
= make_rename_temp (TREE_TYPE (src
), "SR");
2559 stmt
= gimple_build_assign (tmp
, src
);
2560 gimple_seq_add_stmt (&seq
, stmt
);
2562 tmp_seq
= sra_build_assignment (var
,
2563 fold_convert (TREE_TYPE (var
),
2565 gimple_seq_add_seq (&seq
, tmp_seq
);
2570 src
= fold_convert (TREE_TYPE (var
), src
);
2574 src
= fold_convert (TREE_TYPE (var
), tmp
);
2577 return sra_build_assignment (var
, src
);
2580 return sra_build_bf_assignment (dst
, src
);
2583 /* Generate a set of assignment statements in *LIST_P to copy all
2584 instantiated elements under ELT to or from the equivalent structure
2585 rooted at EXPR. COPY_OUT controls the direction of the copy, with
2586 true meaning to copy out of EXPR into ELT. */
2589 generate_copy_inout (struct sra_elt
*elt
, bool copy_out
, tree expr
,
2596 if (!copy_out
&& TREE_CODE (expr
) == SSA_NAME
2597 && TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2601 c
= lookup_element (elt
, integer_zero_node
, NULL
, NO_INSERT
);
2603 c
= lookup_element (elt
, integer_one_node
, NULL
, NO_INSERT
);
2606 t
= build2 (COMPLEX_EXPR
, elt
->type
, r
, i
);
2607 tmp_seq
= sra_build_bf_assignment (expr
, t
);
2608 SSA_NAME_DEF_STMT (expr
) = gimple_seq_last_stmt (tmp_seq
);
2609 gimple_seq_add_seq (seq_p
, tmp_seq
);
2611 else if (elt
->replacement
)
2614 tmp_seq
= sra_build_elt_assignment (elt
, expr
);
2616 tmp_seq
= sra_build_bf_assignment (expr
, REPLDUP (elt
->replacement
));
2617 gimple_seq_add_seq (seq_p
, tmp_seq
);
2621 FOR_EACH_ACTUAL_CHILD (c
, elt
)
2623 t
= generate_one_element_ref (c
, unshare_expr (expr
));
2624 generate_copy_inout (c
, copy_out
, t
, seq_p
);
2629 /* Generate a set of assignment statements in *LIST_P to copy all instantiated
2630 elements under SRC to their counterparts under DST. There must be a 1-1
2631 correspondence of instantiated elements. */
2634 generate_element_copy (struct sra_elt
*dst
, struct sra_elt
*src
, gimple_seq
*seq_p
)
2636 struct sra_elt
*dc
, *sc
;
2638 FOR_EACH_ACTUAL_CHILD (dc
, dst
)
2640 sc
= lookup_element (src
, dc
->element
, NULL
, NO_INSERT
);
2641 if (!sc
&& dc
->in_bitfld_block
== 2)
2643 struct sra_elt
*dcs
;
2645 FOR_EACH_ACTUAL_CHILD (dcs
, dc
)
2647 sc
= lookup_element (src
, dcs
->element
, NULL
, NO_INSERT
);
2649 generate_element_copy (dcs
, sc
, seq_p
);
2655 /* If DST and SRC are structs with the same elements, but do not have
2656 the same TYPE_MAIN_VARIANT, then lookup of DST FIELD_DECL in SRC
2657 will fail. Try harder by finding the corresponding FIELD_DECL
2663 gcc_assert (useless_type_conversion_p (dst
->type
, src
->type
));
2664 gcc_assert (TREE_CODE (dc
->element
) == FIELD_DECL
);
2665 for (f
= TYPE_FIELDS (src
->type
); f
; f
= TREE_CHAIN (f
))
2666 if (simple_cst_equal (DECL_FIELD_OFFSET (f
),
2667 DECL_FIELD_OFFSET (dc
->element
)) > 0
2668 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (f
),
2669 DECL_FIELD_BIT_OFFSET (dc
->element
)) > 0
2670 && simple_cst_equal (DECL_SIZE (f
),
2671 DECL_SIZE (dc
->element
)) > 0
2672 && (useless_type_conversion_p (TREE_TYPE (dc
->element
),
2674 || (POINTER_TYPE_P (TREE_TYPE (dc
->element
))
2675 && POINTER_TYPE_P (TREE_TYPE (f
)))))
2677 gcc_assert (f
!= NULL_TREE
);
2678 sc
= lookup_element (src
, f
, NULL
, NO_INSERT
);
2681 generate_element_copy (dc
, sc
, seq_p
);
2684 if (dst
->replacement
)
2688 gcc_assert (src
->replacement
);
2690 tmp_seq
= sra_build_elt_assignment (dst
, REPLDUP (src
->replacement
));
2691 gimple_seq_add_seq (seq_p
, tmp_seq
);
2695 /* Generate a set of assignment statements in *LIST_P to zero all instantiated
2696 elements under ELT. In addition, do not assign to elements that have been
2697 marked VISITED but do reset the visited flag; this allows easy coordination
2698 with generate_element_init. */
2701 generate_element_zero (struct sra_elt
*elt
, gimple_seq
*seq_p
)
2707 elt
->visited
= false;
2711 if (!elt
->in_bitfld_block
)
2712 FOR_EACH_ACTUAL_CHILD (c
, elt
)
2713 generate_element_zero (c
, seq_p
);
2715 if (elt
->replacement
)
2720 gcc_assert (elt
->is_scalar
);
2721 t
= fold_convert (elt
->type
, integer_zero_node
);
2723 tmp_seq
= sra_build_elt_assignment (elt
, t
);
2724 gimple_seq_add_seq (seq_p
, tmp_seq
);
2728 /* Generate an assignment VAR = INIT, where INIT may need gimplification.
2729 Add the result to *LIST_P. */
2732 generate_one_element_init (struct sra_elt
*elt
, tree init
, gimple_seq
*seq_p
)
2734 gimple_seq tmp_seq
= sra_build_elt_assignment (elt
, init
);
2735 gimple_seq_add_seq (seq_p
, tmp_seq
);
2738 /* Generate a set of assignment statements in *LIST_P to set all instantiated
2739 elements under ELT with the contents of the initializer INIT. In addition,
2740 mark all assigned elements VISITED; this allows easy coordination with
2741 generate_element_zero. Return false if we found a case we couldn't
2745 generate_element_init_1 (struct sra_elt
*elt
, tree init
, gimple_seq
*seq_p
)
2748 enum tree_code init_code
;
2749 struct sra_elt
*sub
;
2751 unsigned HOST_WIDE_INT idx
;
2752 tree value
, purpose
;
2754 /* We can be passed DECL_INITIAL of a static variable. It might have a
2755 conversion, which we strip off here. */
2756 STRIP_USELESS_TYPE_CONVERSION (init
);
2757 init_code
= TREE_CODE (init
);
2761 if (elt
->replacement
)
2763 generate_one_element_init (elt
, init
, seq_p
);
2764 elt
->visited
= true;
2773 FOR_EACH_ACTUAL_CHILD (sub
, elt
)
2775 if (sub
->element
== integer_zero_node
)
2776 t
= (init_code
== COMPLEX_EXPR
2777 ? TREE_OPERAND (init
, 0) : TREE_REALPART (init
));
2779 t
= (init_code
== COMPLEX_EXPR
2780 ? TREE_OPERAND (init
, 1) : TREE_IMAGPART (init
));
2781 result
&= generate_element_init_1 (sub
, t
, seq_p
);
2786 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
, purpose
, value
)
2788 /* Array constructors are routinely created with NULL indices. */
2789 if (purpose
== NULL_TREE
)
2794 if (TREE_CODE (purpose
) == RANGE_EXPR
)
2796 tree lower
= TREE_OPERAND (purpose
, 0);
2797 tree upper
= TREE_OPERAND (purpose
, 1);
2801 sub
= lookup_element (elt
, lower
, NULL
, NO_INSERT
);
2803 result
&= generate_element_init_1 (sub
, value
, seq_p
);
2804 if (tree_int_cst_equal (lower
, upper
))
2806 lower
= int_const_binop (PLUS_EXPR
, lower
,
2807 integer_one_node
, true);
2812 sub
= lookup_element (elt
, purpose
, NULL
, NO_INSERT
);
2814 result
&= generate_element_init_1 (sub
, value
, seq_p
);
2820 elt
->visited
= true;
2827 /* A wrapper function for generate_element_init_1 that handles cleanup after
2831 generate_element_init (struct sra_elt
*elt
, tree init
, gimple_seq
*seq_p
)
2834 struct gimplify_ctx gctx
;
2836 push_gimplify_context (&gctx
);
2837 ret
= generate_element_init_1 (elt
, init
, seq_p
);
2838 pop_gimplify_context (NULL
);
2840 /* The replacement can expose previously unreferenced variables. */
2843 gimple_stmt_iterator i
;
2845 for (i
= gsi_start (*seq_p
); !gsi_end_p (i
); gsi_next (&i
))
2846 find_new_referenced_vars (gsi_stmt (i
));
2852 /* Insert a gimple_seq SEQ on all the outgoing edges out of BB. Note that
2853 if BB has more than one edge, STMT will be replicated for each edge.
2854 Also, abnormal edges will be ignored. */
2857 insert_edge_copies_seq (gimple_seq seq
, basic_block bb
)
2861 unsigned n_copies
= -1;
2863 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2864 if (!(e
->flags
& EDGE_ABNORMAL
))
2867 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2868 if (!(e
->flags
& EDGE_ABNORMAL
))
2869 gsi_insert_seq_on_edge (e
, n_copies
-- > 0 ? gimple_seq_copy (seq
) : seq
);
2872 /* Helper function to insert LIST before GSI, and set up line number info. */
2875 sra_insert_before (gimple_stmt_iterator
*gsi
, gimple_seq seq
)
2877 gimple stmt
= gsi_stmt (*gsi
);
2879 if (gimple_has_location (stmt
))
2880 annotate_all_with_location (seq
, gimple_location (stmt
));
2881 gsi_insert_seq_before (gsi
, seq
, GSI_SAME_STMT
);
2884 /* Similarly, but insert after GSI. Handles insertion onto edges as well. */
2887 sra_insert_after (gimple_stmt_iterator
*gsi
, gimple_seq seq
)
2889 gimple stmt
= gsi_stmt (*gsi
);
2891 if (gimple_has_location (stmt
))
2892 annotate_all_with_location (seq
, gimple_location (stmt
));
2894 if (stmt_ends_bb_p (stmt
))
2895 insert_edge_copies_seq (seq
, gsi_bb (*gsi
));
2897 gsi_insert_seq_after (gsi
, seq
, GSI_SAME_STMT
);
2900 /* Similarly, but replace the statement at GSI. */
2903 sra_replace (gimple_stmt_iterator
*gsi
, gimple_seq seq
)
2905 sra_insert_before (gsi
, seq
);
2906 gsi_remove (gsi
, false);
2907 if (gsi_end_p (*gsi
))
2908 *gsi
= gsi_last (gsi_seq (*gsi
));
2913 /* Data structure that bitfield_overlaps_p fills in with information
2914 about the element passed in and how much of it overlaps with the
2915 bit-range passed it to. */
2917 struct bitfield_overlap_info
2919 /* The bit-length of an element. */
2922 /* The bit-position of the element in its parent. */
2925 /* The number of bits of the element that overlap with the incoming
2929 /* The first bit of the element that overlaps with the incoming bit
2934 /* Return true if a BIT_FIELD_REF<(FLD->parent), BLEN, BPOS>
2935 expression (referenced as BF below) accesses any of the bits in FLD,
2936 false if it doesn't. If DATA is non-null, its field_len and
2937 field_pos are filled in such that BIT_FIELD_REF<(FLD->parent),
2938 field_len, field_pos> (referenced as BFLD below) represents the
2939 entire field FLD->element, and BIT_FIELD_REF<BFLD, overlap_len,
2940 overlap_pos> represents the portion of the entire field that
2941 overlaps with BF. */
2944 bitfield_overlaps_p (tree blen
, tree bpos
, struct sra_elt
*fld
,
2945 struct bitfield_overlap_info
*data
)
2950 if (TREE_CODE (fld
->element
) == FIELD_DECL
)
2952 flen
= fold_convert (bitsizetype
, DECL_SIZE (fld
->element
));
2953 fpos
= fold_convert (bitsizetype
, DECL_FIELD_OFFSET (fld
->element
));
2954 fpos
= size_binop (MULT_EXPR
, fpos
, bitsize_int (BITS_PER_UNIT
));
2955 fpos
= size_binop (PLUS_EXPR
, fpos
, DECL_FIELD_BIT_OFFSET (fld
->element
));
2957 else if (TREE_CODE (fld
->element
) == BIT_FIELD_REF
)
2959 flen
= fold_convert (bitsizetype
, TREE_OPERAND (fld
->element
, 1));
2960 fpos
= fold_convert (bitsizetype
, TREE_OPERAND (fld
->element
, 2));
2962 else if (TREE_CODE (fld
->element
) == INTEGER_CST
)
2964 flen
= fold_convert (bitsizetype
, TYPE_SIZE (fld
->type
));
2965 fpos
= fold_convert (bitsizetype
, fld
->element
);
2966 fpos
= size_binop (MULT_EXPR
, flen
, fpos
);
2971 gcc_assert (host_integerp (blen
, 1)
2972 && host_integerp (bpos
, 1)
2973 && host_integerp (flen
, 1)
2974 && host_integerp (fpos
, 1));
2976 ret
= ((!tree_int_cst_lt (fpos
, bpos
)
2977 && tree_int_cst_lt (size_binop (MINUS_EXPR
, fpos
, bpos
),
2979 || (!tree_int_cst_lt (bpos
, fpos
)
2980 && tree_int_cst_lt (size_binop (MINUS_EXPR
, bpos
, fpos
),
2990 data
->field_len
= flen
;
2991 data
->field_pos
= fpos
;
2993 fend
= size_binop (PLUS_EXPR
, fpos
, flen
);
2994 bend
= size_binop (PLUS_EXPR
, bpos
, blen
);
2996 if (tree_int_cst_lt (bend
, fend
))
2997 data
->overlap_len
= size_binop (MINUS_EXPR
, bend
, fpos
);
2999 data
->overlap_len
= NULL
;
3001 if (tree_int_cst_lt (fpos
, bpos
))
3003 data
->overlap_pos
= size_binop (MINUS_EXPR
, bpos
, fpos
);
3004 data
->overlap_len
= size_binop (MINUS_EXPR
,
3011 data
->overlap_pos
= NULL
;
3017 /* Add to LISTP a sequence of statements that copies BLEN bits between
3018 VAR and the scalarized elements of ELT, starting a bit VPOS of VAR
3019 and at bit BPOS of ELT. The direction of the copy is given by
3023 sra_explode_bitfield_assignment (tree var
, tree vpos
, bool to_var
,
3024 gimple_seq
*seq_p
, tree blen
, tree bpos
,
3025 struct sra_elt
*elt
)
3027 struct sra_elt
*fld
;
3028 struct bitfield_overlap_info flp
;
3030 FOR_EACH_ACTUAL_CHILD (fld
, elt
)
3034 if (!bitfield_overlaps_p (blen
, bpos
, fld
, &flp
))
3037 flen
= flp
.overlap_len
? flp
.overlap_len
: flp
.field_len
;
3038 fpos
= flp
.overlap_pos
? flp
.overlap_pos
: bitsize_int (0);
3040 if (fld
->replacement
)
3042 tree infld
, invar
, type
;
3045 infld
= fld
->replacement
;
3047 type
= TREE_TYPE (infld
);
3048 if (TYPE_PRECISION (type
) != TREE_INT_CST_LOW (flen
))
3049 type
= lang_hooks
.types
.type_for_size (TREE_INT_CST_LOW (flen
), 1);
3051 type
= unsigned_type_for (type
);
3053 if (TREE_CODE (infld
) == BIT_FIELD_REF
)
3055 fpos
= size_binop (PLUS_EXPR
, fpos
, TREE_OPERAND (infld
, 2));
3056 infld
= TREE_OPERAND (infld
, 0);
3058 else if (BYTES_BIG_ENDIAN
&& DECL_P (fld
->element
)
3059 && !tree_int_cst_equal (TYPE_SIZE (TREE_TYPE (infld
)),
3060 DECL_SIZE (fld
->element
)))
3062 fpos
= size_binop (PLUS_EXPR
, fpos
,
3063 TYPE_SIZE (TREE_TYPE (infld
)));
3064 fpos
= size_binop (MINUS_EXPR
, fpos
,
3065 DECL_SIZE (fld
->element
));
3068 infld
= fold_build3 (BIT_FIELD_REF
, type
, infld
, flen
, fpos
);
3070 invar
= size_binop (MINUS_EXPR
, flp
.field_pos
, bpos
);
3071 if (flp
.overlap_pos
)
3072 invar
= size_binop (PLUS_EXPR
, invar
, flp
.overlap_pos
);
3073 invar
= size_binop (PLUS_EXPR
, invar
, vpos
);
3075 invar
= fold_build3 (BIT_FIELD_REF
, type
, var
, flen
, invar
);
3078 st
= sra_build_bf_assignment (invar
, infld
);
3080 st
= sra_build_bf_assignment (infld
, invar
);
3082 gimple_seq_add_seq (seq_p
, st
);
3086 tree sub
= size_binop (MINUS_EXPR
, flp
.field_pos
, bpos
);
3087 sub
= size_binop (PLUS_EXPR
, vpos
, sub
);
3088 if (flp
.overlap_pos
)
3089 sub
= size_binop (PLUS_EXPR
, sub
, flp
.overlap_pos
);
3091 sra_explode_bitfield_assignment (var
, sub
, to_var
, seq_p
,
3097 /* Add to LISTBEFOREP statements that copy scalarized members of ELT
3098 that overlap with BIT_FIELD_REF<(ELT->element), BLEN, BPOS> back
3099 into the full variable, and to LISTAFTERP, if non-NULL, statements
3100 that copy the (presumably modified) overlapping portions of the
3101 full variable back to the scalarized variables. */
3104 sra_sync_for_bitfield_assignment (gimple_seq
*seq_before_p
,
3105 gimple_seq
*seq_after_p
,
3106 tree blen
, tree bpos
,
3107 struct sra_elt
*elt
)
3109 struct sra_elt
*fld
;
3110 struct bitfield_overlap_info flp
;
3112 FOR_EACH_ACTUAL_CHILD (fld
, elt
)
3113 if (bitfield_overlaps_p (blen
, bpos
, fld
, &flp
))
3115 if (fld
->replacement
|| (!flp
.overlap_len
&& !flp
.overlap_pos
))
3117 generate_copy_inout (fld
, false, generate_element_ref (fld
),
3119 mark_no_warning (fld
);
3121 generate_copy_inout (fld
, true, generate_element_ref (fld
),
3126 tree flen
= flp
.overlap_len
? flp
.overlap_len
: flp
.field_len
;
3127 tree fpos
= flp
.overlap_pos
? flp
.overlap_pos
: bitsize_int (0);
3129 sra_sync_for_bitfield_assignment (seq_before_p
, seq_after_p
,
3135 /* Scalarize a USE. To recap, this is either a simple reference to ELT,
3136 if elt is scalar, or some occurrence of ELT that requires a complete
3137 aggregate. IS_OUTPUT is true if ELT is being modified. */
3140 scalarize_use (struct sra_elt
*elt
, tree
*expr_p
, gimple_stmt_iterator
*gsi
,
3141 bool is_output
, bool use_all
)
3143 gimple stmt
= gsi_stmt (*gsi
);
3146 if (elt
->replacement
)
3148 tree replacement
= elt
->replacement
;
3150 /* If we have a replacement, then updating the reference is as
3151 simple as modifying the existing statement in place. */
3153 && TREE_CODE (elt
->replacement
) == BIT_FIELD_REF
3154 && is_gimple_reg (TREE_OPERAND (elt
->replacement
, 0))
3155 && is_gimple_assign (stmt
)
3156 && gimple_assign_lhs_ptr (stmt
) == expr_p
)
3159 /* RHS must be a single operand. */
3160 gcc_assert (gimple_assign_single_p (stmt
));
3161 newseq
= sra_build_elt_assignment (elt
, gimple_assign_rhs1 (stmt
));
3162 sra_replace (gsi
, newseq
);
3166 && TREE_CODE (elt
->replacement
) == BIT_FIELD_REF
3167 && is_gimple_assign (stmt
)
3168 && gimple_assign_rhs1_ptr (stmt
) == expr_p
)
3170 tree tmp
= make_rename_temp
3171 (TREE_TYPE (gimple_assign_lhs (stmt
)), "SR");
3172 gimple_seq newseq
= sra_build_assignment (tmp
, REPLDUP (elt
->replacement
));
3174 sra_insert_before (gsi
, newseq
);
3178 mark_all_v_defs_stmt (stmt
);
3179 *expr_p
= REPLDUP (replacement
);
3182 else if (use_all
&& is_output
3183 && is_gimple_assign (stmt
)
3184 && TREE_CODE (bfexpr
3185 = gimple_assign_lhs (stmt
)) == BIT_FIELD_REF
3186 && &TREE_OPERAND (bfexpr
, 0) == expr_p
3187 && INTEGRAL_TYPE_P (TREE_TYPE (bfexpr
))
3188 && TREE_CODE (TREE_TYPE (*expr_p
)) == RECORD_TYPE
)
3190 gimple_seq seq_before
= NULL
;
3191 gimple_seq seq_after
= NULL
;
3192 tree blen
= fold_convert (bitsizetype
, TREE_OPERAND (bfexpr
, 1));
3193 tree bpos
= fold_convert (bitsizetype
, TREE_OPERAND (bfexpr
, 2));
3194 bool update
= false;
3196 if (!elt
->use_block_copy
)
3198 tree type
= TREE_TYPE (bfexpr
);
3199 tree var
= make_rename_temp (type
, "SR"), tmp
, vpos
;
3202 gimple_assign_set_lhs (stmt
, var
);
3205 if (!TYPE_UNSIGNED (type
))
3207 type
= unsigned_type_for (type
);
3208 tmp
= make_rename_temp (type
, "SR");
3209 st
= gimple_build_assign (tmp
, fold_convert (type
, var
));
3210 gimple_seq_add_stmt (&seq_after
, st
);
3214 /* If VAR is wider than BLEN bits, it is padded at the
3215 most-significant end. We want to set VPOS such that
3216 <BIT_FIELD_REF VAR BLEN VPOS> would refer to the
3217 least-significant BLEN bits of VAR. */
3218 if (BYTES_BIG_ENDIAN
)
3219 vpos
= size_binop (MINUS_EXPR
, TYPE_SIZE (type
), blen
);
3221 vpos
= bitsize_int (0);
3222 sra_explode_bitfield_assignment
3223 (var
, vpos
, false, &seq_after
, blen
, bpos
, elt
);
3226 sra_sync_for_bitfield_assignment
3227 (&seq_before
, &seq_after
, blen
, bpos
, elt
);
3231 mark_all_v_defs_seq (seq_before
);
3232 sra_insert_before (gsi
, seq_before
);
3236 mark_all_v_defs_seq (seq_after
);
3237 sra_insert_after (gsi
, seq_after
);
3243 else if (use_all
&& !is_output
3244 && is_gimple_assign (stmt
)
3245 && TREE_CODE (bfexpr
3246 = gimple_assign_rhs1 (stmt
)) == BIT_FIELD_REF
3247 && &TREE_OPERAND (gimple_assign_rhs1 (stmt
), 0) == expr_p
3248 && INTEGRAL_TYPE_P (TREE_TYPE (bfexpr
))
3249 && TREE_CODE (TREE_TYPE (*expr_p
)) == RECORD_TYPE
)
3251 gimple_seq seq
= NULL
;
3252 tree blen
= fold_convert (bitsizetype
, TREE_OPERAND (bfexpr
, 1));
3253 tree bpos
= fold_convert (bitsizetype
, TREE_OPERAND (bfexpr
, 2));
3254 bool update
= false;
3256 if (!elt
->use_block_copy
)
3258 tree type
= TREE_TYPE (bfexpr
);
3261 if (!TYPE_UNSIGNED (type
))
3262 type
= unsigned_type_for (type
);
3264 var
= make_rename_temp (type
, "SR");
3266 gimple_seq_add_stmt (&seq
,
3268 (var
, build_int_cst_wide (type
, 0, 0)));
3270 /* If VAR is wider than BLEN bits, it is padded at the
3271 most-significant end. We want to set VPOS such that
3272 <BIT_FIELD_REF VAR BLEN VPOS> would refer to the
3273 least-significant BLEN bits of VAR. */
3274 if (BYTES_BIG_ENDIAN
)
3275 vpos
= size_binop (MINUS_EXPR
, TYPE_SIZE (type
), blen
);
3277 vpos
= bitsize_int (0);
3278 sra_explode_bitfield_assignment
3279 (var
, vpos
, true, &seq
, blen
, bpos
, elt
);
3281 gimple_assign_set_rhs1 (stmt
, var
);
3285 sra_sync_for_bitfield_assignment
3286 (&seq
, NULL
, blen
, bpos
, elt
);
3290 mark_all_v_defs_seq (seq
);
3291 sra_insert_before (gsi
, seq
);
3299 gimple_seq seq
= NULL
;
3301 /* Otherwise we need some copies. If ELT is being read, then we
3302 want to store all (modified) sub-elements back into the
3303 structure before the reference takes place. If ELT is being
3304 written, then we want to load the changed values back into
3305 our shadow variables. */
3306 /* ??? We don't check modified for reads, we just always write all of
3307 the values. We should be able to record the SSA number of the VOP
3308 for which the values were last read. If that number matches the
3309 SSA number of the VOP in the current statement, then we needn't
3310 emit an assignment. This would also eliminate double writes when
3311 a structure is passed as more than one argument to a function call.
3312 This optimization would be most effective if sra_walk_function
3313 processed the blocks in dominator order. */
3315 generate_copy_inout (elt
, is_output
, generate_element_ref (elt
), &seq
);
3318 mark_all_v_defs_seq (seq
);
3320 sra_insert_after (gsi
, seq
);
3323 sra_insert_before (gsi
, seq
);
3325 mark_no_warning (elt
);
3330 /* Scalarize a COPY. To recap, this is an assignment statement between
3331 two scalarizable references, LHS_ELT and RHS_ELT. */
3334 scalarize_copy (struct sra_elt
*lhs_elt
, struct sra_elt
*rhs_elt
,
3335 gimple_stmt_iterator
*gsi
)
3340 if (lhs_elt
->replacement
&& rhs_elt
->replacement
)
3342 /* If we have two scalar operands, modify the existing statement. */
3343 stmt
= gsi_stmt (*gsi
);
3345 /* See the commentary in sra_walk_function concerning
3346 RETURN_EXPR, and why we should never see one here. */
3347 gcc_assert (is_gimple_assign (stmt
));
3348 gcc_assert (gimple_assign_copy_p (stmt
));
3351 gimple_assign_set_lhs (stmt
, lhs_elt
->replacement
);
3352 gimple_assign_set_rhs1 (stmt
, REPLDUP (rhs_elt
->replacement
));
3355 else if (lhs_elt
->use_block_copy
|| rhs_elt
->use_block_copy
)
3357 /* If either side requires a block copy, then sync the RHS back
3358 to the original structure, leave the original assignment
3359 statement (which will perform the block copy), then load the
3360 LHS values out of its now-updated original structure. */
3361 /* ??? Could perform a modified pair-wise element copy. That
3362 would at least allow those elements that are instantiated in
3363 both structures to be optimized well. */
3366 generate_copy_inout (rhs_elt
, false,
3367 generate_element_ref (rhs_elt
), &seq
);
3370 mark_all_v_defs_seq (seq
);
3371 sra_insert_before (gsi
, seq
);
3375 generate_copy_inout (lhs_elt
, true,
3376 generate_element_ref (lhs_elt
), &seq
);
3379 mark_all_v_defs_seq (seq
);
3380 sra_insert_after (gsi
, seq
);
3385 /* Otherwise both sides must be fully instantiated. In which
3386 case perform pair-wise element assignments and replace the
3387 original block copy statement. */
3389 stmt
= gsi_stmt (*gsi
);
3390 mark_all_v_defs_stmt (stmt
);
3393 generate_element_copy (lhs_elt
, rhs_elt
, &seq
);
3395 mark_all_v_defs_seq (seq
);
3396 sra_replace (gsi
, seq
);
3400 /* Scalarize an INIT. To recap, this is an assignment to a scalarizable
3401 reference from some form of constructor: CONSTRUCTOR, COMPLEX_CST or
3402 COMPLEX_EXPR. If RHS is NULL, it should be treated as an empty
3406 scalarize_init (struct sra_elt
*lhs_elt
, tree rhs
, gimple_stmt_iterator
*gsi
)
3409 gimple_seq seq
= NULL
, init_seq
= NULL
;
3411 /* Generate initialization statements for all members extant in the RHS. */
3414 /* Unshare the expression just in case this is from a decl's initial. */
3415 rhs
= unshare_expr (rhs
);
3416 result
= generate_element_init (lhs_elt
, rhs
, &init_seq
);
3421 /* If we failed to convert the entire initializer, then we must
3422 leave the structure assignment in place and must load values
3423 from the structure into the slots for which we did not find
3424 constants. The easiest way to do this is to generate a complete
3425 copy-out, and then follow that with the constant assignments
3426 that we were able to build. DCE will clean things up. */
3427 gimple_seq seq0
= NULL
;
3428 generate_copy_inout (lhs_elt
, true, generate_element_ref (lhs_elt
),
3430 gimple_seq_add_seq (&seq0
, seq
);
3435 /* CONSTRUCTOR is defined such that any member not mentioned is assigned
3436 a zero value. Initialize the rest of the instantiated elements. */
3437 generate_element_zero (lhs_elt
, &seq
);
3438 gimple_seq_add_seq (&seq
, init_seq
);
3441 if (lhs_elt
->use_block_copy
|| !result
)
3443 /* Since LHS is not fully instantiated, we must leave the structure
3444 assignment in place. Treating this case differently from a USE
3445 exposes constants to later optimizations. */
3448 mark_all_v_defs_seq (seq
);
3449 sra_insert_after (gsi
, seq
);
3454 /* The LHS is fully instantiated. The list of initializations
3455 replaces the original structure assignment. */
3457 mark_all_v_defs_stmt (gsi_stmt (*gsi
));
3458 mark_all_v_defs_seq (seq
);
3459 sra_replace (gsi
, seq
);
3463 /* A subroutine of scalarize_ldst called via walk_tree. Set TREE_NO_TRAP
3464 on all INDIRECT_REFs. */
3467 mark_notrap (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
3471 if (TREE_CODE (t
) == INDIRECT_REF
)
3473 TREE_THIS_NOTRAP (t
) = 1;
3476 else if (IS_TYPE_OR_DECL_P (t
))
3482 /* Scalarize a LDST. To recap, this is an assignment between one scalarizable
3483 reference ELT and one non-scalarizable reference OTHER. IS_OUTPUT is true
3484 if ELT is on the left-hand side. */
3487 scalarize_ldst (struct sra_elt
*elt
, tree other
,
3488 gimple_stmt_iterator
*gsi
, bool is_output
)
3490 /* Shouldn't have gotten called for a scalar. */
3491 gcc_assert (!elt
->replacement
);
3493 if (elt
->use_block_copy
)
3495 /* Since ELT is not fully instantiated, we have to leave the
3496 block copy in place. Treat this as a USE. */
3497 scalarize_use (elt
, NULL
, gsi
, is_output
, false);
3501 /* The interesting case is when ELT is fully instantiated. In this
3502 case we can have each element stored/loaded directly to/from the
3503 corresponding slot in OTHER. This avoids a block copy. */
3505 gimple_seq seq
= NULL
;
3506 gimple stmt
= gsi_stmt (*gsi
);
3508 mark_all_v_defs_stmt (stmt
);
3509 generate_copy_inout (elt
, is_output
, other
, &seq
);
3511 mark_all_v_defs_seq (seq
);
3513 /* Preserve EH semantics. */
3514 if (stmt_ends_bb_p (stmt
))
3516 gimple_stmt_iterator si
;
3518 gimple_seq blist
= NULL
;
3519 bool thr
= stmt_could_throw_p (stmt
);
3521 /* If the last statement of this BB created an EH edge
3522 before scalarization, we have to locate the first
3523 statement that can throw in the new statement list and
3524 use that as the last statement of this BB, such that EH
3525 semantics is preserved. All statements up to this one
3526 are added to the same BB. All other statements in the
3527 list will be added to normal outgoing edges of the same
3528 BB. If they access any memory, it's the same memory, so
3529 we can assume they won't throw. */
3530 si
= gsi_start (seq
);
3531 for (first
= gsi_stmt (si
);
3532 thr
&& !gsi_end_p (si
) && !stmt_could_throw_p (first
);
3533 first
= gsi_stmt (si
))
3535 gsi_remove (&si
, false);
3536 gimple_seq_add_stmt (&blist
, first
);
3539 /* Extract the first remaining statement from LIST, this is
3540 the EH statement if there is one. */
3541 gsi_remove (&si
, false);
3544 sra_insert_before (gsi
, blist
);
3546 /* Replace the old statement with this new representative. */
3547 gsi_replace (gsi
, first
, true);
3549 if (!gsi_end_p (si
))
3551 /* If any reference would trap, then they all would. And more
3552 to the point, the first would. Therefore none of the rest
3553 will trap since the first didn't. Indicate this by
3554 iterating over the remaining statements and set
3555 TREE_THIS_NOTRAP in all INDIRECT_REFs. */
3558 walk_gimple_stmt (&si
, NULL
, mark_notrap
, NULL
);
3561 while (!gsi_end_p (si
));
3563 insert_edge_copies_seq (seq
, gsi_bb (*gsi
));
3567 sra_replace (gsi
, seq
);
3571 /* Generate initializations for all scalarizable parameters. */
3574 scalarize_parms (void)
3576 gimple_seq seq
= NULL
;
3580 EXECUTE_IF_SET_IN_BITMAP (needs_copy_in
, 0, i
, bi
)
3582 tree var
= referenced_var (i
);
3583 struct sra_elt
*elt
= lookup_element (NULL
, var
, NULL
, NO_INSERT
);
3584 generate_copy_inout (elt
, true, var
, &seq
);
3589 insert_edge_copies_seq (seq
, ENTRY_BLOCK_PTR
);
3590 mark_all_v_defs_seq (seq
);
3594 /* Entry point to phase 4. Update the function to match replacements. */
3597 scalarize_function (void)
3599 static const struct sra_walk_fns fns
= {
3600 scalarize_use
, scalarize_copy
, scalarize_init
, scalarize_ldst
, false
3603 sra_walk_function (&fns
);
3605 gsi_commit_edge_inserts ();
3609 /* Debug helper function. Print ELT in a nice human-readable format. */
3612 dump_sra_elt_name (FILE *f
, struct sra_elt
*elt
)
3614 if (elt
->parent
&& TREE_CODE (elt
->parent
->type
) == COMPLEX_TYPE
)
3616 fputs (elt
->element
== integer_zero_node
? "__real__ " : "__imag__ ", f
);
3617 dump_sra_elt_name (f
, elt
->parent
);
3622 dump_sra_elt_name (f
, elt
->parent
);
3623 if (DECL_P (elt
->element
))
3625 if (TREE_CODE (elt
->element
) == FIELD_DECL
)
3627 print_generic_expr (f
, elt
->element
, dump_flags
);
3629 else if (TREE_CODE (elt
->element
) == BIT_FIELD_REF
)
3630 fprintf (f
, "$B" HOST_WIDE_INT_PRINT_DEC
"F" HOST_WIDE_INT_PRINT_DEC
,
3631 tree_low_cst (TREE_OPERAND (elt
->element
, 2), 1),
3632 tree_low_cst (TREE_OPERAND (elt
->element
, 1), 1));
3633 else if (TREE_CODE (elt
->element
) == RANGE_EXPR
)
3634 fprintf (f
, "["HOST_WIDE_INT_PRINT_DEC
".."HOST_WIDE_INT_PRINT_DEC
"]",
3635 TREE_INT_CST_LOW (TREE_OPERAND (elt
->element
, 0)),
3636 TREE_INT_CST_LOW (TREE_OPERAND (elt
->element
, 1)));
3638 fprintf (f
, "[" HOST_WIDE_INT_PRINT_DEC
"]",
3639 TREE_INT_CST_LOW (elt
->element
));
3643 /* Likewise, but callable from the debugger. */
3646 debug_sra_elt_name (struct sra_elt
*elt
)
3648 dump_sra_elt_name (stderr
, elt
);
3649 fputc ('\n', stderr
);
3653 sra_init_cache (void)
3655 if (sra_type_decomp_cache
)
3658 sra_type_decomp_cache
= BITMAP_ALLOC (NULL
);
3659 sra_type_inst_cache
= BITMAP_ALLOC (NULL
);
3663 /* Main entry point. */
3668 /* Initialize local variables. */
3670 gcc_obstack_init (&sra_obstack
);
3671 sra_candidates
= BITMAP_ALLOC (NULL
);
3672 needs_copy_in
= BITMAP_ALLOC (NULL
);
3674 sra_map
= htab_create (101, sra_elt_hash
, sra_elt_eq
, NULL
);
3676 /* Scan. If we find anything, instantiate and scalarize. */
3677 if (find_candidates_for_sra ())
3680 decide_instantiations ();
3681 scalarize_function ();
3682 if (!bitmap_empty_p (sra_candidates
))
3683 todoflags
|= TODO_rebuild_alias
;
3686 /* Free allocated memory. */
3687 htab_delete (sra_map
);
3689 BITMAP_FREE (sra_candidates
);
3690 BITMAP_FREE (needs_copy_in
);
3691 BITMAP_FREE (sra_type_decomp_cache
);
3692 BITMAP_FREE (sra_type_inst_cache
);
3693 obstack_free (&sra_obstack
, NULL
);
3698 tree_sra_early (void)
3706 return ret
& ~TODO_rebuild_alias
;
3712 return flag_tree_sra
!= 0;
3715 struct gimple_opt_pass pass_sra_early
=
3720 gate_sra
, /* gate */
3721 tree_sra_early
, /* execute */
3724 0, /* static_pass_number */
3725 TV_TREE_SRA
, /* tv_id */
3726 PROP_cfg
| PROP_ssa
, /* properties_required */
3727 0, /* properties_provided */
3728 0, /* properties_destroyed */
3729 0, /* todo_flags_start */
3733 | TODO_verify_ssa
/* todo_flags_finish */
3737 struct gimple_opt_pass pass_sra
=
3742 gate_sra
, /* gate */
3743 tree_sra
, /* execute */
3746 0, /* static_pass_number */
3747 TV_TREE_SRA
, /* tv_id */
3748 PROP_cfg
| PROP_ssa
, /* properties_required */
3749 0, /* properties_provided */
3750 0, /* properties_destroyed */
3751 0, /* todo_flags_start */
3755 | TODO_verify_ssa
/* todo_flags_finish */