1 /* Scalar Replacement of Aggregates (SRA) converts some structure
2 references into scalar references, exposing them to the scalar
4 Copyright (C) 2008-2020 Free Software Foundation, Inc.
5 Contributed by Martin Jambor <mjambor@suse.cz>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* This file implements Scalar Reduction of Aggregates (SRA). SRA is run
24 twice, once in the early stages of compilation (early SRA) and once in the
25 late stages (late SRA). The aim of both is to turn references to scalar
26 parts of aggregates into uses of independent scalar variables.
28 The two passes are nearly identical, the only difference is that early SRA
29 does not scalarize unions which are used as the result in a GIMPLE_RETURN
30 statement because together with inlining this can lead to weird type
33 Both passes operate in four stages:
35 1. The declarations that have properties which make them candidates for
36 scalarization are identified in function find_var_candidates(). The
37 candidates are stored in candidate_bitmap.
39 2. The function body is scanned. In the process, declarations which are
40 used in a manner that prevent their scalarization are removed from the
41 candidate bitmap. More importantly, for every access into an aggregate,
42 an access structure (struct access) is created by create_access() and
43 stored in a vector associated with the aggregate. Among other
44 information, the aggregate declaration, the offset and size of the access
45 and its type are stored in the structure.
47 On a related note, assign_link structures are created for every assign
48 statement between candidate aggregates and attached to the related
51 3. The vectors of accesses are analyzed. They are first sorted according to
52 their offset and size and then scanned for partially overlapping accesses
53 (i.e. those which overlap but one is not entirely within another). Such
54 an access disqualifies the whole aggregate from being scalarized.
56 If there is no such inhibiting overlap, a representative access structure
57 is chosen for every unique combination of offset and size. Afterwards,
58 the pass builds a set of trees from these structures, in which children
59 of an access are within their parent (in terms of offset and size).
61 Then accesses are propagated whenever possible (i.e. in cases when it
62 does not create a partially overlapping access) across assign_links from
63 the right hand side to the left hand side.
65 Then the set of trees for each declaration is traversed again and those
66 accesses which should be replaced by a scalar are identified.
68 4. The function is traversed again, and for every reference into an
69 aggregate that has some component which is about to be scalarized,
70 statements are amended and new statements are created as necessary.
71 Finally, if a parameter got scalarized, the scalar replacements are
72 initialized with values from respective parameter aggregates. */
76 #include "coretypes.h"
83 #include "alloc-pool.h"
84 #include "tree-pass.h"
87 #include "gimple-pretty-print.h"
89 #include "fold-const.h"
91 #include "stor-layout.h"
93 #include "gimple-iterator.h"
94 #include "gimplify-me.h"
95 #include "gimple-walk.h"
100 #include "builtins.h"
101 #include "tree-sra.h"
104 /* Enumeration of all aggregate reductions we can do. */
105 enum sra_mode
{ SRA_MODE_EARLY_IPA
, /* early call regularization */
106 SRA_MODE_EARLY_INTRA
, /* early intraprocedural SRA */
107 SRA_MODE_INTRA
}; /* late intraprocedural SRA */
109 /* Global variable describing which aggregate reduction we are performing at
111 static enum sra_mode sra_mode
;
115 /* ACCESS represents each access to an aggregate variable (as a whole or a
116 part). It can also represent a group of accesses that refer to exactly the
117 same fragment of an aggregate (i.e. those that have exactly the same offset
118 and size). Such representatives for a single aggregate, once determined,
119 are linked in a linked list and have the group fields set.
121 Moreover, when doing intraprocedural SRA, a tree is built from those
122 representatives (by the means of first_child and next_sibling pointers), in
123 which all items in a subtree are "within" the root, i.e. their offset is
124 greater or equal to offset of the root and offset+size is smaller or equal
125 to offset+size of the root. Children of an access are sorted by offset.
127 Note that accesses to parts of vector and complex number types always
128 represented by an access to the whole complex number or a vector. It is a
129 duty of the modifying functions to replace them appropriately. */
133 /* Values returned by `get_ref_base_and_extent' for each component reference
134 If EXPR isn't a component reference just set `BASE = EXPR', `OFFSET = 0',
135 `SIZE = TREE_SIZE (TREE_TYPE (expr))'. */
136 HOST_WIDE_INT offset
;
140 /* Expression. It is context dependent so do not use it to create new
141 expressions to access the original aggregate. See PR 42154 for a
147 /* The statement this access belongs to. */
150 /* Next group representative for this aggregate. */
151 struct access
*next_grp
;
153 /* Pointer to the group representative. Pointer to itself if the struct is
154 the representative. */
155 struct access
*group_representative
;
157 /* After access tree has been constructed, this points to the parent of the
158 current access, if there is one. NULL for roots. */
159 struct access
*parent
;
161 /* If this access has any children (in terms of the definition above), this
162 points to the first one. */
163 struct access
*first_child
;
165 /* In intraprocedural SRA, pointer to the next sibling in the access tree as
167 struct access
*next_sibling
;
169 /* Pointers to the first and last element in the linked list of assign
170 links for propagation from LHS to RHS. */
171 struct assign_link
*first_rhs_link
, *last_rhs_link
;
173 /* Pointers to the first and last element in the linked list of assign
174 links for propagation from LHS to RHS. */
175 struct assign_link
*first_lhs_link
, *last_lhs_link
;
177 /* Pointer to the next access in the work queues. */
178 struct access
*next_rhs_queued
, *next_lhs_queued
;
180 /* Replacement variable for this access "region." Never to be accessed
181 directly, always only by the means of get_access_replacement() and only
182 when grp_to_be_replaced flag is set. */
183 tree replacement_decl
;
185 /* Is this access made in reverse storage order? */
186 unsigned reverse
: 1;
188 /* Is this particular access write access? */
191 /* Is this access currently in the rhs work queue? */
192 unsigned grp_rhs_queued
: 1;
194 /* Is this access currently in the lhs work queue? */
195 unsigned grp_lhs_queued
: 1;
197 /* Does this group contain a write access? This flag is propagated down the
199 unsigned grp_write
: 1;
201 /* Does this group contain a read access? This flag is propagated down the
203 unsigned grp_read
: 1;
205 /* Does this group contain a read access that comes from an assignment
206 statement? This flag is propagated down the access tree. */
207 unsigned grp_assignment_read
: 1;
209 /* Does this group contain a write access that comes from an assignment
210 statement? This flag is propagated down the access tree. */
211 unsigned grp_assignment_write
: 1;
213 /* Does this group contain a read access through a scalar type? This flag is
214 not propagated in the access tree in any direction. */
215 unsigned grp_scalar_read
: 1;
217 /* Does this group contain a write access through a scalar type? This flag
218 is not propagated in the access tree in any direction. */
219 unsigned grp_scalar_write
: 1;
221 /* In a root of an access tree, true means that the entire tree should be
222 totally scalarized - that all scalar leafs should be scalarized and
223 non-root grp_total_scalarization accesses should be honored. Otherwise,
224 non-root accesses with grp_total_scalarization should never get scalar
226 unsigned grp_total_scalarization
: 1;
228 /* Other passes of the analysis use this bit to make function
229 analyze_access_subtree create scalar replacements for this group if
231 unsigned grp_hint
: 1;
233 /* Is the subtree rooted in this access fully covered by scalar
235 unsigned grp_covered
: 1;
237 /* If set to true, this access and all below it in an access tree must not be
239 unsigned grp_unscalarizable_region
: 1;
241 /* Whether data have been written to parts of the aggregate covered by this
242 access which is not to be scalarized. This flag is propagated up in the
244 unsigned grp_unscalarized_data
: 1;
246 /* Set if all accesses in the group consist of the same chain of
247 COMPONENT_REFs and ARRAY_REFs. */
248 unsigned grp_same_access_path
: 1;
250 /* Does this access and/or group contain a write access through a
252 unsigned grp_partial_lhs
: 1;
254 /* Set when a scalar replacement should be created for this variable. */
255 unsigned grp_to_be_replaced
: 1;
257 /* Set when we want a replacement for the sole purpose of having it in
258 generated debug statements. */
259 unsigned grp_to_be_debug_replaced
: 1;
261 /* Should TREE_NO_WARNING of a replacement be set? */
262 unsigned grp_no_warning
: 1;
265 typedef struct access
*access_p
;
268 /* Alloc pool for allocating access structures. */
269 static object_allocator
<struct access
> access_pool ("SRA accesses");
271 /* A structure linking lhs and rhs accesses from an aggregate assignment. They
272 are used to propagate subaccesses from rhs to lhs and vice versa as long as
273 they don't conflict with what is already there. In the RHS->LHS direction,
274 we also propagate grp_write flag to lazily mark that the access contains any
278 struct access
*lacc
, *racc
;
279 struct assign_link
*next_rhs
, *next_lhs
;
282 /* Alloc pool for allocating assign link structures. */
283 static object_allocator
<assign_link
> assign_link_pool ("SRA links");
285 /* Base (tree) -> Vector (vec<access_p> *) map. */
286 static hash_map
<tree
, auto_vec
<access_p
> > *base_access_vec
;
288 /* Hash to limit creation of artificial accesses */
289 static hash_map
<tree
, unsigned> *propagation_budget
;
291 /* Candidate hash table helpers. */
293 struct uid_decl_hasher
: nofree_ptr_hash
<tree_node
>
295 static inline hashval_t
hash (const tree_node
*);
296 static inline bool equal (const tree_node
*, const tree_node
*);
299 /* Hash a tree in a uid_decl_map. */
302 uid_decl_hasher::hash (const tree_node
*item
)
304 return item
->decl_minimal
.uid
;
307 /* Return true if the DECL_UID in both trees are equal. */
310 uid_decl_hasher::equal (const tree_node
*a
, const tree_node
*b
)
312 return (a
->decl_minimal
.uid
== b
->decl_minimal
.uid
);
315 /* Set of candidates. */
316 static bitmap candidate_bitmap
;
317 static hash_table
<uid_decl_hasher
> *candidates
;
319 /* For a candidate UID return the candidates decl. */
322 candidate (unsigned uid
)
325 t
.decl_minimal
.uid
= uid
;
326 return candidates
->find_with_hash (&t
, static_cast <hashval_t
> (uid
));
329 /* Bitmap of candidates which we should try to entirely scalarize away and
330 those which cannot be (because they are and need be used as a whole). */
331 static bitmap should_scalarize_away_bitmap
, cannot_scalarize_away_bitmap
;
333 /* Bitmap of candidates in the constant pool, which cannot be scalarized
334 because this would produce non-constant expressions (e.g. Ada). */
335 static bitmap disqualified_constants
;
337 /* Obstack for creation of fancy names. */
338 static struct obstack name_obstack
;
340 /* Head of a linked list of accesses that need to have its subaccesses
341 propagated to their assignment counterparts. */
342 static struct access
*rhs_work_queue_head
, *lhs_work_queue_head
;
344 /* Dump contents of ACCESS to file F in a human friendly way. If GRP is true,
345 representative fields are dumped, otherwise those which only describe the
346 individual access are. */
350 /* Number of processed aggregates is readily available in
351 analyze_all_variable_accesses and so is not stored here. */
353 /* Number of created scalar replacements. */
356 /* Number of times sra_modify_expr or sra_modify_assign themselves changed an
360 /* Number of statements created by generate_subtree_copies. */
363 /* Number of statements created by load_assign_lhs_subreplacements. */
366 /* Number of times sra_modify_assign has deleted a statement. */
369 /* Number of times sra_modify_assign has to deal with subaccesses of LHS and
370 RHS reparately due to type conversions or nonexistent matching
372 int separate_lhs_rhs_handling
;
374 /* Number of parameters that were removed because they were unused. */
375 int deleted_unused_parameters
;
377 /* Number of scalars passed as parameters by reference that have been
378 converted to be passed by value. */
379 int scalar_by_ref_to_by_val
;
381 /* Number of aggregate parameters that were replaced by one or more of their
383 int aggregate_params_reduced
;
385 /* Numbber of components created when splitting aggregate parameters. */
386 int param_reductions_created
;
390 dump_access (FILE *f
, struct access
*access
, bool grp
)
392 fprintf (f
, "access { ");
393 fprintf (f
, "base = (%d)'", DECL_UID (access
->base
));
394 print_generic_expr (f
, access
->base
);
395 fprintf (f
, "', offset = " HOST_WIDE_INT_PRINT_DEC
, access
->offset
);
396 fprintf (f
, ", size = " HOST_WIDE_INT_PRINT_DEC
, access
->size
);
397 fprintf (f
, ", expr = ");
398 print_generic_expr (f
, access
->expr
);
399 fprintf (f
, ", type = ");
400 print_generic_expr (f
, access
->type
);
401 fprintf (f
, ", reverse = %d", access
->reverse
);
403 fprintf (f
, ", grp_read = %d, grp_write = %d, grp_assignment_read = %d, "
404 "grp_assignment_write = %d, grp_scalar_read = %d, "
405 "grp_scalar_write = %d, grp_total_scalarization = %d, "
406 "grp_hint = %d, grp_covered = %d, "
407 "grp_unscalarizable_region = %d, grp_unscalarized_data = %d, "
408 "grp_same_access_path = %d, grp_partial_lhs = %d, "
409 "grp_to_be_replaced = %d, grp_to_be_debug_replaced = %d}\n",
410 access
->grp_read
, access
->grp_write
, access
->grp_assignment_read
,
411 access
->grp_assignment_write
, access
->grp_scalar_read
,
412 access
->grp_scalar_write
, access
->grp_total_scalarization
,
413 access
->grp_hint
, access
->grp_covered
,
414 access
->grp_unscalarizable_region
, access
->grp_unscalarized_data
,
415 access
->grp_same_access_path
, access
->grp_partial_lhs
,
416 access
->grp_to_be_replaced
, access
->grp_to_be_debug_replaced
);
418 fprintf (f
, ", write = %d, grp_total_scalarization = %d, "
419 "grp_partial_lhs = %d}\n",
420 access
->write
, access
->grp_total_scalarization
,
421 access
->grp_partial_lhs
);
424 /* Dump a subtree rooted in ACCESS to file F, indent by LEVEL. */
427 dump_access_tree_1 (FILE *f
, struct access
*access
, int level
)
433 for (i
= 0; i
< level
; i
++)
436 dump_access (f
, access
, true);
438 if (access
->first_child
)
439 dump_access_tree_1 (f
, access
->first_child
, level
+ 1);
441 access
= access
->next_sibling
;
446 /* Dump all access trees for a variable, given the pointer to the first root in
450 dump_access_tree (FILE *f
, struct access
*access
)
452 for (; access
; access
= access
->next_grp
)
453 dump_access_tree_1 (f
, access
, 0);
456 /* Return true iff ACC is non-NULL and has subaccesses. */
459 access_has_children_p (struct access
*acc
)
461 return acc
&& acc
->first_child
;
464 /* Return true iff ACC is (partly) covered by at least one replacement. */
467 access_has_replacements_p (struct access
*acc
)
469 struct access
*child
;
470 if (acc
->grp_to_be_replaced
)
472 for (child
= acc
->first_child
; child
; child
= child
->next_sibling
)
473 if (access_has_replacements_p (child
))
478 /* Return a vector of pointers to accesses for the variable given in BASE or
479 NULL if there is none. */
481 static vec
<access_p
> *
482 get_base_access_vector (tree base
)
484 return base_access_vec
->get (base
);
487 /* Find an access with required OFFSET and SIZE in a subtree of accesses rooted
488 in ACCESS. Return NULL if it cannot be found. */
490 static struct access
*
491 find_access_in_subtree (struct access
*access
, HOST_WIDE_INT offset
,
494 while (access
&& (access
->offset
!= offset
|| access
->size
!= size
))
496 struct access
*child
= access
->first_child
;
498 while (child
&& (child
->offset
+ child
->size
<= offset
))
499 child
= child
->next_sibling
;
503 /* Total scalarization does not replace single field structures with their
504 single field but rather creates an access for them underneath. Look for
507 while (access
->first_child
508 && access
->first_child
->offset
== offset
509 && access
->first_child
->size
== size
)
510 access
= access
->first_child
;
515 /* Return the first group representative for DECL or NULL if none exists. */
517 static struct access
*
518 get_first_repr_for_decl (tree base
)
520 vec
<access_p
> *access_vec
;
522 access_vec
= get_base_access_vector (base
);
526 return (*access_vec
)[0];
529 /* Find an access representative for the variable BASE and given OFFSET and
530 SIZE. Requires that access trees have already been built. Return NULL if
531 it cannot be found. */
533 static struct access
*
534 get_var_base_offset_size_access (tree base
, HOST_WIDE_INT offset
,
537 struct access
*access
;
539 access
= get_first_repr_for_decl (base
);
540 while (access
&& (access
->offset
+ access
->size
<= offset
))
541 access
= access
->next_grp
;
545 return find_access_in_subtree (access
, offset
, size
);
548 /* Add LINK to the linked list of assign links of RACC. */
551 add_link_to_rhs (struct access
*racc
, struct assign_link
*link
)
553 gcc_assert (link
->racc
== racc
);
555 if (!racc
->first_rhs_link
)
557 gcc_assert (!racc
->last_rhs_link
);
558 racc
->first_rhs_link
= link
;
561 racc
->last_rhs_link
->next_rhs
= link
;
563 racc
->last_rhs_link
= link
;
564 link
->next_rhs
= NULL
;
567 /* Add LINK to the linked list of lhs assign links of LACC. */
570 add_link_to_lhs (struct access
*lacc
, struct assign_link
*link
)
572 gcc_assert (link
->lacc
== lacc
);
574 if (!lacc
->first_lhs_link
)
576 gcc_assert (!lacc
->last_lhs_link
);
577 lacc
->first_lhs_link
= link
;
580 lacc
->last_lhs_link
->next_lhs
= link
;
582 lacc
->last_lhs_link
= link
;
583 link
->next_lhs
= NULL
;
586 /* Move all link structures in their linked list in OLD_ACC to the linked list
589 relink_to_new_repr (struct access
*new_acc
, struct access
*old_acc
)
591 if (old_acc
->first_rhs_link
)
594 if (new_acc
->first_rhs_link
)
596 gcc_assert (!new_acc
->last_rhs_link
->next_rhs
);
597 gcc_assert (!old_acc
->last_rhs_link
598 || !old_acc
->last_rhs_link
->next_rhs
);
600 new_acc
->last_rhs_link
->next_rhs
= old_acc
->first_rhs_link
;
601 new_acc
->last_rhs_link
= old_acc
->last_rhs_link
;
605 gcc_assert (!new_acc
->last_rhs_link
);
607 new_acc
->first_rhs_link
= old_acc
->first_rhs_link
;
608 new_acc
->last_rhs_link
= old_acc
->last_rhs_link
;
610 old_acc
->first_rhs_link
= old_acc
->last_rhs_link
= NULL
;
613 gcc_assert (!old_acc
->last_rhs_link
);
615 if (old_acc
->first_lhs_link
)
618 if (new_acc
->first_lhs_link
)
620 gcc_assert (!new_acc
->last_lhs_link
->next_lhs
);
621 gcc_assert (!old_acc
->last_lhs_link
622 || !old_acc
->last_lhs_link
->next_lhs
);
624 new_acc
->last_lhs_link
->next_lhs
= old_acc
->first_lhs_link
;
625 new_acc
->last_lhs_link
= old_acc
->last_lhs_link
;
629 gcc_assert (!new_acc
->last_lhs_link
);
631 new_acc
->first_lhs_link
= old_acc
->first_lhs_link
;
632 new_acc
->last_lhs_link
= old_acc
->last_lhs_link
;
634 old_acc
->first_lhs_link
= old_acc
->last_lhs_link
= NULL
;
637 gcc_assert (!old_acc
->last_lhs_link
);
641 /* Add ACCESS to the work to queue for propagation of subaccesses from RHS to
642 LHS (which is actually a stack). */
645 add_access_to_rhs_work_queue (struct access
*access
)
647 if (access
->first_rhs_link
&& !access
->grp_rhs_queued
)
649 gcc_assert (!access
->next_rhs_queued
);
650 access
->next_rhs_queued
= rhs_work_queue_head
;
651 access
->grp_rhs_queued
= 1;
652 rhs_work_queue_head
= access
;
656 /* Add ACCESS to the work to queue for propagation of subaccesses from LHS to
657 RHS (which is actually a stack). */
660 add_access_to_lhs_work_queue (struct access
*access
)
662 if (access
->first_lhs_link
&& !access
->grp_lhs_queued
)
664 gcc_assert (!access
->next_lhs_queued
);
665 access
->next_lhs_queued
= lhs_work_queue_head
;
666 access
->grp_lhs_queued
= 1;
667 lhs_work_queue_head
= access
;
671 /* Pop an access from the work queue for propagating from RHS to LHS, and
672 return it, assuming there is one. */
674 static struct access
*
675 pop_access_from_rhs_work_queue (void)
677 struct access
*access
= rhs_work_queue_head
;
679 rhs_work_queue_head
= access
->next_rhs_queued
;
680 access
->next_rhs_queued
= NULL
;
681 access
->grp_rhs_queued
= 0;
685 /* Pop an access from the work queue for propagating from LHS to RHS, and
686 return it, assuming there is one. */
688 static struct access
*
689 pop_access_from_lhs_work_queue (void)
691 struct access
*access
= lhs_work_queue_head
;
693 lhs_work_queue_head
= access
->next_lhs_queued
;
694 access
->next_lhs_queued
= NULL
;
695 access
->grp_lhs_queued
= 0;
699 /* Allocate necessary structures. */
702 sra_initialize (void)
704 candidate_bitmap
= BITMAP_ALLOC (NULL
);
705 candidates
= new hash_table
<uid_decl_hasher
>
706 (vec_safe_length (cfun
->local_decls
) / 2);
707 should_scalarize_away_bitmap
= BITMAP_ALLOC (NULL
);
708 cannot_scalarize_away_bitmap
= BITMAP_ALLOC (NULL
);
709 disqualified_constants
= BITMAP_ALLOC (NULL
);
710 gcc_obstack_init (&name_obstack
);
711 base_access_vec
= new hash_map
<tree
, auto_vec
<access_p
> >;
712 memset (&sra_stats
, 0, sizeof (sra_stats
));
715 /* Deallocate all general structures. */
718 sra_deinitialize (void)
720 BITMAP_FREE (candidate_bitmap
);
723 BITMAP_FREE (should_scalarize_away_bitmap
);
724 BITMAP_FREE (cannot_scalarize_away_bitmap
);
725 BITMAP_FREE (disqualified_constants
);
726 access_pool
.release ();
727 assign_link_pool
.release ();
728 obstack_free (&name_obstack
, NULL
);
730 delete base_access_vec
;
733 /* Return true if DECL is a VAR_DECL in the constant pool, false otherwise. */
735 static bool constant_decl_p (tree decl
)
737 return VAR_P (decl
) && DECL_IN_CONSTANT_POOL (decl
);
740 /* Remove DECL from candidates for SRA and write REASON to the dump file if
744 disqualify_candidate (tree decl
, const char *reason
)
746 if (bitmap_clear_bit (candidate_bitmap
, DECL_UID (decl
)))
747 candidates
->remove_elt_with_hash (decl
, DECL_UID (decl
));
748 if (constant_decl_p (decl
))
749 bitmap_set_bit (disqualified_constants
, DECL_UID (decl
));
751 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
753 fprintf (dump_file
, "! Disqualifying ");
754 print_generic_expr (dump_file
, decl
);
755 fprintf (dump_file
, " - %s\n", reason
);
759 /* Return true iff the type contains a field or an element which does not allow
760 scalarization. Use VISITED_TYPES to avoid re-checking already checked
764 type_internals_preclude_sra_p_1 (tree type
, const char **msg
,
765 hash_set
<tree
> *visited_types
)
770 if (visited_types
->contains (type
))
772 visited_types
->add (type
);
774 switch (TREE_CODE (type
))
778 case QUAL_UNION_TYPE
:
779 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
780 if (TREE_CODE (fld
) == FIELD_DECL
)
782 if (TREE_CODE (fld
) == FUNCTION_DECL
)
784 tree ft
= TREE_TYPE (fld
);
786 if (TREE_THIS_VOLATILE (fld
))
788 *msg
= "volatile structure field";
791 if (!DECL_FIELD_OFFSET (fld
))
793 *msg
= "no structure field offset";
796 if (!DECL_SIZE (fld
))
798 *msg
= "zero structure field size";
801 if (!tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
803 *msg
= "structure field offset not fixed";
806 if (!tree_fits_uhwi_p (DECL_SIZE (fld
)))
808 *msg
= "structure field size not fixed";
811 if (!tree_fits_shwi_p (bit_position (fld
)))
813 *msg
= "structure field size too big";
816 if (AGGREGATE_TYPE_P (ft
)
817 && int_bit_position (fld
) % BITS_PER_UNIT
!= 0)
819 *msg
= "structure field is bit field";
823 if (AGGREGATE_TYPE_P (ft
)
824 && type_internals_preclude_sra_p_1 (ft
, msg
, visited_types
))
831 et
= TREE_TYPE (type
);
833 if (TYPE_VOLATILE (et
))
835 *msg
= "element type is volatile";
839 if (AGGREGATE_TYPE_P (et
)
840 && type_internals_preclude_sra_p_1 (et
, msg
, visited_types
))
850 /* Return true iff the type contains a field or an element which does not allow
854 type_internals_preclude_sra_p (tree type
, const char **msg
)
856 hash_set
<tree
> visited_types
;
857 return type_internals_preclude_sra_p_1 (type
, msg
, &visited_types
);
861 /* Allocate an access structure for BASE, OFFSET and SIZE, clear it, fill in
862 the three fields. Also add it to the vector of accesses corresponding to
863 the base. Finally, return the new access. */
865 static struct access
*
866 create_access_1 (tree base
, HOST_WIDE_INT offset
, HOST_WIDE_INT size
)
868 struct access
*access
= access_pool
.allocate ();
870 memset (access
, 0, sizeof (struct access
));
872 access
->offset
= offset
;
875 base_access_vec
->get_or_insert (base
).safe_push (access
);
880 static bool maybe_add_sra_candidate (tree
);
882 /* Create and insert access for EXPR. Return created access, or NULL if it is
883 not possible. Also scan for uses of constant pool as we go along and add
886 static struct access
*
887 create_access (tree expr
, gimple
*stmt
, bool write
)
889 struct access
*access
;
890 poly_int64 poffset
, psize
, pmax_size
;
892 bool reverse
, unscalarizable_region
= false;
894 base
= get_ref_base_and_extent (expr
, &poffset
, &psize
, &pmax_size
,
897 /* For constant-pool entries, check we can substitute the constant value. */
898 if (constant_decl_p (base
))
900 gcc_assert (!bitmap_bit_p (disqualified_constants
, DECL_UID (base
)));
902 && !is_gimple_reg_type (TREE_TYPE (expr
))
903 && dump_file
&& (dump_flags
& TDF_DETAILS
))
905 /* This occurs in Ada with accesses to ARRAY_RANGE_REFs,
906 and elements of multidimensional arrays (which are
907 multi-element arrays in their own right). */
908 fprintf (dump_file
, "Allowing non-reg-type load of part"
909 " of constant-pool entry: ");
910 print_generic_expr (dump_file
, expr
);
912 maybe_add_sra_candidate (base
);
915 if (!DECL_P (base
) || !bitmap_bit_p (candidate_bitmap
, DECL_UID (base
)))
918 HOST_WIDE_INT offset
, size
, max_size
;
919 if (!poffset
.is_constant (&offset
)
920 || !psize
.is_constant (&size
)
921 || !pmax_size
.is_constant (&max_size
))
923 disqualify_candidate (base
, "Encountered a polynomial-sized access.");
927 if (size
!= max_size
)
930 unscalarizable_region
= true;
936 disqualify_candidate (base
, "Encountered an unconstrained access.");
940 access
= create_access_1 (base
, offset
, size
);
942 access
->type
= TREE_TYPE (expr
);
943 access
->write
= write
;
944 access
->grp_unscalarizable_region
= unscalarizable_region
;
946 access
->reverse
= reverse
;
952 /* Return true iff TYPE is scalarizable - i.e. a RECORD_TYPE or fixed-length
953 ARRAY_TYPE with fields that are either of gimple register types (excluding
954 bit-fields) or (recursively) scalarizable types. CONST_DECL must be true if
955 we are considering a decl from constant pool. If it is false, char arrays
959 scalarizable_type_p (tree type
, bool const_decl
)
961 if (is_gimple_reg_type (type
))
963 if (type_contains_placeholder_p (type
))
966 bool have_predecessor_field
= false;
967 HOST_WIDE_INT prev_pos
= 0;
969 switch (TREE_CODE (type
))
972 for (tree fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
973 if (TREE_CODE (fld
) == FIELD_DECL
)
975 tree ft
= TREE_TYPE (fld
);
977 if (zerop (DECL_SIZE (fld
)))
980 HOST_WIDE_INT pos
= int_bit_position (fld
);
981 if (have_predecessor_field
985 have_predecessor_field
= true;
988 if (DECL_BIT_FIELD (fld
))
991 if (!scalarizable_type_p (ft
, const_decl
))
999 HOST_WIDE_INT min_elem_size
;
1003 min_elem_size
= BITS_PER_UNIT
;
1005 if (TYPE_DOMAIN (type
) == NULL_TREE
1006 || !tree_fits_shwi_p (TYPE_SIZE (type
))
1007 || !tree_fits_shwi_p (TYPE_SIZE (TREE_TYPE (type
)))
1008 || (tree_to_shwi (TYPE_SIZE (TREE_TYPE (type
))) <= min_elem_size
)
1009 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
1011 if (tree_to_shwi (TYPE_SIZE (type
)) == 0
1012 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
)
1013 /* Zero-element array, should not prevent scalarization. */
1015 else if ((tree_to_shwi (TYPE_SIZE (type
)) <= 0)
1016 || !tree_fits_shwi_p (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
1017 /* Variable-length array, do not allow scalarization. */
1020 tree elem
= TREE_TYPE (type
);
1021 if (!scalarizable_type_p (elem
, const_decl
))
1030 /* Return true if REF has an VIEW_CONVERT_EXPR somewhere in it. */
1033 contains_view_convert_expr_p (const_tree ref
)
1035 while (handled_component_p (ref
))
1037 if (TREE_CODE (ref
) == VIEW_CONVERT_EXPR
)
1039 ref
= TREE_OPERAND (ref
, 0);
1045 /* Return true if REF contains a VIEW_CONVERT_EXPR or a COMPONENT_REF with a
1046 bit-field field declaration. If TYPE_CHANGING_P is non-NULL, set the bool
1047 it points to will be set if REF contains any of the above or a MEM_REF
1048 expression that effectively performs type conversion. */
1051 contains_vce_or_bfcref_p (const_tree ref
, bool *type_changing_p
= NULL
)
1053 while (handled_component_p (ref
))
1055 if (TREE_CODE (ref
) == VIEW_CONVERT_EXPR
1056 || (TREE_CODE (ref
) == COMPONENT_REF
1057 && DECL_BIT_FIELD (TREE_OPERAND (ref
, 1))))
1059 if (type_changing_p
)
1060 *type_changing_p
= true;
1063 ref
= TREE_OPERAND (ref
, 0);
1066 if (!type_changing_p
1067 || TREE_CODE (ref
) != MEM_REF
1068 || TREE_CODE (TREE_OPERAND (ref
, 0)) != ADDR_EXPR
)
1071 tree mem
= TREE_OPERAND (TREE_OPERAND (ref
, 0), 0);
1072 if (TYPE_MAIN_VARIANT (TREE_TYPE (ref
))
1073 != TYPE_MAIN_VARIANT (TREE_TYPE (mem
)))
1074 *type_changing_p
= true;
1079 /* Search the given tree for a declaration by skipping handled components and
1080 exclude it from the candidates. */
1083 disqualify_base_of_expr (tree t
, const char *reason
)
1085 t
= get_base_address (t
);
1086 if (t
&& DECL_P (t
))
1087 disqualify_candidate (t
, reason
);
1090 /* Scan expression EXPR and create access structures for all accesses to
1091 candidates for scalarization. Return the created access or NULL if none is
1094 static struct access
*
1095 build_access_from_expr_1 (tree expr
, gimple
*stmt
, bool write
)
1097 struct access
*ret
= NULL
;
1100 if (TREE_CODE (expr
) == BIT_FIELD_REF
1101 || TREE_CODE (expr
) == IMAGPART_EXPR
1102 || TREE_CODE (expr
) == REALPART_EXPR
)
1104 expr
= TREE_OPERAND (expr
, 0);
1108 partial_ref
= false;
1110 if (storage_order_barrier_p (expr
))
1112 disqualify_base_of_expr (expr
, "storage order barrier.");
1116 /* We need to dive through V_C_Es in order to get the size of its parameter
1117 and not the result type. Ada produces such statements. We are also
1118 capable of handling the topmost V_C_E but not any of those buried in other
1119 handled components. */
1120 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
1121 expr
= TREE_OPERAND (expr
, 0);
1123 if (contains_view_convert_expr_p (expr
))
1125 disqualify_base_of_expr (expr
, "V_C_E under a different handled "
1129 if (TREE_THIS_VOLATILE (expr
))
1131 disqualify_base_of_expr (expr
, "part of a volatile reference.");
1135 switch (TREE_CODE (expr
))
1138 if (TREE_CODE (TREE_OPERAND (expr
, 0)) != ADDR_EXPR
)
1146 case ARRAY_RANGE_REF
:
1147 ret
= create_access (expr
, stmt
, write
);
1154 if (write
&& partial_ref
&& ret
)
1155 ret
->grp_partial_lhs
= 1;
1160 /* Scan expression EXPR and create access structures for all accesses to
1161 candidates for scalarization. Return true if any access has been inserted.
1162 STMT must be the statement from which the expression is taken, WRITE must be
1163 true if the expression is a store and false otherwise. */
1166 build_access_from_expr (tree expr
, gimple
*stmt
, bool write
)
1168 struct access
*access
;
1170 access
= build_access_from_expr_1 (expr
, stmt
, write
);
1173 /* This means the aggregate is accesses as a whole in a way other than an
1174 assign statement and thus cannot be removed even if we had a scalar
1175 replacement for everything. */
1176 if (cannot_scalarize_away_bitmap
)
1177 bitmap_set_bit (cannot_scalarize_away_bitmap
, DECL_UID (access
->base
));
1183 /* Return the single non-EH successor edge of BB or NULL if there is none or
1187 single_non_eh_succ (basic_block bb
)
1192 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1193 if (!(e
->flags
& EDGE_EH
))
1203 /* Disqualify LHS and RHS for scalarization if STMT has to terminate its BB and
1204 there is no alternative spot where to put statements SRA might need to
1205 generate after it. The spot we are looking for is an edge leading to a
1206 single non-EH successor, if it exists and is indeed single. RHS may be
1207 NULL, in that case ignore it. */
1210 disqualify_if_bad_bb_terminating_stmt (gimple
*stmt
, tree lhs
, tree rhs
)
1212 if (stmt_ends_bb_p (stmt
))
1214 if (single_non_eh_succ (gimple_bb (stmt
)))
1217 disqualify_base_of_expr (lhs
, "LHS of a throwing stmt.");
1219 disqualify_base_of_expr (rhs
, "RHS of a throwing stmt.");
1225 /* Return true if the nature of BASE is such that it contains data even if
1226 there is no write to it in the function. */
1229 comes_initialized_p (tree base
)
1231 return TREE_CODE (base
) == PARM_DECL
|| constant_decl_p (base
);
1234 /* Scan expressions occurring in STMT, create access structures for all accesses
1235 to candidates for scalarization and remove those candidates which occur in
1236 statements or expressions that prevent them from being split apart. Return
1237 true if any access has been inserted. */
1240 build_accesses_from_assign (gimple
*stmt
)
1243 struct access
*lacc
, *racc
;
1245 if (!gimple_assign_single_p (stmt
)
1246 /* Scope clobbers don't influence scalarization. */
1247 || gimple_clobber_p (stmt
))
1250 lhs
= gimple_assign_lhs (stmt
);
1251 rhs
= gimple_assign_rhs1 (stmt
);
1253 if (disqualify_if_bad_bb_terminating_stmt (stmt
, lhs
, rhs
))
1256 racc
= build_access_from_expr_1 (rhs
, stmt
, false);
1257 lacc
= build_access_from_expr_1 (lhs
, stmt
, true);
1261 lacc
->grp_assignment_write
= 1;
1262 if (storage_order_barrier_p (rhs
))
1263 lacc
->grp_unscalarizable_region
= 1;
1265 if (should_scalarize_away_bitmap
&& !is_gimple_reg_type (lacc
->type
))
1267 bool type_changing_p
= false;
1268 contains_vce_or_bfcref_p (lhs
, &type_changing_p
);
1269 if (type_changing_p
)
1270 bitmap_set_bit (cannot_scalarize_away_bitmap
,
1271 DECL_UID (lacc
->base
));
1277 racc
->grp_assignment_read
= 1;
1278 if (should_scalarize_away_bitmap
&& !is_gimple_reg_type (racc
->type
))
1280 bool type_changing_p
= false;
1281 contains_vce_or_bfcref_p (rhs
, &type_changing_p
);
1283 if (type_changing_p
|| gimple_has_volatile_ops (stmt
))
1284 bitmap_set_bit (cannot_scalarize_away_bitmap
,
1285 DECL_UID (racc
->base
));
1287 bitmap_set_bit (should_scalarize_away_bitmap
,
1288 DECL_UID (racc
->base
));
1290 if (storage_order_barrier_p (lhs
))
1291 racc
->grp_unscalarizable_region
= 1;
1295 && (sra_mode
== SRA_MODE_EARLY_INTRA
|| sra_mode
== SRA_MODE_INTRA
)
1296 && !lacc
->grp_unscalarizable_region
1297 && !racc
->grp_unscalarizable_region
1298 && AGGREGATE_TYPE_P (TREE_TYPE (lhs
))
1299 && lacc
->size
== racc
->size
1300 && useless_type_conversion_p (lacc
->type
, racc
->type
))
1302 struct assign_link
*link
;
1304 link
= assign_link_pool
.allocate ();
1305 memset (link
, 0, sizeof (struct assign_link
));
1309 add_link_to_rhs (racc
, link
);
1310 add_link_to_lhs (lacc
, link
);
1311 add_access_to_rhs_work_queue (racc
);
1312 add_access_to_lhs_work_queue (lacc
);
1314 /* Let's delay marking the areas as written until propagation of accesses
1315 across link, unless the nature of rhs tells us that its data comes
1317 if (!comes_initialized_p (racc
->base
))
1318 lacc
->write
= false;
1321 return lacc
|| racc
;
1324 /* Callback of walk_stmt_load_store_addr_ops visit_addr used to determine
1325 GIMPLE_ASM operands with memory constrains which cannot be scalarized. */
1328 asm_visit_addr (gimple
*, tree op
, tree
, void *)
1330 op
= get_base_address (op
);
1333 disqualify_candidate (op
, "Non-scalarizable GIMPLE_ASM operand.");
1338 /* Scan function and look for interesting expressions and create access
1339 structures for them. Return true iff any access is created. */
1342 scan_function (void)
1347 FOR_EACH_BB_FN (bb
, cfun
)
1349 gimple_stmt_iterator gsi
;
1350 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1352 gimple
*stmt
= gsi_stmt (gsi
);
1356 switch (gimple_code (stmt
))
1359 t
= gimple_return_retval (as_a
<greturn
*> (stmt
));
1361 ret
|= build_access_from_expr (t
, stmt
, false);
1365 ret
|= build_accesses_from_assign (stmt
);
1369 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
1370 ret
|= build_access_from_expr (gimple_call_arg (stmt
, i
),
1373 t
= gimple_call_lhs (stmt
);
1374 if (t
&& !disqualify_if_bad_bb_terminating_stmt (stmt
, t
, NULL
))
1375 ret
|= build_access_from_expr (t
, stmt
, true);
1380 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1381 walk_stmt_load_store_addr_ops (asm_stmt
, NULL
, NULL
, NULL
,
1383 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); i
++)
1385 t
= TREE_VALUE (gimple_asm_input_op (asm_stmt
, i
));
1386 ret
|= build_access_from_expr (t
, asm_stmt
, false);
1388 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); i
++)
1390 t
= TREE_VALUE (gimple_asm_output_op (asm_stmt
, i
));
1391 ret
|= build_access_from_expr (t
, asm_stmt
, true);
1405 /* Helper of QSORT function. There are pointers to accesses in the array. An
1406 access is considered smaller than another if it has smaller offset or if the
1407 offsets are the same but is size is bigger. */
1410 compare_access_positions (const void *a
, const void *b
)
1412 const access_p
*fp1
= (const access_p
*) a
;
1413 const access_p
*fp2
= (const access_p
*) b
;
1414 const access_p f1
= *fp1
;
1415 const access_p f2
= *fp2
;
1417 if (f1
->offset
!= f2
->offset
)
1418 return f1
->offset
< f2
->offset
? -1 : 1;
1420 if (f1
->size
== f2
->size
)
1422 if (f1
->type
== f2
->type
)
1424 /* Put any non-aggregate type before any aggregate type. */
1425 else if (!is_gimple_reg_type (f1
->type
)
1426 && is_gimple_reg_type (f2
->type
))
1428 else if (is_gimple_reg_type (f1
->type
)
1429 && !is_gimple_reg_type (f2
->type
))
1431 /* Put any complex or vector type before any other scalar type. */
1432 else if (TREE_CODE (f1
->type
) != COMPLEX_TYPE
1433 && TREE_CODE (f1
->type
) != VECTOR_TYPE
1434 && (TREE_CODE (f2
->type
) == COMPLEX_TYPE
1435 || TREE_CODE (f2
->type
) == VECTOR_TYPE
))
1437 else if ((TREE_CODE (f1
->type
) == COMPLEX_TYPE
1438 || TREE_CODE (f1
->type
) == VECTOR_TYPE
)
1439 && TREE_CODE (f2
->type
) != COMPLEX_TYPE
1440 && TREE_CODE (f2
->type
) != VECTOR_TYPE
)
1442 /* Put any integral type before any non-integral type. When splicing, we
1443 make sure that those with insufficient precision and occupying the
1444 same space are not scalarized. */
1445 else if (INTEGRAL_TYPE_P (f1
->type
)
1446 && !INTEGRAL_TYPE_P (f2
->type
))
1448 else if (!INTEGRAL_TYPE_P (f1
->type
)
1449 && INTEGRAL_TYPE_P (f2
->type
))
1451 /* Put the integral type with the bigger precision first. */
1452 else if (INTEGRAL_TYPE_P (f1
->type
)
1453 && INTEGRAL_TYPE_P (f2
->type
)
1454 && (TYPE_PRECISION (f2
->type
) != TYPE_PRECISION (f1
->type
)))
1455 return TYPE_PRECISION (f2
->type
) - TYPE_PRECISION (f1
->type
);
1456 /* Stabilize the sort. */
1457 return TYPE_UID (f1
->type
) - TYPE_UID (f2
->type
);
1460 /* We want the bigger accesses first, thus the opposite operator in the next
1462 return f1
->size
> f2
->size
? -1 : 1;
1466 /* Append a name of the declaration to the name obstack. A helper function for
1470 make_fancy_decl_name (tree decl
)
1474 tree name
= DECL_NAME (decl
);
1476 obstack_grow (&name_obstack
, IDENTIFIER_POINTER (name
),
1477 IDENTIFIER_LENGTH (name
));
1480 sprintf (buffer
, "D%u", DECL_UID (decl
));
1481 obstack_grow (&name_obstack
, buffer
, strlen (buffer
));
1485 /* Helper for make_fancy_name. */
1488 make_fancy_name_1 (tree expr
)
1495 make_fancy_decl_name (expr
);
1499 switch (TREE_CODE (expr
))
1502 make_fancy_name_1 (TREE_OPERAND (expr
, 0));
1503 obstack_1grow (&name_obstack
, '$');
1504 make_fancy_decl_name (TREE_OPERAND (expr
, 1));
1508 make_fancy_name_1 (TREE_OPERAND (expr
, 0));
1509 obstack_1grow (&name_obstack
, '$');
1510 /* Arrays with only one element may not have a constant as their
1512 index
= TREE_OPERAND (expr
, 1);
1513 if (TREE_CODE (index
) != INTEGER_CST
)
1515 sprintf (buffer
, HOST_WIDE_INT_PRINT_DEC
, TREE_INT_CST_LOW (index
));
1516 obstack_grow (&name_obstack
, buffer
, strlen (buffer
));
1520 make_fancy_name_1 (TREE_OPERAND (expr
, 0));
1524 make_fancy_name_1 (TREE_OPERAND (expr
, 0));
1525 if (!integer_zerop (TREE_OPERAND (expr
, 1)))
1527 obstack_1grow (&name_obstack
, '$');
1528 sprintf (buffer
, HOST_WIDE_INT_PRINT_DEC
,
1529 TREE_INT_CST_LOW (TREE_OPERAND (expr
, 1)));
1530 obstack_grow (&name_obstack
, buffer
, strlen (buffer
));
1537 gcc_unreachable (); /* we treat these as scalars. */
1544 /* Create a human readable name for replacement variable of ACCESS. */
1547 make_fancy_name (tree expr
)
1549 make_fancy_name_1 (expr
);
1550 obstack_1grow (&name_obstack
, '\0');
1551 return XOBFINISH (&name_obstack
, char *);
1554 /* Construct a MEM_REF that would reference a part of aggregate BASE of type
1555 EXP_TYPE at the given OFFSET and with storage order REVERSE. If BASE is
1556 something for which get_addr_base_and_unit_offset returns NULL, gsi must
1557 be non-NULL and is used to insert new statements either before or below
1558 the current one as specified by INSERT_AFTER. This function is not capable
1559 of handling bitfields. */
1562 build_ref_for_offset (location_t loc
, tree base
, poly_int64 offset
,
1563 bool reverse
, tree exp_type
, gimple_stmt_iterator
*gsi
,
1566 tree prev_base
= base
;
1569 poly_int64 base_offset
;
1570 unsigned HOST_WIDE_INT misalign
;
1573 /* Preserve address-space information. */
1574 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (base
));
1575 if (as
!= TYPE_ADDR_SPACE (exp_type
))
1576 exp_type
= build_qualified_type (exp_type
,
1577 TYPE_QUALS (exp_type
)
1578 | ENCODE_QUAL_ADDR_SPACE (as
));
1580 poly_int64 byte_offset
= exact_div (offset
, BITS_PER_UNIT
);
1581 get_object_alignment_1 (base
, &align
, &misalign
);
1582 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
1584 /* get_addr_base_and_unit_offset returns NULL for references with a variable
1585 offset such as array[var_index]. */
1591 gcc_checking_assert (gsi
);
1592 tmp
= make_ssa_name (build_pointer_type (TREE_TYPE (prev_base
)));
1593 addr
= build_fold_addr_expr (unshare_expr (prev_base
));
1594 STRIP_USELESS_TYPE_CONVERSION (addr
);
1595 stmt
= gimple_build_assign (tmp
, addr
);
1596 gimple_set_location (stmt
, loc
);
1598 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
1600 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
1602 off
= build_int_cst (reference_alias_ptr_type (prev_base
), byte_offset
);
1605 else if (TREE_CODE (base
) == MEM_REF
)
1607 off
= build_int_cst (TREE_TYPE (TREE_OPERAND (base
, 1)),
1608 base_offset
+ byte_offset
);
1609 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1), off
);
1610 base
= unshare_expr (TREE_OPERAND (base
, 0));
1614 off
= build_int_cst (reference_alias_ptr_type (prev_base
),
1615 base_offset
+ byte_offset
);
1616 base
= build_fold_addr_expr (unshare_expr (base
));
1619 unsigned int align_bound
= known_alignment (misalign
+ offset
);
1620 if (align_bound
!= 0)
1621 align
= MIN (align
, align_bound
);
1622 if (align
!= TYPE_ALIGN (exp_type
))
1623 exp_type
= build_aligned_type (exp_type
, align
);
1625 mem_ref
= fold_build2_loc (loc
, MEM_REF
, exp_type
, base
, off
);
1626 REF_REVERSE_STORAGE_ORDER (mem_ref
) = reverse
;
1627 if (TREE_THIS_VOLATILE (prev_base
))
1628 TREE_THIS_VOLATILE (mem_ref
) = 1;
1629 if (TREE_SIDE_EFFECTS (prev_base
))
1630 TREE_SIDE_EFFECTS (mem_ref
) = 1;
1634 /* Construct and return a memory reference that is equal to a portion of
1635 MODEL->expr but is based on BASE. If this cannot be done, return NULL. */
1638 build_reconstructed_reference (location_t
, tree base
, struct access
*model
)
1640 tree expr
= model
->expr
, prev_expr
= NULL
;
1641 while (!types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (base
)))
1643 if (!handled_component_p (expr
))
1646 expr
= TREE_OPERAND (expr
, 0);
1649 /* Guard against broken VIEW_CONVERT_EXPRs... */
1653 TREE_OPERAND (prev_expr
, 0) = base
;
1654 tree ref
= unshare_expr (model
->expr
);
1655 TREE_OPERAND (prev_expr
, 0) = expr
;
1659 /* Construct a memory reference to a part of an aggregate BASE at the given
1660 OFFSET and of the same type as MODEL. In case this is a reference to a
1661 bit-field, the function will replicate the last component_ref of model's
1662 expr to access it. GSI and INSERT_AFTER have the same meaning as in
1663 build_ref_for_offset. */
1666 build_ref_for_model (location_t loc
, tree base
, HOST_WIDE_INT offset
,
1667 struct access
*model
, gimple_stmt_iterator
*gsi
,
1670 if (TREE_CODE (model
->expr
) == COMPONENT_REF
1671 && DECL_BIT_FIELD (TREE_OPERAND (model
->expr
, 1)))
1673 /* This access represents a bit-field. */
1674 tree t
, exp_type
, fld
= TREE_OPERAND (model
->expr
, 1);
1676 offset
-= int_bit_position (fld
);
1677 exp_type
= TREE_TYPE (TREE_OPERAND (model
->expr
, 0));
1678 t
= build_ref_for_offset (loc
, base
, offset
, model
->reverse
, exp_type
,
1680 /* The flag will be set on the record type. */
1681 REF_REVERSE_STORAGE_ORDER (t
) = 0;
1682 return fold_build3_loc (loc
, COMPONENT_REF
, TREE_TYPE (fld
), t
, fld
,
1688 if (model
->grp_same_access_path
1689 && !TREE_THIS_VOLATILE (base
)
1690 && (TYPE_ADDR_SPACE (TREE_TYPE (base
))
1691 == TYPE_ADDR_SPACE (TREE_TYPE (model
->expr
)))
1692 && offset
<= model
->offset
1693 /* build_reconstructed_reference can still fail if we have already
1694 massaged BASE because of another type incompatibility. */
1695 && (res
= build_reconstructed_reference (loc
, base
, model
)))
1698 return build_ref_for_offset (loc
, base
, offset
, model
->reverse
,
1699 model
->type
, gsi
, insert_after
);
1703 /* Attempt to build a memory reference that we could but into a gimple
1704 debug_bind statement. Similar to build_ref_for_model but punts if it has to
1705 create statements and return s NULL instead. This function also ignores
1706 alignment issues and so its results should never end up in non-debug
1710 build_debug_ref_for_model (location_t loc
, tree base
, HOST_WIDE_INT offset
,
1711 struct access
*model
)
1713 poly_int64 base_offset
;
1716 if (TREE_CODE (model
->expr
) == COMPONENT_REF
1717 && DECL_BIT_FIELD (TREE_OPERAND (model
->expr
, 1)))
1720 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
1723 if (TREE_CODE (base
) == MEM_REF
)
1725 off
= build_int_cst (TREE_TYPE (TREE_OPERAND (base
, 1)),
1726 base_offset
+ offset
/ BITS_PER_UNIT
);
1727 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1), off
);
1728 base
= unshare_expr (TREE_OPERAND (base
, 0));
1732 off
= build_int_cst (reference_alias_ptr_type (base
),
1733 base_offset
+ offset
/ BITS_PER_UNIT
);
1734 base
= build_fold_addr_expr (unshare_expr (base
));
1737 return fold_build2_loc (loc
, MEM_REF
, model
->type
, base
, off
);
1740 /* Construct a memory reference consisting of component_refs and array_refs to
1741 a part of an aggregate *RES (which is of type TYPE). The requested part
1742 should have type EXP_TYPE at be the given OFFSET. This function might not
1743 succeed, it returns true when it does and only then *RES points to something
1744 meaningful. This function should be used only to build expressions that we
1745 might need to present to user (e.g. in warnings). In all other situations,
1746 build_ref_for_model or build_ref_for_offset should be used instead. */
1749 build_user_friendly_ref_for_offset (tree
*res
, tree type
, HOST_WIDE_INT offset
,
1755 tree tr_size
, index
, minidx
;
1756 HOST_WIDE_INT el_size
;
1758 if (offset
== 0 && exp_type
1759 && types_compatible_p (exp_type
, type
))
1762 switch (TREE_CODE (type
))
1765 case QUAL_UNION_TYPE
:
1767 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
1769 HOST_WIDE_INT pos
, size
;
1770 tree tr_pos
, expr
, *expr_ptr
;
1772 if (TREE_CODE (fld
) != FIELD_DECL
)
1775 tr_pos
= bit_position (fld
);
1776 if (!tr_pos
|| !tree_fits_uhwi_p (tr_pos
))
1778 pos
= tree_to_uhwi (tr_pos
);
1779 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
|| pos
== 0);
1780 tr_size
= DECL_SIZE (fld
);
1781 if (!tr_size
|| !tree_fits_uhwi_p (tr_size
))
1783 size
= tree_to_uhwi (tr_size
);
1789 else if (pos
> offset
|| (pos
+ size
) <= offset
)
1792 expr
= build3 (COMPONENT_REF
, TREE_TYPE (fld
), *res
, fld
,
1795 if (build_user_friendly_ref_for_offset (expr_ptr
, TREE_TYPE (fld
),
1796 offset
- pos
, exp_type
))
1805 tr_size
= TYPE_SIZE (TREE_TYPE (type
));
1806 if (!tr_size
|| !tree_fits_uhwi_p (tr_size
))
1808 el_size
= tree_to_uhwi (tr_size
);
1810 minidx
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
1811 if (TREE_CODE (minidx
) != INTEGER_CST
|| el_size
== 0)
1813 index
= build_int_cst (TYPE_DOMAIN (type
), offset
/ el_size
);
1814 if (!integer_zerop (minidx
))
1815 index
= int_const_binop (PLUS_EXPR
, index
, minidx
);
1816 *res
= build4 (ARRAY_REF
, TREE_TYPE (type
), *res
, index
,
1817 NULL_TREE
, NULL_TREE
);
1818 offset
= offset
% el_size
;
1819 type
= TREE_TYPE (type
);
1834 /* Print message to dump file why a variable was rejected. */
1837 reject (tree var
, const char *msg
)
1839 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1841 fprintf (dump_file
, "Rejected (%d): %s: ", DECL_UID (var
), msg
);
1842 print_generic_expr (dump_file
, var
);
1843 fprintf (dump_file
, "\n");
1847 /* Return true if VAR is a candidate for SRA. */
1850 maybe_add_sra_candidate (tree var
)
1852 tree type
= TREE_TYPE (var
);
1856 if (!AGGREGATE_TYPE_P (type
))
1858 reject (var
, "not aggregate");
1861 /* Allow constant-pool entries that "need to live in memory". */
1862 if (needs_to_live_in_memory (var
) && !constant_decl_p (var
))
1864 reject (var
, "needs to live in memory");
1867 if (TREE_THIS_VOLATILE (var
))
1869 reject (var
, "is volatile");
1872 if (!COMPLETE_TYPE_P (type
))
1874 reject (var
, "has incomplete type");
1877 if (!tree_fits_uhwi_p (TYPE_SIZE (type
)))
1879 reject (var
, "type size not fixed");
1882 if (tree_to_uhwi (TYPE_SIZE (type
)) == 0)
1884 reject (var
, "type size is zero");
1887 if (type_internals_preclude_sra_p (type
, &msg
))
1892 if (/* Fix for PR 41089. tree-stdarg.c needs to have va_lists intact but
1893 we also want to schedule it rather late. Thus we ignore it in
1895 (sra_mode
== SRA_MODE_EARLY_INTRA
1896 && is_va_list_type (type
)))
1898 reject (var
, "is va_list");
1902 bitmap_set_bit (candidate_bitmap
, DECL_UID (var
));
1903 slot
= candidates
->find_slot_with_hash (var
, DECL_UID (var
), INSERT
);
1906 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1908 fprintf (dump_file
, "Candidate (%d): ", DECL_UID (var
));
1909 print_generic_expr (dump_file
, var
);
1910 fprintf (dump_file
, "\n");
1916 /* The very first phase of intraprocedural SRA. It marks in candidate_bitmap
1917 those with type which is suitable for scalarization. */
1920 find_var_candidates (void)
1926 for (parm
= DECL_ARGUMENTS (current_function_decl
);
1928 parm
= DECL_CHAIN (parm
))
1929 ret
|= maybe_add_sra_candidate (parm
);
1931 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1936 ret
|= maybe_add_sra_candidate (var
);
1942 /* Return true if EXP is a reference chain of COMPONENT_REFs and AREAY_REFs
1943 ending either with a DECL or a MEM_REF with zero offset. */
1946 path_comparable_for_same_access (tree expr
)
1948 while (handled_component_p (expr
))
1950 if (TREE_CODE (expr
) == ARRAY_REF
)
1952 /* SSA name indices can occur here too when the array is of sie one.
1953 But we cannot just re-use array_refs with SSA names elsewhere in
1954 the function, so disallow non-constant indices. TODO: Remove this
1955 limitation after teaching build_reconstructed_reference to replace
1956 the index with the index type lower bound. */
1957 if (TREE_CODE (TREE_OPERAND (expr
, 1)) != INTEGER_CST
)
1960 expr
= TREE_OPERAND (expr
, 0);
1963 if (TREE_CODE (expr
) == MEM_REF
)
1965 if (!zerop (TREE_OPERAND (expr
, 1)))
1969 gcc_assert (DECL_P (expr
));
1974 /* Assuming that EXP1 consists of only COMPONENT_REFs and ARRAY_REFs, return
1975 true if the chain of these handled components are exactly the same as EXP2
1976 and the expression under them is the same DECL or an equivalent MEM_REF.
1977 The reference picked by compare_access_positions must go to EXP1. */
1980 same_access_path_p (tree exp1
, tree exp2
)
1982 if (TREE_CODE (exp1
) != TREE_CODE (exp2
))
1984 /* Special case single-field structures loaded sometimes as the field
1985 and sometimes as the structure. If the field is of a scalar type,
1986 compare_access_positions will put it into exp1.
1988 TODO: The gimple register type condition can be removed if teach
1989 compare_access_positions to put inner types first. */
1990 if (is_gimple_reg_type (TREE_TYPE (exp1
))
1991 && TREE_CODE (exp1
) == COMPONENT_REF
1992 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (exp1
, 0)))
1993 == TYPE_MAIN_VARIANT (TREE_TYPE (exp2
))))
1994 exp1
= TREE_OPERAND (exp1
, 0);
1999 if (!operand_equal_p (exp1
, exp2
, OEP_ADDRESS_OF
))
2005 /* Sort all accesses for the given variable, check for partial overlaps and
2006 return NULL if there are any. If there are none, pick a representative for
2007 each combination of offset and size and create a linked list out of them.
2008 Return the pointer to the first representative and make sure it is the first
2009 one in the vector of accesses. */
2011 static struct access
*
2012 sort_and_splice_var_accesses (tree var
)
2014 int i
, j
, access_count
;
2015 struct access
*res
, **prev_acc_ptr
= &res
;
2016 vec
<access_p
> *access_vec
;
2018 HOST_WIDE_INT low
= -1, high
= 0;
2020 access_vec
= get_base_access_vector (var
);
2023 access_count
= access_vec
->length ();
2025 /* Sort by <OFFSET, SIZE>. */
2026 access_vec
->qsort (compare_access_positions
);
2029 while (i
< access_count
)
2031 struct access
*access
= (*access_vec
)[i
];
2032 bool grp_write
= access
->write
;
2033 bool grp_read
= !access
->write
;
2034 bool grp_scalar_write
= access
->write
2035 && is_gimple_reg_type (access
->type
);
2036 bool grp_scalar_read
= !access
->write
2037 && is_gimple_reg_type (access
->type
);
2038 bool grp_assignment_read
= access
->grp_assignment_read
;
2039 bool grp_assignment_write
= access
->grp_assignment_write
;
2040 bool multiple_scalar_reads
= false;
2041 bool grp_partial_lhs
= access
->grp_partial_lhs
;
2042 bool first_scalar
= is_gimple_reg_type (access
->type
);
2043 bool unscalarizable_region
= access
->grp_unscalarizable_region
;
2044 bool grp_same_access_path
= true;
2045 bool bf_non_full_precision
2046 = (INTEGRAL_TYPE_P (access
->type
)
2047 && TYPE_PRECISION (access
->type
) != access
->size
2048 && TREE_CODE (access
->expr
) == COMPONENT_REF
2049 && DECL_BIT_FIELD (TREE_OPERAND (access
->expr
, 1)));
2051 if (first
|| access
->offset
>= high
)
2054 low
= access
->offset
;
2055 high
= access
->offset
+ access
->size
;
2057 else if (access
->offset
> low
&& access
->offset
+ access
->size
> high
)
2060 gcc_assert (access
->offset
>= low
2061 && access
->offset
+ access
->size
<= high
);
2063 grp_same_access_path
= path_comparable_for_same_access (access
->expr
);
2066 while (j
< access_count
)
2068 struct access
*ac2
= (*access_vec
)[j
];
2069 if (ac2
->offset
!= access
->offset
|| ac2
->size
!= access
->size
)
2074 grp_scalar_write
= (grp_scalar_write
2075 || is_gimple_reg_type (ac2
->type
));
2080 if (is_gimple_reg_type (ac2
->type
))
2082 if (grp_scalar_read
)
2083 multiple_scalar_reads
= true;
2085 grp_scalar_read
= true;
2088 grp_assignment_read
|= ac2
->grp_assignment_read
;
2089 grp_assignment_write
|= ac2
->grp_assignment_write
;
2090 grp_partial_lhs
|= ac2
->grp_partial_lhs
;
2091 unscalarizable_region
|= ac2
->grp_unscalarizable_region
;
2092 relink_to_new_repr (access
, ac2
);
2094 /* If there are both aggregate-type and scalar-type accesses with
2095 this combination of size and offset, the comparison function
2096 should have put the scalars first. */
2097 gcc_assert (first_scalar
|| !is_gimple_reg_type (ac2
->type
));
2098 /* It also prefers integral types to non-integral. However, when the
2099 precision of the selected type does not span the entire area and
2100 should also be used for a non-integer (i.e. float), we must not
2101 let that happen. Normally analyze_access_subtree expands the type
2102 to cover the entire area but for bit-fields it doesn't. */
2103 if (bf_non_full_precision
&& !INTEGRAL_TYPE_P (ac2
->type
))
2105 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2107 fprintf (dump_file
, "Cannot scalarize the following access "
2108 "because insufficient precision integer type was "
2110 dump_access (dump_file
, access
, false);
2112 unscalarizable_region
= true;
2115 if (grp_same_access_path
2116 && !same_access_path_p (access
->expr
, ac2
->expr
))
2117 grp_same_access_path
= false;
2119 ac2
->group_representative
= access
;
2125 access
->group_representative
= access
;
2126 access
->grp_write
= grp_write
;
2127 access
->grp_read
= grp_read
;
2128 access
->grp_scalar_read
= grp_scalar_read
;
2129 access
->grp_scalar_write
= grp_scalar_write
;
2130 access
->grp_assignment_read
= grp_assignment_read
;
2131 access
->grp_assignment_write
= grp_assignment_write
;
2132 access
->grp_hint
= multiple_scalar_reads
&& !constant_decl_p (var
);
2133 access
->grp_partial_lhs
= grp_partial_lhs
;
2134 access
->grp_unscalarizable_region
= unscalarizable_region
;
2135 access
->grp_same_access_path
= grp_same_access_path
;
2137 *prev_acc_ptr
= access
;
2138 prev_acc_ptr
= &access
->next_grp
;
2141 gcc_assert (res
== (*access_vec
)[0]);
2145 /* Create a variable for the given ACCESS which determines the type, name and a
2146 few other properties. Return the variable declaration and store it also to
2147 ACCESS->replacement. REG_TREE is used when creating a declaration to base a
2148 default-definition SSA name on in order to facilitate an uninitialized
2149 warning. It is used instead of the actual ACCESS type if that is not of a
2150 gimple register type. */
2153 create_access_replacement (struct access
*access
, tree reg_type
= NULL_TREE
)
2157 tree type
= access
->type
;
2158 if (reg_type
&& !is_gimple_reg_type (type
))
2161 if (access
->grp_to_be_debug_replaced
)
2163 repl
= create_tmp_var_raw (access
->type
);
2164 DECL_CONTEXT (repl
) = current_function_decl
;
2167 /* Drop any special alignment on the type if it's not on the main
2168 variant. This avoids issues with weirdo ABIs like AAPCS. */
2169 repl
= create_tmp_var (build_qualified_type (TYPE_MAIN_VARIANT (type
),
2170 TYPE_QUALS (type
)), "SR");
2171 if (TREE_CODE (type
) == COMPLEX_TYPE
2172 || TREE_CODE (type
) == VECTOR_TYPE
)
2174 if (!access
->grp_partial_lhs
)
2175 DECL_GIMPLE_REG_P (repl
) = 1;
2177 else if (access
->grp_partial_lhs
2178 && is_gimple_reg_type (type
))
2179 TREE_ADDRESSABLE (repl
) = 1;
2181 DECL_SOURCE_LOCATION (repl
) = DECL_SOURCE_LOCATION (access
->base
);
2182 DECL_ARTIFICIAL (repl
) = 1;
2183 DECL_IGNORED_P (repl
) = DECL_IGNORED_P (access
->base
);
2185 if (DECL_NAME (access
->base
)
2186 && !DECL_IGNORED_P (access
->base
)
2187 && !DECL_ARTIFICIAL (access
->base
))
2189 char *pretty_name
= make_fancy_name (access
->expr
);
2190 tree debug_expr
= unshare_expr_without_location (access
->expr
), d
;
2193 DECL_NAME (repl
) = get_identifier (pretty_name
);
2194 DECL_NAMELESS (repl
) = 1;
2195 obstack_free (&name_obstack
, pretty_name
);
2197 /* Get rid of any SSA_NAMEs embedded in debug_expr,
2198 as DECL_DEBUG_EXPR isn't considered when looking for still
2199 used SSA_NAMEs and thus they could be freed. All debug info
2200 generation cares is whether something is constant or variable
2201 and that get_ref_base_and_extent works properly on the
2202 expression. It cannot handle accesses at a non-constant offset
2203 though, so just give up in those cases. */
2204 for (d
= debug_expr
;
2205 !fail
&& (handled_component_p (d
) || TREE_CODE (d
) == MEM_REF
);
2206 d
= TREE_OPERAND (d
, 0))
2207 switch (TREE_CODE (d
))
2210 case ARRAY_RANGE_REF
:
2211 if (TREE_OPERAND (d
, 1)
2212 && TREE_CODE (TREE_OPERAND (d
, 1)) != INTEGER_CST
)
2214 if (TREE_OPERAND (d
, 3)
2215 && TREE_CODE (TREE_OPERAND (d
, 3)) != INTEGER_CST
)
2219 if (TREE_OPERAND (d
, 2)
2220 && TREE_CODE (TREE_OPERAND (d
, 2)) != INTEGER_CST
)
2224 if (TREE_CODE (TREE_OPERAND (d
, 0)) != ADDR_EXPR
)
2227 d
= TREE_OPERAND (d
, 0);
2234 SET_DECL_DEBUG_EXPR (repl
, debug_expr
);
2235 DECL_HAS_DEBUG_EXPR_P (repl
) = 1;
2237 if (access
->grp_no_warning
)
2238 TREE_NO_WARNING (repl
) = 1;
2240 TREE_NO_WARNING (repl
) = TREE_NO_WARNING (access
->base
);
2243 TREE_NO_WARNING (repl
) = 1;
2247 if (access
->grp_to_be_debug_replaced
)
2249 fprintf (dump_file
, "Created a debug-only replacement for ");
2250 print_generic_expr (dump_file
, access
->base
);
2251 fprintf (dump_file
, " offset: %u, size: %u\n",
2252 (unsigned) access
->offset
, (unsigned) access
->size
);
2256 fprintf (dump_file
, "Created a replacement for ");
2257 print_generic_expr (dump_file
, access
->base
);
2258 fprintf (dump_file
, " offset: %u, size: %u: ",
2259 (unsigned) access
->offset
, (unsigned) access
->size
);
2260 print_generic_expr (dump_file
, repl
);
2261 fprintf (dump_file
, "\n");
2264 sra_stats
.replacements
++;
2269 /* Return ACCESS scalar replacement, which must exist. */
2272 get_access_replacement (struct access
*access
)
2274 gcc_checking_assert (access
->replacement_decl
);
2275 return access
->replacement_decl
;
2279 /* Build a subtree of accesses rooted in *ACCESS, and move the pointer in the
2280 linked list along the way. Stop when *ACCESS is NULL or the access pointed
2281 to it is not "within" the root. Return false iff some accesses partially
2285 build_access_subtree (struct access
**access
)
2287 struct access
*root
= *access
, *last_child
= NULL
;
2288 HOST_WIDE_INT limit
= root
->offset
+ root
->size
;
2290 *access
= (*access
)->next_grp
;
2291 while (*access
&& (*access
)->offset
+ (*access
)->size
<= limit
)
2294 root
->first_child
= *access
;
2296 last_child
->next_sibling
= *access
;
2297 last_child
= *access
;
2298 (*access
)->parent
= root
;
2299 (*access
)->grp_write
|= root
->grp_write
;
2301 if (!build_access_subtree (access
))
2305 if (*access
&& (*access
)->offset
< limit
)
2311 /* Build a tree of access representatives, ACCESS is the pointer to the first
2312 one, others are linked in a list by the next_grp field. Return false iff
2313 some accesses partially overlap. */
2316 build_access_trees (struct access
*access
)
2320 struct access
*root
= access
;
2322 if (!build_access_subtree (&access
))
2324 root
->next_grp
= access
;
2329 /* Traverse the access forest where ROOT is the first root and verify that
2330 various important invariants hold true. */
2333 verify_sra_access_forest (struct access
*root
)
2335 struct access
*access
= root
;
2336 tree first_base
= root
->base
;
2337 gcc_assert (DECL_P (first_base
));
2340 gcc_assert (access
->base
== first_base
);
2342 gcc_assert (access
->offset
>= access
->parent
->offset
2343 && access
->size
<= access
->parent
->size
);
2344 if (access
->next_sibling
)
2345 gcc_assert (access
->next_sibling
->offset
2346 >= access
->offset
+ access
->size
);
2348 poly_int64 poffset
, psize
, pmax_size
;
2350 tree base
= get_ref_base_and_extent (access
->expr
, &poffset
, &psize
,
2351 &pmax_size
, &reverse
);
2352 HOST_WIDE_INT offset
, size
, max_size
;
2353 if (!poffset
.is_constant (&offset
)
2354 || !psize
.is_constant (&size
)
2355 || !pmax_size
.is_constant (&max_size
))
2357 gcc_assert (base
== first_base
);
2358 gcc_assert (offset
== access
->offset
);
2359 gcc_assert (access
->grp_unscalarizable_region
2360 || size
== max_size
);
2361 gcc_assert (!is_gimple_reg_type (access
->type
)
2362 || max_size
== access
->size
);
2363 gcc_assert (reverse
== access
->reverse
);
2365 if (access
->first_child
)
2367 gcc_assert (access
->first_child
->parent
== access
);
2368 access
= access
->first_child
;
2370 else if (access
->next_sibling
)
2372 gcc_assert (access
->next_sibling
->parent
== access
->parent
);
2373 access
= access
->next_sibling
;
2377 while (access
->parent
&& !access
->next_sibling
)
2378 access
= access
->parent
;
2379 if (access
->next_sibling
)
2380 access
= access
->next_sibling
;
2383 gcc_assert (access
== root
);
2384 root
= root
->next_grp
;
2392 /* Verify access forests of all candidates with accesses by calling
2393 verify_access_forest on each on them. */
2396 verify_all_sra_access_forests (void)
2400 EXECUTE_IF_SET_IN_BITMAP (candidate_bitmap
, 0, i
, bi
)
2402 tree var
= candidate (i
);
2403 struct access
*access
= get_first_repr_for_decl (var
);
2406 gcc_assert (access
->base
== var
);
2407 verify_sra_access_forest (access
);
2412 /* Return true if expr contains some ARRAY_REFs into a variable bounded
2416 expr_with_var_bounded_array_refs_p (tree expr
)
2418 while (handled_component_p (expr
))
2420 if (TREE_CODE (expr
) == ARRAY_REF
2421 && !tree_fits_shwi_p (array_ref_low_bound (expr
)))
2423 expr
= TREE_OPERAND (expr
, 0);
2428 /* Analyze the subtree of accesses rooted in ROOT, scheduling replacements when
2429 both seeming beneficial and when ALLOW_REPLACEMENTS allows it. If TOTALLY
2430 is set, we are totally scalarizing the aggregate. Also set all sorts of
2431 access flags appropriately along the way, notably always set grp_read and
2432 grp_assign_read according to MARK_READ and grp_write when MARK_WRITE is
2435 Creating a replacement for a scalar access is considered beneficial if its
2436 grp_hint ot TOTALLY is set (this means either that there is more than one
2437 direct read access or that we are attempting total scalarization) or
2438 according to the following table:
2440 Access written to through a scalar type (once or more times)
2442 | Written to in an assignment statement
2444 | | Access read as scalar _once_
2446 | | | Read in an assignment statement
2448 | | | | Scalarize Comment
2449 -----------------------------------------------------------------------------
2450 0 0 0 0 No access for the scalar
2451 0 0 0 1 No access for the scalar
2452 0 0 1 0 No Single read - won't help
2453 0 0 1 1 No The same case
2454 0 1 0 0 No access for the scalar
2455 0 1 0 1 No access for the scalar
2456 0 1 1 0 Yes s = *g; return s.i;
2457 0 1 1 1 Yes The same case as above
2458 1 0 0 0 No Won't help
2459 1 0 0 1 Yes s.i = 1; *g = s;
2460 1 0 1 0 Yes s.i = 5; g = s.i;
2461 1 0 1 1 Yes The same case as above
2462 1 1 0 0 No Won't help.
2463 1 1 0 1 Yes s.i = 1; *g = s;
2464 1 1 1 0 Yes s = *g; return s.i;
2465 1 1 1 1 Yes Any of the above yeses */
2468 analyze_access_subtree (struct access
*root
, struct access
*parent
,
2469 bool allow_replacements
, bool totally
)
2471 struct access
*child
;
2472 HOST_WIDE_INT limit
= root
->offset
+ root
->size
;
2473 HOST_WIDE_INT covered_to
= root
->offset
;
2474 bool scalar
= is_gimple_reg_type (root
->type
);
2475 bool hole
= false, sth_created
= false;
2479 if (parent
->grp_read
)
2481 if (parent
->grp_assignment_read
)
2482 root
->grp_assignment_read
= 1;
2483 if (parent
->grp_write
)
2484 root
->grp_write
= 1;
2485 if (parent
->grp_assignment_write
)
2486 root
->grp_assignment_write
= 1;
2487 if (!parent
->grp_same_access_path
)
2488 root
->grp_same_access_path
= 0;
2491 if (root
->grp_unscalarizable_region
)
2492 allow_replacements
= false;
2494 if (allow_replacements
&& expr_with_var_bounded_array_refs_p (root
->expr
))
2495 allow_replacements
= false;
2497 for (child
= root
->first_child
; child
; child
= child
->next_sibling
)
2499 hole
|= covered_to
< child
->offset
;
2500 sth_created
|= analyze_access_subtree (child
, root
,
2501 allow_replacements
&& !scalar
,
2504 root
->grp_unscalarized_data
|= child
->grp_unscalarized_data
;
2505 if (child
->grp_covered
)
2506 covered_to
+= child
->size
;
2511 if (allow_replacements
&& scalar
&& !root
->first_child
2512 && (totally
|| !root
->grp_total_scalarization
)
2515 || ((root
->grp_scalar_read
|| root
->grp_assignment_read
)
2516 && (root
->grp_scalar_write
|| root
->grp_assignment_write
))))
2518 /* Always create access replacements that cover the whole access.
2519 For integral types this means the precision has to match.
2520 Avoid assumptions based on the integral type kind, too. */
2521 if (INTEGRAL_TYPE_P (root
->type
)
2522 && (TREE_CODE (root
->type
) != INTEGER_TYPE
2523 || TYPE_PRECISION (root
->type
) != root
->size
)
2524 /* But leave bitfield accesses alone. */
2525 && (TREE_CODE (root
->expr
) != COMPONENT_REF
2526 || !DECL_BIT_FIELD (TREE_OPERAND (root
->expr
, 1))))
2528 tree rt
= root
->type
;
2529 gcc_assert ((root
->offset
% BITS_PER_UNIT
) == 0
2530 && (root
->size
% BITS_PER_UNIT
) == 0);
2531 root
->type
= build_nonstandard_integer_type (root
->size
,
2532 TYPE_UNSIGNED (rt
));
2533 root
->expr
= build_ref_for_offset (UNKNOWN_LOCATION
, root
->base
,
2534 root
->offset
, root
->reverse
,
2535 root
->type
, NULL
, false);
2537 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2539 fprintf (dump_file
, "Changing the type of a replacement for ");
2540 print_generic_expr (dump_file
, root
->base
);
2541 fprintf (dump_file
, " offset: %u, size: %u ",
2542 (unsigned) root
->offset
, (unsigned) root
->size
);
2543 fprintf (dump_file
, " to an integer.\n");
2547 root
->grp_to_be_replaced
= 1;
2548 root
->replacement_decl
= create_access_replacement (root
);
2554 if (allow_replacements
2555 && scalar
&& !root
->first_child
2556 && !root
->grp_total_scalarization
2557 && (root
->grp_scalar_write
|| root
->grp_assignment_write
)
2558 && !bitmap_bit_p (cannot_scalarize_away_bitmap
,
2559 DECL_UID (root
->base
)))
2561 gcc_checking_assert (!root
->grp_scalar_read
2562 && !root
->grp_assignment_read
);
2564 if (MAY_HAVE_DEBUG_BIND_STMTS
)
2566 root
->grp_to_be_debug_replaced
= 1;
2567 root
->replacement_decl
= create_access_replacement (root
);
2571 if (covered_to
< limit
)
2573 if (scalar
|| !allow_replacements
)
2574 root
->grp_total_scalarization
= 0;
2577 if (!hole
|| totally
)
2578 root
->grp_covered
= 1;
2579 else if (root
->grp_write
|| comes_initialized_p (root
->base
))
2580 root
->grp_unscalarized_data
= 1; /* not covered and written to */
2584 /* Analyze all access trees linked by next_grp by the means of
2585 analyze_access_subtree. */
2587 analyze_access_trees (struct access
*access
)
2593 if (analyze_access_subtree (access
, NULL
, true,
2594 access
->grp_total_scalarization
))
2596 access
= access
->next_grp
;
2602 /* Return true iff a potential new child of ACC at offset OFFSET and with size
2603 SIZE would conflict with an already existing one. If exactly such a child
2604 already exists in ACC, store a pointer to it in EXACT_MATCH. */
2607 child_would_conflict_in_acc (struct access
*acc
, HOST_WIDE_INT norm_offset
,
2608 HOST_WIDE_INT size
, struct access
**exact_match
)
2610 struct access
*child
;
2612 for (child
= acc
->first_child
; child
; child
= child
->next_sibling
)
2614 if (child
->offset
== norm_offset
&& child
->size
== size
)
2616 *exact_match
= child
;
2620 if (child
->offset
< norm_offset
+ size
2621 && child
->offset
+ child
->size
> norm_offset
)
2628 /* Create a new child access of PARENT, with all properties just like MODEL
2629 except for its offset and with its grp_write false and grp_read true.
2630 Return the new access or NULL if it cannot be created. Note that this
2631 access is created long after all splicing and sorting, it's not located in
2632 any access vector and is automatically a representative of its group. Set
2633 the gpr_write flag of the new accesss if SET_GRP_WRITE is true. */
2635 static struct access
*
2636 create_artificial_child_access (struct access
*parent
, struct access
*model
,
2637 HOST_WIDE_INT new_offset
,
2638 bool set_grp_read
, bool set_grp_write
)
2640 struct access
**child
;
2641 tree expr
= parent
->base
;
2643 gcc_assert (!model
->grp_unscalarizable_region
);
2645 struct access
*access
= access_pool
.allocate ();
2646 memset (access
, 0, sizeof (struct access
));
2647 if (!build_user_friendly_ref_for_offset (&expr
, TREE_TYPE (expr
), new_offset
,
2650 access
->grp_no_warning
= true;
2651 expr
= build_ref_for_model (EXPR_LOCATION (parent
->base
), parent
->base
,
2652 new_offset
, model
, NULL
, false);
2655 access
->base
= parent
->base
;
2656 access
->expr
= expr
;
2657 access
->offset
= new_offset
;
2658 access
->size
= model
->size
;
2659 access
->type
= model
->type
;
2660 access
->parent
= parent
;
2661 access
->grp_read
= set_grp_read
;
2662 access
->grp_write
= set_grp_write
;
2663 access
->reverse
= model
->reverse
;
2665 child
= &parent
->first_child
;
2666 while (*child
&& (*child
)->offset
< new_offset
)
2667 child
= &(*child
)->next_sibling
;
2669 access
->next_sibling
= *child
;
2676 /* Beginning with ACCESS, traverse its whole access subtree and mark all
2677 sub-trees as written to. If any of them has not been marked so previously
2678 and has assignment links leading from it, re-enqueue it. */
2681 subtree_mark_written_and_rhs_enqueue (struct access
*access
)
2683 if (access
->grp_write
)
2685 access
->grp_write
= true;
2686 add_access_to_rhs_work_queue (access
);
2688 struct access
*child
;
2689 for (child
= access
->first_child
; child
; child
= child
->next_sibling
)
2690 subtree_mark_written_and_rhs_enqueue (child
);
2693 /* If there is still budget to create a propagation access for DECL, return
2694 true and decrement the budget. Otherwise return false. */
2697 budget_for_propagation_access (tree decl
)
2699 unsigned b
, *p
= propagation_budget
->get (decl
);
2703 b
= param_sra_max_propagations
;
2709 if (b
== 0 && dump_file
&& (dump_flags
& TDF_DETAILS
))
2711 fprintf (dump_file
, "The propagation budget of ");
2712 print_generic_expr (dump_file
, decl
);
2713 fprintf (dump_file
, " (UID: %u) has been exhausted.\n", DECL_UID (decl
));
2715 propagation_budget
->put (decl
, b
);
2719 /* Propagate subaccesses and grp_write flags of RACC across an assignment link
2720 to LACC. Enqueue sub-accesses as necessary so that the write flag is
2721 propagated transitively. Return true if anything changed. Additionally, if
2722 RACC is a scalar access but LACC is not, change the type of the latter, if
2726 propagate_subaccesses_from_rhs (struct access
*lacc
, struct access
*racc
)
2728 struct access
*rchild
;
2729 HOST_WIDE_INT norm_delta
= lacc
->offset
- racc
->offset
;
2732 /* IF the LHS is still not marked as being written to, we only need to do so
2733 if the RHS at this level actually was. */
2734 if (!lacc
->grp_write
)
2736 gcc_checking_assert (!comes_initialized_p (racc
->base
));
2737 if (racc
->grp_write
)
2739 subtree_mark_written_and_rhs_enqueue (lacc
);
2744 if (is_gimple_reg_type (lacc
->type
)
2745 || lacc
->grp_unscalarizable_region
2746 || racc
->grp_unscalarizable_region
)
2748 if (!lacc
->grp_write
)
2751 subtree_mark_written_and_rhs_enqueue (lacc
);
2756 if (is_gimple_reg_type (racc
->type
))
2758 if (!lacc
->grp_write
)
2761 subtree_mark_written_and_rhs_enqueue (lacc
);
2763 if (!lacc
->first_child
&& !racc
->first_child
)
2765 tree t
= lacc
->base
;
2767 lacc
->type
= racc
->type
;
2768 if (build_user_friendly_ref_for_offset (&t
, TREE_TYPE (t
),
2769 lacc
->offset
, racc
->type
))
2772 lacc
->grp_same_access_path
= true;
2776 lacc
->expr
= build_ref_for_model (EXPR_LOCATION (lacc
->base
),
2777 lacc
->base
, lacc
->offset
,
2779 lacc
->grp_no_warning
= true;
2780 lacc
->grp_same_access_path
= false;
2786 for (rchild
= racc
->first_child
; rchild
; rchild
= rchild
->next_sibling
)
2788 struct access
*new_acc
= NULL
;
2789 HOST_WIDE_INT norm_offset
= rchild
->offset
+ norm_delta
;
2791 if (child_would_conflict_in_acc (lacc
, norm_offset
, rchild
->size
,
2796 if (!new_acc
->grp_write
&& rchild
->grp_write
)
2798 gcc_assert (!lacc
->grp_write
);
2799 subtree_mark_written_and_rhs_enqueue (new_acc
);
2803 rchild
->grp_hint
= 1;
2804 new_acc
->grp_hint
|= new_acc
->grp_read
;
2805 if (rchild
->first_child
2806 && propagate_subaccesses_from_rhs (new_acc
, rchild
))
2809 add_access_to_rhs_work_queue (new_acc
);
2814 if (!lacc
->grp_write
)
2817 subtree_mark_written_and_rhs_enqueue (lacc
);
2823 if (rchild
->grp_unscalarizable_region
2824 || !budget_for_propagation_access (lacc
->base
))
2826 if (rchild
->grp_write
&& !lacc
->grp_write
)
2829 subtree_mark_written_and_rhs_enqueue (lacc
);
2834 rchild
->grp_hint
= 1;
2835 /* Because get_ref_base_and_extent always includes padding in size for
2836 accesses to DECLs but not necessarily for COMPONENT_REFs of the same
2837 type, we might be actually attempting to here to create a child of the
2838 same type as the parent. */
2839 if (!types_compatible_p (lacc
->type
, rchild
->type
))
2840 new_acc
= create_artificial_child_access (lacc
, rchild
, norm_offset
,
2843 || rchild
->grp_write
));
2846 gcc_checking_assert (new_acc
);
2847 if (racc
->first_child
)
2848 propagate_subaccesses_from_rhs (new_acc
, rchild
);
2850 add_access_to_rhs_work_queue (lacc
);
2857 /* Propagate subaccesses of LACC across an assignment link to RACC if they
2858 should inhibit total scalarization of the corresponding area. No flags are
2859 being propagated in the process. Return true if anything changed. */
2862 propagate_subaccesses_from_lhs (struct access
*lacc
, struct access
*racc
)
2864 if (is_gimple_reg_type (racc
->type
)
2865 || lacc
->grp_unscalarizable_region
2866 || racc
->grp_unscalarizable_region
)
2869 /* TODO: Do we want set some new racc flag to stop potential total
2870 scalarization if lacc is a scalar access (and none fo the two have
2874 HOST_WIDE_INT norm_delta
= racc
->offset
- lacc
->offset
;
2875 for (struct access
*lchild
= lacc
->first_child
;
2877 lchild
= lchild
->next_sibling
)
2879 struct access
*matching_acc
= NULL
;
2880 HOST_WIDE_INT norm_offset
= lchild
->offset
+ norm_delta
;
2882 if (lchild
->grp_unscalarizable_region
2883 || child_would_conflict_in_acc (racc
, norm_offset
, lchild
->size
,
2885 || !budget_for_propagation_access (racc
->base
))
2888 && propagate_subaccesses_from_lhs (lchild
, matching_acc
))
2889 add_access_to_lhs_work_queue (matching_acc
);
2893 /* Because get_ref_base_and_extent always includes padding in size for
2894 accesses to DECLs but not necessarily for COMPONENT_REFs of the same
2895 type, we might be actually attempting to here to create a child of the
2896 same type as the parent. */
2897 if (!types_compatible_p (racc
->type
, lchild
->type
))
2899 struct access
*new_acc
2900 = create_artificial_child_access (racc
, lchild
, norm_offset
,
2902 propagate_subaccesses_from_lhs (lchild
, new_acc
);
2905 propagate_subaccesses_from_lhs (lchild
, racc
);
2911 /* Propagate all subaccesses across assignment links. */
2914 propagate_all_subaccesses (void)
2916 propagation_budget
= new hash_map
<tree
, unsigned>;
2917 while (rhs_work_queue_head
)
2919 struct access
*racc
= pop_access_from_rhs_work_queue ();
2920 struct assign_link
*link
;
2922 if (racc
->group_representative
)
2923 racc
= racc
->group_representative
;
2924 gcc_assert (racc
->first_rhs_link
);
2926 for (link
= racc
->first_rhs_link
; link
; link
= link
->next_rhs
)
2928 struct access
*lacc
= link
->lacc
;
2930 if (!bitmap_bit_p (candidate_bitmap
, DECL_UID (lacc
->base
)))
2932 lacc
= lacc
->group_representative
;
2934 bool reque_parents
= false;
2935 if (!bitmap_bit_p (candidate_bitmap
, DECL_UID (racc
->base
)))
2937 if (!lacc
->grp_write
)
2939 subtree_mark_written_and_rhs_enqueue (lacc
);
2940 reque_parents
= true;
2943 else if (propagate_subaccesses_from_rhs (lacc
, racc
))
2944 reque_parents
= true;
2949 add_access_to_rhs_work_queue (lacc
);
2950 lacc
= lacc
->parent
;
2956 while (lhs_work_queue_head
)
2958 struct access
*lacc
= pop_access_from_lhs_work_queue ();
2959 struct assign_link
*link
;
2961 if (lacc
->group_representative
)
2962 lacc
= lacc
->group_representative
;
2963 gcc_assert (lacc
->first_lhs_link
);
2965 if (!bitmap_bit_p (candidate_bitmap
, DECL_UID (lacc
->base
)))
2968 for (link
= lacc
->first_lhs_link
; link
; link
= link
->next_lhs
)
2970 struct access
*racc
= link
->racc
;
2972 if (racc
->group_representative
)
2973 racc
= racc
->group_representative
;
2974 if (!bitmap_bit_p (candidate_bitmap
, DECL_UID (racc
->base
)))
2976 if (propagate_subaccesses_from_lhs (lacc
, racc
))
2977 add_access_to_lhs_work_queue (racc
);
2980 delete propagation_budget
;
2983 /* Return true if the forest beginning with ROOT does not contain
2984 unscalarizable regions or non-byte aligned accesses. */
2987 can_totally_scalarize_forest_p (struct access
*root
)
2989 struct access
*access
= root
;
2992 if (access
->grp_unscalarizable_region
2993 || (access
->offset
% BITS_PER_UNIT
) != 0
2994 || (access
->size
% BITS_PER_UNIT
) != 0
2995 || (is_gimple_reg_type (access
->type
)
2996 && access
->first_child
))
2999 if (access
->first_child
)
3000 access
= access
->first_child
;
3001 else if (access
->next_sibling
)
3002 access
= access
->next_sibling
;
3005 while (access
->parent
&& !access
->next_sibling
)
3006 access
= access
->parent
;
3007 if (access
->next_sibling
)
3008 access
= access
->next_sibling
;
3011 gcc_assert (access
== root
);
3012 root
= root
->next_grp
;
3021 /* Create and return an ACCESS in PARENT spanning from POS with SIZE, TYPE and
3022 reference EXPR for total scalarization purposes and mark it as such. Within
3023 the children of PARENT, link it in between PTR and NEXT_SIBLING. */
3025 static struct access
*
3026 create_total_scalarization_access (struct access
*parent
, HOST_WIDE_INT pos
,
3027 HOST_WIDE_INT size
, tree type
, tree expr
,
3028 struct access
**ptr
,
3029 struct access
*next_sibling
)
3031 struct access
*access
= access_pool
.allocate ();
3032 memset (access
, 0, sizeof (struct access
));
3033 access
->base
= parent
->base
;
3034 access
->offset
= pos
;
3035 access
->size
= size
;
3036 access
->expr
= expr
;
3037 access
->type
= type
;
3038 access
->parent
= parent
;
3039 access
->grp_write
= parent
->grp_write
;
3040 access
->grp_total_scalarization
= 1;
3041 access
->grp_hint
= 1;
3042 access
->grp_same_access_path
= path_comparable_for_same_access (expr
);
3043 access
->reverse
= reverse_storage_order_for_component_p (expr
);
3045 access
->next_sibling
= next_sibling
;
3050 /* Create and return an ACCESS in PARENT spanning from POS with SIZE, TYPE and
3051 reference EXPR for total scalarization purposes and mark it as such, link it
3052 at *PTR and reshape the tree so that those elements at *PTR and their
3053 siblings which fall within the part described by POS and SIZE are moved to
3054 be children of the new access. If a partial overlap is detected, return
3057 static struct access
*
3058 create_total_access_and_reshape (struct access
*parent
, HOST_WIDE_INT pos
,
3059 HOST_WIDE_INT size
, tree type
, tree expr
,
3060 struct access
**ptr
)
3062 struct access
**p
= ptr
;
3064 while (*p
&& (*p
)->offset
< pos
+ size
)
3066 if ((*p
)->offset
+ (*p
)->size
> pos
+ size
)
3068 p
= &(*p
)->next_sibling
;
3071 struct access
*next_child
= *ptr
;
3072 struct access
*new_acc
3073 = create_total_scalarization_access (parent
, pos
, size
, type
, expr
,
3077 new_acc
->first_child
= next_child
;
3079 for (struct access
*a
= next_child
; a
; a
= a
->next_sibling
)
3080 a
->parent
= new_acc
;
3085 static bool totally_scalarize_subtree (struct access
*root
);
3087 /* Return true if INNER is either the same type as OUTER or if it is the type
3088 of a record field in OUTER at offset zero, possibly in nested
3092 access_and_field_type_match_p (tree outer
, tree inner
)
3094 if (TYPE_MAIN_VARIANT (outer
) == TYPE_MAIN_VARIANT (inner
))
3096 if (TREE_CODE (outer
) != RECORD_TYPE
)
3098 tree fld
= TYPE_FIELDS (outer
);
3101 if (TREE_CODE (fld
) == FIELD_DECL
)
3103 if (!zerop (DECL_FIELD_OFFSET (fld
)))
3105 if (TYPE_MAIN_VARIANT (TREE_TYPE (fld
)) == inner
)
3107 if (TREE_CODE (TREE_TYPE (fld
)) == RECORD_TYPE
)
3108 fld
= TYPE_FIELDS (TREE_TYPE (fld
));
3113 fld
= DECL_CHAIN (fld
);
3118 /* Return type of total_should_skip_creating_access indicating whether a total
3119 scalarization access for a field/element should be created, whether it
3120 already exists or whether the entire total scalarization has to fail. */
3122 enum total_sra_field_state
{TOTAL_FLD_CREATE
, TOTAL_FLD_DONE
, TOTAL_FLD_FAILED
};
3124 /* Do all the necessary steps in total scalarization when the given aggregate
3125 type has a TYPE at POS with the given SIZE should be put into PARENT and
3126 when we have processed all its siblings with smaller offsets up until and
3127 including LAST_SEEN_SIBLING (which can be NULL).
3129 If some further siblings are to be skipped, set *LAST_SEEN_SIBLING as
3130 appropriate. Return TOTAL_FLD_CREATE id the caller should carry on with
3131 creating a new access, TOTAL_FLD_DONE if access or accesses capable of
3132 representing the described part of the aggregate for the purposes of total
3133 scalarization already exist or TOTAL_FLD_FAILED if there is a problem which
3134 prevents total scalarization from happening at all. */
3136 static enum total_sra_field_state
3137 total_should_skip_creating_access (struct access
*parent
,
3138 struct access
**last_seen_sibling
,
3139 tree type
, HOST_WIDE_INT pos
,
3142 struct access
*next_child
;
3143 if (!*last_seen_sibling
)
3144 next_child
= parent
->first_child
;
3146 next_child
= (*last_seen_sibling
)->next_sibling
;
3148 /* First, traverse the chain of siblings until it points to an access with
3149 offset at least equal to POS. Check all skipped accesses whether they
3150 span the POS boundary and if so, return with a failure. */
3151 while (next_child
&& next_child
->offset
< pos
)
3153 if (next_child
->offset
+ next_child
->size
> pos
)
3154 return TOTAL_FLD_FAILED
;
3155 *last_seen_sibling
= next_child
;
3156 next_child
= next_child
->next_sibling
;
3159 /* Now check whether next_child has exactly the right POS and SIZE and if so,
3160 whether it can represent what we need and can be totally scalarized
3162 if (next_child
&& next_child
->offset
== pos
3163 && next_child
->size
== size
)
3165 if (!is_gimple_reg_type (next_child
->type
)
3166 && (!access_and_field_type_match_p (type
, next_child
->type
)
3167 || !totally_scalarize_subtree (next_child
)))
3168 return TOTAL_FLD_FAILED
;
3170 *last_seen_sibling
= next_child
;
3171 return TOTAL_FLD_DONE
;
3174 /* If the child we're looking at would partially overlap, we just cannot
3175 totally scalarize. */
3177 && next_child
->offset
< pos
+ size
3178 && next_child
->offset
+ next_child
->size
> pos
+ size
)
3179 return TOTAL_FLD_FAILED
;
3181 if (is_gimple_reg_type (type
))
3183 /* We don't scalarize accesses that are children of other scalar type
3184 accesses, so if we go on and create an access for a register type,
3185 there should not be any pre-existing children. There are rare cases
3186 where the requested type is a vector but we already have register
3187 accesses for all its elements which is equally good. Detect that
3188 situation or whether we need to bail out. */
3190 HOST_WIDE_INT covered
= pos
;
3191 bool skipping
= false;
3193 && next_child
->offset
+ next_child
->size
<= pos
+ size
)
3195 if (next_child
->offset
!= covered
3196 || !is_gimple_reg_type (next_child
->type
))
3197 return TOTAL_FLD_FAILED
;
3199 covered
+= next_child
->size
;
3200 *last_seen_sibling
= next_child
;
3201 next_child
= next_child
->next_sibling
;
3207 if (covered
!= pos
+ size
)
3208 return TOTAL_FLD_FAILED
;
3210 return TOTAL_FLD_DONE
;
3214 return TOTAL_FLD_CREATE
;
3217 /* Go over sub-tree rooted in ROOT and attempt to create scalar accesses
3218 spanning all uncovered areas covered by ROOT, return false if the attempt
3219 failed. All created accesses will have grp_unscalarizable_region set (and
3220 should be ignored if the function returns false). */
3223 totally_scalarize_subtree (struct access
*root
)
3225 gcc_checking_assert (!root
->grp_unscalarizable_region
);
3226 gcc_checking_assert (!is_gimple_reg_type (root
->type
));
3228 struct access
*last_seen_sibling
= NULL
;
3230 switch (TREE_CODE (root
->type
))
3233 for (tree fld
= TYPE_FIELDS (root
->type
); fld
; fld
= DECL_CHAIN (fld
))
3234 if (TREE_CODE (fld
) == FIELD_DECL
)
3236 tree ft
= TREE_TYPE (fld
);
3237 HOST_WIDE_INT fsize
= tree_to_uhwi (DECL_SIZE (fld
));
3241 HOST_WIDE_INT pos
= root
->offset
+ int_bit_position (fld
);
3242 enum total_sra_field_state
3243 state
= total_should_skip_creating_access (root
,
3248 case TOTAL_FLD_FAILED
:
3250 case TOTAL_FLD_DONE
:
3252 case TOTAL_FLD_CREATE
:
3258 struct access
**p
= (last_seen_sibling
3259 ? &last_seen_sibling
->next_sibling
3260 : &root
->first_child
);
3261 tree nref
= build3 (COMPONENT_REF
, ft
, root
->expr
, fld
, NULL_TREE
);
3262 struct access
*new_child
3263 = create_total_access_and_reshape (root
, pos
, fsize
, ft
, nref
, p
);
3267 if (!is_gimple_reg_type (ft
)
3268 && !totally_scalarize_subtree (new_child
))
3270 last_seen_sibling
= new_child
;
3275 tree elemtype
= TREE_TYPE (root
->type
);
3276 tree elem_size
= TYPE_SIZE (elemtype
);
3277 gcc_assert (elem_size
&& tree_fits_shwi_p (elem_size
));
3278 HOST_WIDE_INT el_size
= tree_to_shwi (elem_size
);
3279 gcc_assert (el_size
> 0);
3281 tree minidx
= TYPE_MIN_VALUE (TYPE_DOMAIN (root
->type
));
3282 gcc_assert (TREE_CODE (minidx
) == INTEGER_CST
);
3283 tree maxidx
= TYPE_MAX_VALUE (TYPE_DOMAIN (root
->type
));
3284 /* Skip (some) zero-length arrays; others have MAXIDX == MINIDX - 1. */
3287 gcc_assert (TREE_CODE (maxidx
) == INTEGER_CST
);
3288 tree domain
= TYPE_DOMAIN (root
->type
);
3289 /* MINIDX and MAXIDX are inclusive, and must be interpreted in
3290 DOMAIN (e.g. signed int, whereas min/max may be size_int). */
3291 offset_int idx
= wi::to_offset (minidx
);
3292 offset_int max
= wi::to_offset (maxidx
);
3293 if (!TYPE_UNSIGNED (domain
))
3295 idx
= wi::sext (idx
, TYPE_PRECISION (domain
));
3296 max
= wi::sext (max
, TYPE_PRECISION (domain
));
3298 for (HOST_WIDE_INT pos
= root
->offset
;
3300 pos
+= el_size
, ++idx
)
3302 enum total_sra_field_state
3303 state
= total_should_skip_creating_access (root
,
3309 case TOTAL_FLD_FAILED
:
3311 case TOTAL_FLD_DONE
:
3313 case TOTAL_FLD_CREATE
:
3319 struct access
**p
= (last_seen_sibling
3320 ? &last_seen_sibling
->next_sibling
3321 : &root
->first_child
);
3322 tree nref
= build4 (ARRAY_REF
, elemtype
, root
->expr
,
3323 wide_int_to_tree (domain
, idx
),
3324 NULL_TREE
, NULL_TREE
);
3325 struct access
*new_child
3326 = create_total_access_and_reshape (root
, pos
, el_size
, elemtype
,
3331 if (!is_gimple_reg_type (elemtype
)
3332 && !totally_scalarize_subtree (new_child
))
3334 last_seen_sibling
= new_child
;
3346 /* Go through all accesses collected throughout the (intraprocedural) analysis
3347 stage, exclude overlapping ones, identify representatives and build trees
3348 out of them, making decisions about scalarization on the way. Return true
3349 iff there are any to-be-scalarized variables after this stage. */
3352 analyze_all_variable_accesses (void)
3355 bitmap tmp
= BITMAP_ALLOC (NULL
);
3359 bitmap_copy (tmp
, candidate_bitmap
);
3360 EXECUTE_IF_SET_IN_BITMAP (tmp
, 0, i
, bi
)
3362 tree var
= candidate (i
);
3363 struct access
*access
;
3365 access
= sort_and_splice_var_accesses (var
);
3366 if (!access
|| !build_access_trees (access
))
3367 disqualify_candidate (var
,
3368 "No or inhibitingly overlapping accesses.");
3371 propagate_all_subaccesses ();
3373 bool optimize_speed_p
= !optimize_function_for_size_p (cfun
);
3374 /* If the user didn't set PARAM_SRA_MAX_SCALARIZATION_SIZE_<...>,
3375 fall back to a target default. */
3376 unsigned HOST_WIDE_INT max_scalarization_size
3377 = get_move_ratio (optimize_speed_p
) * UNITS_PER_WORD
;
3379 if (optimize_speed_p
)
3381 if (global_options_set
.x_param_sra_max_scalarization_size_speed
)
3382 max_scalarization_size
= param_sra_max_scalarization_size_speed
;
3386 if (global_options_set
.x_param_sra_max_scalarization_size_size
)
3387 max_scalarization_size
= param_sra_max_scalarization_size_size
;
3389 max_scalarization_size
*= BITS_PER_UNIT
;
3391 EXECUTE_IF_SET_IN_BITMAP (candidate_bitmap
, 0, i
, bi
)
3392 if (bitmap_bit_p (should_scalarize_away_bitmap
, i
)
3393 && !bitmap_bit_p (cannot_scalarize_away_bitmap
, i
))
3395 tree var
= candidate (i
);
3399 if (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (var
))) > max_scalarization_size
)
3401 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3403 fprintf (dump_file
, "Too big to totally scalarize: ");
3404 print_generic_expr (dump_file
, var
);
3405 fprintf (dump_file
, " (UID: %u)\n", DECL_UID (var
));
3410 bool all_types_ok
= true;
3411 for (struct access
*access
= get_first_repr_for_decl (var
);
3413 access
= access
->next_grp
)
3414 if (!can_totally_scalarize_forest_p (access
)
3415 || !scalarizable_type_p (access
->type
, constant_decl_p (var
)))
3417 all_types_ok
= false;
3423 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3425 fprintf (dump_file
, "Will attempt to totally scalarize ");
3426 print_generic_expr (dump_file
, var
);
3427 fprintf (dump_file
, " (UID: %u): \n", DECL_UID (var
));
3429 bool scalarized
= true;
3430 for (struct access
*access
= get_first_repr_for_decl (var
);
3432 access
= access
->next_grp
)
3433 if (!is_gimple_reg_type (access
->type
)
3434 && !totally_scalarize_subtree (access
))
3441 for (struct access
*access
= get_first_repr_for_decl (var
);
3443 access
= access
->next_grp
)
3444 access
->grp_total_scalarization
= true;
3448 verify_all_sra_access_forests ();
3450 bitmap_copy (tmp
, candidate_bitmap
);
3451 EXECUTE_IF_SET_IN_BITMAP (tmp
, 0, i
, bi
)
3453 tree var
= candidate (i
);
3454 struct access
*access
= get_first_repr_for_decl (var
);
3456 if (analyze_access_trees (access
))
3459 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3461 fprintf (dump_file
, "\nAccess trees for ");
3462 print_generic_expr (dump_file
, var
);
3463 fprintf (dump_file
, " (UID: %u): \n", DECL_UID (var
));
3464 dump_access_tree (dump_file
, access
);
3465 fprintf (dump_file
, "\n");
3469 disqualify_candidate (var
, "No scalar replacements to be created.");
3476 statistics_counter_event (cfun
, "Scalarized aggregates", res
);
3483 /* Generate statements copying scalar replacements of accesses within a subtree
3484 into or out of AGG. ACCESS, all its children, siblings and their children
3485 are to be processed. AGG is an aggregate type expression (can be a
3486 declaration but does not have to be, it can for example also be a mem_ref or
3487 a series of handled components). TOP_OFFSET is the offset of the processed
3488 subtree which has to be subtracted from offsets of individual accesses to
3489 get corresponding offsets for AGG. If CHUNK_SIZE is non-null, copy only
3490 replacements in the interval <start_offset, start_offset + chunk_size>,
3491 otherwise copy all. GSI is a statement iterator used to place the new
3492 statements. WRITE should be true when the statements should write from AGG
3493 to the replacement and false if vice versa. if INSERT_AFTER is true, new
3494 statements will be added after the current statement in GSI, they will be
3495 added before the statement otherwise. */
3498 generate_subtree_copies (struct access
*access
, tree agg
,
3499 HOST_WIDE_INT top_offset
,
3500 HOST_WIDE_INT start_offset
, HOST_WIDE_INT chunk_size
,
3501 gimple_stmt_iterator
*gsi
, bool write
,
3502 bool insert_after
, location_t loc
)
3504 /* Never write anything into constant pool decls. See PR70602. */
3505 if (!write
&& constant_decl_p (agg
))
3509 if (chunk_size
&& access
->offset
>= start_offset
+ chunk_size
)
3512 if (access
->grp_to_be_replaced
3514 || access
->offset
+ access
->size
> start_offset
))
3516 tree expr
, repl
= get_access_replacement (access
);
3519 expr
= build_ref_for_model (loc
, agg
, access
->offset
- top_offset
,
3520 access
, gsi
, insert_after
);
3524 if (access
->grp_partial_lhs
)
3525 expr
= force_gimple_operand_gsi (gsi
, expr
, true, NULL_TREE
,
3527 insert_after
? GSI_NEW_STMT
3529 stmt
= gimple_build_assign (repl
, expr
);
3533 TREE_NO_WARNING (repl
) = 1;
3534 if (access
->grp_partial_lhs
)
3535 repl
= force_gimple_operand_gsi (gsi
, repl
, true, NULL_TREE
,
3537 insert_after
? GSI_NEW_STMT
3539 stmt
= gimple_build_assign (expr
, repl
);
3541 gimple_set_location (stmt
, loc
);
3544 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
3546 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
3548 sra_stats
.subtree_copies
++;
3551 && access
->grp_to_be_debug_replaced
3553 || access
->offset
+ access
->size
> start_offset
))
3556 tree drhs
= build_debug_ref_for_model (loc
, agg
,
3557 access
->offset
- top_offset
,
3559 ds
= gimple_build_debug_bind (get_access_replacement (access
),
3560 drhs
, gsi_stmt (*gsi
));
3562 gsi_insert_after (gsi
, ds
, GSI_NEW_STMT
);
3564 gsi_insert_before (gsi
, ds
, GSI_SAME_STMT
);
3567 if (access
->first_child
)
3568 generate_subtree_copies (access
->first_child
, agg
, top_offset
,
3569 start_offset
, chunk_size
, gsi
,
3570 write
, insert_after
, loc
);
3572 access
= access
->next_sibling
;
3577 /* Assign zero to all scalar replacements in an access subtree. ACCESS is the
3578 root of the subtree to be processed. GSI is the statement iterator used
3579 for inserting statements which are added after the current statement if
3580 INSERT_AFTER is true or before it otherwise. */
3583 init_subtree_with_zero (struct access
*access
, gimple_stmt_iterator
*gsi
,
3584 bool insert_after
, location_t loc
)
3587 struct access
*child
;
3589 if (access
->grp_to_be_replaced
)
3593 stmt
= gimple_build_assign (get_access_replacement (access
),
3594 build_zero_cst (access
->type
));
3596 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
3598 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
3600 gimple_set_location (stmt
, loc
);
3602 else if (access
->grp_to_be_debug_replaced
)
3605 = gimple_build_debug_bind (get_access_replacement (access
),
3606 build_zero_cst (access
->type
),
3609 gsi_insert_after (gsi
, ds
, GSI_NEW_STMT
);
3611 gsi_insert_before (gsi
, ds
, GSI_SAME_STMT
);
3614 for (child
= access
->first_child
; child
; child
= child
->next_sibling
)
3615 init_subtree_with_zero (child
, gsi
, insert_after
, loc
);
3618 /* Clobber all scalar replacements in an access subtree. ACCESS is the
3619 root of the subtree to be processed. GSI is the statement iterator used
3620 for inserting statements which are added after the current statement if
3621 INSERT_AFTER is true or before it otherwise. */
3624 clobber_subtree (struct access
*access
, gimple_stmt_iterator
*gsi
,
3625 bool insert_after
, location_t loc
)
3628 struct access
*child
;
3630 if (access
->grp_to_be_replaced
)
3632 tree rep
= get_access_replacement (access
);
3633 tree clobber
= build_clobber (access
->type
);
3634 gimple
*stmt
= gimple_build_assign (rep
, clobber
);
3637 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
3639 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
3641 gimple_set_location (stmt
, loc
);
3644 for (child
= access
->first_child
; child
; child
= child
->next_sibling
)
3645 clobber_subtree (child
, gsi
, insert_after
, loc
);
3648 /* Search for an access representative for the given expression EXPR and
3649 return it or NULL if it cannot be found. */
3651 static struct access
*
3652 get_access_for_expr (tree expr
)
3654 poly_int64 poffset
, psize
, pmax_size
;
3655 HOST_WIDE_INT offset
, max_size
;
3659 /* FIXME: This should not be necessary but Ada produces V_C_Es with a type of
3660 a different size than the size of its argument and we need the latter
3662 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
3663 expr
= TREE_OPERAND (expr
, 0);
3665 base
= get_ref_base_and_extent (expr
, &poffset
, &psize
, &pmax_size
,
3667 if (!known_size_p (pmax_size
)
3668 || !pmax_size
.is_constant (&max_size
)
3669 || !poffset
.is_constant (&offset
)
3673 if (tree basesize
= DECL_SIZE (base
))
3677 || !poly_int_tree_p (basesize
, &sz
)
3678 || known_le (sz
, offset
))
3683 || !bitmap_bit_p (candidate_bitmap
, DECL_UID (base
)))
3686 return get_var_base_offset_size_access (base
, offset
, max_size
);
3689 /* Replace the expression EXPR with a scalar replacement if there is one and
3690 generate other statements to do type conversion or subtree copying if
3691 necessary. GSI is used to place newly created statements, WRITE is true if
3692 the expression is being written to (it is on a LHS of a statement or output
3693 in an assembly statement). */
3696 sra_modify_expr (tree
*expr
, gimple_stmt_iterator
*gsi
, bool write
)
3699 struct access
*access
;
3700 tree type
, bfr
, orig_expr
;
3702 if (TREE_CODE (*expr
) == BIT_FIELD_REF
)
3705 expr
= &TREE_OPERAND (*expr
, 0);
3710 if (TREE_CODE (*expr
) == REALPART_EXPR
|| TREE_CODE (*expr
) == IMAGPART_EXPR
)
3711 expr
= &TREE_OPERAND (*expr
, 0);
3712 access
= get_access_for_expr (*expr
);
3715 type
= TREE_TYPE (*expr
);
3718 loc
= gimple_location (gsi_stmt (*gsi
));
3719 gimple_stmt_iterator alt_gsi
= gsi_none ();
3720 if (write
&& stmt_ends_bb_p (gsi_stmt (*gsi
)))
3722 alt_gsi
= gsi_start_edge (single_non_eh_succ (gsi_bb (*gsi
)));
3726 if (access
->grp_to_be_replaced
)
3728 tree repl
= get_access_replacement (access
);
3729 /* If we replace a non-register typed access simply use the original
3730 access expression to extract the scalar component afterwards.
3731 This happens if scalarizing a function return value or parameter
3732 like in gcc.c-torture/execute/20041124-1.c, 20050316-1.c and
3733 gcc.c-torture/compile/20011217-1.c.
3735 We also want to use this when accessing a complex or vector which can
3736 be accessed as a different type too, potentially creating a need for
3737 type conversion (see PR42196) and when scalarized unions are involved
3738 in assembler statements (see PR42398). */
3739 if (!useless_type_conversion_p (type
, access
->type
))
3743 ref
= build_ref_for_model (loc
, orig_expr
, 0, access
, gsi
, false);
3749 if (access
->grp_partial_lhs
)
3750 ref
= force_gimple_operand_gsi (gsi
, ref
, true, NULL_TREE
,
3751 false, GSI_NEW_STMT
);
3752 stmt
= gimple_build_assign (repl
, ref
);
3753 gimple_set_location (stmt
, loc
);
3754 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
3760 if (access
->grp_partial_lhs
)
3761 repl
= force_gimple_operand_gsi (gsi
, repl
, true, NULL_TREE
,
3762 true, GSI_SAME_STMT
);
3763 stmt
= gimple_build_assign (ref
, repl
);
3764 gimple_set_location (stmt
, loc
);
3765 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
3772 else if (write
&& access
->grp_to_be_debug_replaced
)
3774 gdebug
*ds
= gimple_build_debug_bind (get_access_replacement (access
),
3777 gsi_insert_after (gsi
, ds
, GSI_NEW_STMT
);
3780 if (access
->first_child
)
3782 HOST_WIDE_INT start_offset
, chunk_size
;
3784 && tree_fits_uhwi_p (TREE_OPERAND (bfr
, 1))
3785 && tree_fits_uhwi_p (TREE_OPERAND (bfr
, 2)))
3787 chunk_size
= tree_to_uhwi (TREE_OPERAND (bfr
, 1));
3788 start_offset
= access
->offset
3789 + tree_to_uhwi (TREE_OPERAND (bfr
, 2));
3792 start_offset
= chunk_size
= 0;
3794 generate_subtree_copies (access
->first_child
, orig_expr
, access
->offset
,
3795 start_offset
, chunk_size
, gsi
, write
, write
,
3801 /* Where scalar replacements of the RHS have been written to when a replacement
3802 of a LHS of an assigments cannot be direclty loaded from a replacement of
3804 enum unscalarized_data_handling
{ SRA_UDH_NONE
, /* Nothing done so far. */
3805 SRA_UDH_RIGHT
, /* Data flushed to the RHS. */
3806 SRA_UDH_LEFT
}; /* Data flushed to the LHS. */
3808 struct subreplacement_assignment_data
3810 /* Offset of the access representing the lhs of the assignment. */
3811 HOST_WIDE_INT left_offset
;
3813 /* LHS and RHS of the original assignment. */
3814 tree assignment_lhs
, assignment_rhs
;
3816 /* Access representing the rhs of the whole assignment. */
3817 struct access
*top_racc
;
3819 /* Stmt iterator used for statement insertions after the original assignment.
3820 It points to the main GSI used to traverse a BB during function body
3822 gimple_stmt_iterator
*new_gsi
;
3824 /* Stmt iterator used for statement insertions before the original
3825 assignment. Keeps on pointing to the original statement. */
3826 gimple_stmt_iterator old_gsi
;
3828 /* Location of the assignment. */
3831 /* Keeps the information whether we have needed to refresh replacements of
3832 the LHS and from which side of the assignments this takes place. */
3833 enum unscalarized_data_handling refreshed
;
3836 /* Store all replacements in the access tree rooted in TOP_RACC either to their
3837 base aggregate if there are unscalarized data or directly to LHS of the
3838 statement that is pointed to by GSI otherwise. */
3841 handle_unscalarized_data_in_subtree (struct subreplacement_assignment_data
*sad
)
3844 if (sad
->top_racc
->grp_unscalarized_data
)
3846 src
= sad
->assignment_rhs
;
3847 sad
->refreshed
= SRA_UDH_RIGHT
;
3851 src
= sad
->assignment_lhs
;
3852 sad
->refreshed
= SRA_UDH_LEFT
;
3854 generate_subtree_copies (sad
->top_racc
->first_child
, src
,
3855 sad
->top_racc
->offset
, 0, 0,
3856 &sad
->old_gsi
, false, false, sad
->loc
);
3859 /* Try to generate statements to load all sub-replacements in an access subtree
3860 formed by children of LACC from scalar replacements in the SAD->top_racc
3861 subtree. If that is not possible, refresh the SAD->top_racc base aggregate
3862 and load the accesses from it. */
3865 load_assign_lhs_subreplacements (struct access
*lacc
,
3866 struct subreplacement_assignment_data
*sad
)
3868 for (lacc
= lacc
->first_child
; lacc
; lacc
= lacc
->next_sibling
)
3870 HOST_WIDE_INT offset
;
3871 offset
= lacc
->offset
- sad
->left_offset
+ sad
->top_racc
->offset
;
3873 if (lacc
->grp_to_be_replaced
)
3875 struct access
*racc
;
3879 racc
= find_access_in_subtree (sad
->top_racc
, offset
, lacc
->size
);
3880 if (racc
&& racc
->grp_to_be_replaced
)
3882 rhs
= get_access_replacement (racc
);
3883 if (!useless_type_conversion_p (lacc
->type
, racc
->type
))
3884 rhs
= fold_build1_loc (sad
->loc
, VIEW_CONVERT_EXPR
,
3887 if (racc
->grp_partial_lhs
&& lacc
->grp_partial_lhs
)
3888 rhs
= force_gimple_operand_gsi (&sad
->old_gsi
, rhs
, true,
3889 NULL_TREE
, true, GSI_SAME_STMT
);
3893 /* No suitable access on the right hand side, need to load from
3894 the aggregate. See if we have to update it first... */
3895 if (sad
->refreshed
== SRA_UDH_NONE
)
3896 handle_unscalarized_data_in_subtree (sad
);
3898 if (sad
->refreshed
== SRA_UDH_LEFT
)
3899 rhs
= build_ref_for_model (sad
->loc
, sad
->assignment_lhs
,
3900 lacc
->offset
- sad
->left_offset
,
3901 lacc
, sad
->new_gsi
, true);
3903 rhs
= build_ref_for_model (sad
->loc
, sad
->assignment_rhs
,
3904 lacc
->offset
- sad
->left_offset
,
3905 lacc
, sad
->new_gsi
, true);
3906 if (lacc
->grp_partial_lhs
)
3907 rhs
= force_gimple_operand_gsi (sad
->new_gsi
,
3908 rhs
, true, NULL_TREE
,
3909 false, GSI_NEW_STMT
);
3912 stmt
= gimple_build_assign (get_access_replacement (lacc
), rhs
);
3913 gsi_insert_after (sad
->new_gsi
, stmt
, GSI_NEW_STMT
);
3914 gimple_set_location (stmt
, sad
->loc
);
3916 sra_stats
.subreplacements
++;
3920 if (sad
->refreshed
== SRA_UDH_NONE
3921 && lacc
->grp_read
&& !lacc
->grp_covered
)
3922 handle_unscalarized_data_in_subtree (sad
);
3924 if (lacc
&& lacc
->grp_to_be_debug_replaced
)
3928 struct access
*racc
= find_access_in_subtree (sad
->top_racc
,
3932 if (racc
&& racc
->grp_to_be_replaced
)
3934 if (racc
->grp_write
|| constant_decl_p (racc
->base
))
3935 drhs
= get_access_replacement (racc
);
3939 else if (sad
->refreshed
== SRA_UDH_LEFT
)
3940 drhs
= build_debug_ref_for_model (sad
->loc
, lacc
->base
,
3941 lacc
->offset
, lacc
);
3942 else if (sad
->refreshed
== SRA_UDH_RIGHT
)
3943 drhs
= build_debug_ref_for_model (sad
->loc
, sad
->top_racc
->base
,
3948 && !useless_type_conversion_p (lacc
->type
, TREE_TYPE (drhs
)))
3949 drhs
= fold_build1_loc (sad
->loc
, VIEW_CONVERT_EXPR
,
3951 ds
= gimple_build_debug_bind (get_access_replacement (lacc
),
3952 drhs
, gsi_stmt (sad
->old_gsi
));
3953 gsi_insert_after (sad
->new_gsi
, ds
, GSI_NEW_STMT
);
3957 if (lacc
->first_child
)
3958 load_assign_lhs_subreplacements (lacc
, sad
);
3962 /* Result code for SRA assignment modification. */
3963 enum assignment_mod_result
{ SRA_AM_NONE
, /* nothing done for the stmt */
3964 SRA_AM_MODIFIED
, /* stmt changed but not
3966 SRA_AM_REMOVED
}; /* stmt eliminated */
3968 /* Modify assignments with a CONSTRUCTOR on their RHS. STMT contains a pointer
3969 to the assignment and GSI is the statement iterator pointing at it. Returns
3970 the same values as sra_modify_assign. */
3972 static enum assignment_mod_result
3973 sra_modify_constructor_assign (gimple
*stmt
, gimple_stmt_iterator
*gsi
)
3975 tree lhs
= gimple_assign_lhs (stmt
);
3976 struct access
*acc
= get_access_for_expr (lhs
);
3979 location_t loc
= gimple_location (stmt
);
3981 if (gimple_clobber_p (stmt
))
3983 /* Clobber the replacement variable. */
3984 clobber_subtree (acc
, gsi
, !acc
->grp_covered
, loc
);
3985 /* Remove clobbers of fully scalarized variables, they are dead. */
3986 if (acc
->grp_covered
)
3988 unlink_stmt_vdef (stmt
);
3989 gsi_remove (gsi
, true);
3990 release_defs (stmt
);
3991 return SRA_AM_REMOVED
;
3994 return SRA_AM_MODIFIED
;
3997 if (CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt
)) > 0)
3999 /* I have never seen this code path trigger but if it can happen the
4000 following should handle it gracefully. */
4001 if (access_has_children_p (acc
))
4002 generate_subtree_copies (acc
->first_child
, lhs
, acc
->offset
, 0, 0, gsi
,
4004 return SRA_AM_MODIFIED
;
4007 if (acc
->grp_covered
)
4009 init_subtree_with_zero (acc
, gsi
, false, loc
);
4010 unlink_stmt_vdef (stmt
);
4011 gsi_remove (gsi
, true);
4012 release_defs (stmt
);
4013 return SRA_AM_REMOVED
;
4017 init_subtree_with_zero (acc
, gsi
, true, loc
);
4018 return SRA_AM_MODIFIED
;
4022 /* Create and return a new suitable default definition SSA_NAME for RACC which
4023 is an access describing an uninitialized part of an aggregate that is being
4024 loaded. REG_TREE is used instead of the actual RACC type if that is not of
4025 a gimple register type. */
4028 get_repl_default_def_ssa_name (struct access
*racc
, tree reg_type
)
4030 gcc_checking_assert (!racc
->grp_to_be_replaced
4031 && !racc
->grp_to_be_debug_replaced
);
4032 if (!racc
->replacement_decl
)
4033 racc
->replacement_decl
= create_access_replacement (racc
, reg_type
);
4034 return get_or_create_ssa_default_def (cfun
, racc
->replacement_decl
);
4037 /* Examine both sides of the assignment statement pointed to by STMT, replace
4038 them with a scalare replacement if there is one and generate copying of
4039 replacements if scalarized aggregates have been used in the assignment. GSI
4040 is used to hold generated statements for type conversions and subtree
4043 static enum assignment_mod_result
4044 sra_modify_assign (gimple
*stmt
, gimple_stmt_iterator
*gsi
)
4046 struct access
*lacc
, *racc
;
4048 bool modify_this_stmt
= false;
4049 bool force_gimple_rhs
= false;
4051 gimple_stmt_iterator orig_gsi
= *gsi
;
4053 if (!gimple_assign_single_p (stmt
))
4055 lhs
= gimple_assign_lhs (stmt
);
4056 rhs
= gimple_assign_rhs1 (stmt
);
4058 if (TREE_CODE (rhs
) == CONSTRUCTOR
)
4059 return sra_modify_constructor_assign (stmt
, gsi
);
4061 if (TREE_CODE (rhs
) == REALPART_EXPR
|| TREE_CODE (lhs
) == REALPART_EXPR
4062 || TREE_CODE (rhs
) == IMAGPART_EXPR
|| TREE_CODE (lhs
) == IMAGPART_EXPR
4063 || TREE_CODE (rhs
) == BIT_FIELD_REF
|| TREE_CODE (lhs
) == BIT_FIELD_REF
)
4065 modify_this_stmt
= sra_modify_expr (gimple_assign_rhs1_ptr (stmt
),
4067 modify_this_stmt
|= sra_modify_expr (gimple_assign_lhs_ptr (stmt
),
4069 return modify_this_stmt
? SRA_AM_MODIFIED
: SRA_AM_NONE
;
4072 lacc
= get_access_for_expr (lhs
);
4073 racc
= get_access_for_expr (rhs
);
4076 /* Avoid modifying initializations of constant-pool replacements. */
4077 if (racc
&& (racc
->replacement_decl
== lhs
))
4080 loc
= gimple_location (stmt
);
4081 if (lacc
&& lacc
->grp_to_be_replaced
)
4083 lhs
= get_access_replacement (lacc
);
4084 gimple_assign_set_lhs (stmt
, lhs
);
4085 modify_this_stmt
= true;
4086 if (lacc
->grp_partial_lhs
)
4087 force_gimple_rhs
= true;
4091 if (racc
&& racc
->grp_to_be_replaced
)
4093 rhs
= get_access_replacement (racc
);
4094 modify_this_stmt
= true;
4095 if (racc
->grp_partial_lhs
)
4096 force_gimple_rhs
= true;
4100 && !racc
->grp_unscalarized_data
4101 && !racc
->grp_unscalarizable_region
4102 && TREE_CODE (lhs
) == SSA_NAME
4103 && !access_has_replacements_p (racc
))
4105 rhs
= get_repl_default_def_ssa_name (racc
, TREE_TYPE (lhs
));
4106 modify_this_stmt
= true;
4110 if (modify_this_stmt
)
4112 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
4114 /* If we can avoid creating a VIEW_CONVERT_EXPR do so.
4115 ??? This should move to fold_stmt which we simply should
4116 call after building a VIEW_CONVERT_EXPR here. */
4117 if (AGGREGATE_TYPE_P (TREE_TYPE (lhs
))
4118 && !contains_bitfld_component_ref_p (lhs
))
4120 lhs
= build_ref_for_model (loc
, lhs
, 0, racc
, gsi
, false);
4121 gimple_assign_set_lhs (stmt
, lhs
);
4124 && AGGREGATE_TYPE_P (TREE_TYPE (rhs
))
4125 && !contains_vce_or_bfcref_p (rhs
))
4126 rhs
= build_ref_for_model (loc
, rhs
, 0, lacc
, gsi
, false);
4128 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
4130 rhs
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (lhs
),
4132 if (is_gimple_reg_type (TREE_TYPE (lhs
))
4133 && TREE_CODE (lhs
) != SSA_NAME
)
4134 force_gimple_rhs
= true;
4139 if (lacc
&& lacc
->grp_to_be_debug_replaced
)
4141 tree dlhs
= get_access_replacement (lacc
);
4142 tree drhs
= unshare_expr (rhs
);
4143 if (!useless_type_conversion_p (TREE_TYPE (dlhs
), TREE_TYPE (drhs
)))
4145 if (AGGREGATE_TYPE_P (TREE_TYPE (drhs
))
4146 && !contains_vce_or_bfcref_p (drhs
))
4147 drhs
= build_debug_ref_for_model (loc
, drhs
, 0, lacc
);
4149 && !useless_type_conversion_p (TREE_TYPE (dlhs
),
4151 drhs
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
,
4152 TREE_TYPE (dlhs
), drhs
);
4154 gdebug
*ds
= gimple_build_debug_bind (dlhs
, drhs
, stmt
);
4155 gsi_insert_before (gsi
, ds
, GSI_SAME_STMT
);
4158 /* From this point on, the function deals with assignments in between
4159 aggregates when at least one has scalar reductions of some of its
4160 components. There are three possible scenarios: Both the LHS and RHS have
4161 to-be-scalarized components, 2) only the RHS has or 3) only the LHS has.
4163 In the first case, we would like to load the LHS components from RHS
4164 components whenever possible. If that is not possible, we would like to
4165 read it directly from the RHS (after updating it by storing in it its own
4166 components). If there are some necessary unscalarized data in the LHS,
4167 those will be loaded by the original assignment too. If neither of these
4168 cases happen, the original statement can be removed. Most of this is done
4169 by load_assign_lhs_subreplacements.
4171 In the second case, we would like to store all RHS scalarized components
4172 directly into LHS and if they cover the aggregate completely, remove the
4173 statement too. In the third case, we want the LHS components to be loaded
4174 directly from the RHS (DSE will remove the original statement if it
4177 This is a bit complex but manageable when types match and when unions do
4178 not cause confusion in a way that we cannot really load a component of LHS
4179 from the RHS or vice versa (the access representing this level can have
4180 subaccesses that are accessible only through a different union field at a
4181 higher level - different from the one used in the examined expression).
4184 Therefore, I specially handle a fourth case, happening when there is a
4185 specific type cast or it is impossible to locate a scalarized subaccess on
4186 the other side of the expression. If that happens, I simply "refresh" the
4187 RHS by storing in it is scalarized components leave the original statement
4188 there to do the copying and then load the scalar replacements of the LHS.
4189 This is what the first branch does. */
4191 if (modify_this_stmt
4192 || gimple_has_volatile_ops (stmt
)
4193 || contains_vce_or_bfcref_p (rhs
)
4194 || contains_vce_or_bfcref_p (lhs
)
4195 || stmt_ends_bb_p (stmt
))
4197 /* No need to copy into a constant-pool, it comes pre-initialized. */
4198 if (access_has_children_p (racc
) && !constant_decl_p (racc
->base
))
4199 generate_subtree_copies (racc
->first_child
, rhs
, racc
->offset
, 0, 0,
4200 gsi
, false, false, loc
);
4201 if (access_has_children_p (lacc
))
4203 gimple_stmt_iterator alt_gsi
= gsi_none ();
4204 if (stmt_ends_bb_p (stmt
))
4206 alt_gsi
= gsi_start_edge (single_non_eh_succ (gsi_bb (*gsi
)));
4209 generate_subtree_copies (lacc
->first_child
, lhs
, lacc
->offset
, 0, 0,
4210 gsi
, true, true, loc
);
4212 sra_stats
.separate_lhs_rhs_handling
++;
4214 /* This gimplification must be done after generate_subtree_copies,
4215 lest we insert the subtree copies in the middle of the gimplified
4217 if (force_gimple_rhs
)
4218 rhs
= force_gimple_operand_gsi (&orig_gsi
, rhs
, true, NULL_TREE
,
4219 true, GSI_SAME_STMT
);
4220 if (gimple_assign_rhs1 (stmt
) != rhs
)
4222 modify_this_stmt
= true;
4223 gimple_assign_set_rhs_from_tree (&orig_gsi
, rhs
);
4224 gcc_assert (stmt
== gsi_stmt (orig_gsi
));
4227 return modify_this_stmt
? SRA_AM_MODIFIED
: SRA_AM_NONE
;
4231 if (access_has_children_p (lacc
)
4232 && access_has_children_p (racc
)
4233 /* When an access represents an unscalarizable region, it usually
4234 represents accesses with variable offset and thus must not be used
4235 to generate new memory accesses. */
4236 && !lacc
->grp_unscalarizable_region
4237 && !racc
->grp_unscalarizable_region
)
4239 struct subreplacement_assignment_data sad
;
4241 sad
.left_offset
= lacc
->offset
;
4242 sad
.assignment_lhs
= lhs
;
4243 sad
.assignment_rhs
= rhs
;
4244 sad
.top_racc
= racc
;
4247 sad
.loc
= gimple_location (stmt
);
4248 sad
.refreshed
= SRA_UDH_NONE
;
4250 if (lacc
->grp_read
&& !lacc
->grp_covered
)
4251 handle_unscalarized_data_in_subtree (&sad
);
4253 load_assign_lhs_subreplacements (lacc
, &sad
);
4254 if (sad
.refreshed
!= SRA_UDH_RIGHT
)
4257 unlink_stmt_vdef (stmt
);
4258 gsi_remove (&sad
.old_gsi
, true);
4259 release_defs (stmt
);
4260 sra_stats
.deleted
++;
4261 return SRA_AM_REMOVED
;
4266 if (access_has_children_p (racc
)
4267 && !racc
->grp_unscalarized_data
4268 && TREE_CODE (lhs
) != SSA_NAME
)
4272 fprintf (dump_file
, "Removing load: ");
4273 print_gimple_stmt (dump_file
, stmt
, 0);
4275 generate_subtree_copies (racc
->first_child
, lhs
,
4276 racc
->offset
, 0, 0, gsi
,
4278 gcc_assert (stmt
== gsi_stmt (*gsi
));
4279 unlink_stmt_vdef (stmt
);
4280 gsi_remove (gsi
, true);
4281 release_defs (stmt
);
4282 sra_stats
.deleted
++;
4283 return SRA_AM_REMOVED
;
4285 /* Restore the aggregate RHS from its components so the
4286 prevailing aggregate copy does the right thing. */
4287 if (access_has_children_p (racc
))
4288 generate_subtree_copies (racc
->first_child
, rhs
, racc
->offset
, 0, 0,
4289 gsi
, false, false, loc
);
4290 /* Re-load the components of the aggregate copy destination.
4291 But use the RHS aggregate to load from to expose more
4292 optimization opportunities. */
4293 if (access_has_children_p (lacc
))
4294 generate_subtree_copies (lacc
->first_child
, rhs
, lacc
->offset
,
4295 0, 0, gsi
, true, true, loc
);
4302 /* Set any scalar replacements of values in the constant pool to the initial
4303 value of the constant. (Constant-pool decls like *.LC0 have effectively
4304 been initialized before the program starts, we must do the same for their
4305 replacements.) Thus, we output statements like 'SR.1 = *.LC0[0];' into
4306 the function's entry block. */
4309 initialize_constant_pool_replacements (void)
4311 gimple_seq seq
= NULL
;
4312 gimple_stmt_iterator gsi
= gsi_start (seq
);
4316 EXECUTE_IF_SET_IN_BITMAP (candidate_bitmap
, 0, i
, bi
)
4318 tree var
= candidate (i
);
4319 if (!constant_decl_p (var
))
4322 struct access
*access
= get_first_repr_for_decl (var
);
4326 if (access
->replacement_decl
)
4329 = gimple_build_assign (get_access_replacement (access
),
4330 unshare_expr (access
->expr
));
4331 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4333 fprintf (dump_file
, "Generating constant initializer: ");
4334 print_gimple_stmt (dump_file
, stmt
, 0);
4335 fprintf (dump_file
, "\n");
4337 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
4341 if (access
->first_child
)
4342 access
= access
->first_child
;
4343 else if (access
->next_sibling
)
4344 access
= access
->next_sibling
;
4347 while (access
->parent
&& !access
->next_sibling
)
4348 access
= access
->parent
;
4349 if (access
->next_sibling
)
4350 access
= access
->next_sibling
;
4352 access
= access
->next_grp
;
4357 seq
= gsi_seq (gsi
);
4359 gsi_insert_seq_on_edge_immediate (
4360 single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)), seq
);
4363 /* Traverse the function body and all modifications as decided in
4364 analyze_all_variable_accesses. Return true iff the CFG has been
4368 sra_modify_function_body (void)
4370 bool cfg_changed
= false;
4373 initialize_constant_pool_replacements ();
4375 FOR_EACH_BB_FN (bb
, cfun
)
4377 gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
4378 while (!gsi_end_p (gsi
))
4380 gimple
*stmt
= gsi_stmt (gsi
);
4381 enum assignment_mod_result assign_result
;
4382 bool modified
= false, deleted
= false;
4386 switch (gimple_code (stmt
))
4389 t
= gimple_return_retval_ptr (as_a
<greturn
*> (stmt
));
4390 if (*t
!= NULL_TREE
)
4391 modified
|= sra_modify_expr (t
, &gsi
, false);
4395 assign_result
= sra_modify_assign (stmt
, &gsi
);
4396 modified
|= assign_result
== SRA_AM_MODIFIED
;
4397 deleted
= assign_result
== SRA_AM_REMOVED
;
4401 /* Operands must be processed before the lhs. */
4402 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
4404 t
= gimple_call_arg_ptr (stmt
, i
);
4405 modified
|= sra_modify_expr (t
, &gsi
, false);
4408 if (gimple_call_lhs (stmt
))
4410 t
= gimple_call_lhs_ptr (stmt
);
4411 modified
|= sra_modify_expr (t
, &gsi
, true);
4417 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
4418 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); i
++)
4420 t
= &TREE_VALUE (gimple_asm_input_op (asm_stmt
, i
));
4421 modified
|= sra_modify_expr (t
, &gsi
, false);
4423 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); i
++)
4425 t
= &TREE_VALUE (gimple_asm_output_op (asm_stmt
, i
));
4426 modified
|= sra_modify_expr (t
, &gsi
, true);
4438 if (maybe_clean_eh_stmt (stmt
)
4439 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
4447 gsi_commit_edge_inserts ();
4451 /* Generate statements initializing scalar replacements of parts of function
4455 initialize_parameter_reductions (void)
4457 gimple_stmt_iterator gsi
;
4458 gimple_seq seq
= NULL
;
4461 gsi
= gsi_start (seq
);
4462 for (parm
= DECL_ARGUMENTS (current_function_decl
);
4464 parm
= DECL_CHAIN (parm
))
4466 vec
<access_p
> *access_vec
;
4467 struct access
*access
;
4469 if (!bitmap_bit_p (candidate_bitmap
, DECL_UID (parm
)))
4471 access_vec
= get_base_access_vector (parm
);
4475 for (access
= (*access_vec
)[0];
4477 access
= access
->next_grp
)
4478 generate_subtree_copies (access
, parm
, 0, 0, 0, &gsi
, true, true,
4479 EXPR_LOCATION (parm
));
4482 seq
= gsi_seq (gsi
);
4484 gsi_insert_seq_on_edge_immediate (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)), seq
);
4487 /* The "main" function of intraprocedural SRA passes. Runs the analysis and if
4488 it reveals there are components of some aggregates to be scalarized, it runs
4489 the required transformations. */
4491 perform_intra_sra (void)
4496 if (!find_var_candidates ())
4499 if (!scan_function ())
4502 if (!analyze_all_variable_accesses ())
4505 if (sra_modify_function_body ())
4506 ret
= TODO_update_ssa
| TODO_cleanup_cfg
;
4508 ret
= TODO_update_ssa
;
4509 initialize_parameter_reductions ();
4511 statistics_counter_event (cfun
, "Scalar replacements created",
4512 sra_stats
.replacements
);
4513 statistics_counter_event (cfun
, "Modified expressions", sra_stats
.exprs
);
4514 statistics_counter_event (cfun
, "Subtree copy stmts",
4515 sra_stats
.subtree_copies
);
4516 statistics_counter_event (cfun
, "Subreplacement stmts",
4517 sra_stats
.subreplacements
);
4518 statistics_counter_event (cfun
, "Deleted stmts", sra_stats
.deleted
);
4519 statistics_counter_event (cfun
, "Separate LHS and RHS handling",
4520 sra_stats
.separate_lhs_rhs_handling
);
4523 sra_deinitialize ();
4527 /* Perform early intraprocedural SRA. */
4529 early_intra_sra (void)
4531 sra_mode
= SRA_MODE_EARLY_INTRA
;
4532 return perform_intra_sra ();
4535 /* Perform "late" intraprocedural SRA. */
4537 late_intra_sra (void)
4539 sra_mode
= SRA_MODE_INTRA
;
4540 return perform_intra_sra ();
4545 gate_intra_sra (void)
4547 return flag_tree_sra
!= 0 && dbg_cnt (tree_sra
);
4553 const pass_data pass_data_sra_early
=
4555 GIMPLE_PASS
, /* type */
4557 OPTGROUP_NONE
, /* optinfo_flags */
4558 TV_TREE_SRA
, /* tv_id */
4559 ( PROP_cfg
| PROP_ssa
), /* properties_required */
4560 0, /* properties_provided */
4561 0, /* properties_destroyed */
4562 0, /* todo_flags_start */
4563 TODO_update_ssa
, /* todo_flags_finish */
4566 class pass_sra_early
: public gimple_opt_pass
4569 pass_sra_early (gcc::context
*ctxt
)
4570 : gimple_opt_pass (pass_data_sra_early
, ctxt
)
4573 /* opt_pass methods: */
4574 virtual bool gate (function
*) { return gate_intra_sra (); }
4575 virtual unsigned int execute (function
*) { return early_intra_sra (); }
4577 }; // class pass_sra_early
4582 make_pass_sra_early (gcc::context
*ctxt
)
4584 return new pass_sra_early (ctxt
);
4589 const pass_data pass_data_sra
=
4591 GIMPLE_PASS
, /* type */
4593 OPTGROUP_NONE
, /* optinfo_flags */
4594 TV_TREE_SRA
, /* tv_id */
4595 ( PROP_cfg
| PROP_ssa
), /* properties_required */
4596 0, /* properties_provided */
4597 0, /* properties_destroyed */
4598 TODO_update_address_taken
, /* todo_flags_start */
4599 TODO_update_ssa
, /* todo_flags_finish */
4602 class pass_sra
: public gimple_opt_pass
4605 pass_sra (gcc::context
*ctxt
)
4606 : gimple_opt_pass (pass_data_sra
, ctxt
)
4609 /* opt_pass methods: */
4610 virtual bool gate (function
*) { return gate_intra_sra (); }
4611 virtual unsigned int execute (function
*) { return late_intra_sra (); }
4613 }; // class pass_sra
4618 make_pass_sra (gcc::context
*ctxt
)
4620 return new pass_sra (ctxt
);