1 /* Scalar Replacement of Aggregates (SRA) converts some structure
2 references into scalar references, exposing them to the scalar
4 Copyright (C) 2008, 2009, 2010 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"
77 #include "alloc-pool.h"
82 #include "tree-flow.h"
84 #include "tree-pretty-print.h"
85 #include "statistics.h"
86 #include "tree-dump.h"
92 #include "tree-inline.h"
94 /* Enumeration of all aggregate reductions we can do. */
95 enum sra_mode
{ SRA_MODE_EARLY_IPA
, /* early call regularization */
96 SRA_MODE_EARLY_INTRA
, /* early intraprocedural SRA */
97 SRA_MODE_INTRA
}; /* late intraprocedural SRA */
99 /* Global variable describing which aggregate reduction we are performing at
101 static enum sra_mode sra_mode
;
105 /* ACCESS represents each access to an aggregate variable (as a whole or a
106 part). It can also represent a group of accesses that refer to exactly the
107 same fragment of an aggregate (i.e. those that have exactly the same offset
108 and size). Such representatives for a single aggregate, once determined,
109 are linked in a linked list and have the group fields set.
111 Moreover, when doing intraprocedural SRA, a tree is built from those
112 representatives (by the means of first_child and next_sibling pointers), in
113 which all items in a subtree are "within" the root, i.e. their offset is
114 greater or equal to offset of the root and offset+size is smaller or equal
115 to offset+size of the root. Children of an access are sorted by offset.
117 Note that accesses to parts of vector and complex number types always
118 represented by an access to the whole complex number or a vector. It is a
119 duty of the modifying functions to replace them appropriately. */
123 /* Values returned by `get_ref_base_and_extent' for each component reference
124 If EXPR isn't a component reference just set `BASE = EXPR', `OFFSET = 0',
125 `SIZE = TREE_SIZE (TREE_TYPE (expr))'. */
126 HOST_WIDE_INT offset
;
130 /* Expression. It is context dependent so do not use it to create new
131 expressions to access the original aggregate. See PR 42154 for a
137 /* The statement this access belongs to. */
140 /* Next group representative for this aggregate. */
141 struct access
*next_grp
;
143 /* Pointer to the group representative. Pointer to itself if the struct is
144 the representative. */
145 struct access
*group_representative
;
147 /* If this access has any children (in terms of the definition above), this
148 points to the first one. */
149 struct access
*first_child
;
151 /* In intraprocedural SRA, pointer to the next sibling in the access tree as
152 described above. In IPA-SRA this is a pointer to the next access
153 belonging to the same group (having the same representative). */
154 struct access
*next_sibling
;
156 /* Pointers to the first and last element in the linked list of assign
158 struct assign_link
*first_link
, *last_link
;
160 /* Pointer to the next access in the work queue. */
161 struct access
*next_queued
;
163 /* Replacement variable for this access "region." Never to be accessed
164 directly, always only by the means of get_access_replacement() and only
165 when grp_to_be_replaced flag is set. */
166 tree replacement_decl
;
168 /* Is this particular access write access? */
171 /* Is this access an artificial one created to scalarize some record
173 unsigned total_scalarization
: 1;
175 /* Is this access currently in the work queue? */
176 unsigned grp_queued
: 1;
178 /* Does this group contain a write access? This flag is propagated down the
180 unsigned grp_write
: 1;
182 /* Does this group contain a read access? This flag is propagated down the
184 unsigned grp_read
: 1;
186 /* Does this group contain a read access that comes from an assignment
187 statement? This flag is propagated down the access tree. */
188 unsigned grp_assignment_read
: 1;
190 /* Other passes of the analysis use this bit to make function
191 analyze_access_subtree create scalar replacements for this group if
193 unsigned grp_hint
: 1;
195 /* Is the subtree rooted in this access fully covered by scalar
197 unsigned grp_covered
: 1;
199 /* If set to true, this access and all below it in an access tree must not be
201 unsigned grp_unscalarizable_region
: 1;
203 /* Whether data have been written to parts of the aggregate covered by this
204 access which is not to be scalarized. This flag is propagated up in the
206 unsigned grp_unscalarized_data
: 1;
208 /* Does this access and/or group contain a write access through a
210 unsigned grp_partial_lhs
: 1;
212 /* Set when a scalar replacement should be created for this variable. We do
213 the decision and creation at different places because create_tmp_var
214 cannot be called from within FOR_EACH_REFERENCED_VAR. */
215 unsigned grp_to_be_replaced
: 1;
217 /* Is it possible that the group refers to data which might be (directly or
218 otherwise) modified? */
219 unsigned grp_maybe_modified
: 1;
221 /* Set when this is a representative of a pointer to scalar (i.e. by
222 reference) parameter which we consider for turning into a plain scalar
223 (i.e. a by value parameter). */
224 unsigned grp_scalar_ptr
: 1;
226 /* Set when we discover that this pointer is not safe to dereference in the
228 unsigned grp_not_necessarilly_dereferenced
: 1;
231 typedef struct access
*access_p
;
233 DEF_VEC_P (access_p
);
234 DEF_VEC_ALLOC_P (access_p
, heap
);
236 /* Alloc pool for allocating access structures. */
237 static alloc_pool access_pool
;
239 /* A structure linking lhs and rhs accesses from an aggregate assignment. They
240 are used to propagate subaccesses from rhs to lhs as long as they don't
241 conflict with what is already there. */
244 struct access
*lacc
, *racc
;
245 struct assign_link
*next
;
248 /* Alloc pool for allocating assign link structures. */
249 static alloc_pool link_pool
;
251 /* Base (tree) -> Vector (VEC(access_p,heap) *) map. */
252 static struct pointer_map_t
*base_access_vec
;
254 /* Bitmap of candidates. */
255 static bitmap candidate_bitmap
;
257 /* Bitmap of candidates which we should try to entirely scalarize away and
258 those which cannot be (because they are and need be used as a whole). */
259 static bitmap should_scalarize_away_bitmap
, cannot_scalarize_away_bitmap
;
261 /* Obstack for creation of fancy names. */
262 static struct obstack name_obstack
;
264 /* Head of a linked list of accesses that need to have its subaccesses
265 propagated to their assignment counterparts. */
266 static struct access
*work_queue_head
;
268 /* Number of parameters of the analyzed function when doing early ipa SRA. */
269 static int func_param_count
;
271 /* scan_function sets the following to true if it encounters a call to
272 __builtin_apply_args. */
273 static bool encountered_apply_args
;
275 /* Set by scan_function when it finds a recursive call. */
276 static bool encountered_recursive_call
;
278 /* Set by scan_function when it finds a recursive call with less actual
279 arguments than formal parameters.. */
280 static bool encountered_unchangable_recursive_call
;
282 /* This is a table in which for each basic block and parameter there is a
283 distance (offset + size) in that parameter which is dereferenced and
284 accessed in that BB. */
285 static HOST_WIDE_INT
*bb_dereferences
;
286 /* Bitmap of BBs that can cause the function to "stop" progressing by
287 returning, throwing externally, looping infinitely or calling a function
288 which might abort etc.. */
289 static bitmap final_bbs
;
291 /* Representative of no accesses at all. */
292 static struct access no_accesses_representant
;
294 /* Predicate to test the special value. */
297 no_accesses_p (struct access
*access
)
299 return access
== &no_accesses_representant
;
302 /* Dump contents of ACCESS to file F in a human friendly way. If GRP is true,
303 representative fields are dumped, otherwise those which only describe the
304 individual access are. */
308 /* Number of processed aggregates is readily available in
309 analyze_all_variable_accesses and so is not stored here. */
311 /* Number of created scalar replacements. */
314 /* Number of times sra_modify_expr or sra_modify_assign themselves changed an
318 /* Number of statements created by generate_subtree_copies. */
321 /* Number of statements created by load_assign_lhs_subreplacements. */
324 /* Number of times sra_modify_assign has deleted a statement. */
327 /* Number of times sra_modify_assign has to deal with subaccesses of LHS and
328 RHS reparately due to type conversions or nonexistent matching
330 int separate_lhs_rhs_handling
;
332 /* Number of parameters that were removed because they were unused. */
333 int deleted_unused_parameters
;
335 /* Number of scalars passed as parameters by reference that have been
336 converted to be passed by value. */
337 int scalar_by_ref_to_by_val
;
339 /* Number of aggregate parameters that were replaced by one or more of their
341 int aggregate_params_reduced
;
343 /* Numbber of components created when splitting aggregate parameters. */
344 int param_reductions_created
;
348 dump_access (FILE *f
, struct access
*access
, bool grp
)
350 fprintf (f
, "access { ");
351 fprintf (f
, "base = (%d)'", DECL_UID (access
->base
));
352 print_generic_expr (f
, access
->base
, 0);
353 fprintf (f
, "', offset = " HOST_WIDE_INT_PRINT_DEC
, access
->offset
);
354 fprintf (f
, ", size = " HOST_WIDE_INT_PRINT_DEC
, access
->size
);
355 fprintf (f
, ", expr = ");
356 print_generic_expr (f
, access
->expr
, 0);
357 fprintf (f
, ", type = ");
358 print_generic_expr (f
, access
->type
, 0);
360 fprintf (f
, ", grp_write = %d, total_scalarization = %d, "
361 "grp_read = %d, grp_hint = %d, grp_assignment_read = %d,"
362 "grp_covered = %d, grp_unscalarizable_region = %d, "
363 "grp_unscalarized_data = %d, grp_partial_lhs = %d, "
364 "grp_to_be_replaced = %d, grp_maybe_modified = %d, "
365 "grp_not_necessarilly_dereferenced = %d\n",
366 access
->grp_write
, access
->total_scalarization
,
367 access
->grp_read
, access
->grp_hint
, access
->grp_assignment_read
,
368 access
->grp_covered
, access
->grp_unscalarizable_region
,
369 access
->grp_unscalarized_data
, access
->grp_partial_lhs
,
370 access
->grp_to_be_replaced
, access
->grp_maybe_modified
,
371 access
->grp_not_necessarilly_dereferenced
);
373 fprintf (f
, ", write = %d, total_scalarization = %d, "
374 "grp_partial_lhs = %d\n",
375 access
->write
, access
->total_scalarization
,
376 access
->grp_partial_lhs
);
379 /* Dump a subtree rooted in ACCESS to file F, indent by LEVEL. */
382 dump_access_tree_1 (FILE *f
, struct access
*access
, int level
)
388 for (i
= 0; i
< level
; i
++)
389 fputs ("* ", dump_file
);
391 dump_access (f
, access
, true);
393 if (access
->first_child
)
394 dump_access_tree_1 (f
, access
->first_child
, level
+ 1);
396 access
= access
->next_sibling
;
401 /* Dump all access trees for a variable, given the pointer to the first root in
405 dump_access_tree (FILE *f
, struct access
*access
)
407 for (; access
; access
= access
->next_grp
)
408 dump_access_tree_1 (f
, access
, 0);
411 /* Return true iff ACC is non-NULL and has subaccesses. */
414 access_has_children_p (struct access
*acc
)
416 return acc
&& acc
->first_child
;
419 /* Return a vector of pointers to accesses for the variable given in BASE or
420 NULL if there is none. */
422 static VEC (access_p
, heap
) *
423 get_base_access_vector (tree base
)
427 slot
= pointer_map_contains (base_access_vec
, base
);
431 return *(VEC (access_p
, heap
) **) slot
;
434 /* Find an access with required OFFSET and SIZE in a subtree of accesses rooted
435 in ACCESS. Return NULL if it cannot be found. */
437 static struct access
*
438 find_access_in_subtree (struct access
*access
, HOST_WIDE_INT offset
,
441 while (access
&& (access
->offset
!= offset
|| access
->size
!= size
))
443 struct access
*child
= access
->first_child
;
445 while (child
&& (child
->offset
+ child
->size
<= offset
))
446 child
= child
->next_sibling
;
453 /* Return the first group representative for DECL or NULL if none exists. */
455 static struct access
*
456 get_first_repr_for_decl (tree base
)
458 VEC (access_p
, heap
) *access_vec
;
460 access_vec
= get_base_access_vector (base
);
464 return VEC_index (access_p
, access_vec
, 0);
467 /* Find an access representative for the variable BASE and given OFFSET and
468 SIZE. Requires that access trees have already been built. Return NULL if
469 it cannot be found. */
471 static struct access
*
472 get_var_base_offset_size_access (tree base
, HOST_WIDE_INT offset
,
475 struct access
*access
;
477 access
= get_first_repr_for_decl (base
);
478 while (access
&& (access
->offset
+ access
->size
<= offset
))
479 access
= access
->next_grp
;
483 return find_access_in_subtree (access
, offset
, size
);
486 /* Add LINK to the linked list of assign links of RACC. */
488 add_link_to_rhs (struct access
*racc
, struct assign_link
*link
)
490 gcc_assert (link
->racc
== racc
);
492 if (!racc
->first_link
)
494 gcc_assert (!racc
->last_link
);
495 racc
->first_link
= link
;
498 racc
->last_link
->next
= link
;
500 racc
->last_link
= link
;
504 /* Move all link structures in their linked list in OLD_RACC to the linked list
507 relink_to_new_repr (struct access
*new_racc
, struct access
*old_racc
)
509 if (!old_racc
->first_link
)
511 gcc_assert (!old_racc
->last_link
);
515 if (new_racc
->first_link
)
517 gcc_assert (!new_racc
->last_link
->next
);
518 gcc_assert (!old_racc
->last_link
|| !old_racc
->last_link
->next
);
520 new_racc
->last_link
->next
= old_racc
->first_link
;
521 new_racc
->last_link
= old_racc
->last_link
;
525 gcc_assert (!new_racc
->last_link
);
527 new_racc
->first_link
= old_racc
->first_link
;
528 new_racc
->last_link
= old_racc
->last_link
;
530 old_racc
->first_link
= old_racc
->last_link
= NULL
;
533 /* Add ACCESS to the work queue (which is actually a stack). */
536 add_access_to_work_queue (struct access
*access
)
538 if (!access
->grp_queued
)
540 gcc_assert (!access
->next_queued
);
541 access
->next_queued
= work_queue_head
;
542 access
->grp_queued
= 1;
543 work_queue_head
= access
;
547 /* Pop an access from the work queue, and return it, assuming there is one. */
549 static struct access
*
550 pop_access_from_work_queue (void)
552 struct access
*access
= work_queue_head
;
554 work_queue_head
= access
->next_queued
;
555 access
->next_queued
= NULL
;
556 access
->grp_queued
= 0;
561 /* Allocate necessary structures. */
564 sra_initialize (void)
566 candidate_bitmap
= BITMAP_ALLOC (NULL
);
567 should_scalarize_away_bitmap
= BITMAP_ALLOC (NULL
);
568 cannot_scalarize_away_bitmap
= BITMAP_ALLOC (NULL
);
569 gcc_obstack_init (&name_obstack
);
570 access_pool
= create_alloc_pool ("SRA accesses", sizeof (struct access
), 16);
571 link_pool
= create_alloc_pool ("SRA links", sizeof (struct assign_link
), 16);
572 base_access_vec
= pointer_map_create ();
573 memset (&sra_stats
, 0, sizeof (sra_stats
));
574 encountered_apply_args
= false;
575 encountered_recursive_call
= false;
576 encountered_unchangable_recursive_call
= false;
579 /* Hook fed to pointer_map_traverse, deallocate stored vectors. */
582 delete_base_accesses (const void *key ATTRIBUTE_UNUSED
, void **value
,
583 void *data ATTRIBUTE_UNUSED
)
585 VEC (access_p
, heap
) *access_vec
;
586 access_vec
= (VEC (access_p
, heap
) *) *value
;
587 VEC_free (access_p
, heap
, access_vec
);
592 /* Deallocate all general structures. */
595 sra_deinitialize (void)
597 BITMAP_FREE (candidate_bitmap
);
598 BITMAP_FREE (should_scalarize_away_bitmap
);
599 BITMAP_FREE (cannot_scalarize_away_bitmap
);
600 free_alloc_pool (access_pool
);
601 free_alloc_pool (link_pool
);
602 obstack_free (&name_obstack
, NULL
);
604 pointer_map_traverse (base_access_vec
, delete_base_accesses
, NULL
);
605 pointer_map_destroy (base_access_vec
);
608 /* Remove DECL from candidates for SRA and write REASON to the dump file if
611 disqualify_candidate (tree decl
, const char *reason
)
613 bitmap_clear_bit (candidate_bitmap
, DECL_UID (decl
));
615 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
617 fprintf (dump_file
, "! Disqualifying ");
618 print_generic_expr (dump_file
, decl
, 0);
619 fprintf (dump_file
, " - %s\n", reason
);
623 /* Return true iff the type contains a field or an element which does not allow
627 type_internals_preclude_sra_p (tree type
)
632 switch (TREE_CODE (type
))
636 case QUAL_UNION_TYPE
:
637 for (fld
= TYPE_FIELDS (type
); fld
; fld
= TREE_CHAIN (fld
))
638 if (TREE_CODE (fld
) == FIELD_DECL
)
640 tree ft
= TREE_TYPE (fld
);
642 if (TREE_THIS_VOLATILE (fld
)
643 || !DECL_FIELD_OFFSET (fld
) || !DECL_SIZE (fld
)
644 || !host_integerp (DECL_FIELD_OFFSET (fld
), 1)
645 || !host_integerp (DECL_SIZE (fld
), 1))
648 if (AGGREGATE_TYPE_P (ft
)
649 && type_internals_preclude_sra_p (ft
))
656 et
= TREE_TYPE (type
);
658 if (AGGREGATE_TYPE_P (et
))
659 return type_internals_preclude_sra_p (et
);
668 /* If T is an SSA_NAME, return NULL if it is not a default def or return its
669 base variable if it is. Return T if it is not an SSA_NAME. */
672 get_ssa_base_param (tree t
)
674 if (TREE_CODE (t
) == SSA_NAME
)
676 if (SSA_NAME_IS_DEFAULT_DEF (t
))
677 return SSA_NAME_VAR (t
);
684 /* Mark a dereference of BASE of distance DIST in a basic block tht STMT
685 belongs to, unless the BB has already been marked as a potentially
689 mark_parm_dereference (tree base
, HOST_WIDE_INT dist
, gimple stmt
)
691 basic_block bb
= gimple_bb (stmt
);
692 int idx
, parm_index
= 0;
695 if (bitmap_bit_p (final_bbs
, bb
->index
))
698 for (parm
= DECL_ARGUMENTS (current_function_decl
);
699 parm
&& parm
!= base
;
700 parm
= TREE_CHAIN (parm
))
703 gcc_assert (parm_index
< func_param_count
);
705 idx
= bb
->index
* func_param_count
+ parm_index
;
706 if (bb_dereferences
[idx
] < dist
)
707 bb_dereferences
[idx
] = dist
;
710 /* Allocate an access structure for BASE, OFFSET and SIZE, clear it, fill in
711 the three fields. Also add it to the vector of accesses corresponding to
712 the base. Finally, return the new access. */
714 static struct access
*
715 create_access_1 (tree base
, HOST_WIDE_INT offset
, HOST_WIDE_INT size
)
717 VEC (access_p
, heap
) *vec
;
718 struct access
*access
;
721 access
= (struct access
*) pool_alloc (access_pool
);
722 memset (access
, 0, sizeof (struct access
));
724 access
->offset
= offset
;
727 slot
= pointer_map_contains (base_access_vec
, base
);
729 vec
= (VEC (access_p
, heap
) *) *slot
;
731 vec
= VEC_alloc (access_p
, heap
, 32);
733 VEC_safe_push (access_p
, heap
, vec
, access
);
735 *((struct VEC (access_p
,heap
) **)
736 pointer_map_insert (base_access_vec
, base
)) = vec
;
741 /* Create and insert access for EXPR. Return created access, or NULL if it is
744 static struct access
*
745 create_access (tree expr
, gimple stmt
, bool write
)
747 struct access
*access
;
748 HOST_WIDE_INT offset
, size
, max_size
;
750 bool ptr
, unscalarizable_region
= false;
752 base
= get_ref_base_and_extent (expr
, &offset
, &size
, &max_size
);
754 if (sra_mode
== SRA_MODE_EARLY_IPA
&& INDIRECT_REF_P (base
))
756 base
= get_ssa_base_param (TREE_OPERAND (base
, 0));
764 if (!DECL_P (base
) || !bitmap_bit_p (candidate_bitmap
, DECL_UID (base
)))
767 if (sra_mode
== SRA_MODE_EARLY_IPA
)
769 if (size
< 0 || size
!= max_size
)
771 disqualify_candidate (base
, "Encountered a variable sized access.");
774 if ((offset
% BITS_PER_UNIT
) != 0 || (size
% BITS_PER_UNIT
) != 0)
776 disqualify_candidate (base
,
777 "Encountered an acces not aligned to a byte.");
782 mark_parm_dereference (base
, offset
+ size
, stmt
);
786 if (size
!= max_size
)
789 unscalarizable_region
= true;
793 disqualify_candidate (base
, "Encountered an unconstrained access.");
798 access
= create_access_1 (base
, offset
, size
);
800 access
->type
= TREE_TYPE (expr
);
801 access
->write
= write
;
802 access
->grp_unscalarizable_region
= unscalarizable_region
;
809 /* Return true iff TYPE is a RECORD_TYPE with fields that are either of gimple
810 register types or (recursively) records with only these two kinds of fields.
811 It also returns false if any of these records has a zero-size field as its
815 type_consists_of_records_p (tree type
)
818 bool last_fld_has_zero_size
= false;
820 if (TREE_CODE (type
) != RECORD_TYPE
)
823 for (fld
= TYPE_FIELDS (type
); fld
; fld
= TREE_CHAIN (fld
))
824 if (TREE_CODE (fld
) == FIELD_DECL
)
826 tree ft
= TREE_TYPE (fld
);
828 if (!is_gimple_reg_type (ft
)
829 && !type_consists_of_records_p (ft
))
832 last_fld_has_zero_size
= tree_low_cst (DECL_SIZE (fld
), 1) == 0;
835 if (last_fld_has_zero_size
)
841 /* Create total_scalarization accesses for all scalar type fields in DECL that
842 must be of a RECORD_TYPE conforming to type_consists_of_records_p. BASE
843 must be the top-most VAR_DECL representing the variable, OFFSET must be the
844 offset of DECL within BASE. */
847 completely_scalarize_record (tree base
, tree decl
, HOST_WIDE_INT offset
)
849 tree fld
, decl_type
= TREE_TYPE (decl
);
851 for (fld
= TYPE_FIELDS (decl_type
); fld
; fld
= TREE_CHAIN (fld
))
852 if (TREE_CODE (fld
) == FIELD_DECL
)
854 HOST_WIDE_INT pos
= offset
+ int_bit_position (fld
);
855 tree ft
= TREE_TYPE (fld
);
857 if (is_gimple_reg_type (ft
))
859 struct access
*access
;
864 size
= tree_low_cst (DECL_SIZE (fld
), 1);
866 ok
= build_ref_for_offset (&expr
, TREE_TYPE (base
), pos
,
870 access
= create_access_1 (base
, pos
, size
);
873 access
->total_scalarization
= 1;
874 /* Accesses for intraprocedural SRA can have their stmt NULL. */
877 completely_scalarize_record (base
, fld
, pos
);
882 /* Search the given tree for a declaration by skipping handled components and
883 exclude it from the candidates. */
886 disqualify_base_of_expr (tree t
, const char *reason
)
888 while (handled_component_p (t
))
889 t
= TREE_OPERAND (t
, 0);
891 if (sra_mode
== SRA_MODE_EARLY_IPA
)
893 if (INDIRECT_REF_P (t
))
894 t
= TREE_OPERAND (t
, 0);
895 t
= get_ssa_base_param (t
);
899 disqualify_candidate (t
, reason
);
902 /* Scan expression EXPR and create access structures for all accesses to
903 candidates for scalarization. Return the created access or NULL if none is
906 static struct access
*
907 build_access_from_expr_1 (tree expr
, gimple stmt
, bool write
)
909 struct access
*ret
= NULL
;
912 if (TREE_CODE (expr
) == BIT_FIELD_REF
913 || TREE_CODE (expr
) == IMAGPART_EXPR
914 || TREE_CODE (expr
) == REALPART_EXPR
)
916 expr
= TREE_OPERAND (expr
, 0);
922 /* We need to dive through V_C_Es in order to get the size of its parameter
923 and not the result type. Ada produces such statements. We are also
924 capable of handling the topmost V_C_E but not any of those buried in other
925 handled components. */
926 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
927 expr
= TREE_OPERAND (expr
, 0);
929 if (contains_view_convert_expr_p (expr
))
931 disqualify_base_of_expr (expr
, "V_C_E under a different handled "
936 switch (TREE_CODE (expr
))
939 if (sra_mode
!= SRA_MODE_EARLY_IPA
)
947 case ARRAY_RANGE_REF
:
948 ret
= create_access (expr
, stmt
, write
);
955 if (write
&& partial_ref
&& ret
)
956 ret
->grp_partial_lhs
= 1;
961 /* Scan expression EXPR and create access structures for all accesses to
962 candidates for scalarization. Return true if any access has been inserted.
963 STMT must be the statement from which the expression is taken, WRITE must be
964 true if the expression is a store and false otherwise. */
967 build_access_from_expr (tree expr
, gimple stmt
, bool write
)
969 struct access
*access
;
971 access
= build_access_from_expr_1 (expr
, stmt
, write
);
974 /* This means the aggregate is accesses as a whole in a way other than an
975 assign statement and thus cannot be removed even if we had a scalar
976 replacement for everything. */
977 if (cannot_scalarize_away_bitmap
)
978 bitmap_set_bit (cannot_scalarize_away_bitmap
, DECL_UID (access
->base
));
984 /* Disqualify LHS and RHS for scalarization if STMT must end its basic block in
985 modes in which it matters, return true iff they have been disqualified. RHS
986 may be NULL, in that case ignore it. If we scalarize an aggregate in
987 intra-SRA we may need to add statements after each statement. This is not
988 possible if a statement unconditionally has to end the basic block. */
990 disqualify_ops_if_throwing_stmt (gimple stmt
, tree lhs
, tree rhs
)
992 if ((sra_mode
== SRA_MODE_EARLY_INTRA
|| sra_mode
== SRA_MODE_INTRA
)
993 && (stmt_can_throw_internal (stmt
) || stmt_ends_bb_p (stmt
)))
995 disqualify_base_of_expr (lhs
, "LHS of a throwing stmt.");
997 disqualify_base_of_expr (rhs
, "RHS of a throwing stmt.");
1003 /* Scan expressions occuring in STMT, create access structures for all accesses
1004 to candidates for scalarization and remove those candidates which occur in
1005 statements or expressions that prevent them from being split apart. Return
1006 true if any access has been inserted. */
1009 build_accesses_from_assign (gimple stmt
)
1012 struct access
*lacc
, *racc
;
1014 if (!gimple_assign_single_p (stmt
))
1017 lhs
= gimple_assign_lhs (stmt
);
1018 rhs
= gimple_assign_rhs1 (stmt
);
1020 if (disqualify_ops_if_throwing_stmt (stmt
, lhs
, rhs
))
1023 racc
= build_access_from_expr_1 (rhs
, stmt
, false);
1024 lacc
= build_access_from_expr_1 (lhs
, stmt
, true);
1028 racc
->grp_assignment_read
= 1;
1029 if (should_scalarize_away_bitmap
&& !gimple_has_volatile_ops (stmt
)
1030 && !is_gimple_reg_type (racc
->type
))
1031 bitmap_set_bit (should_scalarize_away_bitmap
, DECL_UID (racc
->base
));
1035 && (sra_mode
== SRA_MODE_EARLY_INTRA
|| sra_mode
== SRA_MODE_INTRA
)
1036 && !lacc
->grp_unscalarizable_region
1037 && !racc
->grp_unscalarizable_region
1038 && AGGREGATE_TYPE_P (TREE_TYPE (lhs
))
1039 /* FIXME: Turn the following line into an assert after PR 40058 is
1041 && lacc
->size
== racc
->size
1042 && useless_type_conversion_p (lacc
->type
, racc
->type
))
1044 struct assign_link
*link
;
1046 link
= (struct assign_link
*) pool_alloc (link_pool
);
1047 memset (link
, 0, sizeof (struct assign_link
));
1052 add_link_to_rhs (racc
, link
);
1055 return lacc
|| racc
;
1058 /* Callback of walk_stmt_load_store_addr_ops visit_addr used to determine
1059 GIMPLE_ASM operands with memory constrains which cannot be scalarized. */
1062 asm_visit_addr (gimple stmt ATTRIBUTE_UNUSED
, tree op
,
1063 void *data ATTRIBUTE_UNUSED
)
1065 op
= get_base_address (op
);
1068 disqualify_candidate (op
, "Non-scalarizable GIMPLE_ASM operand.");
1073 /* Return true iff callsite CALL has at least as many actual arguments as there
1074 are formal parameters of the function currently processed by IPA-SRA. */
1077 callsite_has_enough_arguments_p (gimple call
)
1079 return gimple_call_num_args (call
) >= (unsigned) func_param_count
;
1082 /* Scan function and look for interesting expressions and create access
1083 structures for them. Return true iff any access is created. */
1086 scan_function (void)
1093 gimple_stmt_iterator gsi
;
1094 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1096 gimple stmt
= gsi_stmt (gsi
);
1100 if (final_bbs
&& stmt_can_throw_external (stmt
))
1101 bitmap_set_bit (final_bbs
, bb
->index
);
1102 switch (gimple_code (stmt
))
1105 t
= gimple_return_retval (stmt
);
1107 ret
|= build_access_from_expr (t
, stmt
, false);
1109 bitmap_set_bit (final_bbs
, bb
->index
);
1113 ret
|= build_accesses_from_assign (stmt
);
1117 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
1118 ret
|= build_access_from_expr (gimple_call_arg (stmt
, i
),
1121 if (sra_mode
== SRA_MODE_EARLY_IPA
)
1123 tree dest
= gimple_call_fndecl (stmt
);
1124 int flags
= gimple_call_flags (stmt
);
1128 if (DECL_BUILT_IN_CLASS (dest
) == BUILT_IN_NORMAL
1129 && DECL_FUNCTION_CODE (dest
) == BUILT_IN_APPLY_ARGS
)
1130 encountered_apply_args
= true;
1131 if (cgraph_get_node (dest
)
1132 == cgraph_get_node (current_function_decl
))
1134 encountered_recursive_call
= true;
1135 if (!callsite_has_enough_arguments_p (stmt
))
1136 encountered_unchangable_recursive_call
= true;
1141 && (flags
& (ECF_CONST
| ECF_PURE
)) == 0)
1142 bitmap_set_bit (final_bbs
, bb
->index
);
1145 t
= gimple_call_lhs (stmt
);
1146 if (t
&& !disqualify_ops_if_throwing_stmt (stmt
, t
, NULL
))
1147 ret
|= build_access_from_expr (t
, stmt
, true);
1151 walk_stmt_load_store_addr_ops (stmt
, NULL
, NULL
, NULL
,
1154 bitmap_set_bit (final_bbs
, bb
->index
);
1156 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
1158 t
= TREE_VALUE (gimple_asm_input_op (stmt
, i
));
1159 ret
|= build_access_from_expr (t
, stmt
, false);
1161 for (i
= 0; i
< gimple_asm_noutputs (stmt
); i
++)
1163 t
= TREE_VALUE (gimple_asm_output_op (stmt
, i
));
1164 ret
|= build_access_from_expr (t
, stmt
, true);
1177 /* Helper of QSORT function. There are pointers to accesses in the array. An
1178 access is considered smaller than another if it has smaller offset or if the
1179 offsets are the same but is size is bigger. */
1182 compare_access_positions (const void *a
, const void *b
)
1184 const access_p
*fp1
= (const access_p
*) a
;
1185 const access_p
*fp2
= (const access_p
*) b
;
1186 const access_p f1
= *fp1
;
1187 const access_p f2
= *fp2
;
1189 if (f1
->offset
!= f2
->offset
)
1190 return f1
->offset
< f2
->offset
? -1 : 1;
1192 if (f1
->size
== f2
->size
)
1194 if (f1
->type
== f2
->type
)
1196 /* Put any non-aggregate type before any aggregate type. */
1197 else if (!is_gimple_reg_type (f1
->type
)
1198 && is_gimple_reg_type (f2
->type
))
1200 else if (is_gimple_reg_type (f1
->type
)
1201 && !is_gimple_reg_type (f2
->type
))
1203 /* Put any complex or vector type before any other scalar type. */
1204 else if (TREE_CODE (f1
->type
) != COMPLEX_TYPE
1205 && TREE_CODE (f1
->type
) != VECTOR_TYPE
1206 && (TREE_CODE (f2
->type
) == COMPLEX_TYPE
1207 || TREE_CODE (f2
->type
) == VECTOR_TYPE
))
1209 else if ((TREE_CODE (f1
->type
) == COMPLEX_TYPE
1210 || TREE_CODE (f1
->type
) == VECTOR_TYPE
)
1211 && TREE_CODE (f2
->type
) != COMPLEX_TYPE
1212 && TREE_CODE (f2
->type
) != VECTOR_TYPE
)
1214 /* Put the integral type with the bigger precision first. */
1215 else if (INTEGRAL_TYPE_P (f1
->type
)
1216 && INTEGRAL_TYPE_P (f2
->type
))
1217 return TYPE_PRECISION (f2
->type
) - TYPE_PRECISION (f1
->type
);
1218 /* Put any integral type with non-full precision last. */
1219 else if (INTEGRAL_TYPE_P (f1
->type
)
1220 && (TREE_INT_CST_LOW (TYPE_SIZE (f1
->type
))
1221 != TYPE_PRECISION (f1
->type
)))
1223 else if (INTEGRAL_TYPE_P (f2
->type
)
1224 && (TREE_INT_CST_LOW (TYPE_SIZE (f2
->type
))
1225 != TYPE_PRECISION (f2
->type
)))
1227 /* Stabilize the sort. */
1228 return TYPE_UID (f1
->type
) - TYPE_UID (f2
->type
);
1231 /* We want the bigger accesses first, thus the opposite operator in the next
1233 return f1
->size
> f2
->size
? -1 : 1;
1237 /* Append a name of the declaration to the name obstack. A helper function for
1241 make_fancy_decl_name (tree decl
)
1245 tree name
= DECL_NAME (decl
);
1247 obstack_grow (&name_obstack
, IDENTIFIER_POINTER (name
),
1248 IDENTIFIER_LENGTH (name
));
1251 sprintf (buffer
, "D%u", DECL_UID (decl
));
1252 obstack_grow (&name_obstack
, buffer
, strlen (buffer
));
1256 /* Helper for make_fancy_name. */
1259 make_fancy_name_1 (tree expr
)
1266 make_fancy_decl_name (expr
);
1270 switch (TREE_CODE (expr
))
1273 make_fancy_name_1 (TREE_OPERAND (expr
, 0));
1274 obstack_1grow (&name_obstack
, '$');
1275 make_fancy_decl_name (TREE_OPERAND (expr
, 1));
1279 make_fancy_name_1 (TREE_OPERAND (expr
, 0));
1280 obstack_1grow (&name_obstack
, '$');
1281 /* Arrays with only one element may not have a constant as their
1283 index
= TREE_OPERAND (expr
, 1);
1284 if (TREE_CODE (index
) != INTEGER_CST
)
1286 sprintf (buffer
, HOST_WIDE_INT_PRINT_DEC
, TREE_INT_CST_LOW (index
));
1287 obstack_grow (&name_obstack
, buffer
, strlen (buffer
));
1294 gcc_unreachable (); /* we treat these as scalars. */
1301 /* Create a human readable name for replacement variable of ACCESS. */
1304 make_fancy_name (tree expr
)
1306 make_fancy_name_1 (expr
);
1307 obstack_1grow (&name_obstack
, '\0');
1308 return XOBFINISH (&name_obstack
, char *);
1311 /* Helper function for build_ref_for_offset. */
1314 build_ref_for_offset_1 (tree
*res
, tree type
, HOST_WIDE_INT offset
,
1320 tree tr_size
, index
, minidx
;
1321 HOST_WIDE_INT el_size
;
1323 if (offset
== 0 && exp_type
1324 && types_compatible_p (exp_type
, type
))
1327 switch (TREE_CODE (type
))
1330 case QUAL_UNION_TYPE
:
1332 for (fld
= TYPE_FIELDS (type
); fld
; fld
= TREE_CHAIN (fld
))
1334 HOST_WIDE_INT pos
, size
;
1335 tree expr
, *expr_ptr
;
1337 if (TREE_CODE (fld
) != FIELD_DECL
)
1340 pos
= int_bit_position (fld
);
1341 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
|| pos
== 0);
1342 tr_size
= DECL_SIZE (fld
);
1343 if (!tr_size
|| !host_integerp (tr_size
, 1))
1345 size
= tree_low_cst (tr_size
, 1);
1351 else if (pos
> offset
|| (pos
+ size
) <= offset
)
1356 expr
= build3 (COMPONENT_REF
, TREE_TYPE (fld
), *res
, fld
,
1362 if (build_ref_for_offset_1 (expr_ptr
, TREE_TYPE (fld
),
1363 offset
- pos
, exp_type
))
1373 tr_size
= TYPE_SIZE (TREE_TYPE (type
));
1374 if (!tr_size
|| !host_integerp (tr_size
, 1))
1376 el_size
= tree_low_cst (tr_size
, 1);
1378 minidx
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
1379 if (TREE_CODE (minidx
) != INTEGER_CST
|| el_size
== 0)
1383 index
= build_int_cst (TYPE_DOMAIN (type
), offset
/ el_size
);
1384 if (!integer_zerop (minidx
))
1385 index
= int_const_binop (PLUS_EXPR
, index
, minidx
, 0);
1386 *res
= build4 (ARRAY_REF
, TREE_TYPE (type
), *res
, index
,
1387 NULL_TREE
, NULL_TREE
);
1389 offset
= offset
% el_size
;
1390 type
= TREE_TYPE (type
);
1405 /* Construct an expression that would reference a part of aggregate *EXPR of
1406 type TYPE at the given OFFSET of the type EXP_TYPE. If EXPR is NULL, the
1407 function only determines whether it can build such a reference without
1408 actually doing it, otherwise, the tree it points to is unshared first and
1409 then used as a base for furhter sub-references.
1411 FIXME: Eventually this should be replaced with
1412 maybe_fold_offset_to_reference() from tree-ssa-ccp.c but that requires a
1413 minor rewrite of fold_stmt.
1417 build_ref_for_offset (tree
*expr
, tree type
, HOST_WIDE_INT offset
,
1418 tree exp_type
, bool allow_ptr
)
1420 location_t loc
= expr
? EXPR_LOCATION (*expr
) : UNKNOWN_LOCATION
;
1423 *expr
= unshare_expr (*expr
);
1425 if (allow_ptr
&& POINTER_TYPE_P (type
))
1427 type
= TREE_TYPE (type
);
1429 *expr
= fold_build1_loc (loc
, INDIRECT_REF
, type
, *expr
);
1432 return build_ref_for_offset_1 (expr
, type
, offset
, exp_type
);
1435 /* Return true iff TYPE is stdarg va_list type. */
1438 is_va_list_type (tree type
)
1440 return TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (va_list_type_node
);
1443 /* The very first phase of intraprocedural SRA. It marks in candidate_bitmap
1444 those with type which is suitable for scalarization. */
1447 find_var_candidates (void)
1450 referenced_var_iterator rvi
;
1453 FOR_EACH_REFERENCED_VAR (var
, rvi
)
1455 if (TREE_CODE (var
) != VAR_DECL
&& TREE_CODE (var
) != PARM_DECL
)
1457 type
= TREE_TYPE (var
);
1459 if (!AGGREGATE_TYPE_P (type
)
1460 || needs_to_live_in_memory (var
)
1461 || TREE_THIS_VOLATILE (var
)
1462 || !COMPLETE_TYPE_P (type
)
1463 || !host_integerp (TYPE_SIZE (type
), 1)
1464 || tree_low_cst (TYPE_SIZE (type
), 1) == 0
1465 || type_internals_preclude_sra_p (type
)
1466 /* Fix for PR 41089. tree-stdarg.c needs to have va_lists intact but
1467 we also want to schedule it rather late. Thus we ignore it in
1469 || (sra_mode
== SRA_MODE_EARLY_INTRA
1470 && is_va_list_type (type
)))
1473 bitmap_set_bit (candidate_bitmap
, DECL_UID (var
));
1475 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1477 fprintf (dump_file
, "Candidate (%d): ", DECL_UID (var
));
1478 print_generic_expr (dump_file
, var
, 0);
1479 fprintf (dump_file
, "\n");
1487 /* Sort all accesses for the given variable, check for partial overlaps and
1488 return NULL if there are any. If there are none, pick a representative for
1489 each combination of offset and size and create a linked list out of them.
1490 Return the pointer to the first representative and make sure it is the first
1491 one in the vector of accesses. */
1493 static struct access
*
1494 sort_and_splice_var_accesses (tree var
)
1496 int i
, j
, access_count
;
1497 struct access
*res
, **prev_acc_ptr
= &res
;
1498 VEC (access_p
, heap
) *access_vec
;
1500 HOST_WIDE_INT low
= -1, high
= 0;
1502 access_vec
= get_base_access_vector (var
);
1505 access_count
= VEC_length (access_p
, access_vec
);
1507 /* Sort by <OFFSET, SIZE>. */
1508 qsort (VEC_address (access_p
, access_vec
), access_count
, sizeof (access_p
),
1509 compare_access_positions
);
1512 while (i
< access_count
)
1514 struct access
*access
= VEC_index (access_p
, access_vec
, i
);
1515 bool grp_write
= access
->write
;
1516 bool grp_read
= !access
->write
;
1517 bool grp_assignment_read
= access
->grp_assignment_read
;
1518 bool multiple_reads
= false;
1519 bool total_scalarization
= access
->total_scalarization
;
1520 bool grp_partial_lhs
= access
->grp_partial_lhs
;
1521 bool first_scalar
= is_gimple_reg_type (access
->type
);
1522 bool unscalarizable_region
= access
->grp_unscalarizable_region
;
1524 if (first
|| access
->offset
>= high
)
1527 low
= access
->offset
;
1528 high
= access
->offset
+ access
->size
;
1530 else if (access
->offset
> low
&& access
->offset
+ access
->size
> high
)
1533 gcc_assert (access
->offset
>= low
1534 && access
->offset
+ access
->size
<= high
);
1537 while (j
< access_count
)
1539 struct access
*ac2
= VEC_index (access_p
, access_vec
, j
);
1540 if (ac2
->offset
!= access
->offset
|| ac2
->size
!= access
->size
)
1547 multiple_reads
= true;
1551 grp_assignment_read
|= ac2
->grp_assignment_read
;
1552 grp_partial_lhs
|= ac2
->grp_partial_lhs
;
1553 unscalarizable_region
|= ac2
->grp_unscalarizable_region
;
1554 total_scalarization
|= ac2
->total_scalarization
;
1555 relink_to_new_repr (access
, ac2
);
1557 /* If there are both aggregate-type and scalar-type accesses with
1558 this combination of size and offset, the comparison function
1559 should have put the scalars first. */
1560 gcc_assert (first_scalar
|| !is_gimple_reg_type (ac2
->type
));
1561 ac2
->group_representative
= access
;
1567 access
->group_representative
= access
;
1568 access
->grp_write
= grp_write
;
1569 access
->grp_read
= grp_read
;
1570 access
->grp_assignment_read
= grp_assignment_read
;
1571 access
->grp_hint
= multiple_reads
|| total_scalarization
;
1572 access
->grp_partial_lhs
= grp_partial_lhs
;
1573 access
->grp_unscalarizable_region
= unscalarizable_region
;
1574 if (access
->first_link
)
1575 add_access_to_work_queue (access
);
1577 *prev_acc_ptr
= access
;
1578 prev_acc_ptr
= &access
->next_grp
;
1581 gcc_assert (res
== VEC_index (access_p
, access_vec
, 0));
1585 /* Create a variable for the given ACCESS which determines the type, name and a
1586 few other properties. Return the variable declaration and store it also to
1587 ACCESS->replacement. */
1590 create_access_replacement (struct access
*access
, bool rename
)
1594 repl
= create_tmp_var (access
->type
, "SR");
1596 add_referenced_var (repl
);
1598 mark_sym_for_renaming (repl
);
1600 if (!access
->grp_partial_lhs
1601 && (TREE_CODE (access
->type
) == COMPLEX_TYPE
1602 || TREE_CODE (access
->type
) == VECTOR_TYPE
))
1603 DECL_GIMPLE_REG_P (repl
) = 1;
1605 DECL_SOURCE_LOCATION (repl
) = DECL_SOURCE_LOCATION (access
->base
);
1606 DECL_ARTIFICIAL (repl
) = 1;
1607 DECL_IGNORED_P (repl
) = DECL_IGNORED_P (access
->base
);
1609 if (DECL_NAME (access
->base
)
1610 && !DECL_IGNORED_P (access
->base
)
1611 && !DECL_ARTIFICIAL (access
->base
))
1613 char *pretty_name
= make_fancy_name (access
->expr
);
1614 tree debug_expr
= unshare_expr (access
->expr
), d
;
1616 DECL_NAME (repl
) = get_identifier (pretty_name
);
1617 obstack_free (&name_obstack
, pretty_name
);
1619 /* Get rid of any SSA_NAMEs embedded in debug_expr,
1620 as DECL_DEBUG_EXPR isn't considered when looking for still
1621 used SSA_NAMEs and thus they could be freed. All debug info
1622 generation cares is whether something is constant or variable
1623 and that get_ref_base_and_extent works properly on the
1625 for (d
= debug_expr
; handled_component_p (d
); d
= TREE_OPERAND (d
, 0))
1626 switch (TREE_CODE (d
))
1629 case ARRAY_RANGE_REF
:
1630 if (TREE_OPERAND (d
, 1)
1631 && TREE_CODE (TREE_OPERAND (d
, 1)) == SSA_NAME
)
1632 TREE_OPERAND (d
, 1) = SSA_NAME_VAR (TREE_OPERAND (d
, 1));
1633 if (TREE_OPERAND (d
, 3)
1634 && TREE_CODE (TREE_OPERAND (d
, 3)) == SSA_NAME
)
1635 TREE_OPERAND (d
, 3) = SSA_NAME_VAR (TREE_OPERAND (d
, 3));
1638 if (TREE_OPERAND (d
, 2)
1639 && TREE_CODE (TREE_OPERAND (d
, 2)) == SSA_NAME
)
1640 TREE_OPERAND (d
, 2) = SSA_NAME_VAR (TREE_OPERAND (d
, 2));
1645 SET_DECL_DEBUG_EXPR (repl
, debug_expr
);
1646 DECL_DEBUG_EXPR_IS_FROM (repl
) = 1;
1647 TREE_NO_WARNING (repl
) = TREE_NO_WARNING (access
->base
);
1650 TREE_NO_WARNING (repl
) = 1;
1654 fprintf (dump_file
, "Created a replacement for ");
1655 print_generic_expr (dump_file
, access
->base
, 0);
1656 fprintf (dump_file
, " offset: %u, size: %u: ",
1657 (unsigned) access
->offset
, (unsigned) access
->size
);
1658 print_generic_expr (dump_file
, repl
, 0);
1659 fprintf (dump_file
, "\n");
1661 sra_stats
.replacements
++;
1666 /* Return ACCESS scalar replacement, create it if it does not exist yet. */
1669 get_access_replacement (struct access
*access
)
1671 gcc_assert (access
->grp_to_be_replaced
);
1673 if (!access
->replacement_decl
)
1674 access
->replacement_decl
= create_access_replacement (access
, true);
1675 return access
->replacement_decl
;
1678 /* Return ACCESS scalar replacement, create it if it does not exist yet but do
1679 not mark it for renaming. */
1682 get_unrenamed_access_replacement (struct access
*access
)
1684 gcc_assert (!access
->grp_to_be_replaced
);
1686 if (!access
->replacement_decl
)
1687 access
->replacement_decl
= create_access_replacement (access
, false);
1688 return access
->replacement_decl
;
1692 /* Build a subtree of accesses rooted in *ACCESS, and move the pointer in the
1693 linked list along the way. Stop when *ACCESS is NULL or the access pointed
1694 to it is not "within" the root. Return false iff some accesses partially
1698 build_access_subtree (struct access
**access
)
1700 struct access
*root
= *access
, *last_child
= NULL
;
1701 HOST_WIDE_INT limit
= root
->offset
+ root
->size
;
1703 *access
= (*access
)->next_grp
;
1704 while (*access
&& (*access
)->offset
+ (*access
)->size
<= limit
)
1707 root
->first_child
= *access
;
1709 last_child
->next_sibling
= *access
;
1710 last_child
= *access
;
1712 if (!build_access_subtree (access
))
1716 if (*access
&& (*access
)->offset
< limit
)
1722 /* Build a tree of access representatives, ACCESS is the pointer to the first
1723 one, others are linked in a list by the next_grp field. Return false iff
1724 some accesses partially overlap. */
1727 build_access_trees (struct access
*access
)
1731 struct access
*root
= access
;
1733 if (!build_access_subtree (&access
))
1735 root
->next_grp
= access
;
1740 /* Return true if expr contains some ARRAY_REFs into a variable bounded
1744 expr_with_var_bounded_array_refs_p (tree expr
)
1746 while (handled_component_p (expr
))
1748 if (TREE_CODE (expr
) == ARRAY_REF
1749 && !host_integerp (array_ref_low_bound (expr
), 0))
1751 expr
= TREE_OPERAND (expr
, 0);
1756 enum mark_read_status
{ SRA_MR_NOT_READ
, SRA_MR_READ
, SRA_MR_ASSIGN_READ
};
1758 /* Analyze the subtree of accesses rooted in ROOT, scheduling replacements when
1759 both seeming beneficial and when ALLOW_REPLACEMENTS allows it. Also set all
1760 sorts of access flags appropriately along the way, notably always set
1761 grp_read and grp_assign_read according to MARK_READ and grp_write when
1762 MARK_WRITE is true. */
1765 analyze_access_subtree (struct access
*root
, bool allow_replacements
,
1766 enum mark_read_status mark_read
, bool mark_write
)
1768 struct access
*child
;
1769 HOST_WIDE_INT limit
= root
->offset
+ root
->size
;
1770 HOST_WIDE_INT covered_to
= root
->offset
;
1771 bool scalar
= is_gimple_reg_type (root
->type
);
1772 bool hole
= false, sth_created
= false;
1773 bool direct_read
= root
->grp_read
;
1775 if (mark_read
== SRA_MR_ASSIGN_READ
)
1778 root
->grp_assignment_read
= 1;
1780 if (mark_read
== SRA_MR_READ
)
1782 else if (root
->grp_assignment_read
)
1783 mark_read
= SRA_MR_ASSIGN_READ
;
1784 else if (root
->grp_read
)
1785 mark_read
= SRA_MR_READ
;
1788 root
->grp_write
= true;
1789 else if (root
->grp_write
)
1792 if (root
->grp_unscalarizable_region
)
1793 allow_replacements
= false;
1795 if (allow_replacements
&& expr_with_var_bounded_array_refs_p (root
->expr
))
1796 allow_replacements
= false;
1798 for (child
= root
->first_child
; child
; child
= child
->next_sibling
)
1800 if (!hole
&& child
->offset
< covered_to
)
1803 covered_to
+= child
->size
;
1805 sth_created
|= analyze_access_subtree (child
,
1806 allow_replacements
&& !scalar
,
1807 mark_read
, mark_write
);
1809 root
->grp_unscalarized_data
|= child
->grp_unscalarized_data
;
1810 hole
|= !child
->grp_covered
;
1813 if (allow_replacements
&& scalar
&& !root
->first_child
1815 || (root
->grp_write
&& (direct_read
|| root
->grp_assignment_read
)))
1816 /* We must not ICE later on when trying to build an access to the
1817 original data within the aggregate even when it is impossible to do in
1818 a defined way like in the PR 42703 testcase. Therefore we check
1819 pre-emptively here that we will be able to do that. */
1820 && build_ref_for_offset (NULL
, TREE_TYPE (root
->base
), root
->offset
,
1823 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1825 fprintf (dump_file
, "Marking ");
1826 print_generic_expr (dump_file
, root
->base
, 0);
1827 fprintf (dump_file
, " offset: %u, size: %u: ",
1828 (unsigned) root
->offset
, (unsigned) root
->size
);
1829 fprintf (dump_file
, " to be replaced.\n");
1832 root
->grp_to_be_replaced
= 1;
1836 else if (covered_to
< limit
)
1839 if (sth_created
&& !hole
)
1841 root
->grp_covered
= 1;
1844 if (root
->grp_write
|| TREE_CODE (root
->base
) == PARM_DECL
)
1845 root
->grp_unscalarized_data
= 1; /* not covered and written to */
1851 /* Analyze all access trees linked by next_grp by the means of
1852 analyze_access_subtree. */
1854 analyze_access_trees (struct access
*access
)
1860 if (analyze_access_subtree (access
, true, SRA_MR_NOT_READ
, false))
1862 access
= access
->next_grp
;
1868 /* Return true iff a potential new child of LACC at offset OFFSET and with size
1869 SIZE would conflict with an already existing one. If exactly such a child
1870 already exists in LACC, store a pointer to it in EXACT_MATCH. */
1873 child_would_conflict_in_lacc (struct access
*lacc
, HOST_WIDE_INT norm_offset
,
1874 HOST_WIDE_INT size
, struct access
**exact_match
)
1876 struct access
*child
;
1878 for (child
= lacc
->first_child
; child
; child
= child
->next_sibling
)
1880 if (child
->offset
== norm_offset
&& child
->size
== size
)
1882 *exact_match
= child
;
1886 if (child
->offset
< norm_offset
+ size
1887 && child
->offset
+ child
->size
> norm_offset
)
1894 /* Create a new child access of PARENT, with all properties just like MODEL
1895 except for its offset and with its grp_write false and grp_read true.
1896 Return the new access or NULL if it cannot be created. Note that this access
1897 is created long after all splicing and sorting, it's not located in any
1898 access vector and is automatically a representative of its group. */
1900 static struct access
*
1901 create_artificial_child_access (struct access
*parent
, struct access
*model
,
1902 HOST_WIDE_INT new_offset
)
1904 struct access
*access
;
1905 struct access
**child
;
1906 tree expr
= parent
->base
;;
1908 gcc_assert (!model
->grp_unscalarizable_region
);
1910 if (!build_ref_for_offset (&expr
, TREE_TYPE (expr
), new_offset
,
1911 model
->type
, false))
1914 access
= (struct access
*) pool_alloc (access_pool
);
1915 memset (access
, 0, sizeof (struct access
));
1916 access
->base
= parent
->base
;
1917 access
->expr
= expr
;
1918 access
->offset
= new_offset
;
1919 access
->size
= model
->size
;
1920 access
->type
= model
->type
;
1921 access
->grp_write
= true;
1922 access
->grp_read
= false;
1924 child
= &parent
->first_child
;
1925 while (*child
&& (*child
)->offset
< new_offset
)
1926 child
= &(*child
)->next_sibling
;
1928 access
->next_sibling
= *child
;
1935 /* Propagate all subaccesses of RACC across an assignment link to LACC. Return
1936 true if any new subaccess was created. Additionally, if RACC is a scalar
1937 access but LACC is not, change the type of the latter, if possible. */
1940 propagate_subaccesses_across_link (struct access
*lacc
, struct access
*racc
)
1942 struct access
*rchild
;
1943 HOST_WIDE_INT norm_delta
= lacc
->offset
- racc
->offset
;
1946 if (is_gimple_reg_type (lacc
->type
)
1947 || lacc
->grp_unscalarizable_region
1948 || racc
->grp_unscalarizable_region
)
1951 if (!lacc
->first_child
&& !racc
->first_child
1952 && is_gimple_reg_type (racc
->type
))
1954 tree t
= lacc
->base
;
1956 if (build_ref_for_offset (&t
, TREE_TYPE (t
), lacc
->offset
, racc
->type
,
1960 lacc
->type
= racc
->type
;
1965 for (rchild
= racc
->first_child
; rchild
; rchild
= rchild
->next_sibling
)
1967 struct access
*new_acc
= NULL
;
1968 HOST_WIDE_INT norm_offset
= rchild
->offset
+ norm_delta
;
1970 if (rchild
->grp_unscalarizable_region
)
1973 if (child_would_conflict_in_lacc (lacc
, norm_offset
, rchild
->size
,
1978 rchild
->grp_hint
= 1;
1979 new_acc
->grp_hint
|= new_acc
->grp_read
;
1980 if (rchild
->first_child
)
1981 ret
|= propagate_subaccesses_across_link (new_acc
, rchild
);
1986 /* If a (part of) a union field is on the RHS of an assignment, it can
1987 have sub-accesses which do not make sense on the LHS (PR 40351).
1988 Check that this is not the case. */
1989 if (!build_ref_for_offset (NULL
, TREE_TYPE (lacc
->base
), norm_offset
,
1990 rchild
->type
, false))
1993 rchild
->grp_hint
= 1;
1994 new_acc
= create_artificial_child_access (lacc
, rchild
, norm_offset
);
1998 if (racc
->first_child
)
1999 propagate_subaccesses_across_link (new_acc
, rchild
);
2006 /* Propagate all subaccesses across assignment links. */
2009 propagate_all_subaccesses (void)
2011 while (work_queue_head
)
2013 struct access
*racc
= pop_access_from_work_queue ();
2014 struct assign_link
*link
;
2016 gcc_assert (racc
->first_link
);
2018 for (link
= racc
->first_link
; link
; link
= link
->next
)
2020 struct access
*lacc
= link
->lacc
;
2022 if (!bitmap_bit_p (candidate_bitmap
, DECL_UID (lacc
->base
)))
2024 lacc
= lacc
->group_representative
;
2025 if (propagate_subaccesses_across_link (lacc
, racc
)
2026 && lacc
->first_link
)
2027 add_access_to_work_queue (lacc
);
2032 /* Go through all accesses collected throughout the (intraprocedural) analysis
2033 stage, exclude overlapping ones, identify representatives and build trees
2034 out of them, making decisions about scalarization on the way. Return true
2035 iff there are any to-be-scalarized variables after this stage. */
2038 analyze_all_variable_accesses (void)
2041 bitmap tmp
= BITMAP_ALLOC (NULL
);
2043 unsigned i
, max_total_scalarization_size
;
2045 max_total_scalarization_size
= UNITS_PER_WORD
* BITS_PER_UNIT
2046 * MOVE_RATIO (optimize_function_for_speed_p (cfun
));
2048 EXECUTE_IF_SET_IN_BITMAP (candidate_bitmap
, 0, i
, bi
)
2049 if (bitmap_bit_p (should_scalarize_away_bitmap
, i
)
2050 && !bitmap_bit_p (cannot_scalarize_away_bitmap
, i
))
2052 tree var
= referenced_var (i
);
2054 if (TREE_CODE (var
) == VAR_DECL
2055 && ((unsigned) tree_low_cst (TYPE_SIZE (TREE_TYPE (var
)), 1)
2056 <= max_total_scalarization_size
)
2057 && type_consists_of_records_p (TREE_TYPE (var
)))
2059 completely_scalarize_record (var
, var
, 0);
2060 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2062 fprintf (dump_file
, "Will attempt to totally scalarize ");
2063 print_generic_expr (dump_file
, var
, 0);
2064 fprintf (dump_file
, " (UID: %u): \n", DECL_UID (var
));
2069 bitmap_copy (tmp
, candidate_bitmap
);
2070 EXECUTE_IF_SET_IN_BITMAP (tmp
, 0, i
, bi
)
2072 tree var
= referenced_var (i
);
2073 struct access
*access
;
2075 access
= sort_and_splice_var_accesses (var
);
2076 if (!access
|| !build_access_trees (access
))
2077 disqualify_candidate (var
,
2078 "No or inhibitingly overlapping accesses.");
2081 propagate_all_subaccesses ();
2083 bitmap_copy (tmp
, candidate_bitmap
);
2084 EXECUTE_IF_SET_IN_BITMAP (tmp
, 0, i
, bi
)
2086 tree var
= referenced_var (i
);
2087 struct access
*access
= get_first_repr_for_decl (var
);
2089 if (analyze_access_trees (access
))
2092 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2094 fprintf (dump_file
, "\nAccess trees for ");
2095 print_generic_expr (dump_file
, var
, 0);
2096 fprintf (dump_file
, " (UID: %u): \n", DECL_UID (var
));
2097 dump_access_tree (dump_file
, access
);
2098 fprintf (dump_file
, "\n");
2102 disqualify_candidate (var
, "No scalar replacements to be created.");
2109 statistics_counter_event (cfun
, "Scalarized aggregates", res
);
2116 /* Return true iff a reference statement into aggregate AGG can be built for
2117 every single to-be-replaced accesses that is a child of ACCESS, its sibling
2118 or a child of its sibling. TOP_OFFSET is the offset from the processed
2119 access subtree that has to be subtracted from offset of each access. */
2122 ref_expr_for_all_replacements_p (struct access
*access
, tree agg
,
2123 HOST_WIDE_INT top_offset
)
2127 if (access
->grp_to_be_replaced
2128 && !build_ref_for_offset (NULL
, TREE_TYPE (agg
),
2129 access
->offset
- top_offset
,
2130 access
->type
, false))
2133 if (access
->first_child
2134 && !ref_expr_for_all_replacements_p (access
->first_child
, agg
,
2138 access
= access
->next_sibling
;
2145 /* Generate statements copying scalar replacements of accesses within a subtree
2146 into or out of AGG. ACCESS is the first child of the root of the subtree to
2147 be processed. AGG is an aggregate type expression (can be a declaration but
2148 does not have to be, it can for example also be an indirect_ref).
2149 TOP_OFFSET is the offset of the processed subtree which has to be subtracted
2150 from offsets of individual accesses to get corresponding offsets for AGG.
2151 If CHUNK_SIZE is non-null, copy only replacements in the interval
2152 <start_offset, start_offset + chunk_size>, otherwise copy all. GSI is a
2153 statement iterator used to place the new statements. WRITE should be true
2154 when the statements should write from AGG to the replacement and false if
2155 vice versa. if INSERT_AFTER is true, new statements will be added after the
2156 current statement in GSI, they will be added before the statement
2160 generate_subtree_copies (struct access
*access
, tree agg
,
2161 HOST_WIDE_INT top_offset
,
2162 HOST_WIDE_INT start_offset
, HOST_WIDE_INT chunk_size
,
2163 gimple_stmt_iterator
*gsi
, bool write
,
2170 if (chunk_size
&& access
->offset
>= start_offset
+ chunk_size
)
2173 if (access
->grp_to_be_replaced
2175 || access
->offset
+ access
->size
> start_offset
))
2177 tree repl
= get_access_replacement (access
);
2181 ref_found
= build_ref_for_offset (&expr
, TREE_TYPE (agg
),
2182 access
->offset
- top_offset
,
2183 access
->type
, false);
2184 gcc_assert (ref_found
);
2188 if (access
->grp_partial_lhs
)
2189 expr
= force_gimple_operand_gsi (gsi
, expr
, true, NULL_TREE
,
2191 insert_after
? GSI_NEW_STMT
2193 stmt
= gimple_build_assign (repl
, expr
);
2197 TREE_NO_WARNING (repl
) = 1;
2198 if (access
->grp_partial_lhs
)
2199 repl
= force_gimple_operand_gsi (gsi
, repl
, true, NULL_TREE
,
2201 insert_after
? GSI_NEW_STMT
2203 stmt
= gimple_build_assign (expr
, repl
);
2207 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
2209 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
2211 sra_stats
.subtree_copies
++;
2214 if (access
->first_child
)
2215 generate_subtree_copies (access
->first_child
, agg
, top_offset
,
2216 start_offset
, chunk_size
, gsi
,
2217 write
, insert_after
);
2219 access
= access
->next_sibling
;
2224 /* Assign zero to all scalar replacements in an access subtree. ACCESS is the
2225 the root of the subtree to be processed. GSI is the statement iterator used
2226 for inserting statements which are added after the current statement if
2227 INSERT_AFTER is true or before it otherwise. */
2230 init_subtree_with_zero (struct access
*access
, gimple_stmt_iterator
*gsi
,
2234 struct access
*child
;
2236 if (access
->grp_to_be_replaced
)
2240 stmt
= gimple_build_assign (get_access_replacement (access
),
2241 fold_convert (access
->type
,
2242 integer_zero_node
));
2244 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
2246 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
2250 for (child
= access
->first_child
; child
; child
= child
->next_sibling
)
2251 init_subtree_with_zero (child
, gsi
, insert_after
);
2254 /* Search for an access representative for the given expression EXPR and
2255 return it or NULL if it cannot be found. */
2257 static struct access
*
2258 get_access_for_expr (tree expr
)
2260 HOST_WIDE_INT offset
, size
, max_size
;
2263 /* FIXME: This should not be necessary but Ada produces V_C_Es with a type of
2264 a different size than the size of its argument and we need the latter
2266 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
2267 expr
= TREE_OPERAND (expr
, 0);
2269 base
= get_ref_base_and_extent (expr
, &offset
, &size
, &max_size
);
2270 if (max_size
== -1 || !DECL_P (base
))
2273 if (!bitmap_bit_p (candidate_bitmap
, DECL_UID (base
)))
2276 return get_var_base_offset_size_access (base
, offset
, max_size
);
2279 /* Replace the expression EXPR with a scalar replacement if there is one and
2280 generate other statements to do type conversion or subtree copying if
2281 necessary. GSI is used to place newly created statements, WRITE is true if
2282 the expression is being written to (it is on a LHS of a statement or output
2283 in an assembly statement). */
2286 sra_modify_expr (tree
*expr
, gimple_stmt_iterator
*gsi
, bool write
)
2288 struct access
*access
;
2291 if (TREE_CODE (*expr
) == BIT_FIELD_REF
)
2294 expr
= &TREE_OPERAND (*expr
, 0);
2299 if (TREE_CODE (*expr
) == REALPART_EXPR
|| TREE_CODE (*expr
) == IMAGPART_EXPR
)
2300 expr
= &TREE_OPERAND (*expr
, 0);
2301 access
= get_access_for_expr (*expr
);
2304 type
= TREE_TYPE (*expr
);
2306 if (access
->grp_to_be_replaced
)
2308 tree repl
= get_access_replacement (access
);
2309 /* If we replace a non-register typed access simply use the original
2310 access expression to extract the scalar component afterwards.
2311 This happens if scalarizing a function return value or parameter
2312 like in gcc.c-torture/execute/20041124-1.c, 20050316-1.c and
2313 gcc.c-torture/compile/20011217-1.c.
2315 We also want to use this when accessing a complex or vector which can
2316 be accessed as a different type too, potentially creating a need for
2317 type conversion (see PR42196) and when scalarized unions are involved
2318 in assembler statements (see PR42398). */
2319 if (!useless_type_conversion_p (type
, access
->type
))
2321 tree ref
= access
->base
;
2324 ok
= build_ref_for_offset (&ref
, TREE_TYPE (ref
),
2325 access
->offset
, access
->type
, false);
2332 if (access
->grp_partial_lhs
)
2333 ref
= force_gimple_operand_gsi (gsi
, ref
, true, NULL_TREE
,
2334 false, GSI_NEW_STMT
);
2335 stmt
= gimple_build_assign (repl
, ref
);
2336 gsi_insert_after (gsi
, stmt
, GSI_NEW_STMT
);
2342 if (access
->grp_partial_lhs
)
2343 repl
= force_gimple_operand_gsi (gsi
, repl
, true, NULL_TREE
,
2344 true, GSI_SAME_STMT
);
2345 stmt
= gimple_build_assign (ref
, repl
);
2346 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
2354 if (access
->first_child
)
2356 HOST_WIDE_INT start_offset
, chunk_size
;
2358 && host_integerp (TREE_OPERAND (bfr
, 1), 1)
2359 && host_integerp (TREE_OPERAND (bfr
, 2), 1))
2361 chunk_size
= tree_low_cst (TREE_OPERAND (bfr
, 1), 1);
2362 start_offset
= access
->offset
2363 + tree_low_cst (TREE_OPERAND (bfr
, 2), 1);
2366 start_offset
= chunk_size
= 0;
2368 generate_subtree_copies (access
->first_child
, access
->base
, 0,
2369 start_offset
, chunk_size
, gsi
, write
, write
);
2374 /* Where scalar replacements of the RHS have been written to when a replacement
2375 of a LHS of an assigments cannot be direclty loaded from a replacement of
2377 enum unscalarized_data_handling
{ SRA_UDH_NONE
, /* Nothing done so far. */
2378 SRA_UDH_RIGHT
, /* Data flushed to the RHS. */
2379 SRA_UDH_LEFT
}; /* Data flushed to the LHS. */
2381 /* Store all replacements in the access tree rooted in TOP_RACC either to their
2382 base aggregate if there are unscalarized data or directly to LHS
2385 static enum unscalarized_data_handling
2386 handle_unscalarized_data_in_subtree (struct access
*top_racc
, tree lhs
,
2387 gimple_stmt_iterator
*gsi
)
2389 if (top_racc
->grp_unscalarized_data
)
2391 generate_subtree_copies (top_racc
->first_child
, top_racc
->base
, 0, 0, 0,
2393 return SRA_UDH_RIGHT
;
2397 generate_subtree_copies (top_racc
->first_child
, lhs
, top_racc
->offset
,
2398 0, 0, gsi
, false, false);
2399 return SRA_UDH_LEFT
;
2404 /* Try to generate statements to load all sub-replacements in an access
2405 (sub)tree (LACC is the first child) from scalar replacements in the TOP_RACC
2406 (sub)tree. If that is not possible, refresh the TOP_RACC base aggregate and
2407 load the accesses from it. LEFT_OFFSET is the offset of the left whole
2408 subtree being copied, RIGHT_OFFSET is the same thing for the right subtree.
2409 GSI is stmt iterator used for statement insertions. *REFRESHED is true iff
2410 the rhs top aggregate has already been refreshed by contents of its scalar
2411 reductions and is set to true if this function has to do it. */
2414 load_assign_lhs_subreplacements (struct access
*lacc
, struct access
*top_racc
,
2415 HOST_WIDE_INT left_offset
,
2416 HOST_WIDE_INT right_offset
,
2417 gimple_stmt_iterator
*old_gsi
,
2418 gimple_stmt_iterator
*new_gsi
,
2419 enum unscalarized_data_handling
*refreshed
,
2422 location_t loc
= EXPR_LOCATION (lacc
->expr
);
2425 if (lacc
->grp_to_be_replaced
)
2427 struct access
*racc
;
2428 HOST_WIDE_INT offset
= lacc
->offset
- left_offset
+ right_offset
;
2432 racc
= find_access_in_subtree (top_racc
, offset
, lacc
->size
);
2433 if (racc
&& racc
->grp_to_be_replaced
)
2435 rhs
= get_access_replacement (racc
);
2436 if (!useless_type_conversion_p (lacc
->type
, racc
->type
))
2437 rhs
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, lacc
->type
, rhs
);
2441 /* No suitable access on the right hand side, need to load from
2442 the aggregate. See if we have to update it first... */
2443 if (*refreshed
== SRA_UDH_NONE
)
2444 *refreshed
= handle_unscalarized_data_in_subtree (top_racc
,
2447 if (*refreshed
== SRA_UDH_LEFT
)
2452 repl_found
= build_ref_for_offset (&rhs
, TREE_TYPE (rhs
),
2453 lacc
->offset
, lacc
->type
,
2455 gcc_assert (repl_found
);
2461 rhs
= top_racc
->base
;
2462 repl_found
= build_ref_for_offset (&rhs
,
2463 TREE_TYPE (top_racc
->base
),
2464 offset
, lacc
->type
, false);
2465 gcc_assert (repl_found
);
2469 stmt
= gimple_build_assign (get_access_replacement (lacc
), rhs
);
2470 gsi_insert_after (new_gsi
, stmt
, GSI_NEW_STMT
);
2472 sra_stats
.subreplacements
++;
2474 else if (*refreshed
== SRA_UDH_NONE
2475 && lacc
->grp_read
&& !lacc
->grp_covered
)
2476 *refreshed
= handle_unscalarized_data_in_subtree (top_racc
, lhs
,
2479 if (lacc
->first_child
)
2480 load_assign_lhs_subreplacements (lacc
->first_child
, top_racc
,
2481 left_offset
, right_offset
,
2482 old_gsi
, new_gsi
, refreshed
, lhs
);
2483 lacc
= lacc
->next_sibling
;
2488 /* Result code for SRA assignment modification. */
2489 enum assignment_mod_result
{ SRA_AM_NONE
, /* nothing done for the stmt */
2490 SRA_AM_MODIFIED
, /* stmt changed but not
2492 SRA_AM_REMOVED
}; /* stmt eliminated */
2494 /* Modify assignments with a CONSTRUCTOR on their RHS. STMT contains a pointer
2495 to the assignment and GSI is the statement iterator pointing at it. Returns
2496 the same values as sra_modify_assign. */
2498 static enum assignment_mod_result
2499 sra_modify_constructor_assign (gimple
*stmt
, gimple_stmt_iterator
*gsi
)
2501 tree lhs
= gimple_assign_lhs (*stmt
);
2504 acc
= get_access_for_expr (lhs
);
2508 if (VEC_length (constructor_elt
,
2509 CONSTRUCTOR_ELTS (gimple_assign_rhs1 (*stmt
))) > 0)
2511 /* I have never seen this code path trigger but if it can happen the
2512 following should handle it gracefully. */
2513 if (access_has_children_p (acc
))
2514 generate_subtree_copies (acc
->first_child
, acc
->base
, 0, 0, 0, gsi
,
2516 return SRA_AM_MODIFIED
;
2519 if (acc
->grp_covered
)
2521 init_subtree_with_zero (acc
, gsi
, false);
2522 unlink_stmt_vdef (*stmt
);
2523 gsi_remove (gsi
, true);
2524 return SRA_AM_REMOVED
;
2528 init_subtree_with_zero (acc
, gsi
, true);
2529 return SRA_AM_MODIFIED
;
2533 /* Create a new suitable default definition SSA_NAME and replace all uses of
2534 SSA with it, RACC is access describing the uninitialized part of an
2535 aggregate that is being loaded. */
2538 replace_uses_with_default_def_ssa_name (tree ssa
, struct access
*racc
)
2542 decl
= get_unrenamed_access_replacement (racc
);
2544 repl
= gimple_default_def (cfun
, decl
);
2547 repl
= make_ssa_name (decl
, gimple_build_nop ());
2548 set_default_def (decl
, repl
);
2551 replace_uses_by (ssa
, repl
);
2554 /* Examine both sides of the assignment statement pointed to by STMT, replace
2555 them with a scalare replacement if there is one and generate copying of
2556 replacements if scalarized aggregates have been used in the assignment. GSI
2557 is used to hold generated statements for type conversions and subtree
2560 static enum assignment_mod_result
2561 sra_modify_assign (gimple
*stmt
, gimple_stmt_iterator
*gsi
)
2563 struct access
*lacc
, *racc
;
2565 bool modify_this_stmt
= false;
2566 bool force_gimple_rhs
= false;
2567 location_t loc
= gimple_location (*stmt
);
2568 gimple_stmt_iterator orig_gsi
= *gsi
;
2570 if (!gimple_assign_single_p (*stmt
))
2572 lhs
= gimple_assign_lhs (*stmt
);
2573 rhs
= gimple_assign_rhs1 (*stmt
);
2575 if (TREE_CODE (rhs
) == CONSTRUCTOR
)
2576 return sra_modify_constructor_assign (stmt
, gsi
);
2578 if (TREE_CODE (rhs
) == REALPART_EXPR
|| TREE_CODE (lhs
) == REALPART_EXPR
2579 || TREE_CODE (rhs
) == IMAGPART_EXPR
|| TREE_CODE (lhs
) == IMAGPART_EXPR
2580 || TREE_CODE (rhs
) == BIT_FIELD_REF
|| TREE_CODE (lhs
) == BIT_FIELD_REF
)
2582 modify_this_stmt
= sra_modify_expr (gimple_assign_rhs1_ptr (*stmt
),
2584 modify_this_stmt
|= sra_modify_expr (gimple_assign_lhs_ptr (*stmt
),
2586 return modify_this_stmt
? SRA_AM_MODIFIED
: SRA_AM_NONE
;
2589 lacc
= get_access_for_expr (lhs
);
2590 racc
= get_access_for_expr (rhs
);
2594 if (lacc
&& lacc
->grp_to_be_replaced
)
2596 lhs
= get_access_replacement (lacc
);
2597 gimple_assign_set_lhs (*stmt
, lhs
);
2598 modify_this_stmt
= true;
2599 if (lacc
->grp_partial_lhs
)
2600 force_gimple_rhs
= true;
2604 if (racc
&& racc
->grp_to_be_replaced
)
2606 rhs
= get_access_replacement (racc
);
2607 modify_this_stmt
= true;
2608 if (racc
->grp_partial_lhs
)
2609 force_gimple_rhs
= true;
2613 if (modify_this_stmt
)
2615 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
2617 /* If we can avoid creating a VIEW_CONVERT_EXPR do so.
2618 ??? This should move to fold_stmt which we simply should
2619 call after building a VIEW_CONVERT_EXPR here. */
2620 if (AGGREGATE_TYPE_P (TREE_TYPE (lhs
))
2621 && !access_has_children_p (lacc
))
2624 if (build_ref_for_offset (&expr
, TREE_TYPE (lhs
), 0,
2625 TREE_TYPE (rhs
), false))
2628 gimple_assign_set_lhs (*stmt
, expr
);
2631 else if (AGGREGATE_TYPE_P (TREE_TYPE (rhs
))
2632 && !access_has_children_p (racc
))
2635 if (build_ref_for_offset (&expr
, TREE_TYPE (rhs
), 0,
2636 TREE_TYPE (lhs
), false))
2639 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
2641 rhs
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (lhs
), rhs
);
2642 if (is_gimple_reg_type (TREE_TYPE (lhs
))
2643 && TREE_CODE (lhs
) != SSA_NAME
)
2644 force_gimple_rhs
= true;
2649 /* From this point on, the function deals with assignments in between
2650 aggregates when at least one has scalar reductions of some of its
2651 components. There are three possible scenarios: Both the LHS and RHS have
2652 to-be-scalarized components, 2) only the RHS has or 3) only the LHS has.
2654 In the first case, we would like to load the LHS components from RHS
2655 components whenever possible. If that is not possible, we would like to
2656 read it directly from the RHS (after updating it by storing in it its own
2657 components). If there are some necessary unscalarized data in the LHS,
2658 those will be loaded by the original assignment too. If neither of these
2659 cases happen, the original statement can be removed. Most of this is done
2660 by load_assign_lhs_subreplacements.
2662 In the second case, we would like to store all RHS scalarized components
2663 directly into LHS and if they cover the aggregate completely, remove the
2664 statement too. In the third case, we want the LHS components to be loaded
2665 directly from the RHS (DSE will remove the original statement if it
2668 This is a bit complex but manageable when types match and when unions do
2669 not cause confusion in a way that we cannot really load a component of LHS
2670 from the RHS or vice versa (the access representing this level can have
2671 subaccesses that are accessible only through a different union field at a
2672 higher level - different from the one used in the examined expression).
2675 Therefore, I specially handle a fourth case, happening when there is a
2676 specific type cast or it is impossible to locate a scalarized subaccess on
2677 the other side of the expression. If that happens, I simply "refresh" the
2678 RHS by storing in it is scalarized components leave the original statement
2679 there to do the copying and then load the scalar replacements of the LHS.
2680 This is what the first branch does. */
2682 if (gimple_has_volatile_ops (*stmt
)
2683 || contains_view_convert_expr_p (rhs
)
2684 || contains_view_convert_expr_p (lhs
)
2685 || (access_has_children_p (racc
)
2686 && !ref_expr_for_all_replacements_p (racc
, lhs
, racc
->offset
))
2687 || (access_has_children_p (lacc
)
2688 && !ref_expr_for_all_replacements_p (lacc
, rhs
, lacc
->offset
)))
2690 if (access_has_children_p (racc
))
2691 generate_subtree_copies (racc
->first_child
, racc
->base
, 0, 0, 0,
2693 if (access_has_children_p (lacc
))
2694 generate_subtree_copies (lacc
->first_child
, lacc
->base
, 0, 0, 0,
2696 sra_stats
.separate_lhs_rhs_handling
++;
2700 if (access_has_children_p (lacc
) && access_has_children_p (racc
))
2702 gimple_stmt_iterator orig_gsi
= *gsi
;
2703 enum unscalarized_data_handling refreshed
;
2705 if (lacc
->grp_read
&& !lacc
->grp_covered
)
2706 refreshed
= handle_unscalarized_data_in_subtree (racc
, lhs
, gsi
);
2708 refreshed
= SRA_UDH_NONE
;
2710 load_assign_lhs_subreplacements (lacc
->first_child
, racc
,
2711 lacc
->offset
, racc
->offset
,
2712 &orig_gsi
, gsi
, &refreshed
, lhs
);
2713 if (refreshed
!= SRA_UDH_RIGHT
)
2715 if (*stmt
== gsi_stmt (*gsi
))
2718 unlink_stmt_vdef (*stmt
);
2719 gsi_remove (&orig_gsi
, true);
2720 sra_stats
.deleted
++;
2721 return SRA_AM_REMOVED
;
2728 if (!racc
->grp_to_be_replaced
&& !racc
->grp_unscalarized_data
)
2730 if (racc
->first_child
)
2731 generate_subtree_copies (racc
->first_child
, lhs
,
2732 racc
->offset
, 0, 0, gsi
,
2734 gcc_assert (*stmt
== gsi_stmt (*gsi
));
2735 if (TREE_CODE (lhs
) == SSA_NAME
)
2736 replace_uses_with_default_def_ssa_name (lhs
, racc
);
2738 unlink_stmt_vdef (*stmt
);
2739 gsi_remove (gsi
, true);
2740 sra_stats
.deleted
++;
2741 return SRA_AM_REMOVED
;
2743 else if (racc
->first_child
)
2744 generate_subtree_copies (racc
->first_child
, lhs
,
2745 racc
->offset
, 0, 0, gsi
, false, true);
2747 if (access_has_children_p (lacc
))
2748 generate_subtree_copies (lacc
->first_child
, rhs
, lacc
->offset
,
2749 0, 0, gsi
, true, true);
2753 /* This gimplification must be done after generate_subtree_copies, lest we
2754 insert the subtree copies in the middle of the gimplified sequence. */
2755 if (force_gimple_rhs
)
2756 rhs
= force_gimple_operand_gsi (&orig_gsi
, rhs
, true, NULL_TREE
,
2757 true, GSI_SAME_STMT
);
2758 if (gimple_assign_rhs1 (*stmt
) != rhs
)
2760 gimple_assign_set_rhs_from_tree (&orig_gsi
, rhs
);
2761 gcc_assert (*stmt
== gsi_stmt (orig_gsi
));
2764 return modify_this_stmt
? SRA_AM_MODIFIED
: SRA_AM_NONE
;
2767 /* Traverse the function body and all modifications as decided in
2768 analyze_all_variable_accesses. */
2771 sra_modify_function_body (void)
2777 gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
2778 while (!gsi_end_p (gsi
))
2780 gimple stmt
= gsi_stmt (gsi
);
2781 enum assignment_mod_result assign_result
;
2782 bool modified
= false, deleted
= false;
2786 switch (gimple_code (stmt
))
2789 t
= gimple_return_retval_ptr (stmt
);
2790 if (*t
!= NULL_TREE
)
2791 modified
|= sra_modify_expr (t
, &gsi
, false);
2795 assign_result
= sra_modify_assign (&stmt
, &gsi
);
2796 modified
|= assign_result
== SRA_AM_MODIFIED
;
2797 deleted
= assign_result
== SRA_AM_REMOVED
;
2801 /* Operands must be processed before the lhs. */
2802 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2804 t
= gimple_call_arg_ptr (stmt
, i
);
2805 modified
|= sra_modify_expr (t
, &gsi
, false);
2808 if (gimple_call_lhs (stmt
))
2810 t
= gimple_call_lhs_ptr (stmt
);
2811 modified
|= sra_modify_expr (t
, &gsi
, true);
2816 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
2818 t
= &TREE_VALUE (gimple_asm_input_op (stmt
, i
));
2819 modified
|= sra_modify_expr (t
, &gsi
, false);
2821 for (i
= 0; i
< gimple_asm_noutputs (stmt
); i
++)
2823 t
= &TREE_VALUE (gimple_asm_output_op (stmt
, i
));
2824 modified
|= sra_modify_expr (t
, &gsi
, true);
2835 maybe_clean_eh_stmt (stmt
);
2843 /* Generate statements initializing scalar replacements of parts of function
2847 initialize_parameter_reductions (void)
2849 gimple_stmt_iterator gsi
;
2850 gimple_seq seq
= NULL
;
2853 for (parm
= DECL_ARGUMENTS (current_function_decl
);
2855 parm
= TREE_CHAIN (parm
))
2857 VEC (access_p
, heap
) *access_vec
;
2858 struct access
*access
;
2860 if (!bitmap_bit_p (candidate_bitmap
, DECL_UID (parm
)))
2862 access_vec
= get_base_access_vector (parm
);
2868 seq
= gimple_seq_alloc ();
2869 gsi
= gsi_start (seq
);
2872 for (access
= VEC_index (access_p
, access_vec
, 0);
2874 access
= access
->next_grp
)
2875 generate_subtree_copies (access
, parm
, 0, 0, 0, &gsi
, true, true);
2879 gsi_insert_seq_on_edge_immediate (single_succ_edge (ENTRY_BLOCK_PTR
), seq
);
2882 /* The "main" function of intraprocedural SRA passes. Runs the analysis and if
2883 it reveals there are components of some aggregates to be scalarized, it runs
2884 the required transformations. */
2886 perform_intra_sra (void)
2891 if (!find_var_candidates ())
2894 if (!scan_function ())
2897 if (!analyze_all_variable_accesses ())
2900 sra_modify_function_body ();
2901 initialize_parameter_reductions ();
2903 statistics_counter_event (cfun
, "Scalar replacements created",
2904 sra_stats
.replacements
);
2905 statistics_counter_event (cfun
, "Modified expressions", sra_stats
.exprs
);
2906 statistics_counter_event (cfun
, "Subtree copy stmts",
2907 sra_stats
.subtree_copies
);
2908 statistics_counter_event (cfun
, "Subreplacement stmts",
2909 sra_stats
.subreplacements
);
2910 statistics_counter_event (cfun
, "Deleted stmts", sra_stats
.deleted
);
2911 statistics_counter_event (cfun
, "Separate LHS and RHS handling",
2912 sra_stats
.separate_lhs_rhs_handling
);
2914 ret
= TODO_update_ssa
;
2917 sra_deinitialize ();
2921 /* Perform early intraprocedural SRA. */
2923 early_intra_sra (void)
2925 sra_mode
= SRA_MODE_EARLY_INTRA
;
2926 return perform_intra_sra ();
2929 /* Perform "late" intraprocedural SRA. */
2931 late_intra_sra (void)
2933 sra_mode
= SRA_MODE_INTRA
;
2934 return perform_intra_sra ();
2939 gate_intra_sra (void)
2941 return flag_tree_sra
!= 0 && dbg_cnt (tree_sra
);
2945 struct gimple_opt_pass pass_sra_early
=
2950 gate_intra_sra
, /* gate */
2951 early_intra_sra
, /* execute */
2954 0, /* static_pass_number */
2955 TV_TREE_SRA
, /* tv_id */
2956 PROP_cfg
| PROP_ssa
, /* properties_required */
2957 0, /* properties_provided */
2958 0, /* properties_destroyed */
2959 0, /* todo_flags_start */
2963 | TODO_verify_ssa
/* todo_flags_finish */
2967 struct gimple_opt_pass pass_sra
=
2972 gate_intra_sra
, /* gate */
2973 late_intra_sra
, /* execute */
2976 0, /* static_pass_number */
2977 TV_TREE_SRA
, /* tv_id */
2978 PROP_cfg
| PROP_ssa
, /* properties_required */
2979 0, /* properties_provided */
2980 0, /* properties_destroyed */
2981 TODO_update_address_taken
, /* todo_flags_start */
2985 | TODO_verify_ssa
/* todo_flags_finish */
2990 /* Return true iff PARM (which must be a parm_decl) is an unused scalar
2994 is_unused_scalar_param (tree parm
)
2997 return (is_gimple_reg (parm
)
2998 && (!(name
= gimple_default_def (cfun
, parm
))
2999 || has_zero_uses (name
)));
3002 /* Scan immediate uses of a default definition SSA name of a parameter PARM and
3003 examine whether there are any direct or otherwise infeasible ones. If so,
3004 return true, otherwise return false. PARM must be a gimple register with a
3005 non-NULL default definition. */
3008 ptr_parm_has_direct_uses (tree parm
)
3010 imm_use_iterator ui
;
3012 tree name
= gimple_default_def (cfun
, parm
);
3015 FOR_EACH_IMM_USE_STMT (stmt
, ui
, name
)
3018 use_operand_p use_p
;
3020 if (is_gimple_debug (stmt
))
3023 /* Valid uses include dereferences on the lhs and the rhs. */
3024 if (gimple_has_lhs (stmt
))
3026 tree lhs
= gimple_get_lhs (stmt
);
3027 while (handled_component_p (lhs
))
3028 lhs
= TREE_OPERAND (lhs
, 0);
3029 if (INDIRECT_REF_P (lhs
)
3030 && TREE_OPERAND (lhs
, 0) == name
)
3033 if (gimple_assign_single_p (stmt
))
3035 tree rhs
= gimple_assign_rhs1 (stmt
);
3036 while (handled_component_p (rhs
))
3037 rhs
= TREE_OPERAND (rhs
, 0);
3038 if (INDIRECT_REF_P (rhs
)
3039 && TREE_OPERAND (rhs
, 0) == name
)
3042 else if (is_gimple_call (stmt
))
3045 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3047 tree arg
= gimple_call_arg (stmt
, i
);
3048 while (handled_component_p (arg
))
3049 arg
= TREE_OPERAND (arg
, 0);
3050 if (INDIRECT_REF_P (arg
)
3051 && TREE_OPERAND (arg
, 0) == name
)
3056 /* If the number of valid uses does not match the number of
3057 uses in this stmt there is an unhandled use. */
3058 FOR_EACH_IMM_USE_ON_STMT (use_p
, ui
)
3065 BREAK_FROM_IMM_USE_STMT (ui
);
3071 /* Identify candidates for reduction for IPA-SRA based on their type and mark
3072 them in candidate_bitmap. Note that these do not necessarily include
3073 parameter which are unused and thus can be removed. Return true iff any
3074 such candidate has been found. */
3077 find_param_candidates (void)
3083 for (parm
= DECL_ARGUMENTS (current_function_decl
);
3085 parm
= TREE_CHAIN (parm
))
3087 tree type
= TREE_TYPE (parm
);
3091 if (TREE_THIS_VOLATILE (parm
)
3092 || TREE_ADDRESSABLE (parm
)
3093 || (!is_gimple_reg_type (type
) && is_va_list_type (type
)))
3096 if (is_unused_scalar_param (parm
))
3102 if (POINTER_TYPE_P (type
))
3104 type
= TREE_TYPE (type
);
3106 if (TREE_CODE (type
) == FUNCTION_TYPE
3107 || TYPE_VOLATILE (type
)
3108 || !is_gimple_reg (parm
)
3109 || is_va_list_type (type
)
3110 || ptr_parm_has_direct_uses (parm
))
3113 else if (!AGGREGATE_TYPE_P (type
))
3116 if (!COMPLETE_TYPE_P (type
)
3117 || !host_integerp (TYPE_SIZE (type
), 1)
3118 || tree_low_cst (TYPE_SIZE (type
), 1) == 0
3119 || (AGGREGATE_TYPE_P (type
)
3120 && type_internals_preclude_sra_p (type
)))
3123 bitmap_set_bit (candidate_bitmap
, DECL_UID (parm
));
3125 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3127 fprintf (dump_file
, "Candidate (%d): ", DECL_UID (parm
));
3128 print_generic_expr (dump_file
, parm
, 0);
3129 fprintf (dump_file
, "\n");
3133 func_param_count
= count
;
3137 /* Callback of walk_aliased_vdefs, marks the access passed as DATA as
3141 mark_maybe_modified (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef ATTRIBUTE_UNUSED
,
3144 struct access
*repr
= (struct access
*) data
;
3146 repr
->grp_maybe_modified
= 1;
3150 /* Analyze what representatives (in linked lists accessible from
3151 REPRESENTATIVES) can be modified by side effects of statements in the
3152 current function. */
3155 analyze_modified_params (VEC (access_p
, heap
) *representatives
)
3159 for (i
= 0; i
< func_param_count
; i
++)
3161 struct access
*repr
;
3163 for (repr
= VEC_index (access_p
, representatives
, i
);
3165 repr
= repr
->next_grp
)
3167 struct access
*access
;
3171 if (no_accesses_p (repr
))
3173 if (!POINTER_TYPE_P (TREE_TYPE (repr
->base
))
3174 || repr
->grp_maybe_modified
)
3177 ao_ref_init (&ar
, repr
->expr
);
3178 visited
= BITMAP_ALLOC (NULL
);
3179 for (access
= repr
; access
; access
= access
->next_sibling
)
3181 /* All accesses are read ones, otherwise grp_maybe_modified would
3182 be trivially set. */
3183 walk_aliased_vdefs (&ar
, gimple_vuse (access
->stmt
),
3184 mark_maybe_modified
, repr
, &visited
);
3185 if (repr
->grp_maybe_modified
)
3188 BITMAP_FREE (visited
);
3193 /* Propagate distances in bb_dereferences in the opposite direction than the
3194 control flow edges, in each step storing the maximum of the current value
3195 and the minimum of all successors. These steps are repeated until the table
3196 stabilizes. Note that BBs which might terminate the functions (according to
3197 final_bbs bitmap) never updated in this way. */
3200 propagate_dereference_distances (void)
3202 VEC (basic_block
, heap
) *queue
;
3205 queue
= VEC_alloc (basic_block
, heap
, last_basic_block_for_function (cfun
));
3206 VEC_quick_push (basic_block
, queue
, ENTRY_BLOCK_PTR
);
3209 VEC_quick_push (basic_block
, queue
, bb
);
3213 while (!VEC_empty (basic_block
, queue
))
3217 bool change
= false;
3220 bb
= VEC_pop (basic_block
, queue
);
3223 if (bitmap_bit_p (final_bbs
, bb
->index
))
3226 for (i
= 0; i
< func_param_count
; i
++)
3228 int idx
= bb
->index
* func_param_count
+ i
;
3230 HOST_WIDE_INT inh
= 0;
3232 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
3234 int succ_idx
= e
->dest
->index
* func_param_count
+ i
;
3236 if (e
->src
== EXIT_BLOCK_PTR
)
3242 inh
= bb_dereferences
[succ_idx
];
3244 else if (bb_dereferences
[succ_idx
] < inh
)
3245 inh
= bb_dereferences
[succ_idx
];
3248 if (!first
&& bb_dereferences
[idx
] < inh
)
3250 bb_dereferences
[idx
] = inh
;
3255 if (change
&& !bitmap_bit_p (final_bbs
, bb
->index
))
3256 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
3261 e
->src
->aux
= e
->src
;
3262 VEC_quick_push (basic_block
, queue
, e
->src
);
3266 VEC_free (basic_block
, heap
, queue
);
3269 /* Dump a dereferences TABLE with heading STR to file F. */
3272 dump_dereferences_table (FILE *f
, const char *str
, HOST_WIDE_INT
*table
)
3276 fprintf (dump_file
, str
);
3277 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
3279 fprintf (f
, "%4i %i ", bb
->index
, bitmap_bit_p (final_bbs
, bb
->index
));
3280 if (bb
!= EXIT_BLOCK_PTR
)
3283 for (i
= 0; i
< func_param_count
; i
++)
3285 int idx
= bb
->index
* func_param_count
+ i
;
3286 fprintf (f
, " %4" HOST_WIDE_INT_PRINT
"d", table
[idx
]);
3291 fprintf (dump_file
, "\n");
3294 /* Determine what (parts of) parameters passed by reference that are not
3295 assigned to are not certainly dereferenced in this function and thus the
3296 dereferencing cannot be safely moved to the caller without potentially
3297 introducing a segfault. Mark such REPRESENTATIVES as
3298 grp_not_necessarilly_dereferenced.
3300 The dereferenced maximum "distance," i.e. the offset + size of the accessed
3301 part is calculated rather than simple booleans are calculated for each
3302 pointer parameter to handle cases when only a fraction of the whole
3303 aggregate is allocated (see testsuite/gcc.c-torture/execute/ipa-sra-2.c for
3306 The maximum dereference distances for each pointer parameter and BB are
3307 already stored in bb_dereference. This routine simply propagates these
3308 values upwards by propagate_dereference_distances and then compares the
3309 distances of individual parameters in the ENTRY BB to the equivalent
3310 distances of each representative of a (fraction of a) parameter. */
3313 analyze_caller_dereference_legality (VEC (access_p
, heap
) *representatives
)
3317 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3318 dump_dereferences_table (dump_file
,
3319 "Dereference table before propagation:\n",
3322 propagate_dereference_distances ();
3324 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3325 dump_dereferences_table (dump_file
,
3326 "Dereference table after propagation:\n",
3329 for (i
= 0; i
< func_param_count
; i
++)
3331 struct access
*repr
= VEC_index (access_p
, representatives
, i
);
3332 int idx
= ENTRY_BLOCK_PTR
->index
* func_param_count
+ i
;
3334 if (!repr
|| no_accesses_p (repr
))
3339 if ((repr
->offset
+ repr
->size
) > bb_dereferences
[idx
])
3340 repr
->grp_not_necessarilly_dereferenced
= 1;
3341 repr
= repr
->next_grp
;
3347 /* Return the representative access for the parameter declaration PARM if it is
3348 a scalar passed by reference which is not written to and the pointer value
3349 is not used directly. Thus, if it is legal to dereference it in the caller
3350 and we can rule out modifications through aliases, such parameter should be
3351 turned into one passed by value. Return NULL otherwise. */
3353 static struct access
*
3354 unmodified_by_ref_scalar_representative (tree parm
)
3356 int i
, access_count
;
3357 struct access
*repr
;
3358 VEC (access_p
, heap
) *access_vec
;
3360 access_vec
= get_base_access_vector (parm
);
3361 gcc_assert (access_vec
);
3362 repr
= VEC_index (access_p
, access_vec
, 0);
3365 repr
->group_representative
= repr
;
3367 access_count
= VEC_length (access_p
, access_vec
);
3368 for (i
= 1; i
< access_count
; i
++)
3370 struct access
*access
= VEC_index (access_p
, access_vec
, i
);
3373 access
->group_representative
= repr
;
3374 access
->next_sibling
= repr
->next_sibling
;
3375 repr
->next_sibling
= access
;
3379 repr
->grp_scalar_ptr
= 1;
3383 /* Return true iff this access precludes IPA-SRA of the parameter it is
3387 access_precludes_ipa_sra_p (struct access
*access
)
3389 /* Avoid issues such as the second simple testcase in PR 42025. The problem
3390 is incompatible assign in a call statement (and possibly even in asm
3391 statements). This can be relaxed by using a new temporary but only for
3392 non-TREE_ADDRESSABLE types and is probably not worth the complexity. (In
3393 intraprocedural SRA we deal with this by keeping the old aggregate around,
3394 something we cannot do in IPA-SRA.) */
3396 && (is_gimple_call (access
->stmt
)
3397 || gimple_code (access
->stmt
) == GIMPLE_ASM
))
3404 /* Sort collected accesses for parameter PARM, identify representatives for
3405 each accessed region and link them together. Return NULL if there are
3406 different but overlapping accesses, return the special ptr value meaning
3407 there are no accesses for this parameter if that is the case and return the
3408 first representative otherwise. Set *RO_GRP if there is a group of accesses
3409 with only read (i.e. no write) accesses. */
3411 static struct access
*
3412 splice_param_accesses (tree parm
, bool *ro_grp
)
3414 int i
, j
, access_count
, group_count
;
3415 int agg_size
, total_size
= 0;
3416 struct access
*access
, *res
, **prev_acc_ptr
= &res
;
3417 VEC (access_p
, heap
) *access_vec
;
3419 access_vec
= get_base_access_vector (parm
);
3421 return &no_accesses_representant
;
3422 access_count
= VEC_length (access_p
, access_vec
);
3424 qsort (VEC_address (access_p
, access_vec
), access_count
, sizeof (access_p
),
3425 compare_access_positions
);
3430 while (i
< access_count
)
3433 access
= VEC_index (access_p
, access_vec
, i
);
3434 modification
= access
->write
;
3435 if (access_precludes_ipa_sra_p (access
))
3438 /* Access is about to become group representative unless we find some
3439 nasty overlap which would preclude us from breaking this parameter
3443 while (j
< access_count
)
3445 struct access
*ac2
= VEC_index (access_p
, access_vec
, j
);
3446 if (ac2
->offset
!= access
->offset
)
3448 /* All or nothing law for parameters. */
3449 if (access
->offset
+ access
->size
> ac2
->offset
)
3454 else if (ac2
->size
!= access
->size
)
3457 if (access_precludes_ipa_sra_p (ac2
))
3460 modification
|= ac2
->write
;
3461 ac2
->group_representative
= access
;
3462 ac2
->next_sibling
= access
->next_sibling
;
3463 access
->next_sibling
= ac2
;
3468 access
->grp_maybe_modified
= modification
;
3471 *prev_acc_ptr
= access
;
3472 prev_acc_ptr
= &access
->next_grp
;
3473 total_size
+= access
->size
;
3477 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
3478 agg_size
= tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))), 1);
3480 agg_size
= tree_low_cst (TYPE_SIZE (TREE_TYPE (parm
)), 1);
3481 if (total_size
>= agg_size
)
3484 gcc_assert (group_count
> 0);
3488 /* Decide whether parameters with representative accesses given by REPR should
3489 be reduced into components. */
3492 decide_one_param_reduction (struct access
*repr
)
3494 int total_size
, cur_parm_size
, agg_size
, new_param_count
, parm_size_limit
;
3499 cur_parm_size
= tree_low_cst (TYPE_SIZE (TREE_TYPE (parm
)), 1);
3500 gcc_assert (cur_parm_size
> 0);
3502 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
3505 agg_size
= tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))), 1);
3510 agg_size
= cur_parm_size
;
3516 fprintf (dump_file
, "Evaluating PARAM group sizes for ");
3517 print_generic_expr (dump_file
, parm
, 0);
3518 fprintf (dump_file
, " (UID: %u): \n", DECL_UID (parm
));
3519 for (acc
= repr
; acc
; acc
= acc
->next_grp
)
3520 dump_access (dump_file
, acc
, true);
3524 new_param_count
= 0;
3526 for (; repr
; repr
= repr
->next_grp
)
3528 gcc_assert (parm
== repr
->base
);
3531 if (!by_ref
|| (!repr
->grp_maybe_modified
3532 && !repr
->grp_not_necessarilly_dereferenced
))
3533 total_size
+= repr
->size
;
3535 total_size
+= cur_parm_size
;
3538 gcc_assert (new_param_count
> 0);
3540 if (optimize_function_for_size_p (cfun
))
3541 parm_size_limit
= cur_parm_size
;
3543 parm_size_limit
= (PARAM_VALUE (PARAM_IPA_SRA_PTR_GROWTH_FACTOR
)
3546 if (total_size
< agg_size
3547 && total_size
<= parm_size_limit
)
3550 fprintf (dump_file
, " ....will be split into %i components\n",
3552 return new_param_count
;
3558 /* The order of the following enums is important, we need to do extra work for
3559 UNUSED_PARAMS, BY_VAL_ACCESSES and UNMODIF_BY_REF_ACCESSES. */
3560 enum ipa_splicing_result
{ NO_GOOD_ACCESS
, UNUSED_PARAMS
, BY_VAL_ACCESSES
,
3561 MODIF_BY_REF_ACCESSES
, UNMODIF_BY_REF_ACCESSES
};
3563 /* Identify representatives of all accesses to all candidate parameters for
3564 IPA-SRA. Return result based on what representatives have been found. */
3566 static enum ipa_splicing_result
3567 splice_all_param_accesses (VEC (access_p
, heap
) **representatives
)
3569 enum ipa_splicing_result result
= NO_GOOD_ACCESS
;
3571 struct access
*repr
;
3573 *representatives
= VEC_alloc (access_p
, heap
, func_param_count
);
3575 for (parm
= DECL_ARGUMENTS (current_function_decl
);
3577 parm
= TREE_CHAIN (parm
))
3579 if (is_unused_scalar_param (parm
))
3581 VEC_quick_push (access_p
, *representatives
,
3582 &no_accesses_representant
);
3583 if (result
== NO_GOOD_ACCESS
)
3584 result
= UNUSED_PARAMS
;
3586 else if (POINTER_TYPE_P (TREE_TYPE (parm
))
3587 && is_gimple_reg_type (TREE_TYPE (TREE_TYPE (parm
)))
3588 && bitmap_bit_p (candidate_bitmap
, DECL_UID (parm
)))
3590 repr
= unmodified_by_ref_scalar_representative (parm
);
3591 VEC_quick_push (access_p
, *representatives
, repr
);
3593 result
= UNMODIF_BY_REF_ACCESSES
;
3595 else if (bitmap_bit_p (candidate_bitmap
, DECL_UID (parm
)))
3597 bool ro_grp
= false;
3598 repr
= splice_param_accesses (parm
, &ro_grp
);
3599 VEC_quick_push (access_p
, *representatives
, repr
);
3601 if (repr
&& !no_accesses_p (repr
))
3603 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
3606 result
= UNMODIF_BY_REF_ACCESSES
;
3607 else if (result
< MODIF_BY_REF_ACCESSES
)
3608 result
= MODIF_BY_REF_ACCESSES
;
3610 else if (result
< BY_VAL_ACCESSES
)
3611 result
= BY_VAL_ACCESSES
;
3613 else if (no_accesses_p (repr
) && (result
== NO_GOOD_ACCESS
))
3614 result
= UNUSED_PARAMS
;
3617 VEC_quick_push (access_p
, *representatives
, NULL
);
3620 if (result
== NO_GOOD_ACCESS
)
3622 VEC_free (access_p
, heap
, *representatives
);
3623 *representatives
= NULL
;
3624 return NO_GOOD_ACCESS
;
3630 /* Return the index of BASE in PARMS. Abort if it is not found. */
3633 get_param_index (tree base
, VEC(tree
, heap
) *parms
)
3637 len
= VEC_length (tree
, parms
);
3638 for (i
= 0; i
< len
; i
++)
3639 if (VEC_index (tree
, parms
, i
) == base
)
3644 /* Convert the decisions made at the representative level into compact
3645 parameter adjustments. REPRESENTATIVES are pointers to first
3646 representatives of each param accesses, ADJUSTMENTS_COUNT is the expected
3647 final number of adjustments. */
3649 static ipa_parm_adjustment_vec
3650 turn_representatives_into_adjustments (VEC (access_p
, heap
) *representatives
,
3651 int adjustments_count
)
3653 VEC (tree
, heap
) *parms
;
3654 ipa_parm_adjustment_vec adjustments
;
3658 gcc_assert (adjustments_count
> 0);
3659 parms
= ipa_get_vector_of_formal_parms (current_function_decl
);
3660 adjustments
= VEC_alloc (ipa_parm_adjustment_t
, heap
, adjustments_count
);
3661 parm
= DECL_ARGUMENTS (current_function_decl
);
3662 for (i
= 0; i
< func_param_count
; i
++, parm
= TREE_CHAIN (parm
))
3664 struct access
*repr
= VEC_index (access_p
, representatives
, i
);
3666 if (!repr
|| no_accesses_p (repr
))
3668 struct ipa_parm_adjustment
*adj
;
3670 adj
= VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, NULL
);
3671 memset (adj
, 0, sizeof (*adj
));
3672 adj
->base_index
= get_param_index (parm
, parms
);
3675 adj
->copy_param
= 1;
3677 adj
->remove_param
= 1;
3681 struct ipa_parm_adjustment
*adj
;
3682 int index
= get_param_index (parm
, parms
);
3684 for (; repr
; repr
= repr
->next_grp
)
3686 adj
= VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, NULL
);
3687 memset (adj
, 0, sizeof (*adj
));
3688 gcc_assert (repr
->base
== parm
);
3689 adj
->base_index
= index
;
3690 adj
->base
= repr
->base
;
3691 adj
->type
= repr
->type
;
3692 adj
->offset
= repr
->offset
;
3693 adj
->by_ref
= (POINTER_TYPE_P (TREE_TYPE (repr
->base
))
3694 && (repr
->grp_maybe_modified
3695 || repr
->grp_not_necessarilly_dereferenced
));
3700 VEC_free (tree
, heap
, parms
);
3704 /* Analyze the collected accesses and produce a plan what to do with the
3705 parameters in the form of adjustments, NULL meaning nothing. */
3707 static ipa_parm_adjustment_vec
3708 analyze_all_param_acesses (void)
3710 enum ipa_splicing_result repr_state
;
3711 bool proceed
= false;
3712 int i
, adjustments_count
= 0;
3713 VEC (access_p
, heap
) *representatives
;
3714 ipa_parm_adjustment_vec adjustments
;
3716 repr_state
= splice_all_param_accesses (&representatives
);
3717 if (repr_state
== NO_GOOD_ACCESS
)
3720 /* If there are any parameters passed by reference which are not modified
3721 directly, we need to check whether they can be modified indirectly. */
3722 if (repr_state
== UNMODIF_BY_REF_ACCESSES
)
3724 analyze_caller_dereference_legality (representatives
);
3725 analyze_modified_params (representatives
);
3728 for (i
= 0; i
< func_param_count
; i
++)
3730 struct access
*repr
= VEC_index (access_p
, representatives
, i
);
3732 if (repr
&& !no_accesses_p (repr
))
3734 if (repr
->grp_scalar_ptr
)
3736 adjustments_count
++;
3737 if (repr
->grp_not_necessarilly_dereferenced
3738 || repr
->grp_maybe_modified
)
3739 VEC_replace (access_p
, representatives
, i
, NULL
);
3743 sra_stats
.scalar_by_ref_to_by_val
++;
3748 int new_components
= decide_one_param_reduction (repr
);
3750 if (new_components
== 0)
3752 VEC_replace (access_p
, representatives
, i
, NULL
);
3753 adjustments_count
++;
3757 adjustments_count
+= new_components
;
3758 sra_stats
.aggregate_params_reduced
++;
3759 sra_stats
.param_reductions_created
+= new_components
;
3766 if (no_accesses_p (repr
))
3769 sra_stats
.deleted_unused_parameters
++;
3771 adjustments_count
++;
3775 if (!proceed
&& dump_file
)
3776 fprintf (dump_file
, "NOT proceeding to change params.\n");
3779 adjustments
= turn_representatives_into_adjustments (representatives
,
3784 VEC_free (access_p
, heap
, representatives
);
3788 /* If a parameter replacement identified by ADJ does not yet exist in the form
3789 of declaration, create it and record it, otherwise return the previously
3793 get_replaced_param_substitute (struct ipa_parm_adjustment
*adj
)
3796 if (!adj
->new_ssa_base
)
3798 char *pretty_name
= make_fancy_name (adj
->base
);
3800 repl
= create_tmp_reg (TREE_TYPE (adj
->base
), "ISR");
3801 DECL_NAME (repl
) = get_identifier (pretty_name
);
3802 obstack_free (&name_obstack
, pretty_name
);
3805 add_referenced_var (repl
);
3806 adj
->new_ssa_base
= repl
;
3809 repl
= adj
->new_ssa_base
;
3813 /* Find the first adjustment for a particular parameter BASE in a vector of
3814 ADJUSTMENTS which is not a copy_param. Return NULL if there is no such
3817 static struct ipa_parm_adjustment
*
3818 get_adjustment_for_base (ipa_parm_adjustment_vec adjustments
, tree base
)
3822 len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
3823 for (i
= 0; i
< len
; i
++)
3825 struct ipa_parm_adjustment
*adj
;
3827 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
3828 if (!adj
->copy_param
&& adj
->base
== base
)
3835 /* If the statement STMT defines an SSA_NAME of a parameter which is to be
3836 removed because its value is not used, replace the SSA_NAME with a one
3837 relating to a created VAR_DECL together all of its uses and return true.
3838 ADJUSTMENTS is a pointer to an adjustments vector. */
3841 replace_removed_params_ssa_names (gimple stmt
,
3842 ipa_parm_adjustment_vec adjustments
)
3844 struct ipa_parm_adjustment
*adj
;
3845 tree lhs
, decl
, repl
, name
;
3847 if (gimple_code (stmt
) == GIMPLE_PHI
)
3848 lhs
= gimple_phi_result (stmt
);
3849 else if (is_gimple_assign (stmt
))
3850 lhs
= gimple_assign_lhs (stmt
);
3851 else if (is_gimple_call (stmt
))
3852 lhs
= gimple_call_lhs (stmt
);
3856 if (TREE_CODE (lhs
) != SSA_NAME
)
3858 decl
= SSA_NAME_VAR (lhs
);
3859 if (TREE_CODE (decl
) != PARM_DECL
)
3862 adj
= get_adjustment_for_base (adjustments
, decl
);
3866 repl
= get_replaced_param_substitute (adj
);
3867 name
= make_ssa_name (repl
, stmt
);
3871 fprintf (dump_file
, "replacing an SSA name of a removed param ");
3872 print_generic_expr (dump_file
, lhs
, 0);
3873 fprintf (dump_file
, " with ");
3874 print_generic_expr (dump_file
, name
, 0);
3875 fprintf (dump_file
, "\n");
3878 if (is_gimple_assign (stmt
))
3879 gimple_assign_set_lhs (stmt
, name
);
3880 else if (is_gimple_call (stmt
))
3881 gimple_call_set_lhs (stmt
, name
);
3883 gimple_phi_set_result (stmt
, name
);
3885 replace_uses_by (lhs
, name
);
3886 release_ssa_name (lhs
);
3890 /* If the expression *EXPR should be replaced by a reduction of a parameter, do
3891 so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT
3892 specifies whether the function should care about type incompatibility the
3893 current and new expressions. If it is false, the function will leave
3894 incompatibility issues to the caller. Return true iff the expression
3898 sra_ipa_modify_expr (tree
*expr
, bool convert
,
3899 ipa_parm_adjustment_vec adjustments
)
3902 struct ipa_parm_adjustment
*adj
, *cand
= NULL
;
3903 HOST_WIDE_INT offset
, size
, max_size
;
3906 len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
3908 if (TREE_CODE (*expr
) == BIT_FIELD_REF
3909 || TREE_CODE (*expr
) == IMAGPART_EXPR
3910 || TREE_CODE (*expr
) == REALPART_EXPR
)
3912 expr
= &TREE_OPERAND (*expr
, 0);
3916 base
= get_ref_base_and_extent (*expr
, &offset
, &size
, &max_size
);
3917 if (!base
|| size
== -1 || max_size
== -1)
3920 if (INDIRECT_REF_P (base
))
3921 base
= TREE_OPERAND (base
, 0);
3923 base
= get_ssa_base_param (base
);
3924 if (!base
|| TREE_CODE (base
) != PARM_DECL
)
3927 for (i
= 0; i
< len
; i
++)
3929 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
3931 if (adj
->base
== base
&&
3932 (adj
->offset
== offset
|| adj
->remove_param
))
3938 if (!cand
|| cand
->copy_param
|| cand
->remove_param
)
3944 src
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (cand
->reduction
)),
3946 folded
= gimple_fold_indirect_ref (src
);
3951 src
= cand
->reduction
;
3953 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3955 fprintf (dump_file
, "About to replace expr ");
3956 print_generic_expr (dump_file
, *expr
, 0);
3957 fprintf (dump_file
, " with ");
3958 print_generic_expr (dump_file
, src
, 0);
3959 fprintf (dump_file
, "\n");
3962 if (convert
&& !useless_type_conversion_p (TREE_TYPE (*expr
), cand
->type
))
3964 tree vce
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (*expr
), src
);
3972 /* If the statement pointed to by STMT_PTR contains any expressions that need
3973 to replaced with a different one as noted by ADJUSTMENTS, do so. Handle any
3974 potential type incompatibilities (GSI is used to accommodate conversion
3975 statements and must point to the statement). Return true iff the statement
3979 sra_ipa_modify_assign (gimple
*stmt_ptr
, gimple_stmt_iterator
*gsi
,
3980 ipa_parm_adjustment_vec adjustments
)
3982 gimple stmt
= *stmt_ptr
;
3983 tree
*lhs_p
, *rhs_p
;
3986 if (!gimple_assign_single_p (stmt
))
3989 rhs_p
= gimple_assign_rhs1_ptr (stmt
);
3990 lhs_p
= gimple_assign_lhs_ptr (stmt
);
3992 any
= sra_ipa_modify_expr (rhs_p
, false, adjustments
);
3993 any
|= sra_ipa_modify_expr (lhs_p
, false, adjustments
);
3996 tree new_rhs
= NULL_TREE
;
3998 if (!useless_type_conversion_p (TREE_TYPE (*lhs_p
), TREE_TYPE (*rhs_p
)))
4000 if (TREE_CODE (*rhs_p
) == CONSTRUCTOR
)
4002 /* V_C_Es of constructors can cause trouble (PR 42714). */
4003 if (is_gimple_reg_type (TREE_TYPE (*lhs_p
)))
4004 *rhs_p
= fold_convert (TREE_TYPE (*lhs_p
), integer_zero_node
);
4006 *rhs_p
= build_constructor (TREE_TYPE (*lhs_p
), 0);
4009 new_rhs
= fold_build1_loc (gimple_location (stmt
),
4010 VIEW_CONVERT_EXPR
, TREE_TYPE (*lhs_p
),
4013 else if (REFERENCE_CLASS_P (*rhs_p
)
4014 && is_gimple_reg_type (TREE_TYPE (*lhs_p
))
4015 && !is_gimple_reg (*lhs_p
))
4016 /* This can happen when an assignment in between two single field
4017 structures is turned into an assignment in between two pointers to
4018 scalars (PR 42237). */
4023 tree tmp
= force_gimple_operand_gsi (gsi
, new_rhs
, true, NULL_TREE
,
4024 true, GSI_SAME_STMT
);
4026 gimple_assign_set_rhs_from_tree (gsi
, tmp
);
4035 /* Traverse the function body and all modifications as described in
4039 ipa_sra_modify_function_body (ipa_parm_adjustment_vec adjustments
)
4045 gimple_stmt_iterator gsi
;
4046 bool bb_changed
= false;
4048 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4049 replace_removed_params_ssa_names (gsi_stmt (gsi
), adjustments
);
4051 gsi
= gsi_start_bb (bb
);
4052 while (!gsi_end_p (gsi
))
4054 gimple stmt
= gsi_stmt (gsi
);
4055 bool modified
= false;
4059 switch (gimple_code (stmt
))
4062 t
= gimple_return_retval_ptr (stmt
);
4063 if (*t
!= NULL_TREE
)
4064 modified
|= sra_ipa_modify_expr (t
, true, adjustments
);
4068 modified
|= sra_ipa_modify_assign (&stmt
, &gsi
, adjustments
);
4069 modified
|= replace_removed_params_ssa_names (stmt
, adjustments
);
4073 /* Operands must be processed before the lhs. */
4074 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
4076 t
= gimple_call_arg_ptr (stmt
, i
);
4077 modified
|= sra_ipa_modify_expr (t
, true, adjustments
);
4080 if (gimple_call_lhs (stmt
))
4082 t
= gimple_call_lhs_ptr (stmt
);
4083 modified
|= sra_ipa_modify_expr (t
, false, adjustments
);
4084 modified
|= replace_removed_params_ssa_names (stmt
,
4090 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
4092 t
= &TREE_VALUE (gimple_asm_input_op (stmt
, i
));
4093 modified
|= sra_ipa_modify_expr (t
, true, adjustments
);
4095 for (i
= 0; i
< gimple_asm_noutputs (stmt
); i
++)
4097 t
= &TREE_VALUE (gimple_asm_output_op (stmt
, i
));
4098 modified
|= sra_ipa_modify_expr (t
, false, adjustments
);
4110 maybe_clean_eh_stmt (stmt
);
4115 gimple_purge_dead_eh_edges (bb
);
4119 /* Call gimple_debug_bind_reset_value on all debug statements describing
4120 gimple register parameters that are being removed or replaced. */
4123 sra_ipa_reset_debug_stmts (ipa_parm_adjustment_vec adjustments
)
4127 len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
4128 for (i
= 0; i
< len
; i
++)
4130 struct ipa_parm_adjustment
*adj
;
4131 imm_use_iterator ui
;
4135 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
4136 if (adj
->copy_param
|| !is_gimple_reg (adj
->base
))
4138 name
= gimple_default_def (cfun
, adj
->base
);
4141 FOR_EACH_IMM_USE_STMT (stmt
, ui
, name
)
4143 /* All other users must have been removed by
4144 ipa_sra_modify_function_body. */
4145 gcc_assert (is_gimple_debug (stmt
));
4146 gimple_debug_bind_reset_value (stmt
);
4152 /* Return true iff all callers have at least as many actual arguments as there
4153 are formal parameters in the current function. */
4156 all_callers_have_enough_arguments_p (struct cgraph_node
*node
)
4158 struct cgraph_edge
*cs
;
4159 for (cs
= node
->callers
; cs
; cs
= cs
->next_caller
)
4160 if (!callsite_has_enough_arguments_p (cs
->call_stmt
))
4167 /* Convert all callers of NODE to pass parameters as given in ADJUSTMENTS. */
4170 convert_callers (struct cgraph_node
*node
, ipa_parm_adjustment_vec adjustments
)
4172 tree old_cur_fndecl
= current_function_decl
;
4173 struct cgraph_edge
*cs
;
4174 basic_block this_block
;
4175 bitmap recomputed_callers
= BITMAP_ALLOC (NULL
);
4177 for (cs
= node
->callers
; cs
; cs
= cs
->next_caller
)
4179 current_function_decl
= cs
->caller
->decl
;
4180 push_cfun (DECL_STRUCT_FUNCTION (cs
->caller
->decl
));
4183 fprintf (dump_file
, "Adjusting call (%i -> %i) %s -> %s\n",
4184 cs
->caller
->uid
, cs
->callee
->uid
,
4185 cgraph_node_name (cs
->caller
),
4186 cgraph_node_name (cs
->callee
));
4188 ipa_modify_call_arguments (cs
, cs
->call_stmt
, adjustments
);
4193 for (cs
= node
->callers
; cs
; cs
= cs
->next_caller
)
4194 if (!bitmap_bit_p (recomputed_callers
, cs
->caller
->uid
))
4196 compute_inline_parameters (cs
->caller
);
4197 bitmap_set_bit (recomputed_callers
, cs
->caller
->uid
);
4199 BITMAP_FREE (recomputed_callers
);
4201 current_function_decl
= old_cur_fndecl
;
4203 if (!encountered_recursive_call
)
4206 FOR_EACH_BB (this_block
)
4208 gimple_stmt_iterator gsi
;
4210 for (gsi
= gsi_start_bb (this_block
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4212 gimple stmt
= gsi_stmt (gsi
);
4214 if (gimple_code (stmt
) != GIMPLE_CALL
)
4216 call_fndecl
= gimple_call_fndecl (stmt
);
4217 if (call_fndecl
&& cgraph_get_node (call_fndecl
) == node
)
4220 fprintf (dump_file
, "Adjusting recursive call");
4221 ipa_modify_call_arguments (NULL
, stmt
, adjustments
);
4229 /* Perform all the modification required in IPA-SRA for NODE to have parameters
4230 as given in ADJUSTMENTS. */
4233 modify_function (struct cgraph_node
*node
, ipa_parm_adjustment_vec adjustments
)
4235 struct cgraph_node
*new_node
;
4236 struct cgraph_edge
*cs
;
4237 VEC (cgraph_edge_p
, heap
) * redirect_callers
;
4241 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
4243 redirect_callers
= VEC_alloc (cgraph_edge_p
, heap
, node_callers
);
4244 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
4245 VEC_quick_push (cgraph_edge_p
, redirect_callers
, cs
);
4247 rebuild_cgraph_edges ();
4249 current_function_decl
= NULL_TREE
;
4251 new_node
= cgraph_function_versioning (node
, redirect_callers
, NULL
, NULL
,
4252 NULL
, NULL
, "isra");
4253 current_function_decl
= new_node
->decl
;
4254 push_cfun (DECL_STRUCT_FUNCTION (new_node
->decl
));
4256 ipa_modify_formal_parameters (current_function_decl
, adjustments
, "ISRA");
4257 ipa_sra_modify_function_body (adjustments
);
4258 sra_ipa_reset_debug_stmts (adjustments
);
4259 convert_callers (new_node
, adjustments
);
4260 cgraph_make_node_local (new_node
);
4264 /* Return false the function is apparently unsuitable for IPA-SRA based on it's
4265 attributes, return true otherwise. NODE is the cgraph node of the current
4269 ipa_sra_preliminary_function_checks (struct cgraph_node
*node
)
4271 if (!cgraph_node_can_be_local_p (node
))
4274 fprintf (dump_file
, "Function not local to this compilation unit.\n");
4278 if (!tree_versionable_function_p (node
->decl
))
4281 fprintf (dump_file
, "Function not local to this compilation unit.\n");
4285 if (DECL_VIRTUAL_P (current_function_decl
))
4288 fprintf (dump_file
, "Function is a virtual method.\n");
4292 if ((DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
))
4293 && node
->global
.size
>= MAX_INLINE_INSNS_AUTO
)
4296 fprintf (dump_file
, "Function too big to be made truly local.\n");
4304 "Function has no callers in this compilation unit.\n");
4311 fprintf (dump_file
, "Function uses stdarg. \n");
4315 if (TYPE_ATTRIBUTES (TREE_TYPE (node
->decl
)))
4321 /* Perform early interprocedural SRA. */
4324 ipa_early_sra (void)
4326 struct cgraph_node
*node
= cgraph_node (current_function_decl
);
4327 ipa_parm_adjustment_vec adjustments
;
4330 if (!ipa_sra_preliminary_function_checks (node
))
4334 sra_mode
= SRA_MODE_EARLY_IPA
;
4336 if (!find_param_candidates ())
4339 fprintf (dump_file
, "Function has no IPA-SRA candidates.\n");
4343 if (!all_callers_have_enough_arguments_p (node
))
4346 fprintf (dump_file
, "There are callers with insufficient number of "
4351 bb_dereferences
= XCNEWVEC (HOST_WIDE_INT
,
4353 * last_basic_block_for_function (cfun
));
4354 final_bbs
= BITMAP_ALLOC (NULL
);
4357 if (encountered_apply_args
)
4360 fprintf (dump_file
, "Function calls __builtin_apply_args().\n");
4364 if (encountered_unchangable_recursive_call
)
4367 fprintf (dump_file
, "Function calls itself with insufficient "
4368 "number of arguments.\n");
4372 adjustments
= analyze_all_param_acesses ();
4376 ipa_dump_param_adjustments (dump_file
, adjustments
, current_function_decl
);
4378 modify_function (node
, adjustments
);
4379 VEC_free (ipa_parm_adjustment_t
, heap
, adjustments
);
4380 ret
= TODO_update_ssa
;
4382 statistics_counter_event (cfun
, "Unused parameters deleted",
4383 sra_stats
.deleted_unused_parameters
);
4384 statistics_counter_event (cfun
, "Scalar parameters converted to by-value",
4385 sra_stats
.scalar_by_ref_to_by_val
);
4386 statistics_counter_event (cfun
, "Aggregate parameters broken up",
4387 sra_stats
.aggregate_params_reduced
);
4388 statistics_counter_event (cfun
, "Aggregate parameter components created",
4389 sra_stats
.param_reductions_created
);
4392 BITMAP_FREE (final_bbs
);
4393 free (bb_dereferences
);
4395 sra_deinitialize ();
4399 /* Return if early ipa sra shall be performed. */
4401 ipa_early_sra_gate (void)
4403 return flag_ipa_sra
;
4406 struct gimple_opt_pass pass_early_ipa_sra
=
4410 "eipa_sra", /* name */
4411 ipa_early_sra_gate
, /* gate */
4412 ipa_early_sra
, /* execute */
4415 0, /* static_pass_number */
4416 TV_IPA_SRA
, /* tv_id */
4417 0, /* properties_required */
4418 0, /* properties_provided */
4419 0, /* properties_destroyed */
4420 0, /* todo_flags_start */
4421 TODO_dump_func
| TODO_dump_cgraph
/* todo_flags_finish */