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"
93 #include "gimple-pretty-print.h"
95 /* Enumeration of all aggregate reductions we can do. */
96 enum sra_mode { SRA_MODE_EARLY_IPA, /* early call regularization */
97 SRA_MODE_EARLY_INTRA, /* early intraprocedural SRA */
98 SRA_MODE_INTRA }; /* late intraprocedural SRA */
100 /* Global variable describing which aggregate reduction we are performing at
102 static enum sra_mode sra_mode;
106 /* ACCESS represents each access to an aggregate variable (as a whole or a
107 part). It can also represent a group of accesses that refer to exactly the
108 same fragment of an aggregate (i.e. those that have exactly the same offset
109 and size). Such representatives for a single aggregate, once determined,
110 are linked in a linked list and have the group fields set.
112 Moreover, when doing intraprocedural SRA, a tree is built from those
113 representatives (by the means of first_child and next_sibling pointers), in
114 which all items in a subtree are "within" the root, i.e. their offset is
115 greater or equal to offset of the root and offset+size is smaller or equal
116 to offset+size of the root. Children of an access are sorted by offset.
118 Note that accesses to parts of vector and complex number types always
119 represented by an access to the whole complex number or a vector. It is a
120 duty of the modifying functions to replace them appropriately. */
124 /* Values returned by `get_ref_base_and_extent' for each component reference
125 If EXPR isn't a component reference just set `BASE = EXPR', `OFFSET = 0',
126 `SIZE = TREE_SIZE (TREE_TYPE (expr))'. */
127 HOST_WIDE_INT offset;
131 /* Expression. It is context dependent so do not use it to create new
132 expressions to access the original aggregate. See PR 42154 for a
138 /* The statement this access belongs to. */
141 /* Next group representative for this aggregate. */
142 struct access *next_grp;
144 /* Pointer to the group representative. Pointer to itself if the struct is
145 the representative. */
146 struct access *group_representative;
148 /* If this access has any children (in terms of the definition above), this
149 points to the first one. */
150 struct access *first_child;
152 /* In intraprocedural SRA, pointer to the next sibling in the access tree as
153 described above. In IPA-SRA this is a pointer to the next access
154 belonging to the same group (having the same representative). */
155 struct access *next_sibling;
157 /* Pointers to the first and last element in the linked list of assign
159 struct assign_link *first_link, *last_link;
161 /* Pointer to the next access in the work queue. */
162 struct access *next_queued;
164 /* Replacement variable for this access "region." Never to be accessed
165 directly, always only by the means of get_access_replacement() and only
166 when grp_to_be_replaced flag is set. */
167 tree replacement_decl;
169 /* Is this particular access write access? */
172 /* Is this access an artificial one created to scalarize some record
174 unsigned total_scalarization : 1;
176 /* Is this access currently in the work queue? */
177 unsigned grp_queued : 1;
179 /* Does this group contain a write access? This flag is propagated down the
181 unsigned grp_write : 1;
183 /* Does this group contain a read access? This flag is propagated down the
185 unsigned grp_read : 1;
187 /* Does this group contain a read access that comes from an assignment
188 statement? This flag is propagated down the access tree. */
189 unsigned grp_assignment_read : 1;
191 /* Other passes of the analysis use this bit to make function
192 analyze_access_subtree create scalar replacements for this group if
194 unsigned grp_hint : 1;
196 /* Is the subtree rooted in this access fully covered by scalar
198 unsigned grp_covered : 1;
200 /* If set to true, this access and all below it in an access tree must not be
202 unsigned grp_unscalarizable_region : 1;
204 /* Whether data have been written to parts of the aggregate covered by this
205 access which is not to be scalarized. This flag is propagated up in the
207 unsigned grp_unscalarized_data : 1;
209 /* Does this access and/or group contain a write access through a
211 unsigned grp_partial_lhs : 1;
213 /* Set when a scalar replacement should be created for this variable. We do
214 the decision and creation at different places because create_tmp_var
215 cannot be called from within FOR_EACH_REFERENCED_VAR. */
216 unsigned grp_to_be_replaced : 1;
218 /* Is it possible that the group refers to data which might be (directly or
219 otherwise) modified? */
220 unsigned grp_maybe_modified : 1;
222 /* Set when this is a representative of a pointer to scalar (i.e. by
223 reference) parameter which we consider for turning into a plain scalar
224 (i.e. a by value parameter). */
225 unsigned grp_scalar_ptr : 1;
227 /* Set when we discover that this pointer is not safe to dereference in the
229 unsigned grp_not_necessarilly_dereferenced : 1;
232 typedef struct access *access_p;
234 DEF_VEC_P (access_p);
235 DEF_VEC_ALLOC_P (access_p, heap);
237 /* Alloc pool for allocating access structures. */
238 static alloc_pool access_pool;
240 /* A structure linking lhs and rhs accesses from an aggregate assignment. They
241 are used to propagate subaccesses from rhs to lhs as long as they don't
242 conflict with what is already there. */
245 struct access *lacc, *racc;
246 struct assign_link *next;
249 /* Alloc pool for allocating assign link structures. */
250 static alloc_pool link_pool;
252 /* Base (tree) -> Vector (VEC(access_p,heap) *) map. */
253 static struct pointer_map_t *base_access_vec;
255 /* Bitmap of candidates. */
256 static bitmap candidate_bitmap;
258 /* Bitmap of candidates which we should try to entirely scalarize away and
259 those which cannot be (because they are and need be used as a whole). */
260 static bitmap should_scalarize_away_bitmap, cannot_scalarize_away_bitmap;
262 /* Obstack for creation of fancy names. */
263 static struct obstack name_obstack;
265 /* Head of a linked list of accesses that need to have its subaccesses
266 propagated to their assignment counterparts. */
267 static struct access *work_queue_head;
269 /* Number of parameters of the analyzed function when doing early ipa SRA. */
270 static int func_param_count;
272 /* scan_function sets the following to true if it encounters a call to
273 __builtin_apply_args. */
274 static bool encountered_apply_args;
276 /* Set by scan_function when it finds a recursive call. */
277 static bool encountered_recursive_call;
279 /* Set by scan_function when it finds a recursive call with less actual
280 arguments than formal parameters.. */
281 static bool encountered_unchangable_recursive_call;
283 /* This is a table in which for each basic block and parameter there is a
284 distance (offset + size) in that parameter which is dereferenced and
285 accessed in that BB. */
286 static HOST_WIDE_INT *bb_dereferences;
287 /* Bitmap of BBs that can cause the function to "stop" progressing by
288 returning, throwing externally, looping infinitely or calling a function
289 which might abort etc.. */
290 static bitmap final_bbs;
292 /* Representative of no accesses at all. */
293 static struct access no_accesses_representant;
295 /* Predicate to test the special value. */
298 no_accesses_p (struct access *access)
300 return access == &no_accesses_representant;
303 /* Dump contents of ACCESS to file F in a human friendly way. If GRP is true,
304 representative fields are dumped, otherwise those which only describe the
305 individual access are. */
309 /* Number of processed aggregates is readily available in
310 analyze_all_variable_accesses and so is not stored here. */
312 /* Number of created scalar replacements. */
315 /* Number of times sra_modify_expr or sra_modify_assign themselves changed an
319 /* Number of statements created by generate_subtree_copies. */
322 /* Number of statements created by load_assign_lhs_subreplacements. */
325 /* Number of times sra_modify_assign has deleted a statement. */
328 /* Number of times sra_modify_assign has to deal with subaccesses of LHS and
329 RHS reparately due to type conversions or nonexistent matching
331 int separate_lhs_rhs_handling;
333 /* Number of parameters that were removed because they were unused. */
334 int deleted_unused_parameters;
336 /* Number of scalars passed as parameters by reference that have been
337 converted to be passed by value. */
338 int scalar_by_ref_to_by_val;
340 /* Number of aggregate parameters that were replaced by one or more of their
342 int aggregate_params_reduced;
344 /* Numbber of components created when splitting aggregate parameters. */
345 int param_reductions_created;
349 dump_access (FILE *f, struct access *access, bool grp)
351 fprintf (f, "access { ");
352 fprintf (f, "base = (%d)'", DECL_UID (access->base));
353 print_generic_expr (f, access->base, 0);
354 fprintf (f, "', offset = " HOST_WIDE_INT_PRINT_DEC, access->offset);
355 fprintf (f, ", size = " HOST_WIDE_INT_PRINT_DEC, access->size);
356 fprintf (f, ", expr = ");
357 print_generic_expr (f, access->expr, 0);
358 fprintf (f, ", type = ");
359 print_generic_expr (f, access->type, 0);
361 fprintf (f, ", grp_write = %d, total_scalarization = %d, "
362 "grp_read = %d, grp_hint = %d, grp_assignment_read = %d,"
363 "grp_covered = %d, grp_unscalarizable_region = %d, "
364 "grp_unscalarized_data = %d, grp_partial_lhs = %d, "
365 "grp_to_be_replaced = %d, grp_maybe_modified = %d, "
366 "grp_not_necessarilly_dereferenced = %d\n",
367 access->grp_write, access->total_scalarization,
368 access->grp_read, access->grp_hint, access->grp_assignment_read,
369 access->grp_covered, access->grp_unscalarizable_region,
370 access->grp_unscalarized_data, access->grp_partial_lhs,
371 access->grp_to_be_replaced, access->grp_maybe_modified,
372 access->grp_not_necessarilly_dereferenced);
374 fprintf (f, ", write = %d, total_scalarization = %d, "
375 "grp_partial_lhs = %d\n",
376 access->write, access->total_scalarization,
377 access->grp_partial_lhs);
380 /* Dump a subtree rooted in ACCESS to file F, indent by LEVEL. */
383 dump_access_tree_1 (FILE *f, struct access *access, int level)
389 for (i = 0; i < level; i++)
390 fputs ("* ", dump_file);
392 dump_access (f, access, true);
394 if (access->first_child)
395 dump_access_tree_1 (f, access->first_child, level + 1);
397 access = access->next_sibling;
402 /* Dump all access trees for a variable, given the pointer to the first root in
406 dump_access_tree (FILE *f, struct access *access)
408 for (; access; access = access->next_grp)
409 dump_access_tree_1 (f, access, 0);
412 /* Return true iff ACC is non-NULL and has subaccesses. */
415 access_has_children_p (struct access *acc)
417 return acc && acc->first_child;
420 /* Return a vector of pointers to accesses for the variable given in BASE or
421 NULL if there is none. */
423 static VEC (access_p, heap) *
424 get_base_access_vector (tree base)
428 slot = pointer_map_contains (base_access_vec, base);
432 return *(VEC (access_p, heap) **) slot;
435 /* Find an access with required OFFSET and SIZE in a subtree of accesses rooted
436 in ACCESS. Return NULL if it cannot be found. */
438 static struct access *
439 find_access_in_subtree (struct access *access, HOST_WIDE_INT offset,
442 while (access && (access->offset != offset || access->size != size))
444 struct access *child = access->first_child;
446 while (child && (child->offset + child->size <= offset))
447 child = child->next_sibling;
454 /* Return the first group representative for DECL or NULL if none exists. */
456 static struct access *
457 get_first_repr_for_decl (tree base)
459 VEC (access_p, heap) *access_vec;
461 access_vec = get_base_access_vector (base);
465 return VEC_index (access_p, access_vec, 0);
468 /* Find an access representative for the variable BASE and given OFFSET and
469 SIZE. Requires that access trees have already been built. Return NULL if
470 it cannot be found. */
472 static struct access *
473 get_var_base_offset_size_access (tree base, HOST_WIDE_INT offset,
476 struct access *access;
478 access = get_first_repr_for_decl (base);
479 while (access && (access->offset + access->size <= offset))
480 access = access->next_grp;
484 return find_access_in_subtree (access, offset, size);
487 /* Add LINK to the linked list of assign links of RACC. */
489 add_link_to_rhs (struct access *racc, struct assign_link *link)
491 gcc_assert (link->racc == racc);
493 if (!racc->first_link)
495 gcc_assert (!racc->last_link);
496 racc->first_link = link;
499 racc->last_link->next = link;
501 racc->last_link = link;
505 /* Move all link structures in their linked list in OLD_RACC to the linked list
508 relink_to_new_repr (struct access *new_racc, struct access *old_racc)
510 if (!old_racc->first_link)
512 gcc_assert (!old_racc->last_link);
516 if (new_racc->first_link)
518 gcc_assert (!new_racc->last_link->next);
519 gcc_assert (!old_racc->last_link || !old_racc->last_link->next);
521 new_racc->last_link->next = old_racc->first_link;
522 new_racc->last_link = old_racc->last_link;
526 gcc_assert (!new_racc->last_link);
528 new_racc->first_link = old_racc->first_link;
529 new_racc->last_link = old_racc->last_link;
531 old_racc->first_link = old_racc->last_link = NULL;
534 /* Add ACCESS to the work queue (which is actually a stack). */
537 add_access_to_work_queue (struct access *access)
539 if (!access->grp_queued)
541 gcc_assert (!access->next_queued);
542 access->next_queued = work_queue_head;
543 access->grp_queued = 1;
544 work_queue_head = access;
548 /* Pop an access from the work queue, and return it, assuming there is one. */
550 static struct access *
551 pop_access_from_work_queue (void)
553 struct access *access = work_queue_head;
555 work_queue_head = access->next_queued;
556 access->next_queued = NULL;
557 access->grp_queued = 0;
562 /* Allocate necessary structures. */
565 sra_initialize (void)
567 candidate_bitmap = BITMAP_ALLOC (NULL);
568 should_scalarize_away_bitmap = BITMAP_ALLOC (NULL);
569 cannot_scalarize_away_bitmap = BITMAP_ALLOC (NULL);
570 gcc_obstack_init (&name_obstack);
571 access_pool = create_alloc_pool ("SRA accesses", sizeof (struct access), 16);
572 link_pool = create_alloc_pool ("SRA links", sizeof (struct assign_link), 16);
573 base_access_vec = pointer_map_create ();
574 memset (&sra_stats, 0, sizeof (sra_stats));
575 encountered_apply_args = false;
576 encountered_recursive_call = false;
577 encountered_unchangable_recursive_call = false;
580 /* Hook fed to pointer_map_traverse, deallocate stored vectors. */
583 delete_base_accesses (const void *key ATTRIBUTE_UNUSED, void **value,
584 void *data ATTRIBUTE_UNUSED)
586 VEC (access_p, heap) *access_vec;
587 access_vec = (VEC (access_p, heap) *) *value;
588 VEC_free (access_p, heap, access_vec);
593 /* Deallocate all general structures. */
596 sra_deinitialize (void)
598 BITMAP_FREE (candidate_bitmap);
599 BITMAP_FREE (should_scalarize_away_bitmap);
600 BITMAP_FREE (cannot_scalarize_away_bitmap);
601 free_alloc_pool (access_pool);
602 free_alloc_pool (link_pool);
603 obstack_free (&name_obstack, NULL);
605 pointer_map_traverse (base_access_vec, delete_base_accesses, NULL);
606 pointer_map_destroy (base_access_vec);
609 /* Remove DECL from candidates for SRA and write REASON to the dump file if
612 disqualify_candidate (tree decl, const char *reason)
614 bitmap_clear_bit (candidate_bitmap, DECL_UID (decl));
616 if (dump_file && (dump_flags & TDF_DETAILS))
618 fprintf (dump_file, "! Disqualifying ");
619 print_generic_expr (dump_file, decl, 0);
620 fprintf (dump_file, " - %s\n", reason);
624 /* Return true iff the type contains a field or an element which does not allow
628 type_internals_preclude_sra_p (tree type)
633 switch (TREE_CODE (type))
637 case QUAL_UNION_TYPE:
638 for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
639 if (TREE_CODE (fld) == FIELD_DECL)
641 tree ft = TREE_TYPE (fld);
643 if (TREE_THIS_VOLATILE (fld)
644 || !DECL_FIELD_OFFSET (fld) || !DECL_SIZE (fld)
645 || !host_integerp (DECL_FIELD_OFFSET (fld), 1)
646 || !host_integerp (DECL_SIZE (fld), 1))
649 if (AGGREGATE_TYPE_P (ft)
650 && type_internals_preclude_sra_p (ft))
657 et = TREE_TYPE (type);
659 if (AGGREGATE_TYPE_P (et))
660 return type_internals_preclude_sra_p (et);
669 /* If T is an SSA_NAME, return NULL if it is not a default def or return its
670 base variable if it is. Return T if it is not an SSA_NAME. */
673 get_ssa_base_param (tree t)
675 if (TREE_CODE (t) == SSA_NAME)
677 if (SSA_NAME_IS_DEFAULT_DEF (t))
678 return SSA_NAME_VAR (t);
685 /* Mark a dereference of BASE of distance DIST in a basic block tht STMT
686 belongs to, unless the BB has already been marked as a potentially
690 mark_parm_dereference (tree base, HOST_WIDE_INT dist, gimple stmt)
692 basic_block bb = gimple_bb (stmt);
693 int idx, parm_index = 0;
696 if (bitmap_bit_p (final_bbs, bb->index))
699 for (parm = DECL_ARGUMENTS (current_function_decl);
700 parm && parm != base;
701 parm = DECL_CHAIN (parm))
704 gcc_assert (parm_index < func_param_count);
706 idx = bb->index * func_param_count + parm_index;
707 if (bb_dereferences[idx] < dist)
708 bb_dereferences[idx] = dist;
711 /* Allocate an access structure for BASE, OFFSET and SIZE, clear it, fill in
712 the three fields. Also add it to the vector of accesses corresponding to
713 the base. Finally, return the new access. */
715 static struct access *
716 create_access_1 (tree base, HOST_WIDE_INT offset, HOST_WIDE_INT size)
718 VEC (access_p, heap) *vec;
719 struct access *access;
722 access = (struct access *) pool_alloc (access_pool);
723 memset (access, 0, sizeof (struct access));
725 access->offset = offset;
728 slot = pointer_map_contains (base_access_vec, base);
730 vec = (VEC (access_p, heap) *) *slot;
732 vec = VEC_alloc (access_p, heap, 32);
734 VEC_safe_push (access_p, heap, vec, access);
736 *((struct VEC (access_p,heap) **)
737 pointer_map_insert (base_access_vec, base)) = vec;
742 /* Create and insert access for EXPR. Return created access, or NULL if it is
745 static struct access *
746 create_access (tree expr, gimple stmt, bool write)
748 struct access *access;
749 HOST_WIDE_INT offset, size, max_size;
751 bool ptr, unscalarizable_region = false;
753 base = get_ref_base_and_extent (expr, &offset, &size, &max_size);
755 if (sra_mode == SRA_MODE_EARLY_IPA
756 && TREE_CODE (base) == MEM_REF)
758 base = get_ssa_base_param (TREE_OPERAND (base, 0));
766 if (!DECL_P (base) || !bitmap_bit_p (candidate_bitmap, DECL_UID (base)))
769 if (sra_mode == SRA_MODE_EARLY_IPA)
771 if (size < 0 || size != max_size)
773 disqualify_candidate (base, "Encountered a variable sized access.");
776 if ((offset % BITS_PER_UNIT) != 0 || (size % BITS_PER_UNIT) != 0)
778 disqualify_candidate (base,
779 "Encountered an acces not aligned to a byte.");
784 mark_parm_dereference (base, offset + size, stmt);
788 if (size != max_size)
791 unscalarizable_region = true;
795 disqualify_candidate (base, "Encountered an unconstrained access.");
800 access = create_access_1 (base, offset, size);
802 access->type = TREE_TYPE (expr);
803 access->write = write;
804 access->grp_unscalarizable_region = unscalarizable_region;
811 /* Return true iff TYPE is a RECORD_TYPE with fields that are either of gimple
812 register types or (recursively) records with only these two kinds of fields.
813 It also returns false if any of these records has a zero-size field as its
817 type_consists_of_records_p (tree type)
820 bool last_fld_has_zero_size = false;
822 if (TREE_CODE (type) != RECORD_TYPE)
825 for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
826 if (TREE_CODE (fld) == FIELD_DECL)
828 tree ft = TREE_TYPE (fld);
830 if (!is_gimple_reg_type (ft)
831 && !type_consists_of_records_p (ft))
834 last_fld_has_zero_size = tree_low_cst (DECL_SIZE (fld), 1) == 0;
837 if (last_fld_has_zero_size)
843 /* Create total_scalarization accesses for all scalar type fields in DECL that
844 must be of a RECORD_TYPE conforming to type_consists_of_records_p. BASE
845 must be the top-most VAR_DECL representing the variable, OFFSET must be the
846 offset of DECL within BASE. REF must be the memory reference expression for
850 completely_scalarize_record (tree base, tree decl, HOST_WIDE_INT offset,
853 tree fld, decl_type = TREE_TYPE (decl);
855 for (fld = TYPE_FIELDS (decl_type); fld; fld = DECL_CHAIN (fld))
856 if (TREE_CODE (fld) == FIELD_DECL)
858 HOST_WIDE_INT pos = offset + int_bit_position (fld);
859 tree ft = TREE_TYPE (fld);
860 tree nref = build3 (COMPONENT_REF, TREE_TYPE (fld), ref, fld,
863 if (is_gimple_reg_type (ft))
865 struct access *access;
868 size = tree_low_cst (DECL_SIZE (fld), 1);
869 access = create_access_1 (base, pos, size);
872 access->total_scalarization = 1;
873 /* Accesses for intraprocedural SRA can have their stmt NULL. */
876 completely_scalarize_record (base, fld, pos, nref);
881 /* Search the given tree for a declaration by skipping handled components and
882 exclude it from the candidates. */
885 disqualify_base_of_expr (tree t, const char *reason)
887 t = get_base_address (t);
888 if (sra_mode == SRA_MODE_EARLY_IPA
889 && TREE_CODE (t) == MEM_REF)
890 t = get_ssa_base_param (TREE_OPERAND (t, 0));
893 disqualify_candidate (t, reason);
896 /* Scan expression EXPR and create access structures for all accesses to
897 candidates for scalarization. Return the created access or NULL if none is
900 static struct access *
901 build_access_from_expr_1 (tree expr, gimple stmt, bool write)
903 struct access *ret = NULL;
906 if (TREE_CODE (expr) == BIT_FIELD_REF
907 || TREE_CODE (expr) == IMAGPART_EXPR
908 || TREE_CODE (expr) == REALPART_EXPR)
910 expr = TREE_OPERAND (expr, 0);
916 /* We need to dive through V_C_Es in order to get the size of its parameter
917 and not the result type. Ada produces such statements. We are also
918 capable of handling the topmost V_C_E but not any of those buried in other
919 handled components. */
920 if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
921 expr = TREE_OPERAND (expr, 0);
923 if (contains_view_convert_expr_p (expr))
925 disqualify_base_of_expr (expr, "V_C_E under a different handled "
930 switch (TREE_CODE (expr))
933 if (TREE_CODE (TREE_OPERAND (expr, 0)) != ADDR_EXPR
934 && sra_mode != SRA_MODE_EARLY_IPA)
942 case ARRAY_RANGE_REF:
943 ret = create_access (expr, stmt, write);
950 if (write && partial_ref && ret)
951 ret->grp_partial_lhs = 1;
956 /* Scan expression EXPR and create access structures for all accesses to
957 candidates for scalarization. Return true if any access has been inserted.
958 STMT must be the statement from which the expression is taken, WRITE must be
959 true if the expression is a store and false otherwise. */
962 build_access_from_expr (tree expr, gimple stmt, bool write)
964 struct access *access;
966 access = build_access_from_expr_1 (expr, stmt, write);
969 /* This means the aggregate is accesses as a whole in a way other than an
970 assign statement and thus cannot be removed even if we had a scalar
971 replacement for everything. */
972 if (cannot_scalarize_away_bitmap)
973 bitmap_set_bit (cannot_scalarize_away_bitmap, DECL_UID (access->base));
979 /* Disqualify LHS and RHS for scalarization if STMT must end its basic block in
980 modes in which it matters, return true iff they have been disqualified. RHS
981 may be NULL, in that case ignore it. If we scalarize an aggregate in
982 intra-SRA we may need to add statements after each statement. This is not
983 possible if a statement unconditionally has to end the basic block. */
985 disqualify_ops_if_throwing_stmt (gimple stmt, tree lhs, tree rhs)
987 if ((sra_mode == SRA_MODE_EARLY_INTRA || sra_mode == SRA_MODE_INTRA)
988 && (stmt_can_throw_internal (stmt) || stmt_ends_bb_p (stmt)))
990 disqualify_base_of_expr (lhs, "LHS of a throwing stmt.");
992 disqualify_base_of_expr (rhs, "RHS of a throwing stmt.");
998 /* Scan expressions occuring in STMT, create access structures for all accesses
999 to candidates for scalarization and remove those candidates which occur in
1000 statements or expressions that prevent them from being split apart. Return
1001 true if any access has been inserted. */
1004 build_accesses_from_assign (gimple stmt)
1007 struct access *lacc, *racc;
1009 if (!gimple_assign_single_p (stmt))
1012 lhs = gimple_assign_lhs (stmt);
1013 rhs = gimple_assign_rhs1 (stmt);
1015 if (disqualify_ops_if_throwing_stmt (stmt, lhs, rhs))
1018 racc = build_access_from_expr_1 (rhs, stmt, false);
1019 lacc = build_access_from_expr_1 (lhs, stmt, true);
1023 racc->grp_assignment_read = 1;
1024 if (should_scalarize_away_bitmap && !gimple_has_volatile_ops (stmt)
1025 && !is_gimple_reg_type (racc->type))
1026 bitmap_set_bit (should_scalarize_away_bitmap, DECL_UID (racc->base));
1030 && (sra_mode == SRA_MODE_EARLY_INTRA || sra_mode == SRA_MODE_INTRA)
1031 && !lacc->grp_unscalarizable_region
1032 && !racc->grp_unscalarizable_region
1033 && AGGREGATE_TYPE_P (TREE_TYPE (lhs))
1034 /* FIXME: Turn the following line into an assert after PR 40058 is
1036 && lacc->size == racc->size
1037 && useless_type_conversion_p (lacc->type, racc->type))
1039 struct assign_link *link;
1041 link = (struct assign_link *) pool_alloc (link_pool);
1042 memset (link, 0, sizeof (struct assign_link));
1047 add_link_to_rhs (racc, link);
1050 return lacc || racc;
1053 /* Callback of walk_stmt_load_store_addr_ops visit_addr used to determine
1054 GIMPLE_ASM operands with memory constrains which cannot be scalarized. */
1057 asm_visit_addr (gimple stmt ATTRIBUTE_UNUSED, tree op,
1058 void *data ATTRIBUTE_UNUSED)
1060 op = get_base_address (op);
1063 disqualify_candidate (op, "Non-scalarizable GIMPLE_ASM operand.");
1068 /* Return true iff callsite CALL has at least as many actual arguments as there
1069 are formal parameters of the function currently processed by IPA-SRA. */
1072 callsite_has_enough_arguments_p (gimple call)
1074 return gimple_call_num_args (call) >= (unsigned) func_param_count;
1077 /* Scan function and look for interesting expressions and create access
1078 structures for them. Return true iff any access is created. */
1081 scan_function (void)
1088 gimple_stmt_iterator gsi;
1089 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1091 gimple stmt = gsi_stmt (gsi);
1095 if (final_bbs && stmt_can_throw_external (stmt))
1096 bitmap_set_bit (final_bbs, bb->index);
1097 switch (gimple_code (stmt))
1100 t = gimple_return_retval (stmt);
1102 ret |= build_access_from_expr (t, stmt, false);
1104 bitmap_set_bit (final_bbs, bb->index);
1108 ret |= build_accesses_from_assign (stmt);
1112 for (i = 0; i < gimple_call_num_args (stmt); i++)
1113 ret |= build_access_from_expr (gimple_call_arg (stmt, i),
1116 if (sra_mode == SRA_MODE_EARLY_IPA)
1118 tree dest = gimple_call_fndecl (stmt);
1119 int flags = gimple_call_flags (stmt);
1123 if (DECL_BUILT_IN_CLASS (dest) == BUILT_IN_NORMAL
1124 && DECL_FUNCTION_CODE (dest) == BUILT_IN_APPLY_ARGS)
1125 encountered_apply_args = true;
1126 if (cgraph_get_node (dest)
1127 == cgraph_get_node (current_function_decl))
1129 encountered_recursive_call = true;
1130 if (!callsite_has_enough_arguments_p (stmt))
1131 encountered_unchangable_recursive_call = true;
1136 && (flags & (ECF_CONST | ECF_PURE)) == 0)
1137 bitmap_set_bit (final_bbs, bb->index);
1140 t = gimple_call_lhs (stmt);
1141 if (t && !disqualify_ops_if_throwing_stmt (stmt, t, NULL))
1142 ret |= build_access_from_expr (t, stmt, true);
1146 walk_stmt_load_store_addr_ops (stmt, NULL, NULL, NULL,
1149 bitmap_set_bit (final_bbs, bb->index);
1151 for (i = 0; i < gimple_asm_ninputs (stmt); i++)
1153 t = TREE_VALUE (gimple_asm_input_op (stmt, i));
1154 ret |= build_access_from_expr (t, stmt, false);
1156 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
1158 t = TREE_VALUE (gimple_asm_output_op (stmt, i));
1159 ret |= build_access_from_expr (t, stmt, true);
1172 /* Helper of QSORT function. There are pointers to accesses in the array. An
1173 access is considered smaller than another if it has smaller offset or if the
1174 offsets are the same but is size is bigger. */
1177 compare_access_positions (const void *a, const void *b)
1179 const access_p *fp1 = (const access_p *) a;
1180 const access_p *fp2 = (const access_p *) b;
1181 const access_p f1 = *fp1;
1182 const access_p f2 = *fp2;
1184 if (f1->offset != f2->offset)
1185 return f1->offset < f2->offset ? -1 : 1;
1187 if (f1->size == f2->size)
1189 if (f1->type == f2->type)
1191 /* Put any non-aggregate type before any aggregate type. */
1192 else if (!is_gimple_reg_type (f1->type)
1193 && is_gimple_reg_type (f2->type))
1195 else if (is_gimple_reg_type (f1->type)
1196 && !is_gimple_reg_type (f2->type))
1198 /* Put any complex or vector type before any other scalar type. */
1199 else if (TREE_CODE (f1->type) != COMPLEX_TYPE
1200 && TREE_CODE (f1->type) != VECTOR_TYPE
1201 && (TREE_CODE (f2->type) == COMPLEX_TYPE
1202 || TREE_CODE (f2->type) == VECTOR_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 /* Put the integral type with the bigger precision first. */
1210 else if (INTEGRAL_TYPE_P (f1->type)
1211 && INTEGRAL_TYPE_P (f2->type))
1212 return TYPE_PRECISION (f2->type) - TYPE_PRECISION (f1->type);
1213 /* Put any integral type with non-full precision last. */
1214 else if (INTEGRAL_TYPE_P (f1->type)
1215 && (TREE_INT_CST_LOW (TYPE_SIZE (f1->type))
1216 != TYPE_PRECISION (f1->type)))
1218 else if (INTEGRAL_TYPE_P (f2->type)
1219 && (TREE_INT_CST_LOW (TYPE_SIZE (f2->type))
1220 != TYPE_PRECISION (f2->type)))
1222 /* Stabilize the sort. */
1223 return TYPE_UID (f1->type) - TYPE_UID (f2->type);
1226 /* We want the bigger accesses first, thus the opposite operator in the next
1228 return f1->size > f2->size ? -1 : 1;
1232 /* Append a name of the declaration to the name obstack. A helper function for
1236 make_fancy_decl_name (tree decl)
1240 tree name = DECL_NAME (decl);
1242 obstack_grow (&name_obstack, IDENTIFIER_POINTER (name),
1243 IDENTIFIER_LENGTH (name));
1246 sprintf (buffer, "D%u", DECL_UID (decl));
1247 obstack_grow (&name_obstack, buffer, strlen (buffer));
1251 /* Helper for make_fancy_name. */
1254 make_fancy_name_1 (tree expr)
1261 make_fancy_decl_name (expr);
1265 switch (TREE_CODE (expr))
1268 make_fancy_name_1 (TREE_OPERAND (expr, 0));
1269 obstack_1grow (&name_obstack, '$');
1270 make_fancy_decl_name (TREE_OPERAND (expr, 1));
1274 make_fancy_name_1 (TREE_OPERAND (expr, 0));
1275 obstack_1grow (&name_obstack, '$');
1276 /* Arrays with only one element may not have a constant as their
1278 index = TREE_OPERAND (expr, 1);
1279 if (TREE_CODE (index) != INTEGER_CST)
1281 sprintf (buffer, HOST_WIDE_INT_PRINT_DEC, TREE_INT_CST_LOW (index));
1282 obstack_grow (&name_obstack, buffer, strlen (buffer));
1286 make_fancy_name_1 (TREE_OPERAND (expr, 0));
1290 make_fancy_name_1 (TREE_OPERAND (expr, 0));
1291 if (!integer_zerop (TREE_OPERAND (expr, 1)))
1293 obstack_1grow (&name_obstack, '$');
1294 sprintf (buffer, HOST_WIDE_INT_PRINT_DEC,
1295 TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)));
1296 obstack_grow (&name_obstack, buffer, strlen (buffer));
1303 gcc_unreachable (); /* we treat these as scalars. */
1310 /* Create a human readable name for replacement variable of ACCESS. */
1313 make_fancy_name (tree expr)
1315 make_fancy_name_1 (expr);
1316 obstack_1grow (&name_obstack, '\0');
1317 return XOBFINISH (&name_obstack, char *);
1320 /* Helper function for build_ref_for_offset.
1322 FIXME: Eventually this should be rewritten to either re-use the
1323 original access expression unshared (which is good for alias
1324 analysis) or to build a MEM_REF expression. */
1327 build_ref_for_offset_1 (tree *res, tree type, HOST_WIDE_INT offset,
1333 tree tr_size, index, minidx;
1334 HOST_WIDE_INT el_size;
1336 if (offset == 0 && exp_type
1337 && types_compatible_p (exp_type, type))
1340 switch (TREE_CODE (type))
1343 case QUAL_UNION_TYPE:
1345 for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
1347 HOST_WIDE_INT pos, size;
1348 tree expr, *expr_ptr;
1350 if (TREE_CODE (fld) != FIELD_DECL)
1353 pos = int_bit_position (fld);
1354 gcc_assert (TREE_CODE (type) == RECORD_TYPE || pos == 0);
1355 tr_size = DECL_SIZE (fld);
1356 if (!tr_size || !host_integerp (tr_size, 1))
1358 size = tree_low_cst (tr_size, 1);
1364 else if (pos > offset || (pos + size) <= offset)
1369 expr = build3 (COMPONENT_REF, TREE_TYPE (fld), *res, fld,
1375 if (build_ref_for_offset_1 (expr_ptr, TREE_TYPE (fld),
1376 offset - pos, exp_type))
1386 tr_size = TYPE_SIZE (TREE_TYPE (type));
1387 if (!tr_size || !host_integerp (tr_size, 1))
1389 el_size = tree_low_cst (tr_size, 1);
1391 minidx = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
1392 if (TREE_CODE (minidx) != INTEGER_CST || el_size == 0)
1396 index = build_int_cst (TYPE_DOMAIN (type), offset / el_size);
1397 if (!integer_zerop (minidx))
1398 index = int_const_binop (PLUS_EXPR, index, minidx, 0);
1399 *res = build4 (ARRAY_REF, TREE_TYPE (type), *res, index,
1400 NULL_TREE, NULL_TREE);
1402 offset = offset % el_size;
1403 type = TREE_TYPE (type);
1418 /* Construct an expression that would reference a part of aggregate *EXPR of
1419 type TYPE at the given OFFSET of the type EXP_TYPE. If EXPR is NULL, the
1420 function only determines whether it can build such a reference without
1421 actually doing it, otherwise, the tree it points to is unshared first and
1422 then used as a base for furhter sub-references. */
1425 build_ref_for_offset (tree *expr, tree type, HOST_WIDE_INT offset,
1426 tree exp_type, bool allow_ptr)
1428 location_t loc = expr ? EXPR_LOCATION (*expr) : UNKNOWN_LOCATION;
1431 *expr = unshare_expr (*expr);
1433 if (allow_ptr && POINTER_TYPE_P (type))
1435 type = TREE_TYPE (type);
1437 *expr = build_simple_mem_ref_loc (loc, *expr);
1440 return build_ref_for_offset_1 (expr, type, offset, exp_type);
1443 /* Return true iff TYPE is stdarg va_list type. */
1446 is_va_list_type (tree type)
1448 return TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (va_list_type_node);
1451 /* The very first phase of intraprocedural SRA. It marks in candidate_bitmap
1452 those with type which is suitable for scalarization. */
1455 find_var_candidates (void)
1458 referenced_var_iterator rvi;
1461 FOR_EACH_REFERENCED_VAR (var, rvi)
1463 if (TREE_CODE (var) != VAR_DECL && TREE_CODE (var) != PARM_DECL)
1465 type = TREE_TYPE (var);
1467 if (!AGGREGATE_TYPE_P (type)
1468 || needs_to_live_in_memory (var)
1469 || TREE_THIS_VOLATILE (var)
1470 || !COMPLETE_TYPE_P (type)
1471 || !host_integerp (TYPE_SIZE (type), 1)
1472 || tree_low_cst (TYPE_SIZE (type), 1) == 0
1473 || type_internals_preclude_sra_p (type)
1474 /* Fix for PR 41089. tree-stdarg.c needs to have va_lists intact but
1475 we also want to schedule it rather late. Thus we ignore it in
1477 || (sra_mode == SRA_MODE_EARLY_INTRA
1478 && is_va_list_type (type)))
1481 bitmap_set_bit (candidate_bitmap, DECL_UID (var));
1483 if (dump_file && (dump_flags & TDF_DETAILS))
1485 fprintf (dump_file, "Candidate (%d): ", DECL_UID (var));
1486 print_generic_expr (dump_file, var, 0);
1487 fprintf (dump_file, "\n");
1495 /* Sort all accesses for the given variable, check for partial overlaps and
1496 return NULL if there are any. If there are none, pick a representative for
1497 each combination of offset and size and create a linked list out of them.
1498 Return the pointer to the first representative and make sure it is the first
1499 one in the vector of accesses. */
1501 static struct access *
1502 sort_and_splice_var_accesses (tree var)
1504 int i, j, access_count;
1505 struct access *res, **prev_acc_ptr = &res;
1506 VEC (access_p, heap) *access_vec;
1508 HOST_WIDE_INT low = -1, high = 0;
1510 access_vec = get_base_access_vector (var);
1513 access_count = VEC_length (access_p, access_vec);
1515 /* Sort by <OFFSET, SIZE>. */
1516 qsort (VEC_address (access_p, access_vec), access_count, sizeof (access_p),
1517 compare_access_positions);
1520 while (i < access_count)
1522 struct access *access = VEC_index (access_p, access_vec, i);
1523 bool grp_write = access->write;
1524 bool grp_read = !access->write;
1525 bool grp_assignment_read = access->grp_assignment_read;
1526 bool multiple_reads = false;
1527 bool total_scalarization = access->total_scalarization;
1528 bool grp_partial_lhs = access->grp_partial_lhs;
1529 bool first_scalar = is_gimple_reg_type (access->type);
1530 bool unscalarizable_region = access->grp_unscalarizable_region;
1532 if (first || access->offset >= high)
1535 low = access->offset;
1536 high = access->offset + access->size;
1538 else if (access->offset > low && access->offset + access->size > high)
1541 gcc_assert (access->offset >= low
1542 && access->offset + access->size <= high);
1545 while (j < access_count)
1547 struct access *ac2 = VEC_index (access_p, access_vec, j);
1548 if (ac2->offset != access->offset || ac2->size != access->size)
1555 multiple_reads = true;
1559 grp_assignment_read |= ac2->grp_assignment_read;
1560 grp_partial_lhs |= ac2->grp_partial_lhs;
1561 unscalarizable_region |= ac2->grp_unscalarizable_region;
1562 total_scalarization |= ac2->total_scalarization;
1563 relink_to_new_repr (access, ac2);
1565 /* If there are both aggregate-type and scalar-type accesses with
1566 this combination of size and offset, the comparison function
1567 should have put the scalars first. */
1568 gcc_assert (first_scalar || !is_gimple_reg_type (ac2->type));
1569 ac2->group_representative = access;
1575 access->group_representative = access;
1576 access->grp_write = grp_write;
1577 access->grp_read = grp_read;
1578 access->grp_assignment_read = grp_assignment_read;
1579 access->grp_hint = multiple_reads || total_scalarization;
1580 access->grp_partial_lhs = grp_partial_lhs;
1581 access->grp_unscalarizable_region = unscalarizable_region;
1582 if (access->first_link)
1583 add_access_to_work_queue (access);
1585 *prev_acc_ptr = access;
1586 prev_acc_ptr = &access->next_grp;
1589 gcc_assert (res == VEC_index (access_p, access_vec, 0));
1593 /* Create a variable for the given ACCESS which determines the type, name and a
1594 few other properties. Return the variable declaration and store it also to
1595 ACCESS->replacement. */
1598 create_access_replacement (struct access *access, bool rename)
1602 repl = create_tmp_var (access->type, "SR");
1604 add_referenced_var (repl);
1606 mark_sym_for_renaming (repl);
1608 if (!access->grp_partial_lhs
1609 && (TREE_CODE (access->type) == COMPLEX_TYPE
1610 || TREE_CODE (access->type) == VECTOR_TYPE))
1611 DECL_GIMPLE_REG_P (repl) = 1;
1613 DECL_SOURCE_LOCATION (repl) = DECL_SOURCE_LOCATION (access->base);
1614 DECL_ARTIFICIAL (repl) = 1;
1615 DECL_IGNORED_P (repl) = DECL_IGNORED_P (access->base);
1617 if (DECL_NAME (access->base)
1618 && !DECL_IGNORED_P (access->base)
1619 && !DECL_ARTIFICIAL (access->base))
1621 char *pretty_name = make_fancy_name (access->expr);
1622 tree debug_expr = unshare_expr (access->expr), d;
1624 DECL_NAME (repl) = get_identifier (pretty_name);
1625 obstack_free (&name_obstack, pretty_name);
1627 /* Get rid of any SSA_NAMEs embedded in debug_expr,
1628 as DECL_DEBUG_EXPR isn't considered when looking for still
1629 used SSA_NAMEs and thus they could be freed. All debug info
1630 generation cares is whether something is constant or variable
1631 and that get_ref_base_and_extent works properly on the
1633 for (d = debug_expr; handled_component_p (d); d = TREE_OPERAND (d, 0))
1634 switch (TREE_CODE (d))
1637 case ARRAY_RANGE_REF:
1638 if (TREE_OPERAND (d, 1)
1639 && TREE_CODE (TREE_OPERAND (d, 1)) == SSA_NAME)
1640 TREE_OPERAND (d, 1) = SSA_NAME_VAR (TREE_OPERAND (d, 1));
1641 if (TREE_OPERAND (d, 3)
1642 && TREE_CODE (TREE_OPERAND (d, 3)) == SSA_NAME)
1643 TREE_OPERAND (d, 3) = SSA_NAME_VAR (TREE_OPERAND (d, 3));
1646 if (TREE_OPERAND (d, 2)
1647 && TREE_CODE (TREE_OPERAND (d, 2)) == SSA_NAME)
1648 TREE_OPERAND (d, 2) = SSA_NAME_VAR (TREE_OPERAND (d, 2));
1653 SET_DECL_DEBUG_EXPR (repl, debug_expr);
1654 DECL_DEBUG_EXPR_IS_FROM (repl) = 1;
1655 TREE_NO_WARNING (repl) = TREE_NO_WARNING (access->base);
1658 TREE_NO_WARNING (repl) = 1;
1662 fprintf (dump_file, "Created a replacement for ");
1663 print_generic_expr (dump_file, access->base, 0);
1664 fprintf (dump_file, " offset: %u, size: %u: ",
1665 (unsigned) access->offset, (unsigned) access->size);
1666 print_generic_expr (dump_file, repl, 0);
1667 fprintf (dump_file, "\n");
1669 sra_stats.replacements++;
1674 /* Return ACCESS scalar replacement, create it if it does not exist yet. */
1677 get_access_replacement (struct access *access)
1679 gcc_assert (access->grp_to_be_replaced);
1681 if (!access->replacement_decl)
1682 access->replacement_decl = create_access_replacement (access, true);
1683 return access->replacement_decl;
1686 /* Return ACCESS scalar replacement, create it if it does not exist yet but do
1687 not mark it for renaming. */
1690 get_unrenamed_access_replacement (struct access *access)
1692 gcc_assert (!access->grp_to_be_replaced);
1694 if (!access->replacement_decl)
1695 access->replacement_decl = create_access_replacement (access, false);
1696 return access->replacement_decl;
1700 /* Build a subtree of accesses rooted in *ACCESS, and move the pointer in the
1701 linked list along the way. Stop when *ACCESS is NULL or the access pointed
1702 to it is not "within" the root. Return false iff some accesses partially
1706 build_access_subtree (struct access **access)
1708 struct access *root = *access, *last_child = NULL;
1709 HOST_WIDE_INT limit = root->offset + root->size;
1711 *access = (*access)->next_grp;
1712 while (*access && (*access)->offset + (*access)->size <= limit)
1715 root->first_child = *access;
1717 last_child->next_sibling = *access;
1718 last_child = *access;
1720 if (!build_access_subtree (access))
1724 if (*access && (*access)->offset < limit)
1730 /* Build a tree of access representatives, ACCESS is the pointer to the first
1731 one, others are linked in a list by the next_grp field. Return false iff
1732 some accesses partially overlap. */
1735 build_access_trees (struct access *access)
1739 struct access *root = access;
1741 if (!build_access_subtree (&access))
1743 root->next_grp = access;
1748 /* Return true if expr contains some ARRAY_REFs into a variable bounded
1752 expr_with_var_bounded_array_refs_p (tree expr)
1754 while (handled_component_p (expr))
1756 if (TREE_CODE (expr) == ARRAY_REF
1757 && !host_integerp (array_ref_low_bound (expr), 0))
1759 expr = TREE_OPERAND (expr, 0);
1764 enum mark_read_status { SRA_MR_NOT_READ, SRA_MR_READ, SRA_MR_ASSIGN_READ};
1766 /* Analyze the subtree of accesses rooted in ROOT, scheduling replacements when
1767 both seeming beneficial and when ALLOW_REPLACEMENTS allows it. Also set all
1768 sorts of access flags appropriately along the way, notably always set
1769 grp_read and grp_assign_read according to MARK_READ and grp_write when
1770 MARK_WRITE is true. */
1773 analyze_access_subtree (struct access *root, bool allow_replacements,
1774 enum mark_read_status mark_read, bool mark_write)
1776 struct access *child;
1777 HOST_WIDE_INT limit = root->offset + root->size;
1778 HOST_WIDE_INT covered_to = root->offset;
1779 bool scalar = is_gimple_reg_type (root->type);
1780 bool hole = false, sth_created = false;
1781 bool direct_read = root->grp_read;
1783 if (mark_read == SRA_MR_ASSIGN_READ)
1786 root->grp_assignment_read = 1;
1788 if (mark_read == SRA_MR_READ)
1790 else if (root->grp_assignment_read)
1791 mark_read = SRA_MR_ASSIGN_READ;
1792 else if (root->grp_read)
1793 mark_read = SRA_MR_READ;
1796 root->grp_write = true;
1797 else if (root->grp_write)
1800 if (root->grp_unscalarizable_region)
1801 allow_replacements = false;
1803 if (allow_replacements && expr_with_var_bounded_array_refs_p (root->expr))
1804 allow_replacements = false;
1806 for (child = root->first_child; child; child = child->next_sibling)
1808 if (!hole && child->offset < covered_to)
1811 covered_to += child->size;
1813 sth_created |= analyze_access_subtree (child,
1814 allow_replacements && !scalar,
1815 mark_read, mark_write);
1817 root->grp_unscalarized_data |= child->grp_unscalarized_data;
1818 hole |= !child->grp_covered;
1821 if (allow_replacements && scalar && !root->first_child
1823 || (root->grp_write && (direct_read || root->grp_assignment_read)))
1824 /* We must not ICE later on when trying to build an access to the
1825 original data within the aggregate even when it is impossible to do in
1826 a defined way like in the PR 42703 testcase. Therefore we check
1827 pre-emptively here that we will be able to do that. */
1828 && build_ref_for_offset (NULL, TREE_TYPE (root->base), root->offset,
1831 if (dump_file && (dump_flags & TDF_DETAILS))
1833 fprintf (dump_file, "Marking ");
1834 print_generic_expr (dump_file, root->base, 0);
1835 fprintf (dump_file, " offset: %u, size: %u: ",
1836 (unsigned) root->offset, (unsigned) root->size);
1837 fprintf (dump_file, " to be replaced.\n");
1840 root->grp_to_be_replaced = 1;
1844 else if (covered_to < limit)
1847 if (sth_created && !hole)
1849 root->grp_covered = 1;
1852 if (root->grp_write || TREE_CODE (root->base) == PARM_DECL)
1853 root->grp_unscalarized_data = 1; /* not covered and written to */
1859 /* Analyze all access trees linked by next_grp by the means of
1860 analyze_access_subtree. */
1862 analyze_access_trees (struct access *access)
1868 if (analyze_access_subtree (access, true, SRA_MR_NOT_READ, false))
1870 access = access->next_grp;
1876 /* Return true iff a potential new child of LACC at offset OFFSET and with size
1877 SIZE would conflict with an already existing one. If exactly such a child
1878 already exists in LACC, store a pointer to it in EXACT_MATCH. */
1881 child_would_conflict_in_lacc (struct access *lacc, HOST_WIDE_INT norm_offset,
1882 HOST_WIDE_INT size, struct access **exact_match)
1884 struct access *child;
1886 for (child = lacc->first_child; child; child = child->next_sibling)
1888 if (child->offset == norm_offset && child->size == size)
1890 *exact_match = child;
1894 if (child->offset < norm_offset + size
1895 && child->offset + child->size > norm_offset)
1902 /* Create a new child access of PARENT, with all properties just like MODEL
1903 except for its offset and with its grp_write false and grp_read true.
1904 Return the new access or NULL if it cannot be created. Note that this access
1905 is created long after all splicing and sorting, it's not located in any
1906 access vector and is automatically a representative of its group. */
1908 static struct access *
1909 create_artificial_child_access (struct access *parent, struct access *model,
1910 HOST_WIDE_INT new_offset)
1912 struct access *access;
1913 struct access **child;
1914 tree expr = parent->base;;
1916 gcc_assert (!model->grp_unscalarizable_region);
1918 if (!build_ref_for_offset (&expr, TREE_TYPE (expr), new_offset,
1919 model->type, false))
1922 access = (struct access *) pool_alloc (access_pool);
1923 memset (access, 0, sizeof (struct access));
1924 access->base = parent->base;
1925 access->expr = expr;
1926 access->offset = new_offset;
1927 access->size = model->size;
1928 access->type = model->type;
1929 access->grp_write = true;
1930 access->grp_read = false;
1932 child = &parent->first_child;
1933 while (*child && (*child)->offset < new_offset)
1934 child = &(*child)->next_sibling;
1936 access->next_sibling = *child;
1943 /* Propagate all subaccesses of RACC across an assignment link to LACC. Return
1944 true if any new subaccess was created. Additionally, if RACC is a scalar
1945 access but LACC is not, change the type of the latter, if possible. */
1948 propagate_subaccesses_across_link (struct access *lacc, struct access *racc)
1950 struct access *rchild;
1951 HOST_WIDE_INT norm_delta = lacc->offset - racc->offset;
1954 if (is_gimple_reg_type (lacc->type)
1955 || lacc->grp_unscalarizable_region
1956 || racc->grp_unscalarizable_region)
1959 if (!lacc->first_child && !racc->first_child
1960 && is_gimple_reg_type (racc->type))
1962 tree t = lacc->base;
1964 if (build_ref_for_offset (&t, TREE_TYPE (t), lacc->offset, racc->type,
1968 lacc->type = racc->type;
1973 for (rchild = racc->first_child; rchild; rchild = rchild->next_sibling)
1975 struct access *new_acc = NULL;
1976 HOST_WIDE_INT norm_offset = rchild->offset + norm_delta;
1978 if (rchild->grp_unscalarizable_region)
1981 if (child_would_conflict_in_lacc (lacc, norm_offset, rchild->size,
1986 rchild->grp_hint = 1;
1987 new_acc->grp_hint |= new_acc->grp_read;
1988 if (rchild->first_child)
1989 ret |= propagate_subaccesses_across_link (new_acc, rchild);
1994 /* If a (part of) a union field is on the RHS of an assignment, it can
1995 have sub-accesses which do not make sense on the LHS (PR 40351).
1996 Check that this is not the case. */
1997 if (!build_ref_for_offset (NULL, TREE_TYPE (lacc->base), norm_offset,
1998 rchild->type, false))
2001 rchild->grp_hint = 1;
2002 new_acc = create_artificial_child_access (lacc, rchild, norm_offset);
2006 if (racc->first_child)
2007 propagate_subaccesses_across_link (new_acc, rchild);
2014 /* Propagate all subaccesses across assignment links. */
2017 propagate_all_subaccesses (void)
2019 while (work_queue_head)
2021 struct access *racc = pop_access_from_work_queue ();
2022 struct assign_link *link;
2024 gcc_assert (racc->first_link);
2026 for (link = racc->first_link; link; link = link->next)
2028 struct access *lacc = link->lacc;
2030 if (!bitmap_bit_p (candidate_bitmap, DECL_UID (lacc->base)))
2032 lacc = lacc->group_representative;
2033 if (propagate_subaccesses_across_link (lacc, racc)
2034 && lacc->first_link)
2035 add_access_to_work_queue (lacc);
2040 /* Go through all accesses collected throughout the (intraprocedural) analysis
2041 stage, exclude overlapping ones, identify representatives and build trees
2042 out of them, making decisions about scalarization on the way. Return true
2043 iff there are any to-be-scalarized variables after this stage. */
2046 analyze_all_variable_accesses (void)
2049 bitmap tmp = BITMAP_ALLOC (NULL);
2051 unsigned i, max_total_scalarization_size;
2053 max_total_scalarization_size = UNITS_PER_WORD * BITS_PER_UNIT
2054 * MOVE_RATIO (optimize_function_for_speed_p (cfun));
2056 EXECUTE_IF_SET_IN_BITMAP (candidate_bitmap, 0, i, bi)
2057 if (bitmap_bit_p (should_scalarize_away_bitmap, i)
2058 && !bitmap_bit_p (cannot_scalarize_away_bitmap, i))
2060 tree var = referenced_var (i);
2062 if (TREE_CODE (var) == VAR_DECL
2063 && ((unsigned) tree_low_cst (TYPE_SIZE (TREE_TYPE (var)), 1)
2064 <= max_total_scalarization_size)
2065 && type_consists_of_records_p (TREE_TYPE (var)))
2067 completely_scalarize_record (var, var, 0, var);
2068 if (dump_file && (dump_flags & TDF_DETAILS))
2070 fprintf (dump_file, "Will attempt to totally scalarize ");
2071 print_generic_expr (dump_file, var, 0);
2072 fprintf (dump_file, " (UID: %u): \n", DECL_UID (var));
2077 bitmap_copy (tmp, candidate_bitmap);
2078 EXECUTE_IF_SET_IN_BITMAP (tmp, 0, i, bi)
2080 tree var = referenced_var (i);
2081 struct access *access;
2083 access = sort_and_splice_var_accesses (var);
2084 if (!access || !build_access_trees (access))
2085 disqualify_candidate (var,
2086 "No or inhibitingly overlapping accesses.");
2089 propagate_all_subaccesses ();
2091 bitmap_copy (tmp, candidate_bitmap);
2092 EXECUTE_IF_SET_IN_BITMAP (tmp, 0, i, bi)
2094 tree var = referenced_var (i);
2095 struct access *access = get_first_repr_for_decl (var);
2097 if (analyze_access_trees (access))
2100 if (dump_file && (dump_flags & TDF_DETAILS))
2102 fprintf (dump_file, "\nAccess trees for ");
2103 print_generic_expr (dump_file, var, 0);
2104 fprintf (dump_file, " (UID: %u): \n", DECL_UID (var));
2105 dump_access_tree (dump_file, access);
2106 fprintf (dump_file, "\n");
2110 disqualify_candidate (var, "No scalar replacements to be created.");
2117 statistics_counter_event (cfun, "Scalarized aggregates", res);
2124 /* Return true iff a reference statement into aggregate AGG can be built for
2125 every single to-be-replaced accesses that is a child of ACCESS, its sibling
2126 or a child of its sibling. TOP_OFFSET is the offset from the processed
2127 access subtree that has to be subtracted from offset of each access. */
2130 ref_expr_for_all_replacements_p (struct access *access, tree agg,
2131 HOST_WIDE_INT top_offset)
2135 if (access->grp_to_be_replaced
2136 && !build_ref_for_offset (NULL, TREE_TYPE (agg),
2137 access->offset - top_offset,
2138 access->type, false))
2141 if (access->first_child
2142 && !ref_expr_for_all_replacements_p (access->first_child, agg,
2146 access = access->next_sibling;
2153 /* Generate statements copying scalar replacements of accesses within a subtree
2154 into or out of AGG. ACCESS is the first child of the root of the subtree to
2155 be processed. AGG is an aggregate type expression (can be a declaration but
2156 does not have to be, it can for example also be an indirect_ref).
2157 TOP_OFFSET is the offset of the processed subtree which has to be subtracted
2158 from offsets of individual accesses to get corresponding offsets for AGG.
2159 If CHUNK_SIZE is non-null, copy only replacements in the interval
2160 <start_offset, start_offset + chunk_size>, otherwise copy all. GSI is a
2161 statement iterator used to place the new statements. WRITE should be true
2162 when the statements should write from AGG to the replacement and false if
2163 vice versa. if INSERT_AFTER is true, new statements will be added after the
2164 current statement in GSI, they will be added before the statement
2168 generate_subtree_copies (struct access *access, tree agg,
2169 HOST_WIDE_INT top_offset,
2170 HOST_WIDE_INT start_offset, HOST_WIDE_INT chunk_size,
2171 gimple_stmt_iterator *gsi, bool write,
2178 if (chunk_size && access->offset >= start_offset + chunk_size)
2181 if (access->grp_to_be_replaced
2183 || access->offset + access->size > start_offset))
2185 tree repl = get_access_replacement (access);
2189 ref_found = build_ref_for_offset (&expr, TREE_TYPE (agg),
2190 access->offset - top_offset,
2191 access->type, false);
2192 gcc_assert (ref_found);
2196 if (access->grp_partial_lhs)
2197 expr = force_gimple_operand_gsi (gsi, expr, true, NULL_TREE,
2199 insert_after ? GSI_NEW_STMT
2201 stmt = gimple_build_assign (repl, expr);
2205 TREE_NO_WARNING (repl) = 1;
2206 if (access->grp_partial_lhs)
2207 repl = force_gimple_operand_gsi (gsi, repl, true, NULL_TREE,
2209 insert_after ? GSI_NEW_STMT
2211 stmt = gimple_build_assign (expr, repl);
2215 gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
2217 gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
2219 sra_stats.subtree_copies++;
2222 if (access->first_child)
2223 generate_subtree_copies (access->first_child, agg, top_offset,
2224 start_offset, chunk_size, gsi,
2225 write, insert_after);
2227 access = access->next_sibling;
2232 /* Assign zero to all scalar replacements in an access subtree. ACCESS is the
2233 the root of the subtree to be processed. GSI is the statement iterator used
2234 for inserting statements which are added after the current statement if
2235 INSERT_AFTER is true or before it otherwise. */
2238 init_subtree_with_zero (struct access *access, gimple_stmt_iterator *gsi,
2242 struct access *child;
2244 if (access->grp_to_be_replaced)
2248 stmt = gimple_build_assign (get_access_replacement (access),
2249 fold_convert (access->type,
2250 integer_zero_node));
2252 gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
2254 gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
2258 for (child = access->first_child; child; child = child->next_sibling)
2259 init_subtree_with_zero (child, gsi, insert_after);
2262 /* Search for an access representative for the given expression EXPR and
2263 return it or NULL if it cannot be found. */
2265 static struct access *
2266 get_access_for_expr (tree expr)
2268 HOST_WIDE_INT offset, size, max_size;
2271 /* FIXME: This should not be necessary but Ada produces V_C_Es with a type of
2272 a different size than the size of its argument and we need the latter
2274 if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
2275 expr = TREE_OPERAND (expr, 0);
2277 base = get_ref_base_and_extent (expr, &offset, &size, &max_size);
2278 if (max_size == -1 || !DECL_P (base))
2281 if (!bitmap_bit_p (candidate_bitmap, DECL_UID (base)))
2284 return get_var_base_offset_size_access (base, offset, max_size);
2287 /* Replace the expression EXPR with a scalar replacement if there is one and
2288 generate other statements to do type conversion or subtree copying if
2289 necessary. GSI is used to place newly created statements, WRITE is true if
2290 the expression is being written to (it is on a LHS of a statement or output
2291 in an assembly statement). */
2294 sra_modify_expr (tree *expr, gimple_stmt_iterator *gsi, bool write)
2296 struct access *access;
2299 if (TREE_CODE (*expr) == BIT_FIELD_REF)
2302 expr = &TREE_OPERAND (*expr, 0);
2307 if (TREE_CODE (*expr) == REALPART_EXPR || TREE_CODE (*expr) == IMAGPART_EXPR)
2308 expr = &TREE_OPERAND (*expr, 0);
2309 access = get_access_for_expr (*expr);
2312 type = TREE_TYPE (*expr);
2314 if (access->grp_to_be_replaced)
2316 tree repl = get_access_replacement (access);
2317 /* If we replace a non-register typed access simply use the original
2318 access expression to extract the scalar component afterwards.
2319 This happens if scalarizing a function return value or parameter
2320 like in gcc.c-torture/execute/20041124-1.c, 20050316-1.c and
2321 gcc.c-torture/compile/20011217-1.c.
2323 We also want to use this when accessing a complex or vector which can
2324 be accessed as a different type too, potentially creating a need for
2325 type conversion (see PR42196) and when scalarized unions are involved
2326 in assembler statements (see PR42398). */
2327 if (!useless_type_conversion_p (type, access->type))
2329 tree ref = access->base;
2332 ok = build_ref_for_offset (&ref, TREE_TYPE (ref),
2333 access->offset, access->type, false);
2340 if (access->grp_partial_lhs)
2341 ref = force_gimple_operand_gsi (gsi, ref, true, NULL_TREE,
2342 false, GSI_NEW_STMT);
2343 stmt = gimple_build_assign (repl, ref);
2344 gsi_insert_after (gsi, stmt, GSI_NEW_STMT);
2350 if (access->grp_partial_lhs)
2351 repl = force_gimple_operand_gsi (gsi, repl, true, NULL_TREE,
2352 true, GSI_SAME_STMT);
2353 stmt = gimple_build_assign (ref, repl);
2354 gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
2362 if (access->first_child)
2364 HOST_WIDE_INT start_offset, chunk_size;
2366 && host_integerp (TREE_OPERAND (bfr, 1), 1)
2367 && host_integerp (TREE_OPERAND (bfr, 2), 1))
2369 chunk_size = tree_low_cst (TREE_OPERAND (bfr, 1), 1);
2370 start_offset = access->offset
2371 + tree_low_cst (TREE_OPERAND (bfr, 2), 1);
2374 start_offset = chunk_size = 0;
2376 generate_subtree_copies (access->first_child, access->base, 0,
2377 start_offset, chunk_size, gsi, write, write);
2382 /* Where scalar replacements of the RHS have been written to when a replacement
2383 of a LHS of an assigments cannot be direclty loaded from a replacement of
2385 enum unscalarized_data_handling { SRA_UDH_NONE, /* Nothing done so far. */
2386 SRA_UDH_RIGHT, /* Data flushed to the RHS. */
2387 SRA_UDH_LEFT }; /* Data flushed to the LHS. */
2389 /* Store all replacements in the access tree rooted in TOP_RACC either to their
2390 base aggregate if there are unscalarized data or directly to LHS
2393 static enum unscalarized_data_handling
2394 handle_unscalarized_data_in_subtree (struct access *top_racc, tree lhs,
2395 gimple_stmt_iterator *gsi)
2397 if (top_racc->grp_unscalarized_data)
2399 generate_subtree_copies (top_racc->first_child, top_racc->base, 0, 0, 0,
2401 return SRA_UDH_RIGHT;
2405 generate_subtree_copies (top_racc->first_child, lhs, top_racc->offset,
2406 0, 0, gsi, false, false);
2407 return SRA_UDH_LEFT;
2412 /* Try to generate statements to load all sub-replacements in an access
2413 (sub)tree (LACC is the first child) from scalar replacements in the TOP_RACC
2414 (sub)tree. If that is not possible, refresh the TOP_RACC base aggregate and
2415 load the accesses from it. LEFT_OFFSET is the offset of the left whole
2416 subtree being copied, RIGHT_OFFSET is the same thing for the right subtree.
2417 NEW_GSI is stmt iterator used for statement insertions after the original
2418 assignment, OLD_GSI is used to insert statements before the assignment.
2419 *REFRESHED keeps the information whether we have needed to refresh
2420 replacements of the LHS and from which side of the assignments this takes
2424 load_assign_lhs_subreplacements (struct access *lacc, struct access *top_racc,
2425 HOST_WIDE_INT left_offset,
2426 HOST_WIDE_INT right_offset,
2427 gimple_stmt_iterator *old_gsi,
2428 gimple_stmt_iterator *new_gsi,
2429 enum unscalarized_data_handling *refreshed,
2432 location_t loc = EXPR_LOCATION (lacc->expr);
2435 if (lacc->grp_to_be_replaced)
2437 struct access *racc;
2438 HOST_WIDE_INT offset = lacc->offset - left_offset + right_offset;
2442 racc = find_access_in_subtree (top_racc, offset, lacc->size);
2443 if (racc && racc->grp_to_be_replaced)
2445 rhs = get_access_replacement (racc);
2446 if (!useless_type_conversion_p (lacc->type, racc->type))
2447 rhs = fold_build1_loc (loc, VIEW_CONVERT_EXPR, lacc->type, rhs);
2451 /* No suitable access on the right hand side, need to load from
2452 the aggregate. See if we have to update it first... */
2453 if (*refreshed == SRA_UDH_NONE)
2454 *refreshed = handle_unscalarized_data_in_subtree (top_racc,
2457 if (*refreshed == SRA_UDH_LEFT)
2462 repl_found = build_ref_for_offset (&rhs, TREE_TYPE (rhs),
2463 lacc->offset, lacc->type,
2465 gcc_assert (repl_found);
2471 rhs = top_racc->base;
2472 repl_found = build_ref_for_offset (&rhs,
2473 TREE_TYPE (top_racc->base),
2474 offset, lacc->type, false);
2475 gcc_assert (repl_found);
2479 stmt = gimple_build_assign (get_access_replacement (lacc), rhs);
2480 gsi_insert_after (new_gsi, stmt, GSI_NEW_STMT);
2482 sra_stats.subreplacements++;
2484 else if (*refreshed == SRA_UDH_NONE
2485 && lacc->grp_read && !lacc->grp_covered)
2486 *refreshed = handle_unscalarized_data_in_subtree (top_racc, lhs,
2489 if (lacc->first_child)
2490 load_assign_lhs_subreplacements (lacc->first_child, top_racc,
2491 left_offset, right_offset,
2492 old_gsi, new_gsi, refreshed, lhs);
2493 lacc = lacc->next_sibling;
2498 /* Result code for SRA assignment modification. */
2499 enum assignment_mod_result { SRA_AM_NONE, /* nothing done for the stmt */
2500 SRA_AM_MODIFIED, /* stmt changed but not
2502 SRA_AM_REMOVED }; /* stmt eliminated */
2504 /* Modify assignments with a CONSTRUCTOR on their RHS. STMT contains a pointer
2505 to the assignment and GSI is the statement iterator pointing at it. Returns
2506 the same values as sra_modify_assign. */
2508 static enum assignment_mod_result
2509 sra_modify_constructor_assign (gimple *stmt, gimple_stmt_iterator *gsi)
2511 tree lhs = gimple_assign_lhs (*stmt);
2514 acc = get_access_for_expr (lhs);
2518 if (VEC_length (constructor_elt,
2519 CONSTRUCTOR_ELTS (gimple_assign_rhs1 (*stmt))) > 0)
2521 /* I have never seen this code path trigger but if it can happen the
2522 following should handle it gracefully. */
2523 if (access_has_children_p (acc))
2524 generate_subtree_copies (acc->first_child, acc->base, 0, 0, 0, gsi,
2526 return SRA_AM_MODIFIED;
2529 if (acc->grp_covered)
2531 init_subtree_with_zero (acc, gsi, false);
2532 unlink_stmt_vdef (*stmt);
2533 gsi_remove (gsi, true);
2534 return SRA_AM_REMOVED;
2538 init_subtree_with_zero (acc, gsi, true);
2539 return SRA_AM_MODIFIED;
2543 /* Create and return a new suitable default definition SSA_NAME for RACC which
2544 is an access describing an uninitialized part of an aggregate that is being
2548 get_repl_default_def_ssa_name (struct access *racc)
2552 decl = get_unrenamed_access_replacement (racc);
2554 repl = gimple_default_def (cfun, decl);
2557 repl = make_ssa_name (decl, gimple_build_nop ());
2558 set_default_def (decl, repl);
2564 /* Examine both sides of the assignment statement pointed to by STMT, replace
2565 them with a scalare replacement if there is one and generate copying of
2566 replacements if scalarized aggregates have been used in the assignment. GSI
2567 is used to hold generated statements for type conversions and subtree
2570 static enum assignment_mod_result
2571 sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi)
2573 struct access *lacc, *racc;
2575 bool modify_this_stmt = false;
2576 bool force_gimple_rhs = false;
2577 location_t loc = gimple_location (*stmt);
2578 gimple_stmt_iterator orig_gsi = *gsi;
2580 if (!gimple_assign_single_p (*stmt))
2582 lhs = gimple_assign_lhs (*stmt);
2583 rhs = gimple_assign_rhs1 (*stmt);
2585 if (TREE_CODE (rhs) == CONSTRUCTOR)
2586 return sra_modify_constructor_assign (stmt, gsi);
2588 if (TREE_CODE (rhs) == REALPART_EXPR || TREE_CODE (lhs) == REALPART_EXPR
2589 || TREE_CODE (rhs) == IMAGPART_EXPR || TREE_CODE (lhs) == IMAGPART_EXPR
2590 || TREE_CODE (rhs) == BIT_FIELD_REF || TREE_CODE (lhs) == BIT_FIELD_REF)
2592 modify_this_stmt = sra_modify_expr (gimple_assign_rhs1_ptr (*stmt),
2594 modify_this_stmt |= sra_modify_expr (gimple_assign_lhs_ptr (*stmt),
2596 return modify_this_stmt ? SRA_AM_MODIFIED : SRA_AM_NONE;
2599 lacc = get_access_for_expr (lhs);
2600 racc = get_access_for_expr (rhs);
2604 if (lacc && lacc->grp_to_be_replaced)
2606 lhs = get_access_replacement (lacc);
2607 gimple_assign_set_lhs (*stmt, lhs);
2608 modify_this_stmt = true;
2609 if (lacc->grp_partial_lhs)
2610 force_gimple_rhs = true;
2614 if (racc && racc->grp_to_be_replaced)
2616 rhs = get_access_replacement (racc);
2617 modify_this_stmt = true;
2618 if (racc->grp_partial_lhs)
2619 force_gimple_rhs = true;
2623 if (modify_this_stmt)
2625 if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
2627 /* If we can avoid creating a VIEW_CONVERT_EXPR do so.
2628 ??? This should move to fold_stmt which we simply should
2629 call after building a VIEW_CONVERT_EXPR here. */
2630 if (AGGREGATE_TYPE_P (TREE_TYPE (lhs))
2631 && !access_has_children_p (lacc))
2634 if (build_ref_for_offset (&expr, TREE_TYPE (lhs), 0,
2635 TREE_TYPE (rhs), false))
2638 gimple_assign_set_lhs (*stmt, expr);
2641 else if (AGGREGATE_TYPE_P (TREE_TYPE (rhs))
2642 && !access_has_children_p (racc))
2645 if (build_ref_for_offset (&expr, TREE_TYPE (rhs), 0,
2646 TREE_TYPE (lhs), false))
2649 if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
2651 rhs = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (lhs), rhs);
2652 if (is_gimple_reg_type (TREE_TYPE (lhs))
2653 && TREE_CODE (lhs) != SSA_NAME)
2654 force_gimple_rhs = true;
2659 /* From this point on, the function deals with assignments in between
2660 aggregates when at least one has scalar reductions of some of its
2661 components. There are three possible scenarios: Both the LHS and RHS have
2662 to-be-scalarized components, 2) only the RHS has or 3) only the LHS has.
2664 In the first case, we would like to load the LHS components from RHS
2665 components whenever possible. If that is not possible, we would like to
2666 read it directly from the RHS (after updating it by storing in it its own
2667 components). If there are some necessary unscalarized data in the LHS,
2668 those will be loaded by the original assignment too. If neither of these
2669 cases happen, the original statement can be removed. Most of this is done
2670 by load_assign_lhs_subreplacements.
2672 In the second case, we would like to store all RHS scalarized components
2673 directly into LHS and if they cover the aggregate completely, remove the
2674 statement too. In the third case, we want the LHS components to be loaded
2675 directly from the RHS (DSE will remove the original statement if it
2678 This is a bit complex but manageable when types match and when unions do
2679 not cause confusion in a way that we cannot really load a component of LHS
2680 from the RHS or vice versa (the access representing this level can have
2681 subaccesses that are accessible only through a different union field at a
2682 higher level - different from the one used in the examined expression).
2685 Therefore, I specially handle a fourth case, happening when there is a
2686 specific type cast or it is impossible to locate a scalarized subaccess on
2687 the other side of the expression. If that happens, I simply "refresh" the
2688 RHS by storing in it is scalarized components leave the original statement
2689 there to do the copying and then load the scalar replacements of the LHS.
2690 This is what the first branch does. */
2692 if (gimple_has_volatile_ops (*stmt)
2693 || contains_view_convert_expr_p (rhs)
2694 || contains_view_convert_expr_p (lhs)
2695 || (access_has_children_p (racc)
2696 && !ref_expr_for_all_replacements_p (racc, lhs, racc->offset))
2697 || (access_has_children_p (lacc)
2698 && !ref_expr_for_all_replacements_p (lacc, rhs, lacc->offset)))
2700 if (access_has_children_p (racc))
2701 generate_subtree_copies (racc->first_child, racc->base, 0, 0, 0,
2703 if (access_has_children_p (lacc))
2704 generate_subtree_copies (lacc->first_child, lacc->base, 0, 0, 0,
2706 sra_stats.separate_lhs_rhs_handling++;
2710 if (access_has_children_p (lacc) && access_has_children_p (racc))
2712 gimple_stmt_iterator orig_gsi = *gsi;
2713 enum unscalarized_data_handling refreshed;
2715 if (lacc->grp_read && !lacc->grp_covered)
2716 refreshed = handle_unscalarized_data_in_subtree (racc, lhs, gsi);
2718 refreshed = SRA_UDH_NONE;
2720 load_assign_lhs_subreplacements (lacc->first_child, racc,
2721 lacc->offset, racc->offset,
2722 &orig_gsi, gsi, &refreshed, lhs);
2723 if (refreshed != SRA_UDH_RIGHT)
2726 unlink_stmt_vdef (*stmt);
2727 gsi_remove (&orig_gsi, true);
2728 sra_stats.deleted++;
2729 return SRA_AM_REMOVED;
2736 if (!racc->grp_to_be_replaced && !racc->grp_unscalarized_data)
2740 fprintf (dump_file, "Removing load: ");
2741 print_gimple_stmt (dump_file, *stmt, 0, 0);
2744 if (TREE_CODE (lhs) == SSA_NAME)
2746 rhs = get_repl_default_def_ssa_name (racc);
2747 if (!useless_type_conversion_p (TREE_TYPE (lhs),
2749 rhs = fold_build1_loc (loc, VIEW_CONVERT_EXPR,
2750 TREE_TYPE (lhs), rhs);
2754 if (racc->first_child)
2755 generate_subtree_copies (racc->first_child, lhs,
2756 racc->offset, 0, 0, gsi,
2759 gcc_assert (*stmt == gsi_stmt (*gsi));
2760 unlink_stmt_vdef (*stmt);
2761 gsi_remove (gsi, true);
2762 sra_stats.deleted++;
2763 return SRA_AM_REMOVED;
2766 else if (racc->first_child)
2767 generate_subtree_copies (racc->first_child, lhs,
2768 racc->offset, 0, 0, gsi, false, true);
2770 if (access_has_children_p (lacc))
2771 generate_subtree_copies (lacc->first_child, rhs, lacc->offset,
2772 0, 0, gsi, true, true);
2776 /* This gimplification must be done after generate_subtree_copies, lest we
2777 insert the subtree copies in the middle of the gimplified sequence. */
2778 if (force_gimple_rhs)
2779 rhs = force_gimple_operand_gsi (&orig_gsi, rhs, true, NULL_TREE,
2780 true, GSI_SAME_STMT);
2781 if (gimple_assign_rhs1 (*stmt) != rhs)
2783 gimple_assign_set_rhs_from_tree (&orig_gsi, rhs);
2784 gcc_assert (*stmt == gsi_stmt (orig_gsi));
2787 return modify_this_stmt ? SRA_AM_MODIFIED : SRA_AM_NONE;
2790 /* Traverse the function body and all modifications as decided in
2791 analyze_all_variable_accesses. Return true iff the CFG has been
2795 sra_modify_function_body (void)
2797 bool cfg_changed = false;
2802 gimple_stmt_iterator gsi = gsi_start_bb (bb);
2803 while (!gsi_end_p (gsi))
2805 gimple stmt = gsi_stmt (gsi);
2806 enum assignment_mod_result assign_result;
2807 bool modified = false, deleted = false;
2811 switch (gimple_code (stmt))
2814 t = gimple_return_retval_ptr (stmt);
2815 if (*t != NULL_TREE)
2816 modified |= sra_modify_expr (t, &gsi, false);
2820 assign_result = sra_modify_assign (&stmt, &gsi);
2821 modified |= assign_result == SRA_AM_MODIFIED;
2822 deleted = assign_result == SRA_AM_REMOVED;
2826 /* Operands must be processed before the lhs. */
2827 for (i = 0; i < gimple_call_num_args (stmt); i++)
2829 t = gimple_call_arg_ptr (stmt, i);
2830 modified |= sra_modify_expr (t, &gsi, false);
2833 if (gimple_call_lhs (stmt))
2835 t = gimple_call_lhs_ptr (stmt);
2836 modified |= sra_modify_expr (t, &gsi, true);
2841 for (i = 0; i < gimple_asm_ninputs (stmt); i++)
2843 t = &TREE_VALUE (gimple_asm_input_op (stmt, i));
2844 modified |= sra_modify_expr (t, &gsi, false);
2846 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
2848 t = &TREE_VALUE (gimple_asm_output_op (stmt, i));
2849 modified |= sra_modify_expr (t, &gsi, true);
2860 if (maybe_clean_eh_stmt (stmt)
2861 && gimple_purge_dead_eh_edges (gimple_bb (stmt)))
2872 /* Generate statements initializing scalar replacements of parts of function
2876 initialize_parameter_reductions (void)
2878 gimple_stmt_iterator gsi;
2879 gimple_seq seq = NULL;
2882 for (parm = DECL_ARGUMENTS (current_function_decl);
2884 parm = DECL_CHAIN (parm))
2886 VEC (access_p, heap) *access_vec;
2887 struct access *access;
2889 if (!bitmap_bit_p (candidate_bitmap, DECL_UID (parm)))
2891 access_vec = get_base_access_vector (parm);
2897 seq = gimple_seq_alloc ();
2898 gsi = gsi_start (seq);
2901 for (access = VEC_index (access_p, access_vec, 0);
2903 access = access->next_grp)
2904 generate_subtree_copies (access, parm, 0, 0, 0, &gsi, true, true);
2908 gsi_insert_seq_on_edge_immediate (single_succ_edge (ENTRY_BLOCK_PTR), seq);
2911 /* The "main" function of intraprocedural SRA passes. Runs the analysis and if
2912 it reveals there are components of some aggregates to be scalarized, it runs
2913 the required transformations. */
2915 perform_intra_sra (void)
2920 if (!find_var_candidates ())
2923 if (!scan_function ())
2926 if (!analyze_all_variable_accesses ())
2929 if (sra_modify_function_body ())
2930 ret = TODO_update_ssa | TODO_cleanup_cfg;
2932 ret = TODO_update_ssa;
2933 initialize_parameter_reductions ();
2935 statistics_counter_event (cfun, "Scalar replacements created",
2936 sra_stats.replacements);
2937 statistics_counter_event (cfun, "Modified expressions", sra_stats.exprs);
2938 statistics_counter_event (cfun, "Subtree copy stmts",
2939 sra_stats.subtree_copies);
2940 statistics_counter_event (cfun, "Subreplacement stmts",
2941 sra_stats.subreplacements);
2942 statistics_counter_event (cfun, "Deleted stmts", sra_stats.deleted);
2943 statistics_counter_event (cfun, "Separate LHS and RHS handling",
2944 sra_stats.separate_lhs_rhs_handling);
2947 sra_deinitialize ();
2951 /* Perform early intraprocedural SRA. */
2953 early_intra_sra (void)
2955 sra_mode = SRA_MODE_EARLY_INTRA;
2956 return perform_intra_sra ();
2959 /* Perform "late" intraprocedural SRA. */
2961 late_intra_sra (void)
2963 sra_mode = SRA_MODE_INTRA;
2964 return perform_intra_sra ();
2969 gate_intra_sra (void)
2971 return flag_tree_sra != 0 && dbg_cnt (tree_sra);
2975 struct gimple_opt_pass pass_sra_early =
2980 gate_intra_sra, /* gate */
2981 early_intra_sra, /* execute */
2984 0, /* static_pass_number */
2985 TV_TREE_SRA, /* tv_id */
2986 PROP_cfg | PROP_ssa, /* properties_required */
2987 0, /* properties_provided */
2988 0, /* properties_destroyed */
2989 0, /* todo_flags_start */
2993 | TODO_verify_ssa /* todo_flags_finish */
2997 struct gimple_opt_pass pass_sra =
3002 gate_intra_sra, /* gate */
3003 late_intra_sra, /* execute */
3006 0, /* static_pass_number */
3007 TV_TREE_SRA, /* tv_id */
3008 PROP_cfg | PROP_ssa, /* properties_required */
3009 0, /* properties_provided */
3010 0, /* properties_destroyed */
3011 TODO_update_address_taken, /* todo_flags_start */
3015 | TODO_verify_ssa /* todo_flags_finish */
3020 /* Return true iff PARM (which must be a parm_decl) is an unused scalar
3024 is_unused_scalar_param (tree parm)
3027 return (is_gimple_reg (parm)
3028 && (!(name = gimple_default_def (cfun, parm))
3029 || has_zero_uses (name)));
3032 /* Scan immediate uses of a default definition SSA name of a parameter PARM and
3033 examine whether there are any direct or otherwise infeasible ones. If so,
3034 return true, otherwise return false. PARM must be a gimple register with a
3035 non-NULL default definition. */
3038 ptr_parm_has_direct_uses (tree parm)
3040 imm_use_iterator ui;
3042 tree name = gimple_default_def (cfun, parm);
3045 FOR_EACH_IMM_USE_STMT (stmt, ui, name)
3048 use_operand_p use_p;
3050 if (is_gimple_debug (stmt))
3053 /* Valid uses include dereferences on the lhs and the rhs. */
3054 if (gimple_has_lhs (stmt))
3056 tree lhs = gimple_get_lhs (stmt);
3057 while (handled_component_p (lhs))
3058 lhs = TREE_OPERAND (lhs, 0);
3059 if (TREE_CODE (lhs) == MEM_REF
3060 && TREE_OPERAND (lhs, 0) == name
3061 && integer_zerop (TREE_OPERAND (lhs, 1))
3062 && types_compatible_p (TREE_TYPE (lhs),
3063 TREE_TYPE (TREE_TYPE (name))))
3066 if (gimple_assign_single_p (stmt))
3068 tree rhs = gimple_assign_rhs1 (stmt);
3069 while (handled_component_p (rhs))
3070 rhs = TREE_OPERAND (rhs, 0);
3071 if (TREE_CODE (rhs) == MEM_REF
3072 && TREE_OPERAND (rhs, 0) == name
3073 && integer_zerop (TREE_OPERAND (rhs, 1))
3074 && types_compatible_p (TREE_TYPE (rhs),
3075 TREE_TYPE (TREE_TYPE (name))))
3078 else if (is_gimple_call (stmt))
3081 for (i = 0; i < gimple_call_num_args (stmt); ++i)
3083 tree arg = gimple_call_arg (stmt, i);
3084 while (handled_component_p (arg))
3085 arg = TREE_OPERAND (arg, 0);
3086 if (TREE_CODE (arg) == MEM_REF
3087 && TREE_OPERAND (arg, 0) == name
3088 && integer_zerop (TREE_OPERAND (arg, 1))
3089 && types_compatible_p (TREE_TYPE (arg),
3090 TREE_TYPE (TREE_TYPE (name))))
3095 /* If the number of valid uses does not match the number of
3096 uses in this stmt there is an unhandled use. */
3097 FOR_EACH_IMM_USE_ON_STMT (use_p, ui)
3104 BREAK_FROM_IMM_USE_STMT (ui);
3110 /* Identify candidates for reduction for IPA-SRA based on their type and mark
3111 them in candidate_bitmap. Note that these do not necessarily include
3112 parameter which are unused and thus can be removed. Return true iff any
3113 such candidate has been found. */
3116 find_param_candidates (void)
3122 for (parm = DECL_ARGUMENTS (current_function_decl);
3124 parm = DECL_CHAIN (parm))
3126 tree type = TREE_TYPE (parm);
3130 if (TREE_THIS_VOLATILE (parm)
3131 || TREE_ADDRESSABLE (parm)
3132 || (!is_gimple_reg_type (type) && is_va_list_type (type)))
3135 if (is_unused_scalar_param (parm))
3141 if (POINTER_TYPE_P (type))
3143 type = TREE_TYPE (type);
3145 if (TREE_CODE (type) == FUNCTION_TYPE
3146 || TYPE_VOLATILE (type)
3147 || (TREE_CODE (type) == ARRAY_TYPE
3148 && TYPE_NONALIASED_COMPONENT (type))
3149 || !is_gimple_reg (parm)
3150 || is_va_list_type (type)
3151 || ptr_parm_has_direct_uses (parm))
3154 else if (!AGGREGATE_TYPE_P (type))
3157 if (!COMPLETE_TYPE_P (type)
3158 || !host_integerp (TYPE_SIZE (type), 1)
3159 || tree_low_cst (TYPE_SIZE (type), 1) == 0
3160 || (AGGREGATE_TYPE_P (type)
3161 && type_internals_preclude_sra_p (type)))
3164 bitmap_set_bit (candidate_bitmap, DECL_UID (parm));
3166 if (dump_file && (dump_flags & TDF_DETAILS))
3168 fprintf (dump_file, "Candidate (%d): ", DECL_UID (parm));
3169 print_generic_expr (dump_file, parm, 0);
3170 fprintf (dump_file, "\n");
3174 func_param_count = count;
3178 /* Callback of walk_aliased_vdefs, marks the access passed as DATA as
3182 mark_maybe_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
3185 struct access *repr = (struct access *) data;
3187 repr->grp_maybe_modified = 1;
3191 /* Analyze what representatives (in linked lists accessible from
3192 REPRESENTATIVES) can be modified by side effects of statements in the
3193 current function. */
3196 analyze_modified_params (VEC (access_p, heap) *representatives)
3200 for (i = 0; i < func_param_count; i++)
3202 struct access *repr;
3204 for (repr = VEC_index (access_p, representatives, i);
3206 repr = repr->next_grp)
3208 struct access *access;
3212 if (no_accesses_p (repr))
3214 if (!POINTER_TYPE_P (TREE_TYPE (repr->base))
3215 || repr->grp_maybe_modified)
3218 ao_ref_init (&ar, repr->expr);
3219 visited = BITMAP_ALLOC (NULL);
3220 for (access = repr; access; access = access->next_sibling)
3222 /* All accesses are read ones, otherwise grp_maybe_modified would
3223 be trivially set. */
3224 walk_aliased_vdefs (&ar, gimple_vuse (access->stmt),
3225 mark_maybe_modified, repr, &visited);
3226 if (repr->grp_maybe_modified)
3229 BITMAP_FREE (visited);
3234 /* Propagate distances in bb_dereferences in the opposite direction than the
3235 control flow edges, in each step storing the maximum of the current value
3236 and the minimum of all successors. These steps are repeated until the table
3237 stabilizes. Note that BBs which might terminate the functions (according to
3238 final_bbs bitmap) never updated in this way. */
3241 propagate_dereference_distances (void)
3243 VEC (basic_block, heap) *queue;
3246 queue = VEC_alloc (basic_block, heap, last_basic_block_for_function (cfun));
3247 VEC_quick_push (basic_block, queue, ENTRY_BLOCK_PTR);
3250 VEC_quick_push (basic_block, queue, bb);
3254 while (!VEC_empty (basic_block, queue))
3258 bool change = false;
3261 bb = VEC_pop (basic_block, queue);
3264 if (bitmap_bit_p (final_bbs, bb->index))
3267 for (i = 0; i < func_param_count; i++)
3269 int idx = bb->index * func_param_count + i;
3271 HOST_WIDE_INT inh = 0;
3273 FOR_EACH_EDGE (e, ei, bb->succs)
3275 int succ_idx = e->dest->index * func_param_count + i;
3277 if (e->src == EXIT_BLOCK_PTR)
3283 inh = bb_dereferences [succ_idx];
3285 else if (bb_dereferences [succ_idx] < inh)
3286 inh = bb_dereferences [succ_idx];
3289 if (!first && bb_dereferences[idx] < inh)
3291 bb_dereferences[idx] = inh;
3296 if (change && !bitmap_bit_p (final_bbs, bb->index))
3297 FOR_EACH_EDGE (e, ei, bb->preds)
3302 e->src->aux = e->src;
3303 VEC_quick_push (basic_block, queue, e->src);
3307 VEC_free (basic_block, heap, queue);
3310 /* Dump a dereferences TABLE with heading STR to file F. */
3313 dump_dereferences_table (FILE *f, const char *str, HOST_WIDE_INT *table)
3317 fprintf (dump_file, str);
3318 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
3320 fprintf (f, "%4i %i ", bb->index, bitmap_bit_p (final_bbs, bb->index));
3321 if (bb != EXIT_BLOCK_PTR)
3324 for (i = 0; i < func_param_count; i++)
3326 int idx = bb->index * func_param_count + i;
3327 fprintf (f, " %4" HOST_WIDE_INT_PRINT "d", table[idx]);
3332 fprintf (dump_file, "\n");
3335 /* Determine what (parts of) parameters passed by reference that are not
3336 assigned to are not certainly dereferenced in this function and thus the
3337 dereferencing cannot be safely moved to the caller without potentially
3338 introducing a segfault. Mark such REPRESENTATIVES as
3339 grp_not_necessarilly_dereferenced.
3341 The dereferenced maximum "distance," i.e. the offset + size of the accessed
3342 part is calculated rather than simple booleans are calculated for each
3343 pointer parameter to handle cases when only a fraction of the whole
3344 aggregate is allocated (see testsuite/gcc.c-torture/execute/ipa-sra-2.c for
3347 The maximum dereference distances for each pointer parameter and BB are
3348 already stored in bb_dereference. This routine simply propagates these
3349 values upwards by propagate_dereference_distances and then compares the
3350 distances of individual parameters in the ENTRY BB to the equivalent
3351 distances of each representative of a (fraction of a) parameter. */
3354 analyze_caller_dereference_legality (VEC (access_p, heap) *representatives)
3358 if (dump_file && (dump_flags & TDF_DETAILS))
3359 dump_dereferences_table (dump_file,
3360 "Dereference table before propagation:\n",
3363 propagate_dereference_distances ();
3365 if (dump_file && (dump_flags & TDF_DETAILS))
3366 dump_dereferences_table (dump_file,
3367 "Dereference table after propagation:\n",
3370 for (i = 0; i < func_param_count; i++)
3372 struct access *repr = VEC_index (access_p, representatives, i);
3373 int idx = ENTRY_BLOCK_PTR->index * func_param_count + i;
3375 if (!repr || no_accesses_p (repr))
3380 if ((repr->offset + repr->size) > bb_dereferences[idx])
3381 repr->grp_not_necessarilly_dereferenced = 1;
3382 repr = repr->next_grp;
3388 /* Return the representative access for the parameter declaration PARM if it is
3389 a scalar passed by reference which is not written to and the pointer value
3390 is not used directly. Thus, if it is legal to dereference it in the caller
3391 and we can rule out modifications through aliases, such parameter should be
3392 turned into one passed by value. Return NULL otherwise. */
3394 static struct access *
3395 unmodified_by_ref_scalar_representative (tree parm)
3397 int i, access_count;
3398 struct access *repr;
3399 VEC (access_p, heap) *access_vec;
3401 access_vec = get_base_access_vector (parm);
3402 gcc_assert (access_vec);
3403 repr = VEC_index (access_p, access_vec, 0);
3406 repr->group_representative = repr;
3408 access_count = VEC_length (access_p, access_vec);
3409 for (i = 1; i < access_count; i++)
3411 struct access *access = VEC_index (access_p, access_vec, i);
3414 access->group_representative = repr;
3415 access->next_sibling = repr->next_sibling;
3416 repr->next_sibling = access;
3420 repr->grp_scalar_ptr = 1;
3424 /* Return true iff this access precludes IPA-SRA of the parameter it is
3428 access_precludes_ipa_sra_p (struct access *access)
3430 /* Avoid issues such as the second simple testcase in PR 42025. The problem
3431 is incompatible assign in a call statement (and possibly even in asm
3432 statements). This can be relaxed by using a new temporary but only for
3433 non-TREE_ADDRESSABLE types and is probably not worth the complexity. (In
3434 intraprocedural SRA we deal with this by keeping the old aggregate around,
3435 something we cannot do in IPA-SRA.) */
3437 && (is_gimple_call (access->stmt)
3438 || gimple_code (access->stmt) == GIMPLE_ASM))
3445 /* Sort collected accesses for parameter PARM, identify representatives for
3446 each accessed region and link them together. Return NULL if there are
3447 different but overlapping accesses, return the special ptr value meaning
3448 there are no accesses for this parameter if that is the case and return the
3449 first representative otherwise. Set *RO_GRP if there is a group of accesses
3450 with only read (i.e. no write) accesses. */
3452 static struct access *
3453 splice_param_accesses (tree parm, bool *ro_grp)
3455 int i, j, access_count, group_count;
3456 int agg_size, total_size = 0;
3457 struct access *access, *res, **prev_acc_ptr = &res;
3458 VEC (access_p, heap) *access_vec;
3460 access_vec = get_base_access_vector (parm);
3462 return &no_accesses_representant;
3463 access_count = VEC_length (access_p, access_vec);
3465 qsort (VEC_address (access_p, access_vec), access_count, sizeof (access_p),
3466 compare_access_positions);
3471 while (i < access_count)
3474 access = VEC_index (access_p, access_vec, i);
3475 modification = access->write;
3476 if (access_precludes_ipa_sra_p (access))
3479 /* Access is about to become group representative unless we find some
3480 nasty overlap which would preclude us from breaking this parameter
3484 while (j < access_count)
3486 struct access *ac2 = VEC_index (access_p, access_vec, j);
3487 if (ac2->offset != access->offset)
3489 /* All or nothing law for parameters. */
3490 if (access->offset + access->size > ac2->offset)
3495 else if (ac2->size != access->size)
3498 if (access_precludes_ipa_sra_p (ac2))
3501 modification |= ac2->write;
3502 ac2->group_representative = access;
3503 ac2->next_sibling = access->next_sibling;
3504 access->next_sibling = ac2;
3509 access->grp_maybe_modified = modification;
3512 *prev_acc_ptr = access;
3513 prev_acc_ptr = &access->next_grp;
3514 total_size += access->size;
3518 if (POINTER_TYPE_P (TREE_TYPE (parm)))
3519 agg_size = tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))), 1);
3521 agg_size = tree_low_cst (TYPE_SIZE (TREE_TYPE (parm)), 1);
3522 if (total_size >= agg_size)
3525 gcc_assert (group_count > 0);
3529 /* Decide whether parameters with representative accesses given by REPR should
3530 be reduced into components. */
3533 decide_one_param_reduction (struct access *repr)
3535 int total_size, cur_parm_size, agg_size, new_param_count, parm_size_limit;
3540 cur_parm_size = tree_low_cst (TYPE_SIZE (TREE_TYPE (parm)), 1);
3541 gcc_assert (cur_parm_size > 0);
3543 if (POINTER_TYPE_P (TREE_TYPE (parm)))
3546 agg_size = tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))), 1);
3551 agg_size = cur_parm_size;
3557 fprintf (dump_file, "Evaluating PARAM group sizes for ");
3558 print_generic_expr (dump_file, parm, 0);
3559 fprintf (dump_file, " (UID: %u): \n", DECL_UID (parm));
3560 for (acc = repr; acc; acc = acc->next_grp)
3561 dump_access (dump_file, acc, true);
3565 new_param_count = 0;
3567 for (; repr; repr = repr->next_grp)
3569 gcc_assert (parm == repr->base);
3572 if (!by_ref || (!repr->grp_maybe_modified
3573 && !repr->grp_not_necessarilly_dereferenced))
3574 total_size += repr->size;
3576 total_size += cur_parm_size;
3579 gcc_assert (new_param_count > 0);
3581 if (optimize_function_for_size_p (cfun))
3582 parm_size_limit = cur_parm_size;
3584 parm_size_limit = (PARAM_VALUE (PARAM_IPA_SRA_PTR_GROWTH_FACTOR)
3587 if (total_size < agg_size
3588 && total_size <= parm_size_limit)
3591 fprintf (dump_file, " ....will be split into %i components\n",
3593 return new_param_count;
3599 /* The order of the following enums is important, we need to do extra work for
3600 UNUSED_PARAMS, BY_VAL_ACCESSES and UNMODIF_BY_REF_ACCESSES. */
3601 enum ipa_splicing_result { NO_GOOD_ACCESS, UNUSED_PARAMS, BY_VAL_ACCESSES,
3602 MODIF_BY_REF_ACCESSES, UNMODIF_BY_REF_ACCESSES };
3604 /* Identify representatives of all accesses to all candidate parameters for
3605 IPA-SRA. Return result based on what representatives have been found. */
3607 static enum ipa_splicing_result
3608 splice_all_param_accesses (VEC (access_p, heap) **representatives)
3610 enum ipa_splicing_result result = NO_GOOD_ACCESS;
3612 struct access *repr;
3614 *representatives = VEC_alloc (access_p, heap, func_param_count);
3616 for (parm = DECL_ARGUMENTS (current_function_decl);
3618 parm = DECL_CHAIN (parm))
3620 if (is_unused_scalar_param (parm))
3622 VEC_quick_push (access_p, *representatives,
3623 &no_accesses_representant);
3624 if (result == NO_GOOD_ACCESS)
3625 result = UNUSED_PARAMS;
3627 else if (POINTER_TYPE_P (TREE_TYPE (parm))
3628 && is_gimple_reg_type (TREE_TYPE (TREE_TYPE (parm)))
3629 && bitmap_bit_p (candidate_bitmap, DECL_UID (parm)))
3631 repr = unmodified_by_ref_scalar_representative (parm);
3632 VEC_quick_push (access_p, *representatives, repr);
3634 result = UNMODIF_BY_REF_ACCESSES;
3636 else if (bitmap_bit_p (candidate_bitmap, DECL_UID (parm)))
3638 bool ro_grp = false;
3639 repr = splice_param_accesses (parm, &ro_grp);
3640 VEC_quick_push (access_p, *representatives, repr);
3642 if (repr && !no_accesses_p (repr))
3644 if (POINTER_TYPE_P (TREE_TYPE (parm)))
3647 result = UNMODIF_BY_REF_ACCESSES;
3648 else if (result < MODIF_BY_REF_ACCESSES)
3649 result = MODIF_BY_REF_ACCESSES;
3651 else if (result < BY_VAL_ACCESSES)
3652 result = BY_VAL_ACCESSES;
3654 else if (no_accesses_p (repr) && (result == NO_GOOD_ACCESS))
3655 result = UNUSED_PARAMS;
3658 VEC_quick_push (access_p, *representatives, NULL);
3661 if (result == NO_GOOD_ACCESS)
3663 VEC_free (access_p, heap, *representatives);
3664 *representatives = NULL;
3665 return NO_GOOD_ACCESS;
3671 /* Return the index of BASE in PARMS. Abort if it is not found. */
3674 get_param_index (tree base, VEC(tree, heap) *parms)
3678 len = VEC_length (tree, parms);
3679 for (i = 0; i < len; i++)
3680 if (VEC_index (tree, parms, i) == base)
3685 /* Convert the decisions made at the representative level into compact
3686 parameter adjustments. REPRESENTATIVES are pointers to first
3687 representatives of each param accesses, ADJUSTMENTS_COUNT is the expected
3688 final number of adjustments. */
3690 static ipa_parm_adjustment_vec
3691 turn_representatives_into_adjustments (VEC (access_p, heap) *representatives,
3692 int adjustments_count)
3694 VEC (tree, heap) *parms;
3695 ipa_parm_adjustment_vec adjustments;
3699 gcc_assert (adjustments_count > 0);
3700 parms = ipa_get_vector_of_formal_parms (current_function_decl);
3701 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, adjustments_count);
3702 parm = DECL_ARGUMENTS (current_function_decl);
3703 for (i = 0; i < func_param_count; i++, parm = DECL_CHAIN (parm))
3705 struct access *repr = VEC_index (access_p, representatives, i);
3707 if (!repr || no_accesses_p (repr))
3709 struct ipa_parm_adjustment *adj;
3711 adj = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
3712 memset (adj, 0, sizeof (*adj));
3713 adj->base_index = get_param_index (parm, parms);
3716 adj->copy_param = 1;
3718 adj->remove_param = 1;
3722 struct ipa_parm_adjustment *adj;
3723 int index = get_param_index (parm, parms);
3725 for (; repr; repr = repr->next_grp)
3727 adj = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
3728 memset (adj, 0, sizeof (*adj));
3729 gcc_assert (repr->base == parm);
3730 adj->base_index = index;
3731 adj->base = repr->base;
3732 adj->type = repr->type;
3733 adj->offset = repr->offset;
3734 adj->by_ref = (POINTER_TYPE_P (TREE_TYPE (repr->base))
3735 && (repr->grp_maybe_modified
3736 || repr->grp_not_necessarilly_dereferenced));
3741 VEC_free (tree, heap, parms);
3745 /* Analyze the collected accesses and produce a plan what to do with the
3746 parameters in the form of adjustments, NULL meaning nothing. */
3748 static ipa_parm_adjustment_vec
3749 analyze_all_param_acesses (void)
3751 enum ipa_splicing_result repr_state;
3752 bool proceed = false;
3753 int i, adjustments_count = 0;
3754 VEC (access_p, heap) *representatives;
3755 ipa_parm_adjustment_vec adjustments;
3757 repr_state = splice_all_param_accesses (&representatives);
3758 if (repr_state == NO_GOOD_ACCESS)
3761 /* If there are any parameters passed by reference which are not modified
3762 directly, we need to check whether they can be modified indirectly. */
3763 if (repr_state == UNMODIF_BY_REF_ACCESSES)
3765 analyze_caller_dereference_legality (representatives);
3766 analyze_modified_params (representatives);
3769 for (i = 0; i < func_param_count; i++)
3771 struct access *repr = VEC_index (access_p, representatives, i);
3773 if (repr && !no_accesses_p (repr))
3775 if (repr->grp_scalar_ptr)
3777 adjustments_count++;
3778 if (repr->grp_not_necessarilly_dereferenced
3779 || repr->grp_maybe_modified)
3780 VEC_replace (access_p, representatives, i, NULL);
3784 sra_stats.scalar_by_ref_to_by_val++;
3789 int new_components = decide_one_param_reduction (repr);
3791 if (new_components == 0)
3793 VEC_replace (access_p, representatives, i, NULL);
3794 adjustments_count++;
3798 adjustments_count += new_components;
3799 sra_stats.aggregate_params_reduced++;
3800 sra_stats.param_reductions_created += new_components;
3807 if (no_accesses_p (repr))
3810 sra_stats.deleted_unused_parameters++;
3812 adjustments_count++;
3816 if (!proceed && dump_file)
3817 fprintf (dump_file, "NOT proceeding to change params.\n");
3820 adjustments = turn_representatives_into_adjustments (representatives,
3825 VEC_free (access_p, heap, representatives);
3829 /* If a parameter replacement identified by ADJ does not yet exist in the form
3830 of declaration, create it and record it, otherwise return the previously
3834 get_replaced_param_substitute (struct ipa_parm_adjustment *adj)
3837 if (!adj->new_ssa_base)
3839 char *pretty_name = make_fancy_name (adj->base);
3841 repl = create_tmp_reg (TREE_TYPE (adj->base), "ISR");
3842 DECL_NAME (repl) = get_identifier (pretty_name);
3843 obstack_free (&name_obstack, pretty_name);
3846 add_referenced_var (repl);
3847 adj->new_ssa_base = repl;
3850 repl = adj->new_ssa_base;
3854 /* Find the first adjustment for a particular parameter BASE in a vector of
3855 ADJUSTMENTS which is not a copy_param. Return NULL if there is no such
3858 static struct ipa_parm_adjustment *
3859 get_adjustment_for_base (ipa_parm_adjustment_vec adjustments, tree base)
3863 len = VEC_length (ipa_parm_adjustment_t, adjustments);
3864 for (i = 0; i < len; i++)
3866 struct ipa_parm_adjustment *adj;
3868 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
3869 if (!adj->copy_param && adj->base == base)
3876 /* If the statement STMT defines an SSA_NAME of a parameter which is to be
3877 removed because its value is not used, replace the SSA_NAME with a one
3878 relating to a created VAR_DECL together all of its uses and return true.
3879 ADJUSTMENTS is a pointer to an adjustments vector. */
3882 replace_removed_params_ssa_names (gimple stmt,
3883 ipa_parm_adjustment_vec adjustments)
3885 struct ipa_parm_adjustment *adj;
3886 tree lhs, decl, repl, name;
3888 if (gimple_code (stmt) == GIMPLE_PHI)
3889 lhs = gimple_phi_result (stmt);
3890 else if (is_gimple_assign (stmt))
3891 lhs = gimple_assign_lhs (stmt);
3892 else if (is_gimple_call (stmt))
3893 lhs = gimple_call_lhs (stmt);
3897 if (TREE_CODE (lhs) != SSA_NAME)
3899 decl = SSA_NAME_VAR (lhs);
3900 if (TREE_CODE (decl) != PARM_DECL)
3903 adj = get_adjustment_for_base (adjustments, decl);
3907 repl = get_replaced_param_substitute (adj);
3908 name = make_ssa_name (repl, stmt);
3912 fprintf (dump_file, "replacing an SSA name of a removed param ");
3913 print_generic_expr (dump_file, lhs, 0);
3914 fprintf (dump_file, " with ");
3915 print_generic_expr (dump_file, name, 0);
3916 fprintf (dump_file, "\n");
3919 if (is_gimple_assign (stmt))
3920 gimple_assign_set_lhs (stmt, name);
3921 else if (is_gimple_call (stmt))
3922 gimple_call_set_lhs (stmt, name);
3924 gimple_phi_set_result (stmt, name);
3926 replace_uses_by (lhs, name);
3927 release_ssa_name (lhs);
3931 /* If the expression *EXPR should be replaced by a reduction of a parameter, do
3932 so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT
3933 specifies whether the function should care about type incompatibility the
3934 current and new expressions. If it is false, the function will leave
3935 incompatibility issues to the caller. Return true iff the expression
3939 sra_ipa_modify_expr (tree *expr, bool convert,
3940 ipa_parm_adjustment_vec adjustments)
3943 struct ipa_parm_adjustment *adj, *cand = NULL;
3944 HOST_WIDE_INT offset, size, max_size;
3947 len = VEC_length (ipa_parm_adjustment_t, adjustments);
3949 if (TREE_CODE (*expr) == BIT_FIELD_REF
3950 || TREE_CODE (*expr) == IMAGPART_EXPR
3951 || TREE_CODE (*expr) == REALPART_EXPR)
3953 expr = &TREE_OPERAND (*expr, 0);
3957 base = get_ref_base_and_extent (*expr, &offset, &size, &max_size);
3958 if (!base || size == -1 || max_size == -1)
3961 if (TREE_CODE (base) == MEM_REF)
3963 offset += mem_ref_offset (base).low * BITS_PER_UNIT;
3964 base = TREE_OPERAND (base, 0);
3967 base = get_ssa_base_param (base);
3968 if (!base || TREE_CODE (base) != PARM_DECL)
3971 for (i = 0; i < len; i++)
3973 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
3975 if (adj->base == base &&
3976 (adj->offset == offset || adj->remove_param))
3982 if (!cand || cand->copy_param || cand->remove_param)
3986 src = build_simple_mem_ref (cand->reduction);
3988 src = cand->reduction;
3990 if (dump_file && (dump_flags & TDF_DETAILS))
3992 fprintf (dump_file, "About to replace expr ");
3993 print_generic_expr (dump_file, *expr, 0);
3994 fprintf (dump_file, " with ");
3995 print_generic_expr (dump_file, src, 0);
3996 fprintf (dump_file, "\n");
3999 if (convert && !useless_type_conversion_p (TREE_TYPE (*expr), cand->type))
4001 tree vce = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*expr), src);
4009 /* If the statement pointed to by STMT_PTR contains any expressions that need
4010 to replaced with a different one as noted by ADJUSTMENTS, do so. Handle any
4011 potential type incompatibilities (GSI is used to accommodate conversion
4012 statements and must point to the statement). Return true iff the statement
4016 sra_ipa_modify_assign (gimple *stmt_ptr, gimple_stmt_iterator *gsi,
4017 ipa_parm_adjustment_vec adjustments)
4019 gimple stmt = *stmt_ptr;
4020 tree *lhs_p, *rhs_p;
4023 if (!gimple_assign_single_p (stmt))
4026 rhs_p = gimple_assign_rhs1_ptr (stmt);
4027 lhs_p = gimple_assign_lhs_ptr (stmt);
4029 any = sra_ipa_modify_expr (rhs_p, false, adjustments);
4030 any |= sra_ipa_modify_expr (lhs_p, false, adjustments);
4033 tree new_rhs = NULL_TREE;
4035 if (!useless_type_conversion_p (TREE_TYPE (*lhs_p), TREE_TYPE (*rhs_p)))
4037 if (TREE_CODE (*rhs_p) == CONSTRUCTOR)
4039 /* V_C_Es of constructors can cause trouble (PR 42714). */
4040 if (is_gimple_reg_type (TREE_TYPE (*lhs_p)))
4041 *rhs_p = fold_convert (TREE_TYPE (*lhs_p), integer_zero_node);
4043 *rhs_p = build_constructor (TREE_TYPE (*lhs_p), 0);
4046 new_rhs = fold_build1_loc (gimple_location (stmt),
4047 VIEW_CONVERT_EXPR, TREE_TYPE (*lhs_p),
4050 else if (REFERENCE_CLASS_P (*rhs_p)
4051 && is_gimple_reg_type (TREE_TYPE (*lhs_p))
4052 && !is_gimple_reg (*lhs_p))
4053 /* This can happen when an assignment in between two single field
4054 structures is turned into an assignment in between two pointers to
4055 scalars (PR 42237). */
4060 tree tmp = force_gimple_operand_gsi (gsi, new_rhs, true, NULL_TREE,
4061 true, GSI_SAME_STMT);
4063 gimple_assign_set_rhs_from_tree (gsi, tmp);
4072 /* Traverse the function body and all modifications as described in
4073 ADJUSTMENTS. Return true iff the CFG has been changed. */
4076 ipa_sra_modify_function_body (ipa_parm_adjustment_vec adjustments)
4078 bool cfg_changed = false;
4083 gimple_stmt_iterator gsi;
4085 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4086 replace_removed_params_ssa_names (gsi_stmt (gsi), adjustments);
4088 gsi = gsi_start_bb (bb);
4089 while (!gsi_end_p (gsi))
4091 gimple stmt = gsi_stmt (gsi);
4092 bool modified = false;
4096 switch (gimple_code (stmt))
4099 t = gimple_return_retval_ptr (stmt);
4100 if (*t != NULL_TREE)
4101 modified |= sra_ipa_modify_expr (t, true, adjustments);
4105 modified |= sra_ipa_modify_assign (&stmt, &gsi, adjustments);
4106 modified |= replace_removed_params_ssa_names (stmt, adjustments);
4110 /* Operands must be processed before the lhs. */
4111 for (i = 0; i < gimple_call_num_args (stmt); i++)
4113 t = gimple_call_arg_ptr (stmt, i);
4114 modified |= sra_ipa_modify_expr (t, true, adjustments);
4117 if (gimple_call_lhs (stmt))
4119 t = gimple_call_lhs_ptr (stmt);
4120 modified |= sra_ipa_modify_expr (t, false, adjustments);
4121 modified |= replace_removed_params_ssa_names (stmt,
4127 for (i = 0; i < gimple_asm_ninputs (stmt); i++)
4129 t = &TREE_VALUE (gimple_asm_input_op (stmt, i));
4130 modified |= sra_ipa_modify_expr (t, true, adjustments);
4132 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
4134 t = &TREE_VALUE (gimple_asm_output_op (stmt, i));
4135 modified |= sra_ipa_modify_expr (t, false, adjustments);
4146 if (maybe_clean_eh_stmt (stmt)
4147 && gimple_purge_dead_eh_edges (gimple_bb (stmt)))
4157 /* Call gimple_debug_bind_reset_value on all debug statements describing
4158 gimple register parameters that are being removed or replaced. */
4161 sra_ipa_reset_debug_stmts (ipa_parm_adjustment_vec adjustments)
4165 len = VEC_length (ipa_parm_adjustment_t, adjustments);
4166 for (i = 0; i < len; i++)
4168 struct ipa_parm_adjustment *adj;
4169 imm_use_iterator ui;
4173 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
4174 if (adj->copy_param || !is_gimple_reg (adj->base))
4176 name = gimple_default_def (cfun, adj->base);
4179 FOR_EACH_IMM_USE_STMT (stmt, ui, name)
4181 /* All other users must have been removed by
4182 ipa_sra_modify_function_body. */
4183 gcc_assert (is_gimple_debug (stmt));
4184 gimple_debug_bind_reset_value (stmt);
4190 /* Return true iff all callers have at least as many actual arguments as there
4191 are formal parameters in the current function. */
4194 all_callers_have_enough_arguments_p (struct cgraph_node *node)
4196 struct cgraph_edge *cs;
4197 for (cs = node->callers; cs; cs = cs->next_caller)
4198 if (!callsite_has_enough_arguments_p (cs->call_stmt))
4205 /* Convert all callers of NODE to pass parameters as given in ADJUSTMENTS. */
4208 convert_callers (struct cgraph_node *node, tree old_decl,
4209 ipa_parm_adjustment_vec adjustments)
4211 tree old_cur_fndecl = current_function_decl;
4212 struct cgraph_edge *cs;
4213 basic_block this_block;
4214 bitmap recomputed_callers = BITMAP_ALLOC (NULL);
4216 for (cs = node->callers; cs; cs = cs->next_caller)
4218 current_function_decl = cs->caller->decl;
4219 push_cfun (DECL_STRUCT_FUNCTION (cs->caller->decl));
4222 fprintf (dump_file, "Adjusting call (%i -> %i) %s -> %s\n",
4223 cs->caller->uid, cs->callee->uid,
4224 cgraph_node_name (cs->caller),
4225 cgraph_node_name (cs->callee));
4227 ipa_modify_call_arguments (cs, cs->call_stmt, adjustments);
4232 for (cs = node->callers; cs; cs = cs->next_caller)
4233 if (!bitmap_bit_p (recomputed_callers, cs->caller->uid))
4235 compute_inline_parameters (cs->caller);
4236 bitmap_set_bit (recomputed_callers, cs->caller->uid);
4238 BITMAP_FREE (recomputed_callers);
4240 current_function_decl = old_cur_fndecl;
4242 if (!encountered_recursive_call)
4245 FOR_EACH_BB (this_block)
4247 gimple_stmt_iterator gsi;
4249 for (gsi = gsi_start_bb (this_block); !gsi_end_p (gsi); gsi_next (&gsi))
4251 gimple stmt = gsi_stmt (gsi);
4253 if (gimple_code (stmt) != GIMPLE_CALL)
4255 call_fndecl = gimple_call_fndecl (stmt);
4256 if (call_fndecl == old_decl)
4259 fprintf (dump_file, "Adjusting recursive call");
4260 gimple_call_set_fndecl (stmt, node->decl);
4261 ipa_modify_call_arguments (NULL, stmt, adjustments);
4269 /* Perform all the modification required in IPA-SRA for NODE to have parameters
4270 as given in ADJUSTMENTS. Return true iff the CFG has been changed. */
4273 modify_function (struct cgraph_node *node, ipa_parm_adjustment_vec adjustments)
4275 struct cgraph_node *new_node;
4276 struct cgraph_edge *cs;
4278 VEC (cgraph_edge_p, heap) * redirect_callers;
4282 for (cs = node->callers; cs != NULL; cs = cs->next_caller)
4284 redirect_callers = VEC_alloc (cgraph_edge_p, heap, node_callers);
4285 for (cs = node->callers; cs != NULL; cs = cs->next_caller)
4286 VEC_quick_push (cgraph_edge_p, redirect_callers, cs);
4288 rebuild_cgraph_edges ();
4290 current_function_decl = NULL_TREE;
4292 new_node = cgraph_function_versioning (node, redirect_callers, NULL, NULL,
4293 NULL, NULL, "isra");
4294 current_function_decl = new_node->decl;
4295 push_cfun (DECL_STRUCT_FUNCTION (new_node->decl));
4297 ipa_modify_formal_parameters (current_function_decl, adjustments, "ISRA");
4298 cfg_changed = ipa_sra_modify_function_body (adjustments);
4299 sra_ipa_reset_debug_stmts (adjustments);
4300 convert_callers (new_node, node->decl, adjustments);
4301 cgraph_make_node_local (new_node);
4305 /* Return false the function is apparently unsuitable for IPA-SRA based on it's
4306 attributes, return true otherwise. NODE is the cgraph node of the current
4310 ipa_sra_preliminary_function_checks (struct cgraph_node *node)
4312 if (!cgraph_node_can_be_local_p (node))
4315 fprintf (dump_file, "Function not local to this compilation unit.\n");
4319 if (!tree_versionable_function_p (node->decl))
4322 fprintf (dump_file, "Function is not versionable.\n");
4326 if (DECL_VIRTUAL_P (current_function_decl))
4329 fprintf (dump_file, "Function is a virtual method.\n");
4333 if ((DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl))
4334 && node->global.size >= MAX_INLINE_INSNS_AUTO)
4337 fprintf (dump_file, "Function too big to be made truly local.\n");
4345 "Function has no callers in this compilation unit.\n");
4352 fprintf (dump_file, "Function uses stdarg. \n");
4356 if (TYPE_ATTRIBUTES (TREE_TYPE (node->decl)))
4362 /* Perform early interprocedural SRA. */
4365 ipa_early_sra (void)
4367 struct cgraph_node *node = cgraph_node (current_function_decl);
4368 ipa_parm_adjustment_vec adjustments;
4371 if (!ipa_sra_preliminary_function_checks (node))
4375 sra_mode = SRA_MODE_EARLY_IPA;
4377 if (!find_param_candidates ())
4380 fprintf (dump_file, "Function has no IPA-SRA candidates.\n");
4384 if (!all_callers_have_enough_arguments_p (node))
4387 fprintf (dump_file, "There are callers with insufficient number of "
4392 bb_dereferences = XCNEWVEC (HOST_WIDE_INT,
4394 * last_basic_block_for_function (cfun));
4395 final_bbs = BITMAP_ALLOC (NULL);
4398 if (encountered_apply_args)
4401 fprintf (dump_file, "Function calls __builtin_apply_args().\n");
4405 if (encountered_unchangable_recursive_call)
4408 fprintf (dump_file, "Function calls itself with insufficient "
4409 "number of arguments.\n");
4413 adjustments = analyze_all_param_acesses ();
4417 ipa_dump_param_adjustments (dump_file, adjustments, current_function_decl);
4419 if (modify_function (node, adjustments))
4420 ret = TODO_update_ssa | TODO_cleanup_cfg;
4422 ret = TODO_update_ssa;
4423 VEC_free (ipa_parm_adjustment_t, heap, adjustments);
4425 statistics_counter_event (cfun, "Unused parameters deleted",
4426 sra_stats.deleted_unused_parameters);
4427 statistics_counter_event (cfun, "Scalar parameters converted to by-value",
4428 sra_stats.scalar_by_ref_to_by_val);
4429 statistics_counter_event (cfun, "Aggregate parameters broken up",
4430 sra_stats.aggregate_params_reduced);
4431 statistics_counter_event (cfun, "Aggregate parameter components created",
4432 sra_stats.param_reductions_created);
4435 BITMAP_FREE (final_bbs);
4436 free (bb_dereferences);
4438 sra_deinitialize ();
4442 /* Return if early ipa sra shall be performed. */
4444 ipa_early_sra_gate (void)
4446 return flag_ipa_sra && dbg_cnt (eipa_sra);
4449 struct gimple_opt_pass pass_early_ipa_sra =
4453 "eipa_sra", /* name */
4454 ipa_early_sra_gate, /* gate */
4455 ipa_early_sra, /* execute */
4458 0, /* static_pass_number */
4459 TV_IPA_SRA, /* tv_id */
4460 0, /* properties_required */
4461 0, /* properties_provided */
4462 0, /* properties_destroyed */
4463 0, /* todo_flags_start */
4464 TODO_dump_func | TODO_dump_cgraph /* todo_flags_finish */