1 /* Interprocedural scalar replacement of aggregates
2 Copyright (C) 2008-2021 Free Software Foundation, Inc.
4 Contributed by Martin Jambor <mjambor@suse.cz>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* IPA-SRA is an interprocedural pass that removes unused function return
23 values (turning functions returning a value which is never used into void
24 functions), removes unused function parameters. It can also replace an
25 aggregate parameter by a set of other parameters representing part of the
26 original, turning those passed by reference into new ones which pass the
29 The pass is a true IPA one, which means that it works in three stages in
30 order to be able to take advantage of LTO. First, summaries about functions
31 and each calls are generated. Function summaries (often called call graph
32 node summaries) contain mainly information about which parameters are
33 potential transformation candidates and which bits of candidates are
34 accessed. We differentiate between accesses done as a part of a call
35 statement (which might be not necessary if the callee is also transformed)
36 and others (which are mandatory). Call summaries (often called call graph
37 edge summaries) contain information about which function formal parameters
38 feed into which actual call arguments so that if two parameters are only
39 used in a sum which is then passed to another function which then however
40 does not use this parameter, all three parameters of the two functions can
41 be eliminated. Edge summaries also have flags whether the return value is
42 used or if it is only returned in the caller too. In LTO mode these
43 summaries are then streamed to the object file in the compilation phase and
44 streamed back in in the WPA analysis stage.
46 The interprocedural analysis phase traverses the graph in topological order
47 in two sweeps, one in each direction. First, from callees to callers for
48 parameter removal and splitting. Each strongly-connected component is
49 processed iteratively until the situation in it stabilizes. The pass from
50 callers to callees is then carried out to remove unused return values in a
53 Because parameter manipulation has big implications for call redirection
54 which is done only after all call graph nodes materialize, the
55 transformation phase is not part of this patch but is carried out by the
56 clone materialization and edge redirection itself, see comments in
57 ipa-param-manipulation.h for more details. */
63 #include "coretypes.h"
68 #include "tree-pass.h"
71 #include "gimple-pretty-print.h"
74 #include "gimple-iterator.h"
75 #include "gimple-walk.h"
78 #include "alloc-pool.h"
79 #include "symbol-summary.h"
81 #include "tree-inline.h"
82 #include "ipa-utils.h"
85 #include "tree-streamer.h"
86 #include "internal-fn.h"
87 #include "symtab-clones.h"
89 static void ipa_sra_summarize_function (cgraph_node
*);
91 /* Bits used to track size of an aggregate in bytes interprocedurally. */
92 #define ISRA_ARG_SIZE_LIMIT_BITS 16
93 #define ISRA_ARG_SIZE_LIMIT (1 << ISRA_ARG_SIZE_LIMIT_BITS)
94 /* How many parameters can feed into a call actual argument and still be
96 #define IPA_SRA_MAX_PARAM_FLOW_LEN 7
98 /* Structure describing accesses to a specific portion of an aggregate
99 parameter, as given by the offset and size. Any smaller accesses that occur
100 within a function that fall within another access form a tree. The pass
101 cannot analyze parameters with only partially overlapping accesses. */
103 struct GTY(()) param_access
105 /* Type that a potential replacement should have. This field only has
106 meaning in the summary building and transformation phases, when it is
107 reconstructed from the body. Must not be touched in IPA analysis
111 /* Alias reference type to be used in MEM_REFs when adjusting caller
115 /* Values returned by get_ref_base_and_extent but converted to bytes and
116 stored as unsigned ints. */
117 unsigned unit_offset
;
118 unsigned unit_size
: ISRA_ARG_SIZE_LIMIT_BITS
;
120 /* Set once we are sure that the access will really end up in a potentially
121 transformed function - initially not set for portions of formal parameters
122 that are only used as actual function arguments passed to callees. */
123 unsigned certain
: 1;
124 /* Set if the access has a reversed scalar storage order. */
125 unsigned reverse
: 1;
128 /* This structure has the same purpose as the one above and additionally it
129 contains some fields that are only necessary in the summary generation
132 struct gensum_param_access
134 /* Values returned by get_ref_base_and_extent. */
135 HOST_WIDE_INT offset
;
138 /* if this access has any children (in terms of the definition above), this
139 points to the first one. */
140 struct gensum_param_access
*first_child
;
141 /* In intraprocedural SRA, pointer to the next sibling in the access tree as
143 struct gensum_param_access
*next_sibling
;
145 /* Type that a potential replacement should have. This field only has
146 meaning in the summary building and transformation phases, when it is
147 reconstructed from the body. Must not be touched in IPA analysis
150 /* Alias reference type to be used in MEM_REFs when adjusting caller
154 /* Have there been writes to or reads from this exact location except for as
155 arguments to a function call that can be tracked. */
158 /* Set if the access has a reversed scalar storage order. */
162 /* Summary describing a parameter in the IPA stages. */
164 struct GTY(()) isra_param_desc
166 /* List of access representatives to the parameters, sorted according to
168 vec
<param_access
*, va_gc
> *accesses
;
170 /* Unit size limit of total size of all replacements. */
171 unsigned param_size_limit
: ISRA_ARG_SIZE_LIMIT_BITS
;
172 /* Sum of unit sizes of all certain replacements. */
173 unsigned size_reached
: ISRA_ARG_SIZE_LIMIT_BITS
;
175 /* A parameter that is used only in call arguments and can be removed if all
176 concerned actual arguments are removed. */
177 unsigned locally_unused
: 1;
178 /* An aggregate that is a candidate for breaking up or complete removal. */
179 unsigned split_candidate
: 1;
180 /* Is this a parameter passing stuff by reference? */
184 /* Structure used when generating summaries that describes a parameter. */
186 struct gensum_param_desc
188 /* Roots of param_accesses. */
189 gensum_param_access
*accesses
;
190 /* Number of accesses in the access tree rooted in field accesses. */
191 unsigned access_count
;
193 /* If the below is non-zero, this is the number of uses as actual arguments. */
195 /* Number of times this parameter has been directly passed to. */
196 unsigned ptr_pt_count
;
198 /* Size limit of total size of all replacements. */
199 unsigned param_size_limit
;
200 /* Sum of sizes of nonarg accesses. */
201 unsigned nonarg_acc_size
;
203 /* A parameter that is used only in call arguments and can be removed if all
204 concerned actual arguments are removed. */
206 /* An aggregate that is a candidate for breaking up or a pointer passing data
207 by reference that is a candidate for being converted to a set of
208 parameters passing those data by value. */
209 bool split_candidate
;
210 /* Is this a parameter passing stuff by reference? */
213 /* The number of this parameter as they are ordered in function decl. */
215 /* For parameters passing data by reference, this is parameter index to
216 compute indices to bb_dereferences. */
220 /* Properly deallocate accesses of DESC. TODO: Since this data structure is
221 not in GC memory, this is not necessary and we can consider removing the
225 free_param_decl_accesses (isra_param_desc
*desc
)
227 unsigned len
= vec_safe_length (desc
->accesses
);
228 for (unsigned i
= 0; i
< len
; ++i
)
229 ggc_free ((*desc
->accesses
)[i
]);
230 vec_free (desc
->accesses
);
233 /* Class used to convey information about functions from the
234 intra-procedural analysis stage to inter-procedural one. */
236 class GTY((for_user
)) isra_func_summary
239 /* initialize the object. */
242 : m_parameters (NULL
), m_candidate (false), m_returns_value (false),
243 m_return_ignored (false), m_queued (false)
246 /* Destroy m_parameters. */
248 ~isra_func_summary ();
250 /* Mark the function as not a candidate for any IPA-SRA transformation.
251 Return true if it was a candidate until now. */
255 /* Vector of parameter descriptors corresponding to the function being
257 vec
<isra_param_desc
, va_gc
> *m_parameters
;
259 /* Whether the node is even a candidate for any IPA-SRA transformation at
261 unsigned m_candidate
: 1;
263 /* Whether the original function returns any value. */
264 unsigned m_returns_value
: 1;
266 /* Set to true if all call statements do not actually use the returned
269 unsigned m_return_ignored
: 1;
271 /* Whether the node is already queued in IPA SRA stack during processing of
274 unsigned m_queued
: 1;
277 /* Clean up and deallocate isra_func_summary points to. TODO: Since this data
278 structure is not in GC memory, this is not necessary and we can consider
279 removing the destructor. */
281 isra_func_summary::~isra_func_summary ()
283 unsigned len
= vec_safe_length (m_parameters
);
284 for (unsigned i
= 0; i
< len
; ++i
)
285 free_param_decl_accesses (&(*m_parameters
)[i
]);
286 vec_free (m_parameters
);
290 /* Mark the function as not a candidate for any IPA-SRA transformation. Return
291 true if it was a candidate until now. */
294 isra_func_summary::zap ()
296 bool ret
= m_candidate
;
299 unsigned len
= vec_safe_length (m_parameters
);
300 for (unsigned i
= 0; i
< len
; ++i
)
301 free_param_decl_accesses (&(*m_parameters
)[i
]);
302 vec_free (m_parameters
);
307 /* Structure to describe which formal parameters feed into a particular actual
310 struct isra_param_flow
312 /* Number of elements in array inputs that contain valid data. */
314 /* Indices of formal parameters that feed into the described actual argument.
315 If aggregate_pass_through or pointer_pass_through below are true, it must
316 contain exactly one element which is passed through from a formal
317 parameter if the given number. Otherwise, the array contains indices of
318 callee's formal parameters which are used to calculate value of this
320 unsigned char inputs
[IPA_SRA_MAX_PARAM_FLOW_LEN
];
322 /* Offset within the formal parameter. */
323 unsigned unit_offset
;
324 /* Size of the portion of the formal parameter that is being passed. */
325 unsigned unit_size
: ISRA_ARG_SIZE_LIMIT_BITS
;
327 /* True when the value of this actual copy is a portion of a formal
329 unsigned aggregate_pass_through
: 1;
330 /* True when the value of this actual copy is a verbatim pass through of an
332 unsigned pointer_pass_through
: 1;
333 /* True when it is safe to copy access candidates here from the callee, which
334 would mean introducing dereferences into callers of the caller. */
335 unsigned safe_to_import_accesses
: 1;
338 /* Structure used to convey information about calls from the intra-procedural
339 analysis stage to inter-procedural one. */
341 class isra_call_summary
345 : m_arg_flow (), m_return_ignored (false), m_return_returned (false),
346 m_bit_aligned_arg (false)
349 void init_inputs (unsigned arg_count
);
352 /* Information about what formal parameters of the caller are used to compute
353 individual actual arguments of this call. */
354 auto_vec
<isra_param_flow
> m_arg_flow
;
356 /* Set to true if the call statement does not have a LHS. */
357 unsigned m_return_ignored
: 1;
359 /* Set to true if the LHS of call statement is only used to construct the
360 return value of the caller. */
361 unsigned m_return_returned
: 1;
363 /* Set when any of the call arguments are not byte-aligned. */
364 unsigned m_bit_aligned_arg
: 1;
367 /* Class to manage function summaries. */
369 class GTY((user
)) ipa_sra_function_summaries
370 : public function_summary
<isra_func_summary
*>
373 ipa_sra_function_summaries (symbol_table
*table
, bool ggc
):
374 function_summary
<isra_func_summary
*> (table
, ggc
) { }
376 virtual void duplicate (cgraph_node
*, cgraph_node
*,
377 isra_func_summary
*old_sum
,
378 isra_func_summary
*new_sum
);
379 virtual void insert (cgraph_node
*, isra_func_summary
*);
382 /* Hook that is called by summary when a node is duplicated. */
385 ipa_sra_function_summaries::duplicate (cgraph_node
*, cgraph_node
*,
386 isra_func_summary
*old_sum
,
387 isra_func_summary
*new_sum
)
389 /* TODO: Somehow stop copying when ISRA is doing the cloning, it is
391 new_sum
->m_candidate
= old_sum
->m_candidate
;
392 new_sum
->m_returns_value
= old_sum
->m_returns_value
;
393 new_sum
->m_return_ignored
= old_sum
->m_return_ignored
;
394 gcc_assert (!old_sum
->m_queued
);
395 new_sum
->m_queued
= false;
397 unsigned param_count
= vec_safe_length (old_sum
->m_parameters
);
400 vec_safe_reserve_exact (new_sum
->m_parameters
, param_count
);
401 new_sum
->m_parameters
->quick_grow_cleared (param_count
);
402 for (unsigned i
= 0; i
< param_count
; i
++)
404 isra_param_desc
*s
= &(*old_sum
->m_parameters
)[i
];
405 isra_param_desc
*d
= &(*new_sum
->m_parameters
)[i
];
407 d
->param_size_limit
= s
->param_size_limit
;
408 d
->size_reached
= s
->size_reached
;
409 d
->locally_unused
= s
->locally_unused
;
410 d
->split_candidate
= s
->split_candidate
;
411 d
->by_ref
= s
->by_ref
;
413 unsigned acc_count
= vec_safe_length (s
->accesses
);
414 vec_safe_reserve_exact (d
->accesses
, acc_count
);
415 for (unsigned j
= 0; j
< acc_count
; j
++)
417 param_access
*from
= (*s
->accesses
)[j
];
418 param_access
*to
= ggc_cleared_alloc
<param_access
> ();
419 to
->type
= from
->type
;
420 to
->alias_ptr_type
= from
->alias_ptr_type
;
421 to
->unit_offset
= from
->unit_offset
;
422 to
->unit_size
= from
->unit_size
;
423 to
->certain
= from
->certain
;
424 d
->accesses
->quick_push (to
);
429 /* Pointer to the pass function summary holder. */
431 static GTY(()) ipa_sra_function_summaries
*func_sums
;
433 /* Hook that is called by summary when new node appears. */
436 ipa_sra_function_summaries::insert (cgraph_node
*node
, isra_func_summary
*)
438 if (opt_for_fn (node
->decl
, flag_ipa_sra
))
440 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
441 ipa_sra_summarize_function (node
);
445 func_sums
->remove (node
);
448 /* Class to manage call summaries. */
450 class ipa_sra_call_summaries
: public call_summary
<isra_call_summary
*>
453 ipa_sra_call_summaries (symbol_table
*table
):
454 call_summary
<isra_call_summary
*> (table
) { }
456 /* Duplicate info when an edge is cloned. */
457 virtual void duplicate (cgraph_edge
*, cgraph_edge
*,
458 isra_call_summary
*old_sum
,
459 isra_call_summary
*new_sum
);
462 static ipa_sra_call_summaries
*call_sums
;
465 /* Initialize m_arg_flow of a particular instance of isra_call_summary.
466 ARG_COUNT is the number of actual arguments passed. */
469 isra_call_summary::init_inputs (unsigned arg_count
)
473 gcc_checking_assert (m_arg_flow
.length () == 0);
476 if (m_arg_flow
.length () == 0)
478 m_arg_flow
.reserve_exact (arg_count
);
479 m_arg_flow
.quick_grow_cleared (arg_count
);
482 gcc_checking_assert (arg_count
== m_arg_flow
.length ());
485 /* Dump all information in call summary to F. */
488 isra_call_summary::dump (FILE *f
)
490 if (m_return_ignored
)
491 fprintf (f
, " return value ignored\n");
492 if (m_return_returned
)
493 fprintf (f
, " return value used only to compute caller return value\n");
494 for (unsigned i
= 0; i
< m_arg_flow
.length (); i
++)
496 fprintf (f
, " Parameter %u:\n", i
);
497 isra_param_flow
*ipf
= &m_arg_flow
[i
];
502 fprintf (f
, " Scalar param sources: ");
503 for (int j
= 0; j
< ipf
->length
; j
++)
509 fprintf (f
, "%i", (int) ipf
->inputs
[j
]);
513 if (ipf
->aggregate_pass_through
)
514 fprintf (f
, " Aggregate pass through from the param given above, "
515 "unit offset: %u , unit size: %u\n",
516 ipf
->unit_offset
, ipf
->unit_size
);
517 if (ipf
->pointer_pass_through
)
518 fprintf (f
, " Pointer pass through from the param given above, "
519 "safe_to_import_accesses: %u\n", ipf
->safe_to_import_accesses
);
523 /* Duplicate edge summary when an edge is cloned. */
526 ipa_sra_call_summaries::duplicate (cgraph_edge
*, cgraph_edge
*,
527 isra_call_summary
*old_sum
,
528 isra_call_summary
*new_sum
)
530 unsigned arg_count
= old_sum
->m_arg_flow
.length ();
531 new_sum
->init_inputs (arg_count
);
532 for (unsigned i
= 0; i
< arg_count
; i
++)
533 new_sum
->m_arg_flow
[i
] = old_sum
->m_arg_flow
[i
];
535 new_sum
->m_return_ignored
= old_sum
->m_return_ignored
;
536 new_sum
->m_return_returned
= old_sum
->m_return_returned
;
537 new_sum
->m_bit_aligned_arg
= old_sum
->m_bit_aligned_arg
;
541 /* With all GTY stuff done, we can move to anonymous namespace. */
543 /* Quick mapping from a decl to its param descriptor. */
545 hash_map
<tree
, gensum_param_desc
*> *decl2desc
;
547 /* Countdown of allowed Alias analysis steps during summary building. */
549 int aa_walking_limit
;
551 /* This is a table in which for each basic block and parameter there is a
552 distance (offset + size) in that parameter which is dereferenced and
553 accessed in that BB. */
554 HOST_WIDE_INT
*bb_dereferences
= NULL
;
555 /* How many by-reference parameters there are in the current function. */
558 /* Bitmap of BBs that can cause the function to "stop" progressing by
559 returning, throwing externally, looping infinitely or calling a function
560 which might abort etc.. */
563 /* Obstack to allocate various small structures required only when generating
564 summary for a function. */
565 struct obstack gensum_obstack
;
567 /* Return false the function is apparently unsuitable for IPA-SRA based on it's
568 attributes, return true otherwise. NODE is the cgraph node of the current
572 ipa_sra_preliminary_function_checks (cgraph_node
*node
)
574 if (!node
->can_change_signature
)
577 fprintf (dump_file
, "Function cannot change signature.\n");
581 if (!tree_versionable_function_p (node
->decl
))
584 fprintf (dump_file
, "Function is not versionable.\n");
588 if (!opt_for_fn (node
->decl
, optimize
)
589 || !opt_for_fn (node
->decl
, flag_ipa_sra
))
592 fprintf (dump_file
, "Not optimizing or IPA-SRA turned off for this "
597 if (DECL_VIRTUAL_P (node
->decl
))
600 fprintf (dump_file
, "Function is a virtual method.\n");
604 struct function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
608 fprintf (dump_file
, "Function uses stdarg. \n");
612 if (TYPE_ATTRIBUTES (TREE_TYPE (node
->decl
)))
615 fprintf (dump_file
, "Function type has attributes. \n");
619 if (DECL_DISREGARD_INLINE_LIMITS (node
->decl
))
622 fprintf (dump_file
, "Always inline function will be inlined "
630 /* Print access tree starting at ACCESS to F. */
633 dump_gensum_access (FILE *f
, gensum_param_access
*access
, unsigned indent
)
636 for (unsigned i
= 0; i
< indent
; i
++)
638 fprintf (f
, " * Access to offset: " HOST_WIDE_INT_PRINT_DEC
,
640 fprintf (f
, ", size: " HOST_WIDE_INT_PRINT_DEC
, access
->size
);
641 fprintf (f
, ", type: ");
642 print_generic_expr (f
, access
->type
);
643 fprintf (f
, ", alias_ptr_type: ");
644 print_generic_expr (f
, access
->alias_ptr_type
);
645 fprintf (f
, ", nonarg: %u, reverse: %u\n", access
->nonarg
, access
->reverse
);
646 for (gensum_param_access
*ch
= access
->first_child
;
648 ch
= ch
->next_sibling
)
649 dump_gensum_access (f
, ch
, indent
+ 2);
653 /* Print access tree starting at ACCESS to F. */
656 dump_isra_access (FILE *f
, param_access
*access
)
658 fprintf (f
, " * Access to unit offset: %u", access
->unit_offset
);
659 fprintf (f
, ", unit size: %u", access
->unit_size
);
660 fprintf (f
, ", type: ");
661 print_generic_expr (f
, access
->type
);
662 fprintf (f
, ", alias_ptr_type: ");
663 print_generic_expr (f
, access
->alias_ptr_type
);
665 fprintf (f
, ", certain");
667 fprintf (f
, ", not-certain");
669 fprintf (f
, ", reverse");
673 /* Dump access tree starting at ACCESS to stderr. */
676 debug_isra_access (param_access
*access
)
678 dump_isra_access (stderr
, access
);
681 /* Dump DESC to F. */
684 dump_gensum_param_descriptor (FILE *f
, gensum_param_desc
*desc
)
686 if (desc
->locally_unused
)
687 fprintf (f
, " unused with %i call_uses\n", desc
->call_uses
);
688 if (!desc
->split_candidate
)
690 fprintf (f
, " not a candidate\n");
694 fprintf (f
, " by_ref with %u pass throughs\n", desc
->ptr_pt_count
);
696 for (gensum_param_access
*acc
= desc
->accesses
; acc
; acc
= acc
->next_sibling
)
697 dump_gensum_access (f
, acc
, 2);
700 /* Dump all parameter descriptors in IFS, assuming it describes FNDECL, to
704 dump_gensum_param_descriptors (FILE *f
, tree fndecl
,
705 vec
<gensum_param_desc
> *param_descriptions
)
707 tree parm
= DECL_ARGUMENTS (fndecl
);
709 i
< param_descriptions
->length ();
710 ++i
, parm
= DECL_CHAIN (parm
))
712 fprintf (f
, " Descriptor for parameter %i ", i
);
713 print_generic_expr (f
, parm
, TDF_UID
);
715 dump_gensum_param_descriptor (f
, &(*param_descriptions
)[i
]);
720 /* Dump DESC to F. */
723 dump_isra_param_descriptor (FILE *f
, isra_param_desc
*desc
)
725 if (desc
->locally_unused
)
727 fprintf (f
, " (locally) unused\n");
729 if (!desc
->split_candidate
)
731 fprintf (f
, " not a candidate for splitting\n");
734 fprintf (f
, " param_size_limit: %u, size_reached: %u%s\n",
735 desc
->param_size_limit
, desc
->size_reached
,
736 desc
->by_ref
? ", by_ref" : "");
738 for (unsigned i
= 0; i
< vec_safe_length (desc
->accesses
); ++i
)
740 param_access
*access
= (*desc
->accesses
)[i
];
741 dump_isra_access (f
, access
);
745 /* Dump all parameter descriptors in IFS, assuming it describes FNDECL, to
749 dump_isra_param_descriptors (FILE *f
, tree fndecl
,
750 isra_func_summary
*ifs
)
752 tree parm
= DECL_ARGUMENTS (fndecl
);
753 if (!ifs
->m_parameters
)
755 fprintf (f
, " parameter descriptors not available\n");
760 i
< ifs
->m_parameters
->length ();
761 ++i
, parm
= DECL_CHAIN (parm
))
763 fprintf (f
, " Descriptor for parameter %i ", i
);
764 print_generic_expr (f
, parm
, TDF_UID
);
766 dump_isra_param_descriptor (f
, &(*ifs
->m_parameters
)[i
]);
770 /* Add SRC to inputs of PARAM_FLOW, unless it would exceed storage. If the
771 function fails return false, otherwise return true. SRC must fit into an
772 unsigned char. Used for purposes of transitive unused parameter
776 add_src_to_param_flow (isra_param_flow
*param_flow
, int src
)
778 gcc_checking_assert (src
>= 0 && src
<= UCHAR_MAX
);
779 if (param_flow
->length
== IPA_SRA_MAX_PARAM_FLOW_LEN
)
782 param_flow
->inputs
[(int) param_flow
->length
] = src
;
783 param_flow
->length
++;
787 /* Add a SRC to the inputs of PARAM_FLOW unless it is already there and assert
788 it is the only input. Used for purposes of transitive parameter
792 set_single_param_flow_source (isra_param_flow
*param_flow
, int src
)
794 gcc_checking_assert (src
>= 0 && src
<= UCHAR_MAX
);
795 if (param_flow
->length
== 0)
797 param_flow
->inputs
[0] = src
;
798 param_flow
->length
= 1;
800 else if (param_flow
->length
== 1)
801 gcc_assert (param_flow
->inputs
[0] == src
);
806 /* Assert that there is only a single value in PARAM_FLOW's inputs and return
810 get_single_param_flow_source (const isra_param_flow
*param_flow
)
812 gcc_assert (param_flow
->length
== 1);
813 return param_flow
->inputs
[0];
816 /* Inspect all uses of NAME and simple arithmetic calculations involving NAME
817 in FUN represented with NODE and return a negative number if any of them is
818 used for something else than either an actual call argument, simple
819 arithmetic operation or debug statement. If there are no such uses, return
820 the number of actual arguments that this parameter eventually feeds to (or
821 zero if there is none). For any such parameter, mark PARM_NUM as one of its
822 sources. ANALYZED is a bitmap that tracks which SSA names we have already
823 started investigating. */
826 isra_track_scalar_value_uses (function
*fun
, cgraph_node
*node
, tree name
,
827 int parm_num
, bitmap analyzed
)
830 imm_use_iterator imm_iter
;
833 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
835 if (is_gimple_debug (stmt
))
838 /* TODO: We could handle at least const builtin functions like arithmetic
840 if (is_gimple_call (stmt
))
844 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
847 gcall
*call
= as_a
<gcall
*> (stmt
);
849 if (gimple_call_internal_p (call
)
850 || (arg_count
= gimple_call_num_args (call
)) == 0)
856 cgraph_edge
*cs
= node
->get_edge (stmt
);
857 gcc_checking_assert (cs
);
858 isra_call_summary
*csum
= call_sums
->get_create (cs
);
859 csum
->init_inputs (arg_count
);
862 for (unsigned i
= 0; i
< arg_count
; i
++)
863 if (gimple_call_arg (call
, i
) == name
)
865 if (!add_src_to_param_flow (&csum
->m_arg_flow
[i
], parm_num
))
874 || all_uses
!= simple_uses
)
881 else if (!stmt_unremovable_because_of_non_call_eh_p (fun
, stmt
)
882 && ((is_gimple_assign (stmt
) && !gimple_has_volatile_ops (stmt
))
883 || gimple_code (stmt
) == GIMPLE_PHI
))
886 if (gimple_code (stmt
) == GIMPLE_PHI
)
887 lhs
= gimple_phi_result (stmt
);
889 lhs
= gimple_assign_lhs (stmt
);
891 if (TREE_CODE (lhs
) != SSA_NAME
)
896 gcc_assert (!gimple_vdef (stmt
));
897 if (bitmap_set_bit (analyzed
, SSA_NAME_VERSION (lhs
)))
899 int tmp
= isra_track_scalar_value_uses (fun
, node
, lhs
, parm_num
,
918 /* Inspect all uses of PARM, which must be a gimple register, in FUN (which is
919 also described by NODE) and simple arithmetic calculations involving PARM
920 and return false if any of them is used for something else than either an
921 actual call argument, simple arithmetic operation or debug statement. If
922 there are no such uses, return true and store the number of actual arguments
923 that this parameter eventually feeds to (or zero if there is none) to
924 *CALL_USES_P. For any such parameter, mark PARM_NUM as one of its
927 This function is similar to ptr_parm_has_nonarg_uses but its results are
928 meant for unused parameter removal, as opposed to splitting of parameters
929 passed by reference or converting them to passed by value.
933 isra_track_scalar_param_local_uses (function
*fun
, cgraph_node
*node
, tree parm
,
934 int parm_num
, int *call_uses_p
)
936 gcc_checking_assert (is_gimple_reg (parm
));
938 tree name
= ssa_default_def (fun
, parm
);
939 if (!name
|| has_zero_uses (name
))
945 /* Edge summaries can only handle callers with fewer than 256 parameters. */
946 if (parm_num
> UCHAR_MAX
)
949 bitmap analyzed
= BITMAP_ALLOC (NULL
);
950 int call_uses
= isra_track_scalar_value_uses (fun
, node
, name
, parm_num
,
952 BITMAP_FREE (analyzed
);
955 *call_uses_p
= call_uses
;
959 /* Scan immediate uses of a default definition SSA name of a parameter PARM and
960 examine whether there are any nonarg uses that are not actual arguments or
961 otherwise infeasible uses. If so, return true, otherwise return false.
962 Create pass-through IPA flow records for any direct uses as argument calls
963 and if returning false, store their number into *PT_COUNT_P. NODE and FUN
964 must represent the function that is currently analyzed, PARM_NUM must be the
965 index of the analyzed parameter.
967 This function is similar to isra_track_scalar_param_local_uses but its
968 results are meant for splitting of parameters passed by reference or turning
969 them into bits passed by value, as opposed to generic unused parameter
974 ptr_parm_has_nonarg_uses (cgraph_node
*node
, function
*fun
, tree parm
,
975 int parm_num
, unsigned *pt_count_p
)
979 tree name
= ssa_default_def (fun
, parm
);
981 unsigned pt_count
= 0;
983 if (!name
|| has_zero_uses (name
))
986 /* Edge summaries can only handle callers with fewer than 256 parameters. */
987 if (parm_num
> UCHAR_MAX
)
990 FOR_EACH_IMM_USE_STMT (stmt
, ui
, name
)
992 unsigned uses_ok
= 0;
995 if (is_gimple_debug (stmt
))
998 if (gimple_assign_single_p (stmt
))
1000 tree rhs
= gimple_assign_rhs1 (stmt
);
1001 while (handled_component_p (rhs
))
1002 rhs
= TREE_OPERAND (rhs
, 0);
1003 if (TREE_CODE (rhs
) == MEM_REF
1004 && TREE_OPERAND (rhs
, 0) == name
1005 && integer_zerop (TREE_OPERAND (rhs
, 1))
1006 && types_compatible_p (TREE_TYPE (rhs
),
1007 TREE_TYPE (TREE_TYPE (name
)))
1008 && !TREE_THIS_VOLATILE (rhs
))
1011 else if (is_gimple_call (stmt
))
1013 gcall
*call
= as_a
<gcall
*> (stmt
);
1015 if (gimple_call_internal_p (call
)
1016 || (arg_count
= gimple_call_num_args (call
)) == 0)
1022 cgraph_edge
*cs
= node
->get_edge (stmt
);
1023 gcc_checking_assert (cs
);
1024 isra_call_summary
*csum
= call_sums
->get_create (cs
);
1025 csum
->init_inputs (arg_count
);
1027 for (unsigned i
= 0; i
< arg_count
; ++i
)
1029 tree arg
= gimple_call_arg (stmt
, i
);
1033 /* TODO: Allow &MEM_REF[name + offset] here,
1034 ipa_param_body_adjustments::modify_call_stmt has to be
1036 csum
->m_arg_flow
[i
].pointer_pass_through
= true;
1037 set_single_param_flow_source (&csum
->m_arg_flow
[i
], parm_num
);
1043 while (handled_component_p (arg
))
1044 arg
= TREE_OPERAND (arg
, 0);
1045 if (TREE_CODE (arg
) == MEM_REF
1046 && TREE_OPERAND (arg
, 0) == name
1047 && integer_zerop (TREE_OPERAND (arg
, 1))
1048 && types_compatible_p (TREE_TYPE (arg
),
1049 TREE_TYPE (TREE_TYPE (name
)))
1050 && !TREE_THIS_VOLATILE (arg
))
1055 /* If the number of valid uses does not match the number of
1056 uses in this stmt there is an unhandled use. */
1057 unsigned all_uses
= 0;
1058 FOR_EACH_IMM_USE_ON_STMT (use_p
, ui
)
1061 gcc_checking_assert (uses_ok
<= all_uses
);
1062 if (uses_ok
!= all_uses
)
1069 *pt_count_p
= pt_count
;
1073 /* Initialize vector of parameter descriptors of NODE. Return true if there
1074 are any candidates for splitting or unused aggregate parameter removal (the
1075 function may return false if there are candidates for removal of register
1076 parameters) and function body must be scanned. */
1079 create_parameter_descriptors (cgraph_node
*node
,
1080 vec
<gensum_param_desc
> *param_descriptions
)
1082 function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
1086 for (tree parm
= DECL_ARGUMENTS (node
->decl
);
1088 parm
= DECL_CHAIN (parm
), num
++)
1091 gensum_param_desc
*desc
= &(*param_descriptions
)[num
];
1092 /* param_descriptions vector is grown cleared in the caller. */
1093 desc
->param_number
= num
;
1094 decl2desc
->put (parm
, desc
);
1096 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1097 print_generic_expr (dump_file
, parm
, TDF_UID
);
1099 int scalar_call_uses
;
1100 tree type
= TREE_TYPE (parm
);
1101 if (TREE_THIS_VOLATILE (parm
))
1103 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1104 fprintf (dump_file
, " not a candidate, is volatile\n");
1107 if (!is_gimple_reg_type (type
) && is_va_list_type (type
))
1109 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1110 fprintf (dump_file
, " not a candidate, is a va_list type\n");
1113 if (TREE_ADDRESSABLE (parm
))
1115 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1116 fprintf (dump_file
, " not a candidate, is addressable\n");
1119 if (TREE_ADDRESSABLE (type
))
1121 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1122 fprintf (dump_file
, " not a candidate, type cannot be split\n");
1126 if (is_gimple_reg (parm
)
1127 && !isra_track_scalar_param_local_uses (fun
, node
, parm
, num
,
1130 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1131 fprintf (dump_file
, " is a scalar with only %i call uses\n",
1134 desc
->locally_unused
= true;
1135 desc
->call_uses
= scalar_call_uses
;
1138 if (POINTER_TYPE_P (type
))
1140 type
= TREE_TYPE (type
);
1142 if (TREE_CODE (type
) == FUNCTION_TYPE
1143 || TREE_CODE (type
) == METHOD_TYPE
)
1145 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1146 fprintf (dump_file
, " not a candidate, reference to "
1150 if (TYPE_VOLATILE (type
))
1152 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1153 fprintf (dump_file
, " not a candidate, reference to "
1154 "a volatile type\n");
1157 if (TREE_CODE (type
) == ARRAY_TYPE
1158 && TYPE_NONALIASED_COMPONENT (type
))
1160 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1161 fprintf (dump_file
, " not a candidate, reference to "
1162 "a nonaliased component array\n");
1165 if (!is_gimple_reg (parm
))
1167 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1168 fprintf (dump_file
, " not a candidate, a reference which is "
1169 "not a gimple register (probably addressable)\n");
1172 if (is_va_list_type (type
))
1174 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1175 fprintf (dump_file
, " not a candidate, reference to "
1179 if (ptr_parm_has_nonarg_uses (node
, fun
, parm
, num
,
1180 &desc
->ptr_pt_count
))
1182 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1183 fprintf (dump_file
, " not a candidate, reference has "
1187 desc
->by_ref
= true;
1189 else if (!AGGREGATE_TYPE_P (type
))
1191 /* This is in an else branch because scalars passed by reference are
1192 still candidates to be passed by value. */
1193 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1194 fprintf (dump_file
, " not a candidate, not an aggregate\n");
1198 if (!COMPLETE_TYPE_P (type
))
1200 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1201 fprintf (dump_file
, " not a candidate, not a complete type\n");
1204 if (!tree_fits_uhwi_p (TYPE_SIZE (type
)))
1206 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1207 fprintf (dump_file
, " not a candidate, size not representable\n");
1210 unsigned HOST_WIDE_INT type_size
1211 = tree_to_uhwi (TYPE_SIZE (type
)) / BITS_PER_UNIT
;
1213 || type_size
>= ISRA_ARG_SIZE_LIMIT
)
1215 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1216 fprintf (dump_file
, " not a candidate, has zero or huge size\n");
1219 if (type_internals_preclude_sra_p (type
, &msg
))
1221 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1222 fprintf (dump_file
, " not a candidate, %s\n", msg
);
1226 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1227 fprintf (dump_file
, " is a candidate\n");
1230 desc
->split_candidate
= true;
1232 desc
->deref_index
= by_ref_count
++;
1237 /* Return pointer to descriptor of parameter DECL or NULL if it cannot be
1238 found, which happens if DECL is for a static chain. */
1240 static gensum_param_desc
*
1241 get_gensum_param_desc (tree decl
)
1243 gcc_checking_assert (TREE_CODE (decl
) == PARM_DECL
);
1244 gensum_param_desc
**slot
= decl2desc
->get (decl
);
1246 /* This can happen for static chains which we cannot handle so far. */
1248 gcc_checking_assert (*slot
);
1253 /* Remove parameter described by DESC from candidates for IPA-SRA splitting and
1254 write REASON to the dump file if there is one. */
1257 disqualify_split_candidate (gensum_param_desc
*desc
, const char *reason
)
1259 if (!desc
->split_candidate
)
1262 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1263 fprintf (dump_file
, "! Disqualifying parameter number %i - %s\n",
1264 desc
->param_number
, reason
);
1266 desc
->split_candidate
= false;
1269 /* Remove DECL from candidates for IPA-SRA and write REASON to the dump file if
1273 disqualify_split_candidate (tree decl
, const char *reason
)
1275 gensum_param_desc
*desc
= get_gensum_param_desc (decl
);
1277 disqualify_split_candidate (desc
, reason
);
1280 /* Allocate a new access to DESC and fill it in with OFFSET and SIZE. But
1281 first, check that there are not too many of them already. If so, do not
1282 allocate anything and return NULL. */
1284 static gensum_param_access
*
1285 allocate_access (gensum_param_desc
*desc
,
1286 HOST_WIDE_INT offset
, HOST_WIDE_INT size
)
1288 if (desc
->access_count
1289 == (unsigned) param_ipa_sra_max_replacements
)
1291 disqualify_split_candidate (desc
, "Too many replacement candidates");
1295 gensum_param_access
*access
1296 = (gensum_param_access
*) obstack_alloc (&gensum_obstack
,
1297 sizeof (gensum_param_access
));
1298 memset (access
, 0, sizeof (*access
));
1299 access
->offset
= offset
;
1300 access
->size
= size
;
1304 /* In what context scan_expr_access has been called, whether it deals with a
1305 load, a function argument, or a store. Please note that in rare
1306 circumstances when it is not clear if the access is a load or store,
1307 ISRA_CTX_STORE is used too. */
1309 enum isra_scan_context
{ISRA_CTX_LOAD
, ISRA_CTX_ARG
, ISRA_CTX_STORE
};
1311 /* Return an access describing memory access to the variable described by DESC
1312 at OFFSET with SIZE in context CTX, starting at pointer to the linked list
1313 at a certain tree level FIRST. Attempt to create it and put into the
1314 appropriate place in the access tree if does not exist, but fail and return
1315 NULL if there are already too many accesses, if it would create a partially
1316 overlapping access or if an access would end up within a pre-existing
1319 static gensum_param_access
*
1320 get_access_1 (gensum_param_desc
*desc
, gensum_param_access
**first
,
1321 HOST_WIDE_INT offset
, HOST_WIDE_INT size
, isra_scan_context ctx
)
1323 gensum_param_access
*access
= *first
, **ptr
= first
;
1327 /* No pre-existing access at this level, just create it. */
1328 gensum_param_access
*a
= allocate_access (desc
, offset
, size
);
1335 if (access
->offset
>= offset
+ size
)
1337 /* We want to squeeze it in front of the very first access, just do
1339 gensum_param_access
*r
= allocate_access (desc
, offset
, size
);
1342 r
->next_sibling
= access
;
1347 /* Skip all accesses that have to come before us until the next sibling is
1349 while (offset
>= access
->offset
+ access
->size
1350 && access
->next_sibling
1351 && access
->next_sibling
->offset
< offset
+ size
)
1353 ptr
= &access
->next_sibling
;
1354 access
= access
->next_sibling
;
1357 /* At this point we know we do not belong before access. */
1358 gcc_assert (access
->offset
< offset
+ size
);
1360 if (access
->offset
== offset
&& access
->size
== size
)
1361 /* We found what we were looking for. */
1364 if (access
->offset
<= offset
1365 && access
->offset
+ access
->size
>= offset
+ size
)
1367 /* We fit into access which is larger than us. We need to find/create
1368 something below access. But we only allow nesting in call
1373 return get_access_1 (desc
, &access
->first_child
, offset
, size
, ctx
);
1376 if (offset
<= access
->offset
1377 && offset
+ size
>= access
->offset
+ access
->size
)
1378 /* We are actually bigger than access, which fully fits into us, take its
1379 place and make all accesses fitting into it its children. */
1381 /* But first, we only allow nesting in call arguments so check if that is
1382 what we are trying to represent. */
1383 if (ctx
!= ISRA_CTX_ARG
)
1386 gensum_param_access
*r
= allocate_access (desc
, offset
, size
);
1389 r
->first_child
= access
;
1391 while (access
->next_sibling
1392 && access
->next_sibling
->offset
< offset
+ size
)
1393 access
= access
->next_sibling
;
1394 if (access
->offset
+ access
->size
> offset
+ size
)
1396 /* This must be a different access, which are sorted, so the
1397 following must be true and this signals a partial overlap. */
1398 gcc_assert (access
->offset
> offset
);
1402 r
->next_sibling
= access
->next_sibling
;
1403 access
->next_sibling
= NULL
;
1408 if (offset
>= access
->offset
+ access
->size
)
1410 /* We belong after access. */
1411 gensum_param_access
*r
= allocate_access (desc
, offset
, size
);
1414 r
->next_sibling
= access
->next_sibling
;
1415 access
->next_sibling
= r
;
1419 if (offset
< access
->offset
)
1421 /* We know the following, otherwise we would have created a
1423 gcc_checking_assert (offset
+ size
< access
->offset
+ access
->size
);
1427 if (offset
+ size
> access
->offset
+ access
->size
)
1430 gcc_checking_assert (offset
> access
->offset
);
1437 /* Return an access describing memory access to the variable described by DESC
1438 at OFFSET with SIZE in context CTX, mark it as used in context CTX. Attempt
1439 to create if it does not exist, but fail and return NULL if there are
1440 already too many accesses, if it would create a partially overlapping access
1441 or if an access would end up in a non-call access. */
1443 static gensum_param_access
*
1444 get_access (gensum_param_desc
*desc
, HOST_WIDE_INT offset
, HOST_WIDE_INT size
,
1445 isra_scan_context ctx
)
1447 gcc_checking_assert (desc
->split_candidate
);
1449 gensum_param_access
*access
= get_access_1 (desc
, &desc
->accesses
, offset
,
1453 disqualify_split_candidate (desc
,
1454 "Bad access overlap or too many accesses");
1460 case ISRA_CTX_STORE
:
1461 gcc_assert (!desc
->by_ref
);
1464 access
->nonarg
= true;
1473 /* Verify that parameter access tree starting with ACCESS is in good shape.
1474 PARENT_OFFSET and PARENT_SIZE are the corresponding fields of parent of
1475 ACCESS or zero if there is none. */
1478 verify_access_tree_1 (gensum_param_access
*access
, HOST_WIDE_INT parent_offset
,
1479 HOST_WIDE_INT parent_size
)
1483 gcc_assert (access
->offset
>= 0 && access
->size
>= 0);
1485 if (parent_size
!= 0)
1487 if (access
->offset
< parent_offset
)
1489 error ("Access offset before parent offset");
1492 if (access
->size
>= parent_size
)
1494 error ("Access size greater or equal to its parent size");
1497 if (access
->offset
+ access
->size
> parent_offset
+ parent_size
)
1499 error ("Access terminates outside of its parent");
1504 if (verify_access_tree_1 (access
->first_child
, access
->offset
,
1508 if (access
->next_sibling
1509 && (access
->next_sibling
->offset
< access
->offset
+ access
->size
))
1511 error ("Access overlaps with its sibling");
1515 access
= access
->next_sibling
;
1520 /* Verify that parameter access tree starting with ACCESS is in good shape,
1521 halt compilation and dump the tree to stderr if not. */
1524 isra_verify_access_tree (gensum_param_access
*access
)
1526 if (verify_access_tree_1 (access
, 0, 0))
1528 for (; access
; access
= access
->next_sibling
)
1529 dump_gensum_access (stderr
, access
, 2);
1530 internal_error ("IPA-SRA access verification failed");
1535 /* Callback of walk_stmt_load_store_addr_ops visit_addr used to determine
1536 GIMPLE_ASM operands with memory constrains which cannot be scalarized. */
1539 asm_visit_addr (gimple
*, tree op
, tree
, void *)
1541 op
= get_base_address (op
);
1543 && TREE_CODE (op
) == PARM_DECL
)
1544 disqualify_split_candidate (op
, "Non-scalarizable GIMPLE_ASM operand.");
1549 /* Mark a dereference of parameter identified by DESC of distance DIST in a
1550 basic block BB, unless the BB has already been marked as a potentially
1554 mark_param_dereference (gensum_param_desc
*desc
, HOST_WIDE_INT dist
,
1557 gcc_assert (desc
->by_ref
);
1558 gcc_checking_assert (desc
->split_candidate
);
1560 if (bitmap_bit_p (final_bbs
, bb
->index
))
1563 int idx
= bb
->index
* by_ref_count
+ desc
->deref_index
;
1564 if (bb_dereferences
[idx
] < dist
)
1565 bb_dereferences
[idx
] = dist
;
1568 /* Return true, if any potential replacements should use NEW_TYPE as opposed to
1569 previously recorded OLD_TYPE. */
1572 type_prevails_p (tree old_type
, tree new_type
)
1574 if (old_type
== new_type
)
1577 /* Non-aggregates are always better. */
1578 if (!is_gimple_reg_type (old_type
)
1579 && is_gimple_reg_type (new_type
))
1581 if (is_gimple_reg_type (old_type
)
1582 && !is_gimple_reg_type (new_type
))
1585 /* Prefer any complex or vector type over any other scalar type. */
1586 if (TREE_CODE (old_type
) != COMPLEX_TYPE
1587 && TREE_CODE (old_type
) != VECTOR_TYPE
1588 && (TREE_CODE (new_type
) == COMPLEX_TYPE
1589 || TREE_CODE (new_type
) == VECTOR_TYPE
))
1591 if ((TREE_CODE (old_type
) == COMPLEX_TYPE
1592 || TREE_CODE (old_type
) == VECTOR_TYPE
)
1593 && TREE_CODE (new_type
) != COMPLEX_TYPE
1594 && TREE_CODE (new_type
) != VECTOR_TYPE
)
1597 /* Use the integral type with the bigger precision. */
1598 if (INTEGRAL_TYPE_P (old_type
)
1599 && INTEGRAL_TYPE_P (new_type
))
1600 return (TYPE_PRECISION (new_type
) > TYPE_PRECISION (old_type
));
1602 /* Attempt to disregard any integral type with non-full precision. */
1603 if (INTEGRAL_TYPE_P (old_type
)
1604 && (TREE_INT_CST_LOW (TYPE_SIZE (old_type
))
1605 != TYPE_PRECISION (old_type
)))
1607 if (INTEGRAL_TYPE_P (new_type
)
1608 && (TREE_INT_CST_LOW (TYPE_SIZE (new_type
))
1609 != TYPE_PRECISION (new_type
)))
1611 /* Stabilize the selection. */
1612 return TYPE_UID (old_type
) < TYPE_UID (new_type
);
1615 /* When scanning an expression which is a call argument, this structure
1616 specifies the call and the position of the argument. */
1618 struct scan_call_info
1620 /* Call graph edge representing the call. */
1622 /* Total number of arguments in the call. */
1623 unsigned argument_count
;
1624 /* Number of the actual argument being scanned. */
1628 /* Record use of ACCESS which belongs to a parameter described by DESC in a
1629 call argument described by CALL_INFO. */
1632 record_nonregister_call_use (gensum_param_desc
*desc
,
1633 scan_call_info
*call_info
,
1634 unsigned unit_offset
, unsigned unit_size
)
1636 isra_call_summary
*csum
= call_sums
->get_create (call_info
->cs
);
1637 csum
->init_inputs (call_info
->argument_count
);
1639 isra_param_flow
*param_flow
= &csum
->m_arg_flow
[call_info
->arg_idx
];
1640 param_flow
->aggregate_pass_through
= true;
1641 set_single_param_flow_source (param_flow
, desc
->param_number
);
1642 param_flow
->unit_offset
= unit_offset
;
1643 param_flow
->unit_size
= unit_size
;
1647 /* Callback of walk_aliased_vdefs, just mark that there was a possible
1651 mark_maybe_modified (ao_ref
*, tree
, void *data
)
1653 bool *maybe_modified
= (bool *) data
;
1654 *maybe_modified
= true;
1658 /* Analyze expression EXPR from GIMPLE for accesses to parameters. CTX
1659 specifies whether EXPR is used in a load, store or as an argument call. BB
1660 must be the basic block in which expr resides. If CTX specifies call
1661 argument context, CALL_INFO must describe that call and argument position,
1662 otherwise it is ignored. */
1665 scan_expr_access (tree expr
, gimple
*stmt
, isra_scan_context ctx
,
1666 basic_block bb
, scan_call_info
*call_info
= NULL
)
1668 poly_int64 poffset
, psize
, pmax_size
;
1669 HOST_WIDE_INT offset
, size
, max_size
;
1674 if (TREE_CODE (expr
) == BIT_FIELD_REF
1675 || TREE_CODE (expr
) == IMAGPART_EXPR
1676 || TREE_CODE (expr
) == REALPART_EXPR
)
1677 expr
= TREE_OPERAND (expr
, 0);
1679 base
= get_ref_base_and_extent (expr
, &poffset
, &psize
, &pmax_size
, &reverse
);
1681 if (TREE_CODE (base
) == MEM_REF
)
1683 tree op
= TREE_OPERAND (base
, 0);
1684 if (TREE_CODE (op
) != SSA_NAME
1685 || !SSA_NAME_IS_DEFAULT_DEF (op
))
1687 base
= SSA_NAME_VAR (op
);
1692 if (TREE_CODE (base
) != PARM_DECL
)
1695 gensum_param_desc
*desc
= get_gensum_param_desc (base
);
1696 if (!desc
|| !desc
->split_candidate
)
1699 if (!poffset
.is_constant (&offset
)
1700 || !psize
.is_constant (&size
)
1701 || !pmax_size
.is_constant (&max_size
))
1703 disqualify_split_candidate (desc
, "Encountered a polynomial-sized "
1707 if (size
< 0 || size
!= max_size
)
1709 disqualify_split_candidate (desc
, "Encountered a variable sized access.");
1712 if (TREE_CODE (expr
) == COMPONENT_REF
1713 && DECL_BIT_FIELD (TREE_OPERAND (expr
, 1)))
1715 disqualify_split_candidate (desc
, "Encountered a bit-field access.");
1720 disqualify_split_candidate (desc
, "Encountered an access at a "
1721 "negative offset.");
1724 gcc_assert ((offset
% BITS_PER_UNIT
) == 0);
1725 gcc_assert ((size
% BITS_PER_UNIT
) == 0);
1726 if ((offset
/ BITS_PER_UNIT
) >= (UINT_MAX
- ISRA_ARG_SIZE_LIMIT
)
1727 || (size
/ BITS_PER_UNIT
) >= ISRA_ARG_SIZE_LIMIT
)
1729 disqualify_split_candidate (desc
, "Encountered an access with too big "
1734 tree type
= TREE_TYPE (expr
);
1735 unsigned int exp_align
= get_object_alignment (expr
);
1737 if (exp_align
< TYPE_ALIGN (type
))
1739 disqualify_split_candidate (desc
, "Underaligned access.");
1747 disqualify_split_candidate (desc
, "Dereferencing a non-reference.");
1750 else if (ctx
== ISRA_CTX_STORE
)
1752 disqualify_split_candidate (desc
, "Storing to data passed by "
1757 if (!aa_walking_limit
)
1759 disqualify_split_candidate (desc
, "Out of alias analysis step "
1764 gcc_checking_assert (gimple_vuse (stmt
));
1765 bool maybe_modified
= false;
1768 ao_ref_init (&ar
, expr
);
1769 bitmap visited
= BITMAP_ALLOC (NULL
);
1770 int walked
= walk_aliased_vdefs (&ar
, gimple_vuse (stmt
),
1771 mark_maybe_modified
, &maybe_modified
,
1772 &visited
, NULL
, aa_walking_limit
);
1773 BITMAP_FREE (visited
);
1776 gcc_assert (aa_walking_limit
> walked
);
1777 aa_walking_limit
= aa_walking_limit
- walked
;
1780 aa_walking_limit
= 0;
1781 if (maybe_modified
|| walked
< 0)
1783 disqualify_split_candidate (desc
, "Data passed by reference possibly "
1784 "modified through an alias.");
1788 mark_param_dereference (desc
, offset
+ size
, bb
);
1791 /* Pointer parameters with direct uses should have been ruled out by
1792 analyzing SSA default def when looking at the parameters. */
1793 gcc_assert (!desc
->by_ref
);
1795 gensum_param_access
*access
= get_access (desc
, offset
, size
, ctx
);
1799 if (ctx
== ISRA_CTX_ARG
)
1801 gcc_checking_assert (call_info
);
1804 record_nonregister_call_use (desc
, call_info
, offset
/ BITS_PER_UNIT
,
1805 size
/ BITS_PER_UNIT
);
1807 /* This is not a pass-through of a pointer, this is a use like any
1809 access
->nonarg
= true;
1814 access
->type
= type
;
1815 access
->alias_ptr_type
= reference_alias_ptr_type (expr
);
1816 access
->reverse
= reverse
;
1820 if (exp_align
< TYPE_ALIGN (access
->type
))
1822 disqualify_split_candidate (desc
, "Reference has lower alignment "
1823 "than a previous one.");
1826 if (access
->alias_ptr_type
!= reference_alias_ptr_type (expr
))
1828 disqualify_split_candidate (desc
, "Multiple alias pointer types.");
1831 if (access
->reverse
!= reverse
)
1833 disqualify_split_candidate (desc
, "Both normal and reverse "
1834 "scalar storage order.");
1838 && (AGGREGATE_TYPE_P (type
) || AGGREGATE_TYPE_P (access
->type
))
1839 && (TYPE_MAIN_VARIANT (access
->type
) != TYPE_MAIN_VARIANT (type
)))
1841 /* We need the same aggregate type on all accesses to be able to
1842 distinguish transformation spots from pass-through arguments in
1843 the transformation phase. */
1844 disqualify_split_candidate (desc
, "We do not support aggregate "
1849 if (type_prevails_p (access
->type
, type
))
1850 access
->type
= type
;
1854 /* Scan body function described by NODE and FUN and create access trees for
1858 scan_function (cgraph_node
*node
, struct function
*fun
)
1862 FOR_EACH_BB_FN (bb
, fun
)
1864 gimple_stmt_iterator gsi
;
1865 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1867 gimple
*stmt
= gsi_stmt (gsi
);
1869 if (stmt_can_throw_external (fun
, stmt
))
1870 bitmap_set_bit (final_bbs
, bb
->index
);
1871 switch (gimple_code (stmt
))
1875 tree t
= gimple_return_retval (as_a
<greturn
*> (stmt
));
1877 scan_expr_access (t
, stmt
, ISRA_CTX_LOAD
, bb
);
1878 bitmap_set_bit (final_bbs
, bb
->index
);
1883 if (gimple_assign_single_p (stmt
)
1884 && !gimple_clobber_p (stmt
))
1886 tree rhs
= gimple_assign_rhs1 (stmt
);
1887 scan_expr_access (rhs
, stmt
, ISRA_CTX_LOAD
, bb
);
1888 tree lhs
= gimple_assign_lhs (stmt
);
1889 scan_expr_access (lhs
, stmt
, ISRA_CTX_STORE
, bb
);
1895 unsigned argument_count
= gimple_call_num_args (stmt
);
1896 isra_scan_context ctx
= ISRA_CTX_ARG
;
1897 scan_call_info call_info
, *call_info_p
= &call_info
;
1898 if (gimple_call_internal_p (stmt
))
1901 ctx
= ISRA_CTX_LOAD
;
1902 internal_fn ifn
= gimple_call_internal_fn (stmt
);
1903 if (internal_store_fn_p (ifn
))
1904 ctx
= ISRA_CTX_STORE
;
1908 call_info
.cs
= node
->get_edge (stmt
);
1909 call_info
.argument_count
= argument_count
;
1912 for (unsigned i
= 0; i
< argument_count
; i
++)
1914 call_info
.arg_idx
= i
;
1915 scan_expr_access (gimple_call_arg (stmt
, i
), stmt
,
1916 ctx
, bb
, call_info_p
);
1919 tree lhs
= gimple_call_lhs (stmt
);
1921 scan_expr_access (lhs
, stmt
, ISRA_CTX_STORE
, bb
);
1922 int flags
= gimple_call_flags (stmt
);
1923 if ((flags
& (ECF_CONST
| ECF_PURE
)) == 0)
1924 bitmap_set_bit (final_bbs
, bb
->index
);
1930 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1931 walk_stmt_load_store_addr_ops (asm_stmt
, NULL
, NULL
, NULL
,
1933 bitmap_set_bit (final_bbs
, bb
->index
);
1935 for (unsigned i
= 0; i
< gimple_asm_ninputs (asm_stmt
); i
++)
1937 tree t
= TREE_VALUE (gimple_asm_input_op (asm_stmt
, i
));
1938 scan_expr_access (t
, stmt
, ISRA_CTX_LOAD
, bb
);
1940 for (unsigned i
= 0; i
< gimple_asm_noutputs (asm_stmt
); i
++)
1942 tree t
= TREE_VALUE (gimple_asm_output_op (asm_stmt
, i
));
1943 scan_expr_access (t
, stmt
, ISRA_CTX_STORE
, bb
);
1955 /* Return true if SSA_NAME NAME of function described by FUN is only used in
1956 return statements, or if results of any operations it is involved in are
1957 only used in return statements. ANALYZED is a bitmap that tracks which SSA
1958 names we have already started investigating. */
1961 ssa_name_only_returned_p (function
*fun
, tree name
, bitmap analyzed
)
1964 imm_use_iterator imm_iter
;
1967 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
1969 if (is_gimple_debug (stmt
))
1972 if (gimple_code (stmt
) == GIMPLE_RETURN
)
1974 tree t
= gimple_return_retval (as_a
<greturn
*> (stmt
));
1981 else if (!stmt_unremovable_because_of_non_call_eh_p (fun
, stmt
)
1982 && ((is_gimple_assign (stmt
) && !gimple_has_volatile_ops (stmt
))
1983 || gimple_code (stmt
) == GIMPLE_PHI
))
1985 /* TODO: And perhaps for const function calls too? */
1987 if (gimple_code (stmt
) == GIMPLE_PHI
)
1988 lhs
= gimple_phi_result (stmt
);
1990 lhs
= gimple_assign_lhs (stmt
);
1992 if (TREE_CODE (lhs
) != SSA_NAME
)
1997 gcc_assert (!gimple_vdef (stmt
));
1998 if (bitmap_set_bit (analyzed
, SSA_NAME_VERSION (lhs
))
1999 && !ssa_name_only_returned_p (fun
, lhs
, analyzed
))
2014 /* Inspect the uses of the return value of the call associated with CS, and if
2015 it is not used or if it is only used to construct the return value of the
2016 caller, mark it as such in call or caller summary. Also check for
2017 misaligned arguments. */
2020 isra_analyze_call (cgraph_edge
*cs
)
2022 gcall
*call_stmt
= cs
->call_stmt
;
2023 unsigned count
= gimple_call_num_args (call_stmt
);
2024 isra_call_summary
*csum
= call_sums
->get_create (cs
);
2026 for (unsigned i
= 0; i
< count
; i
++)
2028 tree arg
= gimple_call_arg (call_stmt
, i
);
2029 if (is_gimple_reg (arg
))
2033 poly_int64 bitsize
, bitpos
;
2035 int unsignedp
, reversep
, volatilep
= 0;
2036 get_inner_reference (arg
, &bitsize
, &bitpos
, &offset
, &mode
,
2037 &unsignedp
, &reversep
, &volatilep
);
2038 if (!multiple_p (bitpos
, BITS_PER_UNIT
))
2040 csum
->m_bit_aligned_arg
= true;
2045 tree lhs
= gimple_call_lhs (call_stmt
);
2048 /* TODO: Also detect aggregates on a LHS of a call that are only returned
2049 from this function (without being read anywhere). */
2050 if (TREE_CODE (lhs
) == SSA_NAME
)
2052 bitmap analyzed
= BITMAP_ALLOC (NULL
);
2053 if (ssa_name_only_returned_p (DECL_STRUCT_FUNCTION (cs
->caller
->decl
),
2055 csum
->m_return_returned
= true;
2056 BITMAP_FREE (analyzed
);
2060 csum
->m_return_ignored
= true;
2063 /* Look at all calls going out of NODE, described also by IFS and perform all
2064 analyses necessary for IPA-SRA that are not done at body scan time or done
2065 even when body is not scanned because the function is not a candidate. */
2068 isra_analyze_all_outgoing_calls (cgraph_node
*node
)
2070 for (cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
2071 isra_analyze_call (cs
);
2072 for (cgraph_edge
*cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
2073 isra_analyze_call (cs
);
2076 /* Dump a dereferences table with heading STR to file F. */
2079 dump_dereferences_table (FILE *f
, struct function
*fun
, const char *str
)
2083 fprintf (dump_file
, "%s", str
);
2084 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
),
2085 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
2087 fprintf (f
, "%4i %i ", bb
->index
, bitmap_bit_p (final_bbs
, bb
->index
));
2088 if (bb
!= EXIT_BLOCK_PTR_FOR_FN (fun
))
2091 for (i
= 0; i
< by_ref_count
; i
++)
2093 int idx
= bb
->index
* by_ref_count
+ i
;
2094 fprintf (f
, " %4" HOST_WIDE_INT_PRINT
"d", bb_dereferences
[idx
]);
2099 fprintf (dump_file
, "\n");
2102 /* Propagate distances in bb_dereferences in the opposite direction than the
2103 control flow edges, in each step storing the maximum of the current value
2104 and the minimum of all successors. These steps are repeated until the table
2105 stabilizes. Note that BBs which might terminate the functions (according to
2106 final_bbs bitmap) never updated in this way. */
2109 propagate_dereference_distances (struct function
*fun
)
2113 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2114 dump_dereferences_table (dump_file
, fun
,
2115 "Dereference table before propagation:\n");
2117 auto_vec
<basic_block
> queue (last_basic_block_for_fn (fun
));
2118 queue
.quick_push (ENTRY_BLOCK_PTR_FOR_FN (fun
));
2119 FOR_EACH_BB_FN (bb
, fun
)
2121 queue
.quick_push (bb
);
2125 while (!queue
.is_empty ())
2129 bool change
= false;
2135 if (bitmap_bit_p (final_bbs
, bb
->index
))
2138 for (i
= 0; i
< by_ref_count
; i
++)
2140 int idx
= bb
->index
* by_ref_count
+ i
;
2142 HOST_WIDE_INT inh
= 0;
2144 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
2146 int succ_idx
= e
->dest
->index
* by_ref_count
+ i
;
2148 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (fun
))
2154 inh
= bb_dereferences
[succ_idx
];
2156 else if (bb_dereferences
[succ_idx
] < inh
)
2157 inh
= bb_dereferences
[succ_idx
];
2160 if (!first
&& bb_dereferences
[idx
] < inh
)
2162 bb_dereferences
[idx
] = inh
;
2168 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
2173 e
->src
->aux
= e
->src
;
2174 queue
.quick_push (e
->src
);
2178 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2179 dump_dereferences_table (dump_file
, fun
,
2180 "Dereference table after propagation:\n");
2183 /* Perform basic checks on ACCESS to PARM described by DESC and all its
2184 children, return true if the parameter cannot be split, otherwise return
2185 true and update *TOTAL_SIZE and *ONLY_CALLS. ENTRY_BB_INDEX must be the
2186 index of the entry BB in the function of PARM. */
2189 check_gensum_access (tree parm
, gensum_param_desc
*desc
,
2190 gensum_param_access
*access
,
2191 HOST_WIDE_INT
*nonarg_acc_size
, bool *only_calls
,
2196 *only_calls
= false;
2197 *nonarg_acc_size
+= access
->size
;
2199 if (access
->first_child
)
2201 disqualify_split_candidate (desc
, "Overlapping non-call uses.");
2205 /* Do not decompose a non-BLKmode param in a way that would create
2206 BLKmode params. Especially for by-reference passing (thus,
2207 pointer-type param) this is hardly worthwhile. */
2208 if (DECL_MODE (parm
) != BLKmode
2209 && TYPE_MODE (access
->type
) == BLKmode
)
2211 disqualify_split_candidate (desc
, "Would convert a non-BLK to a BLK.");
2217 int idx
= (entry_bb_index
* by_ref_count
+ desc
->deref_index
);
2218 if ((access
->offset
+ access
->size
) > bb_dereferences
[idx
])
2220 disqualify_split_candidate (desc
, "Would create a possibly "
2221 "illegal dereference in a caller.");
2226 for (gensum_param_access
*ch
= access
->first_child
;
2228 ch
= ch
->next_sibling
)
2229 if (check_gensum_access (parm
, desc
, ch
, nonarg_acc_size
, only_calls
,
2236 /* Copy data from FROM and all of its children to a vector of accesses in IPA
2240 copy_accesses_to_ipa_desc (gensum_param_access
*from
, isra_param_desc
*desc
)
2242 param_access
*to
= ggc_cleared_alloc
<param_access
> ();
2243 gcc_checking_assert ((from
->offset
% BITS_PER_UNIT
) == 0);
2244 gcc_checking_assert ((from
->size
% BITS_PER_UNIT
) == 0);
2245 to
->unit_offset
= from
->offset
/ BITS_PER_UNIT
;
2246 to
->unit_size
= from
->size
/ BITS_PER_UNIT
;
2247 to
->type
= from
->type
;
2248 to
->alias_ptr_type
= from
->alias_ptr_type
;
2249 to
->certain
= from
->nonarg
;
2250 to
->reverse
= from
->reverse
;
2251 vec_safe_push (desc
->accesses
, to
);
2253 for (gensum_param_access
*ch
= from
->first_child
;
2255 ch
= ch
->next_sibling
)
2256 copy_accesses_to_ipa_desc (ch
, desc
);
2259 /* Analyze function body scan results stored in param_accesses and
2260 param_accesses, detect possible transformations and store information of
2261 those in function summary. NODE, FUN and IFS are all various structures
2262 describing the currently analyzed function. */
2265 process_scan_results (cgraph_node
*node
, struct function
*fun
,
2266 isra_func_summary
*ifs
,
2267 vec
<gensum_param_desc
> *param_descriptions
)
2269 bool check_pass_throughs
= false;
2270 bool dereferences_propagated
= false;
2271 tree parm
= DECL_ARGUMENTS (node
->decl
);
2272 unsigned param_count
= param_descriptions
->length();
2274 for (unsigned desc_index
= 0;
2275 desc_index
< param_count
;
2276 desc_index
++, parm
= DECL_CHAIN (parm
))
2278 gensum_param_desc
*desc
= &(*param_descriptions
)[desc_index
];
2279 if (!desc
->split_candidate
)
2283 isra_verify_access_tree (desc
->accesses
);
2285 if (!dereferences_propagated
2289 propagate_dereference_distances (fun
);
2290 dereferences_propagated
= true;
2293 HOST_WIDE_INT nonarg_acc_size
= 0;
2294 bool only_calls
= true;
2295 bool check_failed
= false;
2297 int entry_bb_index
= ENTRY_BLOCK_PTR_FOR_FN (fun
)->index
;
2298 for (gensum_param_access
*acc
= desc
->accesses
;
2300 acc
= acc
->next_sibling
)
2301 if (check_gensum_access (parm
, desc
, acc
, &nonarg_acc_size
, &only_calls
,
2304 check_failed
= true;
2311 desc
->locally_unused
= true;
2313 HOST_WIDE_INT cur_param_size
2314 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (parm
)));
2315 HOST_WIDE_INT param_size_limit
;
2316 if (!desc
->by_ref
|| optimize_function_for_size_p (fun
))
2317 param_size_limit
= cur_param_size
;
2320 = opt_for_fn (node
->decl
,
2321 param_ipa_sra_ptr_growth_factor
) * cur_param_size
;
2322 if (nonarg_acc_size
> param_size_limit
2323 || (!desc
->by_ref
&& nonarg_acc_size
== param_size_limit
))
2325 disqualify_split_candidate (desc
, "Would result into a too big set "
2326 "of replacements.");
2330 /* create_parameter_descriptors makes sure unit sizes of all
2331 candidate parameters fit unsigned integers restricted to
2332 ISRA_ARG_SIZE_LIMIT. */
2333 desc
->param_size_limit
= param_size_limit
/ BITS_PER_UNIT
;
2334 desc
->nonarg_acc_size
= nonarg_acc_size
/ BITS_PER_UNIT
;
2335 if (desc
->split_candidate
&& desc
->ptr_pt_count
)
2337 gcc_assert (desc
->by_ref
);
2338 check_pass_throughs
= true;
2343 /* When a pointer parameter is passed-through to a callee, in which it is
2344 only used to read only one or a few items, we can attempt to transform it
2345 to obtaining and passing through the items instead of the pointer. But we
2346 must take extra care that 1) we do not introduce any segfault by moving
2347 dereferences above control flow and that 2) the data is not modified
2348 through an alias in this function. The IPA analysis must not introduce
2349 any accesses candidates unless it can prove both.
2351 The current solution is very crude as it consists of ensuring that the
2352 call postdominates entry BB and that the definition of VUSE of the call is
2353 default definition. TODO: For non-recursive callees in the same
2354 compilation unit we could do better by doing analysis in topological order
2355 an looking into access candidates of callees, using their alias_ptr_types
2356 to attempt real AA. We could also use the maximum known dereferenced
2357 offset in this function at IPA level.
2359 TODO: Measure the overhead and the effect of just being pessimistic.
2360 Maybe this is only -O3 material?
2362 bool pdoms_calculated
= false;
2363 if (check_pass_throughs
)
2364 for (cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
2366 gcall
*call_stmt
= cs
->call_stmt
;
2367 tree vuse
= gimple_vuse (call_stmt
);
2369 /* If the callee is a const function, we don't get a VUSE. In such
2370 case there will be no memory accesses in the called function (or the
2371 const attribute is wrong) and then we just don't care. */
2372 bool uses_memory_as_obtained
= vuse
&& SSA_NAME_IS_DEFAULT_DEF (vuse
);
2374 unsigned count
= gimple_call_num_args (call_stmt
);
2375 isra_call_summary
*csum
= call_sums
->get_create (cs
);
2376 csum
->init_inputs (count
);
2377 for (unsigned argidx
= 0; argidx
< count
; argidx
++)
2379 if (!csum
->m_arg_flow
[argidx
].pointer_pass_through
)
2382 = get_single_param_flow_source (&csum
->m_arg_flow
[argidx
]);
2383 gensum_param_desc
*desc
= &(*param_descriptions
)[pidx
];
2384 if (!desc
->split_candidate
)
2386 csum
->m_arg_flow
[argidx
].pointer_pass_through
= false;
2389 if (!uses_memory_as_obtained
)
2392 /* Post-dominator check placed last, hoping that it usually won't
2394 if (!pdoms_calculated
)
2396 gcc_checking_assert (cfun
);
2397 add_noreturn_fake_exit_edges ();
2398 connect_infinite_loops_to_exit ();
2399 calculate_dominance_info (CDI_POST_DOMINATORS
);
2400 pdoms_calculated
= true;
2402 if (dominated_by_p (CDI_POST_DOMINATORS
,
2403 gimple_bb (call_stmt
),
2404 single_succ (ENTRY_BLOCK_PTR_FOR_FN (fun
))))
2405 csum
->m_arg_flow
[argidx
].safe_to_import_accesses
= true;
2409 if (pdoms_calculated
)
2411 free_dominance_info (CDI_POST_DOMINATORS
);
2412 remove_fake_exit_edges ();
2415 /* TODO: Add early exit if we disqualified everything. This also requires
2416 that we either relax the restriction that
2417 ipa_param_adjustments.m_always_copy_start must be the number of PARM_DECLs
2418 or store the number of parameters to IPA-SRA function summary and use that
2419 when just removing params. */
2421 vec_safe_reserve_exact (ifs
->m_parameters
, param_count
);
2422 ifs
->m_parameters
->quick_grow_cleared (param_count
);
2423 for (unsigned desc_index
= 0; desc_index
< param_count
; desc_index
++)
2425 gensum_param_desc
*s
= &(*param_descriptions
)[desc_index
];
2426 isra_param_desc
*d
= &(*ifs
->m_parameters
)[desc_index
];
2428 d
->param_size_limit
= s
->param_size_limit
;
2429 d
->size_reached
= s
->nonarg_acc_size
;
2430 d
->locally_unused
= s
->locally_unused
;
2431 d
->split_candidate
= s
->split_candidate
;
2432 d
->by_ref
= s
->by_ref
;
2434 for (gensum_param_access
*acc
= s
->accesses
;
2436 acc
= acc
->next_sibling
)
2437 copy_accesses_to_ipa_desc (acc
, d
);
2441 dump_isra_param_descriptors (dump_file
, node
->decl
, ifs
);
2444 /* Return true if there are any overlaps among certain accesses of DESC. If
2445 non-NULL, set *CERTAIN_ACCESS_PRESENT_P upon encountering a certain access
2446 too. DESC is assumed to be a split candidate that is not locally
2450 overlapping_certain_accesses_p (isra_param_desc
*desc
,
2451 bool *certain_access_present_p
)
2453 unsigned pclen
= vec_safe_length (desc
->accesses
);
2454 for (unsigned i
= 0; i
< pclen
; i
++)
2456 param_access
*a1
= (*desc
->accesses
)[i
];
2460 if (certain_access_present_p
)
2461 *certain_access_present_p
= true;
2462 for (unsigned j
= i
+ 1; j
< pclen
; j
++)
2464 param_access
*a2
= (*desc
->accesses
)[j
];
2466 && a1
->unit_offset
< a2
->unit_offset
+ a2
->unit_size
2467 && a1
->unit_offset
+ a1
->unit_size
> a2
->unit_offset
)
2474 /* Check for any overlaps of certain param accesses among splitting candidates
2475 and signal an ICE if there are any. If CERTAIN_MUST_EXIST is set, also
2476 check that used splitting candidates have at least one certain access. */
2479 verify_splitting_accesses (cgraph_node
*node
, bool certain_must_exist
)
2481 isra_func_summary
*ifs
= func_sums
->get (node
);
2482 if (!ifs
|| !ifs
->m_candidate
)
2484 unsigned param_count
= vec_safe_length (ifs
->m_parameters
);
2485 for (unsigned pidx
= 0; pidx
< param_count
; pidx
++)
2487 isra_param_desc
*desc
= &(*ifs
->m_parameters
)[pidx
];
2488 if (!desc
->split_candidate
|| desc
->locally_unused
)
2491 bool certain_access_present
= !certain_must_exist
;
2492 if (overlapping_certain_accesses_p (desc
, &certain_access_present
))
2493 internal_error ("Function %qs, parameter %u, has IPA-SRA accesses "
2494 "which overlap", node
->dump_name (), pidx
);
2495 if (!certain_access_present
)
2496 internal_error ("Function %s, parameter %u, is used but does not "
2497 "have any certain IPA-SRA access",
2498 node
->dump_name (), pidx
);
2502 /* Intraprocedural part of IPA-SRA analysis. Scan bodies of all functions in
2503 this compilation unit and create summary structures describing IPA-SRA
2504 opportunities and constraints in them. */
2507 ipa_sra_generate_summary (void)
2509 struct cgraph_node
*node
;
2511 gcc_checking_assert (!func_sums
);
2512 gcc_checking_assert (!call_sums
);
2514 = (new (ggc_alloc_no_dtor
<ipa_sra_function_summaries
> ())
2515 ipa_sra_function_summaries (symtab
, true));
2516 call_sums
= new ipa_sra_call_summaries (symtab
);
2518 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node
)
2519 ipa_sra_summarize_function (node
);
2523 /* Write intraprocedural analysis information about E and all of its outgoing
2524 edges into a stream for LTO WPA. */
2527 isra_write_edge_summary (output_block
*ob
, cgraph_edge
*e
)
2529 isra_call_summary
*csum
= call_sums
->get (e
);
2530 unsigned input_count
= csum
->m_arg_flow
.length ();
2531 streamer_write_uhwi (ob
, input_count
);
2532 for (unsigned i
= 0; i
< input_count
; i
++)
2534 isra_param_flow
*ipf
= &csum
->m_arg_flow
[i
];
2535 streamer_write_hwi (ob
, ipf
->length
);
2536 bitpack_d bp
= bitpack_create (ob
->main_stream
);
2537 for (int j
= 0; j
< ipf
->length
; j
++)
2538 bp_pack_value (&bp
, ipf
->inputs
[j
], 8);
2539 bp_pack_value (&bp
, ipf
->aggregate_pass_through
, 1);
2540 bp_pack_value (&bp
, ipf
->pointer_pass_through
, 1);
2541 bp_pack_value (&bp
, ipf
->safe_to_import_accesses
, 1);
2542 streamer_write_bitpack (&bp
);
2543 streamer_write_uhwi (ob
, ipf
->unit_offset
);
2544 streamer_write_uhwi (ob
, ipf
->unit_size
);
2546 bitpack_d bp
= bitpack_create (ob
->main_stream
);
2547 bp_pack_value (&bp
, csum
->m_return_ignored
, 1);
2548 bp_pack_value (&bp
, csum
->m_return_returned
, 1);
2549 bp_pack_value (&bp
, csum
->m_bit_aligned_arg
, 1);
2550 streamer_write_bitpack (&bp
);
2553 /* Write intraprocedural analysis information about NODE and all of its outgoing
2554 edges into a stream for LTO WPA. */
2557 isra_write_node_summary (output_block
*ob
, cgraph_node
*node
)
2559 isra_func_summary
*ifs
= func_sums
->get (node
);
2560 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
2561 int node_ref
= lto_symtab_encoder_encode (encoder
, node
);
2562 streamer_write_uhwi (ob
, node_ref
);
2564 unsigned param_desc_count
= vec_safe_length (ifs
->m_parameters
);
2565 streamer_write_uhwi (ob
, param_desc_count
);
2566 for (unsigned i
= 0; i
< param_desc_count
; i
++)
2568 isra_param_desc
*desc
= &(*ifs
->m_parameters
)[i
];
2569 unsigned access_count
= vec_safe_length (desc
->accesses
);
2570 streamer_write_uhwi (ob
, access_count
);
2571 for (unsigned j
= 0; j
< access_count
; j
++)
2573 param_access
*acc
= (*desc
->accesses
)[j
];
2574 stream_write_tree (ob
, acc
->type
, true);
2575 stream_write_tree (ob
, acc
->alias_ptr_type
, true);
2576 streamer_write_uhwi (ob
, acc
->unit_offset
);
2577 streamer_write_uhwi (ob
, acc
->unit_size
);
2578 bitpack_d bp
= bitpack_create (ob
->main_stream
);
2579 bp_pack_value (&bp
, acc
->certain
, 1);
2580 streamer_write_bitpack (&bp
);
2582 streamer_write_uhwi (ob
, desc
->param_size_limit
);
2583 streamer_write_uhwi (ob
, desc
->size_reached
);
2584 bitpack_d bp
= bitpack_create (ob
->main_stream
);
2585 bp_pack_value (&bp
, desc
->locally_unused
, 1);
2586 bp_pack_value (&bp
, desc
->split_candidate
, 1);
2587 bp_pack_value (&bp
, desc
->by_ref
, 1);
2588 streamer_write_bitpack (&bp
);
2590 bitpack_d bp
= bitpack_create (ob
->main_stream
);
2591 bp_pack_value (&bp
, ifs
->m_candidate
, 1);
2592 bp_pack_value (&bp
, ifs
->m_returns_value
, 1);
2593 bp_pack_value (&bp
, ifs
->m_return_ignored
, 1);
2594 gcc_assert (!ifs
->m_queued
);
2595 streamer_write_bitpack (&bp
);
2597 for (cgraph_edge
*e
= node
->callees
; e
; e
= e
->next_callee
)
2598 isra_write_edge_summary (ob
, e
);
2599 for (cgraph_edge
*e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2600 isra_write_edge_summary (ob
, e
);
2603 /* Write intraprocedural analysis information into a stream for LTO WPA. */
2606 ipa_sra_write_summary (void)
2608 if (!func_sums
|| !call_sums
)
2611 struct output_block
*ob
= create_output_block (LTO_section_ipa_sra
);
2612 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
2615 unsigned int count
= 0;
2616 lto_symtab_encoder_iterator lsei
;
2617 for (lsei
= lsei_start_function_in_partition (encoder
);
2619 lsei_next_function_in_partition (&lsei
))
2621 cgraph_node
*node
= lsei_cgraph_node (lsei
);
2622 if (node
->has_gimple_body_p ()
2623 && func_sums
->get (node
) != NULL
)
2626 streamer_write_uhwi (ob
, count
);
2628 /* Process all of the functions. */
2629 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
2630 lsei_next_function_in_partition (&lsei
))
2632 cgraph_node
*node
= lsei_cgraph_node (lsei
);
2633 if (node
->has_gimple_body_p ()
2634 && func_sums
->get (node
) != NULL
)
2635 isra_write_node_summary (ob
, node
);
2637 streamer_write_char_stream (ob
->main_stream
, 0);
2638 produce_asm (ob
, NULL
);
2639 destroy_output_block (ob
);
2642 /* Read intraprocedural analysis information about E and all of its outgoing
2643 edges into a stream for LTO WPA. */
2646 isra_read_edge_summary (struct lto_input_block
*ib
, cgraph_edge
*cs
)
2648 isra_call_summary
*csum
= call_sums
->get_create (cs
);
2649 unsigned input_count
= streamer_read_uhwi (ib
);
2650 csum
->init_inputs (input_count
);
2651 for (unsigned i
= 0; i
< input_count
; i
++)
2653 isra_param_flow
*ipf
= &csum
->m_arg_flow
[i
];
2654 ipf
->length
= streamer_read_hwi (ib
);
2655 bitpack_d bp
= streamer_read_bitpack (ib
);
2656 for (int j
= 0; j
< ipf
->length
; j
++)
2657 ipf
->inputs
[j
] = bp_unpack_value (&bp
, 8);
2658 ipf
->aggregate_pass_through
= bp_unpack_value (&bp
, 1);
2659 ipf
->pointer_pass_through
= bp_unpack_value (&bp
, 1);
2660 ipf
->safe_to_import_accesses
= bp_unpack_value (&bp
, 1);
2661 ipf
->unit_offset
= streamer_read_uhwi (ib
);
2662 ipf
->unit_size
= streamer_read_uhwi (ib
);
2664 bitpack_d bp
= streamer_read_bitpack (ib
);
2665 csum
->m_return_ignored
= bp_unpack_value (&bp
, 1);
2666 csum
->m_return_returned
= bp_unpack_value (&bp
, 1);
2667 csum
->m_bit_aligned_arg
= bp_unpack_value (&bp
, 1);
2670 /* Read intraprocedural analysis information about NODE and all of its outgoing
2671 edges into a stream for LTO WPA. */
2674 isra_read_node_info (struct lto_input_block
*ib
, cgraph_node
*node
,
2675 struct data_in
*data_in
)
2677 isra_func_summary
*ifs
= func_sums
->get_create (node
);
2678 unsigned param_desc_count
= streamer_read_uhwi (ib
);
2679 if (param_desc_count
> 0)
2681 vec_safe_reserve_exact (ifs
->m_parameters
, param_desc_count
);
2682 ifs
->m_parameters
->quick_grow_cleared (param_desc_count
);
2684 for (unsigned i
= 0; i
< param_desc_count
; i
++)
2686 isra_param_desc
*desc
= &(*ifs
->m_parameters
)[i
];
2687 unsigned access_count
= streamer_read_uhwi (ib
);
2688 for (unsigned j
= 0; j
< access_count
; j
++)
2690 param_access
*acc
= ggc_cleared_alloc
<param_access
> ();
2691 acc
->type
= stream_read_tree (ib
, data_in
);
2692 acc
->alias_ptr_type
= stream_read_tree (ib
, data_in
);
2693 acc
->unit_offset
= streamer_read_uhwi (ib
);
2694 acc
->unit_size
= streamer_read_uhwi (ib
);
2695 bitpack_d bp
= streamer_read_bitpack (ib
);
2696 acc
->certain
= bp_unpack_value (&bp
, 1);
2697 vec_safe_push (desc
->accesses
, acc
);
2699 desc
->param_size_limit
= streamer_read_uhwi (ib
);
2700 desc
->size_reached
= streamer_read_uhwi (ib
);
2701 bitpack_d bp
= streamer_read_bitpack (ib
);
2702 desc
->locally_unused
= bp_unpack_value (&bp
, 1);
2703 desc
->split_candidate
= bp_unpack_value (&bp
, 1);
2704 desc
->by_ref
= bp_unpack_value (&bp
, 1);
2706 bitpack_d bp
= streamer_read_bitpack (ib
);
2707 ifs
->m_candidate
= bp_unpack_value (&bp
, 1);
2708 ifs
->m_returns_value
= bp_unpack_value (&bp
, 1);
2709 ifs
->m_return_ignored
= bp_unpack_value (&bp
, 1);
2712 for (cgraph_edge
*e
= node
->callees
; e
; e
= e
->next_callee
)
2713 isra_read_edge_summary (ib
, e
);
2714 for (cgraph_edge
*e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2715 isra_read_edge_summary (ib
, e
);
2718 /* Read IPA-SRA summaries from a section in file FILE_DATA of length LEN with
2719 data DATA. TODO: This function was copied almost verbatim from ipa-prop.c,
2720 it should be possible to unify them somehow. */
2723 isra_read_summary_section (struct lto_file_decl_data
*file_data
,
2724 const char *data
, size_t len
)
2726 const struct lto_function_header
*header
=
2727 (const struct lto_function_header
*) data
;
2728 const int cfg_offset
= sizeof (struct lto_function_header
);
2729 const int main_offset
= cfg_offset
+ header
->cfg_size
;
2730 const int string_offset
= main_offset
+ header
->main_size
;
2731 struct data_in
*data_in
;
2735 lto_input_block
ib_main ((const char *) data
+ main_offset
,
2736 header
->main_size
, file_data
->mode_table
);
2739 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
2740 header
->string_size
, vNULL
);
2741 count
= streamer_read_uhwi (&ib_main
);
2743 for (i
= 0; i
< count
; i
++)
2746 struct cgraph_node
*node
;
2747 lto_symtab_encoder_t encoder
;
2749 index
= streamer_read_uhwi (&ib_main
);
2750 encoder
= file_data
->symtab_node_encoder
;
2751 node
= dyn_cast
<cgraph_node
*> (lto_symtab_encoder_deref (encoder
,
2753 gcc_assert (node
->definition
);
2754 isra_read_node_info (&ib_main
, node
, data_in
);
2756 lto_free_section_data (file_data
, LTO_section_ipa_sra
, NULL
, data
,
2758 lto_data_in_delete (data_in
);
2761 /* Read intraprocedural analysis information into a stream for LTO WPA. */
2764 ipa_sra_read_summary (void)
2766 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
2767 struct lto_file_decl_data
*file_data
;
2770 gcc_checking_assert (!func_sums
);
2771 gcc_checking_assert (!call_sums
);
2773 = (new (ggc_alloc_no_dtor
<ipa_sra_function_summaries
> ())
2774 ipa_sra_function_summaries (symtab
, true));
2775 call_sums
= new ipa_sra_call_summaries (symtab
);
2777 while ((file_data
= file_data_vec
[j
++]))
2781 = lto_get_summary_section_data (file_data
, LTO_section_ipa_sra
, &len
);
2783 isra_read_summary_section (file_data
, data
, len
);
2787 /* Dump all IPA-SRA summary data for all cgraph nodes and edges to file F. */
2790 ipa_sra_dump_all_summaries (FILE *f
)
2793 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node
)
2795 fprintf (f
, "\nSummary for node %s:\n", node
->dump_name ());
2797 isra_func_summary
*ifs
= func_sums
->get (node
);
2800 fprintf (f
, " Function does not have any associated IPA-SRA "
2804 if (!ifs
->m_candidate
)
2806 fprintf (f
, " Not a candidate function\n");
2809 if (ifs
->m_returns_value
)
2810 fprintf (f
, " Returns value\n");
2811 if (vec_safe_is_empty (ifs
->m_parameters
))
2812 fprintf (f
, " No parameter information. \n");
2814 for (unsigned i
= 0; i
< ifs
->m_parameters
->length (); ++i
)
2816 fprintf (f
, " Descriptor for parameter %i:\n", i
);
2817 dump_isra_param_descriptor (f
, &(*ifs
->m_parameters
)[i
]);
2821 struct cgraph_edge
*cs
;
2822 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
2824 fprintf (f
, " Summary for edge %s->%s:\n", cs
->caller
->dump_name (),
2825 cs
->callee
->dump_name ());
2826 isra_call_summary
*csum
= call_sums
->get (cs
);
2830 fprintf (f
, " Call summary is MISSING!\n");
2834 fprintf (f
, "\n\n");
2837 /* Perform function-scope viability tests that can be only made at IPA level
2838 and return false if the function is deemed unsuitable for IPA-SRA. */
2841 ipa_sra_ipa_function_checks (cgraph_node
*node
)
2843 if (!node
->can_be_local_p ())
2846 fprintf (dump_file
, "Function %s disqualified because it cannot be "
2847 "made local.\n", node
->dump_name ());
2850 if (!node
->can_change_signature
)
2853 fprintf (dump_file
, "Function can not change signature.\n");
2860 /* Issues found out by check_callers_for_issues. */
2862 struct caller_issues
2864 /* The candidate being considered. */
2865 cgraph_node
*candidate
;
2866 /* There is a thunk among callers. */
2868 /* Call site with no available information. */
2869 bool unknown_callsite
;
2870 /* Call from outside the the candidate's comdat group. */
2871 bool call_from_outside_comdat
;
2872 /* There is a bit-aligned load into one of non-gimple-typed arguments. */
2873 bool bit_aligned_aggregate_argument
;
2876 /* Worker for call_for_symbol_and_aliases, set any flags of passed caller_issues
2880 check_for_caller_issues (struct cgraph_node
*node
, void *data
)
2882 struct caller_issues
*issues
= (struct caller_issues
*) data
;
2884 for (cgraph_edge
*cs
= node
->callers
; cs
; cs
= cs
->next_caller
)
2886 if (cs
->caller
->thunk
)
2888 issues
->thunk
= true;
2889 /* TODO: We should be able to process at least some types of
2893 if (issues
->candidate
->calls_comdat_local
2894 && issues
->candidate
->same_comdat_group
2895 && !issues
->candidate
->in_same_comdat_group_p (cs
->caller
))
2897 issues
->call_from_outside_comdat
= true;
2901 isra_call_summary
*csum
= call_sums
->get (cs
);
2904 issues
->unknown_callsite
= true;
2908 if (csum
->m_bit_aligned_arg
)
2909 issues
->bit_aligned_aggregate_argument
= true;
2914 /* Look at all incoming edges to NODE, including aliases and thunks and look
2915 for problems. Return true if NODE type should not be modified at all. */
2918 check_all_callers_for_issues (cgraph_node
*node
)
2920 struct caller_issues issues
;
2921 memset (&issues
, 0, sizeof (issues
));
2922 issues
.candidate
= node
;
2924 node
->call_for_symbol_and_aliases (check_for_caller_issues
, &issues
, true);
2925 if (issues
.unknown_callsite
)
2927 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2928 fprintf (dump_file
, "A call of %s has not been analyzed. Disabling "
2929 "all modifications.\n", node
->dump_name ());
2932 /* TODO: We should be able to process at least some types of thunks. */
2935 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2936 fprintf (dump_file
, "A call of %s is through thunk, which are not"
2937 " handled yet. Disabling all modifications.\n",
2938 node
->dump_name ());
2941 if (issues
.call_from_outside_comdat
)
2944 fprintf (dump_file
, "Function would become private comdat called "
2945 "outside of its comdat group.\n");
2949 if (issues
.bit_aligned_aggregate_argument
)
2951 /* Let's only remove parameters/return values from such functions.
2952 TODO: We could only prevent splitting the problematic parameters if
2953 anybody thinks it is worth it. */
2954 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2955 fprintf (dump_file
, "A call of %s has bit-aligned aggregate argument,"
2956 " disabling parameter splitting.\n", node
->dump_name ());
2958 isra_func_summary
*ifs
= func_sums
->get (node
);
2959 gcc_checking_assert (ifs
);
2960 unsigned param_count
= vec_safe_length (ifs
->m_parameters
);
2961 for (unsigned i
= 0; i
< param_count
; i
++)
2962 (*ifs
->m_parameters
)[i
].split_candidate
= false;
2967 /* Find the access with corresponding OFFSET and SIZE among accesses in
2968 PARAM_DESC and return it or NULL if such an access is not there. */
2970 static param_access
*
2971 find_param_access (isra_param_desc
*param_desc
, unsigned offset
, unsigned size
)
2973 unsigned pclen
= vec_safe_length (param_desc
->accesses
);
2975 /* The search is linear but the number of stored accesses is bound by
2976 PARAM_IPA_SRA_MAX_REPLACEMENTS, so most probably 8. */
2978 for (unsigned i
= 0; i
< pclen
; i
++)
2979 if ((*param_desc
->accesses
)[i
]->unit_offset
== offset
2980 && (*param_desc
->accesses
)[i
]->unit_size
== size
)
2981 return (*param_desc
->accesses
)[i
];
2986 /* Return iff the total size of definite replacement SIZE would violate the
2987 limit set for it in PARAM. */
2990 size_would_violate_limit_p (isra_param_desc
*desc
, unsigned size
)
2992 unsigned limit
= desc
->param_size_limit
;
2994 || (!desc
->by_ref
&& size
== limit
))
2999 /* Increase reached size of DESC by SIZE or disqualify it if it would violate
3000 the set limit. IDX is the parameter number which is dumped when
3004 bump_reached_size (isra_param_desc
*desc
, unsigned size
, unsigned idx
)
3006 unsigned after
= desc
->size_reached
+ size
;
3007 if (size_would_violate_limit_p (desc
, after
))
3009 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3010 fprintf (dump_file
, " ...size limit reached, disqualifying "
3011 "candidate parameter %u\n", idx
);
3012 desc
->split_candidate
= false;
3015 desc
->size_reached
= after
;
3018 /* Take all actions required to deal with an edge CS that represents a call to
3019 an unknown or un-analyzed function, for both parameter removal and
3023 process_edge_to_unknown_caller (cgraph_edge
*cs
)
3025 isra_func_summary
*from_ifs
= func_sums
->get (cs
->caller
);
3026 gcc_checking_assert (from_ifs
);
3027 isra_call_summary
*csum
= call_sums
->get (cs
);
3029 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3030 fprintf (dump_file
, "Processing an edge to an unknown caller from %s:\n",
3031 cs
->caller
->dump_name ());
3033 unsigned args_count
= csum
->m_arg_flow
.length ();
3034 for (unsigned i
= 0; i
< args_count
; i
++)
3036 isra_param_flow
*ipf
= &csum
->m_arg_flow
[i
];
3038 if (ipf
->pointer_pass_through
)
3040 isra_param_desc
*param_desc
3041 = &(*from_ifs
->m_parameters
)[get_single_param_flow_source (ipf
)];
3042 param_desc
->locally_unused
= false;
3043 param_desc
->split_candidate
= false;
3046 if (ipf
->aggregate_pass_through
)
3048 unsigned idx
= get_single_param_flow_source (ipf
);
3049 isra_param_desc
*param_desc
= &(*from_ifs
->m_parameters
)[idx
];
3051 param_desc
->locally_unused
= false;
3052 if (!param_desc
->split_candidate
)
3054 gcc_assert (!param_desc
->by_ref
);
3055 param_access
*pacc
= find_param_access (param_desc
, ipf
->unit_offset
,
3057 gcc_checking_assert (pacc
);
3058 pacc
->certain
= true;
3059 if (overlapping_certain_accesses_p (param_desc
, NULL
))
3061 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3062 fprintf (dump_file
, " ...leading to overlap, "
3063 " disqualifying candidate parameter %u\n",
3065 param_desc
->split_candidate
= false;
3068 bump_reached_size (param_desc
, pacc
->unit_size
, idx
);
3069 ipf
->aggregate_pass_through
= false;
3073 for (int j
= 0; j
< ipf
->length
; j
++)
3075 int input_idx
= ipf
->inputs
[j
];
3076 (*from_ifs
->m_parameters
)[input_idx
].locally_unused
= false;
3081 /* Propagate parameter removal information through cross-SCC edge CS,
3082 i.e. decrease the use count in the caller parameter descriptor for each use
3086 param_removal_cross_scc_edge (cgraph_edge
*cs
)
3088 enum availability availability
;
3089 cgraph_node
*callee
= cs
->callee
->function_symbol (&availability
);
3090 isra_func_summary
*to_ifs
= func_sums
->get (callee
);
3091 if (!to_ifs
|| !to_ifs
->m_candidate
3092 || (availability
< AVAIL_AVAILABLE
)
3093 || vec_safe_is_empty (to_ifs
->m_parameters
))
3095 process_edge_to_unknown_caller (cs
);
3098 isra_func_summary
*from_ifs
= func_sums
->get (cs
->caller
);
3099 gcc_checking_assert (from_ifs
);
3101 isra_call_summary
*csum
= call_sums
->get (cs
);
3102 unsigned args_count
= csum
->m_arg_flow
.length ();
3103 unsigned param_count
= vec_safe_length (to_ifs
->m_parameters
);
3105 for (unsigned i
= 0; i
< args_count
; i
++)
3107 bool unused_in_callee
;
3108 if (i
< param_count
)
3109 unused_in_callee
= (*to_ifs
->m_parameters
)[i
].locally_unused
;
3111 unused_in_callee
= false;
3113 if (!unused_in_callee
)
3115 isra_param_flow
*ipf
= &csum
->m_arg_flow
[i
];
3116 for (int j
= 0; j
< ipf
->length
; j
++)
3118 int input_idx
= ipf
->inputs
[j
];
3119 (*from_ifs
->m_parameters
)[input_idx
].locally_unused
= false;
3125 /* Unless it is already there, push NODE which is also described by IFS to
3129 isra_push_node_to_stack (cgraph_node
*node
, isra_func_summary
*ifs
,
3130 vec
<cgraph_node
*> *stack
)
3134 ifs
->m_queued
= true;
3135 stack
->safe_push (node
);
3139 /* If parameter with index INPUT_IDX is marked as locally unused, mark it as
3140 used and push CALLER on STACK. */
3143 isra_mark_caller_param_used (isra_func_summary
*from_ifs
, int input_idx
,
3144 cgraph_node
*caller
, vec
<cgraph_node
*> *stack
)
3146 if ((*from_ifs
->m_parameters
)[input_idx
].locally_unused
)
3148 (*from_ifs
->m_parameters
)[input_idx
].locally_unused
= false;
3149 isra_push_node_to_stack (caller
, from_ifs
, stack
);
3154 /* Propagate information that any parameter is not used only locally within a
3155 SCC across CS to the caller, which must be in the same SCC as the
3156 callee. Push any callers that need to be re-processed to STACK. */
3159 propagate_used_across_scc_edge (cgraph_edge
*cs
, vec
<cgraph_node
*> *stack
)
3161 isra_func_summary
*from_ifs
= func_sums
->get (cs
->caller
);
3162 if (!from_ifs
|| vec_safe_is_empty (from_ifs
->m_parameters
))
3165 isra_call_summary
*csum
= call_sums
->get (cs
);
3166 gcc_checking_assert (csum
);
3167 unsigned args_count
= csum
->m_arg_flow
.length ();
3168 enum availability availability
;
3169 cgraph_node
*callee
= cs
->callee
->function_symbol (&availability
);
3170 isra_func_summary
*to_ifs
= func_sums
->get (callee
);
3172 unsigned param_count
3173 = (to_ifs
&& (availability
>= AVAIL_AVAILABLE
))
3174 ? vec_safe_length (to_ifs
->m_parameters
) : 0;
3175 for (unsigned i
= 0; i
< args_count
; i
++)
3178 && (*to_ifs
->m_parameters
)[i
].locally_unused
)
3181 /* The argument is needed in the callee it, we must mark the parameter as
3182 used also in the caller and its callers within this SCC. */
3183 isra_param_flow
*ipf
= &csum
->m_arg_flow
[i
];
3184 for (int j
= 0; j
< ipf
->length
; j
++)
3186 int input_idx
= ipf
->inputs
[j
];
3187 isra_mark_caller_param_used (from_ifs
, input_idx
, cs
->caller
, stack
);
3192 /* Propagate information that any parameter is not used only locally within a
3193 SCC (i.e. is used also elsewhere) to all callers of NODE that are in the
3194 same SCC. Push any callers that need to be re-processed to STACK. */
3197 propagate_used_to_scc_callers (cgraph_node
*node
, void *data
)
3199 vec
<cgraph_node
*> *stack
= (vec
<cgraph_node
*> *) data
;
3201 for (cs
= node
->callers
; cs
; cs
= cs
->next_caller
)
3202 if (ipa_edge_within_scc (cs
))
3203 propagate_used_across_scc_edge (cs
, stack
);
3207 /* Return true iff all certain accesses in ARG_DESC are also present as
3208 certain accesses in PARAM_DESC. */
3211 all_callee_accesses_present_p (isra_param_desc
*param_desc
,
3212 isra_param_desc
*arg_desc
)
3214 unsigned aclen
= vec_safe_length (arg_desc
->accesses
);
3215 for (unsigned j
= 0; j
< aclen
; j
++)
3217 param_access
*argacc
= (*arg_desc
->accesses
)[j
];
3218 if (!argacc
->certain
)
3220 param_access
*pacc
= find_param_access (param_desc
, argacc
->unit_offset
,
3224 || !types_compatible_p (argacc
->type
, pacc
->type
))
3230 /* Type internal to function pull_accesses_from_callee. Unfortunately gcc 4.8
3231 does not allow instantiating an auto_vec with a type defined within a
3232 function so it is a global type. */
3233 enum acc_prop_kind
{ACC_PROP_DONT
, ACC_PROP_COPY
, ACC_PROP_CERTAIN
};
3236 /* Attempt to propagate all definite accesses from ARG_DESC to PARAM_DESC,
3237 (which belongs to CALLER) if they would not violate some constraint there.
3238 If successful, return NULL, otherwise return the string reason for failure
3239 (which can be written to the dump file). DELTA_OFFSET is the known offset
3240 of the actual argument withing the formal parameter (so of ARG_DESCS within
3241 PARAM_DESCS), ARG_SIZE is the size of the actual argument or zero, if not
3242 known. In case of success, set *CHANGE_P to true if propagation actually
3243 changed anything. */
3246 pull_accesses_from_callee (cgraph_node
*caller
, isra_param_desc
*param_desc
,
3247 isra_param_desc
*arg_desc
,
3248 unsigned delta_offset
, unsigned arg_size
,
3251 unsigned pclen
= vec_safe_length (param_desc
->accesses
);
3252 unsigned aclen
= vec_safe_length (arg_desc
->accesses
);
3253 unsigned prop_count
= 0;
3254 unsigned prop_size
= 0;
3255 bool change
= false;
3257 auto_vec
<enum acc_prop_kind
, 8> prop_kinds (aclen
);
3258 for (unsigned j
= 0; j
< aclen
; j
++)
3260 param_access
*argacc
= (*arg_desc
->accesses
)[j
];
3261 prop_kinds
.safe_push (ACC_PROP_DONT
);
3264 && argacc
->unit_offset
+ argacc
->unit_size
> arg_size
)
3265 return "callee access outsize size boundary";
3267 if (!argacc
->certain
)
3270 unsigned offset
= argacc
->unit_offset
+ delta_offset
;
3271 /* Given that accesses are initially stored according to increasing
3272 offset and decreasing size in case of equal offsets, the following
3273 searches could be written more efficiently if we kept the ordering
3274 when copying. But the number of accesses is capped at
3275 PARAM_IPA_SRA_MAX_REPLACEMENTS (so most likely 8) and the code gets
3276 messy quickly, so let's improve on that only if necessary. */
3278 bool exact_match
= false;
3279 for (unsigned i
= 0; i
< pclen
; i
++)
3281 /* Check for overlaps. */
3282 param_access
*pacc
= (*param_desc
->accesses
)[i
];
3283 if (pacc
->unit_offset
== offset
3284 && pacc
->unit_size
== argacc
->unit_size
)
3286 if (argacc
->alias_ptr_type
!= pacc
->alias_ptr_type
3287 || !types_compatible_p (argacc
->type
, pacc
->type
))
3288 return "propagated access types would not match existing ones";
3293 prop_kinds
[j
] = ACC_PROP_CERTAIN
;
3294 prop_size
+= argacc
->unit_size
;
3300 if (offset
< pacc
->unit_offset
+ pacc
->unit_size
3301 && offset
+ argacc
->unit_size
> pacc
->unit_offset
)
3303 /* None permissible with load accesses, possible to fit into
3306 || offset
< pacc
->unit_offset
3307 || (offset
+ argacc
->unit_size
3308 > pacc
->unit_offset
+ pacc
->unit_size
))
3309 return "a propagated access would conflict in caller";
3315 prop_kinds
[j
] = ACC_PROP_COPY
;
3317 prop_size
+= argacc
->unit_size
;
3325 if ((prop_count
+ pclen
3326 > (unsigned) opt_for_fn (caller
->decl
, param_ipa_sra_max_replacements
))
3327 || size_would_violate_limit_p (param_desc
,
3328 param_desc
->size_reached
+ prop_size
))
3329 return "propagating accesses would violate the count or size limit";
3332 for (unsigned j
= 0; j
< aclen
; j
++)
3334 if (prop_kinds
[j
] == ACC_PROP_COPY
)
3336 param_access
*argacc
= (*arg_desc
->accesses
)[j
];
3338 param_access
*copy
= ggc_cleared_alloc
<param_access
> ();
3339 copy
->unit_offset
= argacc
->unit_offset
+ delta_offset
;
3340 copy
->unit_size
= argacc
->unit_size
;
3341 copy
->type
= argacc
->type
;
3342 copy
->alias_ptr_type
= argacc
->alias_ptr_type
;
3343 copy
->certain
= true;
3344 vec_safe_push (param_desc
->accesses
, copy
);
3346 else if (prop_kinds
[j
] == ACC_PROP_CERTAIN
)
3348 param_access
*argacc
= (*arg_desc
->accesses
)[j
];
3350 = find_param_access (param_desc
, argacc
->unit_offset
+ delta_offset
,
3352 csp
->certain
= true;
3356 param_desc
->size_reached
+= prop_size
;
3361 /* Propagate parameter splitting information through call graph edge CS.
3362 Return true if any changes that might need to be propagated within SCCs have
3363 been made. The function also clears the aggregate_pass_through and
3364 pointer_pass_through in call summaries which do not need to be processed
3365 again if this CS is revisited when iterating while changes are propagated
3369 param_splitting_across_edge (cgraph_edge
*cs
)
3372 bool cross_scc
= !ipa_edge_within_scc (cs
);
3373 enum availability availability
;
3374 cgraph_node
*callee
= cs
->callee
->function_symbol (&availability
);
3375 isra_func_summary
*from_ifs
= func_sums
->get (cs
->caller
);
3376 gcc_checking_assert (from_ifs
&& from_ifs
->m_parameters
);
3378 isra_call_summary
*csum
= call_sums
->get (cs
);
3379 gcc_checking_assert (csum
);
3380 unsigned args_count
= csum
->m_arg_flow
.length ();
3381 isra_func_summary
*to_ifs
= func_sums
->get (callee
);
3382 unsigned param_count
3383 = ((to_ifs
&& to_ifs
->m_candidate
&& (availability
>= AVAIL_AVAILABLE
))
3384 ? vec_safe_length (to_ifs
->m_parameters
)
3387 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3388 fprintf (dump_file
, "Splitting across %s->%s:\n",
3389 cs
->caller
->dump_name (), callee
->dump_name ());
3392 for (i
= 0; (i
< args_count
) && (i
< param_count
); i
++)
3394 isra_param_desc
*arg_desc
= &(*to_ifs
->m_parameters
)[i
];
3395 isra_param_flow
*ipf
= &csum
->m_arg_flow
[i
];
3397 if (arg_desc
->locally_unused
)
3399 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3400 fprintf (dump_file
, " ->%u: unused in callee\n", i
);
3401 ipf
->pointer_pass_through
= false;
3405 if (ipf
->pointer_pass_through
)
3407 int idx
= get_single_param_flow_source (ipf
);
3408 isra_param_desc
*param_desc
= &(*from_ifs
->m_parameters
)[idx
];
3409 if (!param_desc
->split_candidate
)
3411 gcc_assert (param_desc
->by_ref
);
3413 if (!arg_desc
->split_candidate
|| !arg_desc
->by_ref
)
3415 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3416 fprintf (dump_file
, " %u->%u: not candidate or not by "
3417 "reference in callee\n", idx
, i
);
3418 param_desc
->split_candidate
= false;
3419 ipf
->pointer_pass_through
= false;
3422 else if (!ipf
->safe_to_import_accesses
)
3424 if (!all_callee_accesses_present_p (param_desc
, arg_desc
))
3426 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3427 fprintf (dump_file
, " %u->%u: cannot import accesses.\n",
3429 param_desc
->split_candidate
= false;
3430 ipf
->pointer_pass_through
= false;
3436 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3437 fprintf (dump_file
, " %u->%u: verified callee accesses "
3438 "present.\n", idx
, i
);
3440 ipf
->pointer_pass_through
= false;
3445 const char *pull_failure
3446 = pull_accesses_from_callee (cs
->caller
, param_desc
, arg_desc
,
3450 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3451 fprintf (dump_file
, " %u->%u: by_ref access pull "
3452 "failed: %s.\n", idx
, i
, pull_failure
);
3453 param_desc
->split_candidate
= false;
3454 ipf
->pointer_pass_through
= false;
3459 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3460 fprintf (dump_file
, " %u->%u: by_ref access pull "
3461 "succeeded.\n", idx
, i
);
3463 ipf
->pointer_pass_through
= false;
3467 else if (ipf
->aggregate_pass_through
)
3469 int idx
= get_single_param_flow_source (ipf
);
3470 isra_param_desc
*param_desc
= &(*from_ifs
->m_parameters
)[idx
];
3471 if (!param_desc
->split_candidate
)
3473 gcc_assert (!param_desc
->by_ref
);
3474 param_access
*pacc
= find_param_access (param_desc
, ipf
->unit_offset
,
3476 gcc_checking_assert (pacc
);
3480 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3481 fprintf (dump_file
, " %u->%u: already certain\n", idx
, i
);
3482 ipf
->aggregate_pass_through
= false;
3484 else if (!arg_desc
->split_candidate
|| arg_desc
->by_ref
)
3486 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3487 fprintf (dump_file
, " %u->%u: not candidate or by "
3488 "reference in callee\n", idx
, i
);
3490 pacc
->certain
= true;
3491 if (overlapping_certain_accesses_p (param_desc
, NULL
))
3493 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3494 fprintf (dump_file
, " ...leading to overlap, "
3495 " disqualifying candidate parameter %u\n",
3497 param_desc
->split_candidate
= false;
3500 bump_reached_size (param_desc
, pacc
->unit_size
, idx
);
3502 ipf
->aggregate_pass_through
= false;
3507 const char *pull_failure
3508 = pull_accesses_from_callee (cs
->caller
, param_desc
, arg_desc
,
3510 ipf
->unit_size
, &res
);
3513 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3514 fprintf (dump_file
, " %u->%u: arg access pull "
3515 "failed: %s.\n", idx
, i
, pull_failure
);
3517 ipf
->aggregate_pass_through
= false;
3518 pacc
->certain
= true;
3520 if (overlapping_certain_accesses_p (param_desc
, NULL
))
3522 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3523 fprintf (dump_file
, " ...leading to overlap, "
3524 " disqualifying candidate parameter %u\n",
3526 param_desc
->split_candidate
= false;
3529 bump_reached_size (param_desc
, pacc
->unit_size
, idx
);
3535 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3536 fprintf (dump_file
, " %u->%u: arg access pull "
3537 "succeeded.\n", idx
, i
);
3539 ipf
->aggregate_pass_through
= false;
3545 /* Handle argument-parameter count mismatches. */
3546 for (; (i
< args_count
); i
++)
3548 isra_param_flow
*ipf
= &csum
->m_arg_flow
[i
];
3550 if (ipf
->pointer_pass_through
|| ipf
->aggregate_pass_through
)
3552 int idx
= get_single_param_flow_source (ipf
);
3553 ipf
->pointer_pass_through
= false;
3554 ipf
->aggregate_pass_through
= false;
3555 isra_param_desc
*param_desc
= &(*from_ifs
->m_parameters
)[idx
];
3556 if (!param_desc
->split_candidate
)
3559 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3560 fprintf (dump_file
, " %u->%u: no corresponding formal parameter\n",
3562 param_desc
->split_candidate
= false;
3569 /* Worker for call_for_symbol_and_aliases, look at all callers and if all their
3570 callers ignore the return value, or come from the same SCC and use the
3571 return value only to compute their return value, return false, otherwise
3575 retval_used_p (cgraph_node
*node
, void *)
3577 for (cgraph_edge
*cs
= node
->callers
; cs
; cs
= cs
->next_caller
)
3579 isra_call_summary
*csum
= call_sums
->get (cs
);
3580 gcc_checking_assert (csum
);
3581 if (csum
->m_return_ignored
)
3583 if (!csum
->m_return_returned
)
3586 isra_func_summary
*from_ifs
= func_sums
->get (cs
->caller
);
3587 if (!from_ifs
|| !from_ifs
->m_candidate
)
3590 if (!ipa_edge_within_scc (cs
)
3591 && !from_ifs
->m_return_ignored
)
3598 /* Push into NEW_PARAMS all required parameter adjustment entries to copy or
3599 modify parameter which originally had index BASE_INDEX, in the adjustment
3600 vector of parent clone (if any) had PREV_CLONE_INDEX and was described by
3601 PREV_ADJUSTMENT. If the parent clone is the original function,
3602 PREV_ADJUSTMENT is NULL and PREV_CLONE_INDEX is equal to BASE_INDEX. */
3606 push_param_adjustments_for_index (isra_func_summary
*ifs
, unsigned base_index
,
3607 unsigned prev_clone_index
,
3608 ipa_adjusted_param
*prev_adjustment
,
3609 vec
<ipa_adjusted_param
, va_gc
> **new_params
)
3611 isra_param_desc
*desc
= &(*ifs
->m_parameters
)[base_index
];
3612 if (desc
->locally_unused
)
3615 fprintf (dump_file
, " Will remove parameter %u\n", base_index
);
3619 if (!desc
->split_candidate
)
3621 ipa_adjusted_param adj
;
3622 if (prev_adjustment
)
3624 adj
= *prev_adjustment
;
3625 adj
.prev_clone_adjustment
= true;
3626 adj
.prev_clone_index
= prev_clone_index
;
3630 memset (&adj
, 0, sizeof (adj
));
3631 adj
.op
= IPA_PARAM_OP_COPY
;
3632 adj
.base_index
= base_index
;
3633 adj
.prev_clone_index
= prev_clone_index
;
3635 vec_safe_push ((*new_params
), adj
);
3640 fprintf (dump_file
, " Will split parameter %u\n", base_index
);
3642 gcc_assert (!prev_adjustment
|| prev_adjustment
->op
== IPA_PARAM_OP_COPY
);
3643 unsigned aclen
= vec_safe_length (desc
->accesses
);
3644 for (unsigned j
= 0; j
< aclen
; j
++)
3646 param_access
*pa
= (*desc
->accesses
)[j
];
3650 fprintf (dump_file
, " - component at byte offset %u, "
3651 "size %u\n", pa
->unit_offset
, pa
->unit_size
);
3653 ipa_adjusted_param adj
;
3654 memset (&adj
, 0, sizeof (adj
));
3655 adj
.op
= IPA_PARAM_OP_SPLIT
;
3656 adj
.base_index
= base_index
;
3657 adj
.prev_clone_index
= prev_clone_index
;
3658 adj
.param_prefix_index
= IPA_PARAM_PREFIX_ISRA
;
3659 adj
.reverse
= pa
->reverse
;
3660 adj
.type
= pa
->type
;
3661 adj
.alias_ptr_type
= pa
->alias_ptr_type
;
3662 adj
.unit_offset
= pa
->unit_offset
;
3663 vec_safe_push ((*new_params
), adj
);
3667 /* Worker for all call_for_symbol_thunks_and_aliases. Set calls_comdat_local
3668 flag of all callers of NODE. */
3671 mark_callers_calls_comdat_local (struct cgraph_node
*node
, void *)
3673 for (cgraph_edge
*cs
= node
->callers
; cs
; cs
= cs
->next_caller
)
3674 cs
->caller
->calls_comdat_local
= true;
3679 /* Do final processing of results of IPA propagation regarding NODE, clone it
3683 process_isra_node_results (cgraph_node
*node
,
3684 hash_map
<const char *, unsigned> *clone_num_suffixes
)
3686 isra_func_summary
*ifs
= func_sums
->get (node
);
3687 if (!ifs
|| !ifs
->m_candidate
)
3690 auto_vec
<bool, 16> surviving_params
;
3691 bool check_surviving
= false;
3692 clone_info
*cinfo
= clone_info::get (node
);
3693 if (cinfo
&& cinfo
->param_adjustments
)
3695 check_surviving
= true;
3696 cinfo
->param_adjustments
->get_surviving_params (&surviving_params
);
3699 unsigned param_count
= vec_safe_length (ifs
->m_parameters
);
3700 bool will_change_function
= false;
3701 if (ifs
->m_returns_value
&& ifs
->m_return_ignored
)
3702 will_change_function
= true;
3704 for (unsigned i
= 0; i
< param_count
; i
++)
3706 isra_param_desc
*desc
= &(*ifs
->m_parameters
)[i
];
3707 if ((desc
->locally_unused
|| desc
->split_candidate
)
3708 /* Make sure we do not clone just to attempt to remove an already
3709 removed unused argument. */
3710 && (!check_surviving
3711 || (i
< surviving_params
.length ()
3712 && surviving_params
[i
])))
3714 will_change_function
= true;
3718 if (!will_change_function
)
3723 fprintf (dump_file
, "\nEvaluating analysis results for %s\n",
3724 node
->dump_name ());
3725 if (ifs
->m_returns_value
&& ifs
->m_return_ignored
)
3726 fprintf (dump_file
, " Will remove return value.\n");
3729 vec
<ipa_adjusted_param
, va_gc
> *new_params
= NULL
;
3730 if (ipa_param_adjustments
*old_adjustments
3731 = cinfo
? cinfo
->param_adjustments
: NULL
)
3733 unsigned old_adj_len
= vec_safe_length (old_adjustments
->m_adj_params
);
3734 for (unsigned i
= 0; i
< old_adj_len
; i
++)
3736 ipa_adjusted_param
*old_adj
= &(*old_adjustments
->m_adj_params
)[i
];
3737 push_param_adjustments_for_index (ifs
, old_adj
->base_index
, i
,
3738 old_adj
, &new_params
);
3742 for (unsigned i
= 0; i
< param_count
; i
++)
3743 push_param_adjustments_for_index (ifs
, i
, i
, NULL
, &new_params
);
3745 ipa_param_adjustments
*new_adjustments
3746 = (new (ggc_alloc
<ipa_param_adjustments
> ())
3747 ipa_param_adjustments (new_params
, param_count
,
3748 ifs
->m_returns_value
&& ifs
->m_return_ignored
));
3750 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3752 fprintf (dump_file
, "\n Created adjustments:\n");
3753 new_adjustments
->dump (dump_file
);
3756 unsigned &suffix_counter
= clone_num_suffixes
->get_or_insert (
3757 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (
3759 vec
<cgraph_edge
*> callers
= node
->collect_callers ();
3760 cgraph_node
*new_node
3761 = node
->create_virtual_clone (callers
, NULL
, new_adjustments
, "isra",
3764 if (node
->calls_comdat_local
&& node
->same_comdat_group
)
3766 new_node
->add_to_same_comdat_group (node
);
3767 new_node
->call_for_symbol_and_aliases (mark_callers_calls_comdat_local
,
3770 new_node
->calls_comdat_local
= node
->calls_comdat_local
;
3773 fprintf (dump_file
, " Created new node %s\n", new_node
->dump_name ());
3777 /* Check which parameters of NODE described by IFS have survived until IPA-SRA
3778 and disable transformations for those which have not or which should not
3779 transformed because the associated debug counter reached its limit. Return
3780 true if none survived or if there were no candidates to begin with. */
3783 disable_unavailable_parameters (cgraph_node
*node
, isra_func_summary
*ifs
)
3786 unsigned len
= vec_safe_length (ifs
->m_parameters
);
3790 auto_vec
<bool, 16> surviving_params
;
3791 bool check_surviving
= false;
3792 clone_info
*cinfo
= clone_info::get (node
);
3793 if (cinfo
&& cinfo
->param_adjustments
)
3795 check_surviving
= true;
3796 cinfo
->param_adjustments
->get_surviving_params (&surviving_params
);
3798 bool dumped_first
= false;
3799 for (unsigned i
= 0; i
< len
; i
++)
3801 isra_param_desc
*desc
= &(*ifs
->m_parameters
)[i
];
3802 if (!dbg_cnt (ipa_sra_params
))
3804 desc
->locally_unused
= false;
3805 desc
->split_candidate
= false;
3807 else if (check_surviving
3808 && (i
>= surviving_params
.length ()
3809 || !surviving_params
[i
]))
3811 /* Even if the parameter was removed by a previous IPA pass, we do
3812 not clear locally_unused because if it really is unused, this
3813 information might be useful in callers. */
3814 desc
->split_candidate
= false;
3816 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3821 "The following parameters of %s are dead on "
3822 "arrival:", node
->dump_name ());
3823 dumped_first
= true;
3825 fprintf (dump_file
, " %u", i
);
3828 else if (desc
->locally_unused
|| desc
->split_candidate
)
3833 fprintf (dump_file
, "\n");
3839 /* Run the interprocedural part of IPA-SRA. */
3842 ipa_sra_analysis (void)
3846 fprintf (dump_file
, "\n========== IPA-SRA IPA stage ==========\n");
3847 ipa_sra_dump_all_summaries (dump_file
);
3850 gcc_checking_assert (func_sums
);
3851 gcc_checking_assert (call_sums
);
3852 cgraph_node
**order
= XCNEWVEC (cgraph_node
*, symtab
->cgraph_count
);
3853 auto_vec
<cgraph_node
*, 16> stack
;
3854 int node_scc_count
= ipa_reduced_postorder (order
, true, NULL
);
3856 /* One sweep from callees to callers for parameter removal and splitting. */
3857 for (int i
= 0; i
< node_scc_count
; i
++)
3859 cgraph_node
*scc_rep
= order
[i
];
3860 vec
<cgraph_node
*> cycle_nodes
= ipa_get_nodes_in_cycle (scc_rep
);
3863 /* Preliminary IPA function level checks and first step of parameter
3866 FOR_EACH_VEC_ELT (cycle_nodes
, j
, v
)
3868 isra_func_summary
*ifs
= func_sums
->get (v
);
3869 if (!ifs
|| !ifs
->m_candidate
)
3871 if (!ipa_sra_ipa_function_checks (v
)
3872 || check_all_callers_for_issues (v
))
3877 if (disable_unavailable_parameters (v
, ifs
))
3879 for (cgraph_edge
*cs
= v
->indirect_calls
; cs
; cs
= cs
->next_callee
)
3880 process_edge_to_unknown_caller (cs
);
3881 for (cgraph_edge
*cs
= v
->callees
; cs
; cs
= cs
->next_callee
)
3882 if (!ipa_edge_within_scc (cs
))
3883 param_removal_cross_scc_edge (cs
);
3886 /* Look at edges within the current SCC and propagate used-ness across
3887 them, pushing onto the stack all notes which might need to be
3889 FOR_EACH_VEC_ELT (cycle_nodes
, j
, v
)
3890 v
->call_for_symbol_thunks_and_aliases (propagate_used_to_scc_callers
,
3893 /* Keep revisiting and pushing until nothing changes. */
3894 while (!stack
.is_empty ())
3896 cgraph_node
*v
= stack
.pop ();
3897 isra_func_summary
*ifs
= func_sums
->get (v
);
3898 gcc_checking_assert (ifs
&& ifs
->m_queued
);
3899 ifs
->m_queued
= false;
3901 v
->call_for_symbol_thunks_and_aliases (propagate_used_to_scc_callers
,
3905 /* Parameter splitting. */
3906 bool repeat_scc_access_propagation
;
3909 repeat_scc_access_propagation
= false;
3910 FOR_EACH_VEC_ELT (cycle_nodes
, j
, v
)
3912 isra_func_summary
*ifs
= func_sums
->get (v
);
3914 || !ifs
->m_candidate
3915 || vec_safe_is_empty (ifs
->m_parameters
))
3917 for (cgraph_edge
*cs
= v
->callees
; cs
; cs
= cs
->next_callee
)
3918 if (param_splitting_across_edge (cs
))
3919 repeat_scc_access_propagation
= true;
3922 while (repeat_scc_access_propagation
);
3925 FOR_EACH_VEC_ELT (cycle_nodes
, j
, v
)
3926 verify_splitting_accesses (v
, true);
3928 cycle_nodes
.release ();
3931 /* One sweep from caller to callees for result removal. */
3932 for (int i
= node_scc_count
- 1; i
>= 0 ; i
--)
3934 cgraph_node
*scc_rep
= order
[i
];
3935 vec
<cgraph_node
*> cycle_nodes
= ipa_get_nodes_in_cycle (scc_rep
);
3939 FOR_EACH_VEC_ELT (cycle_nodes
, j
, v
)
3941 isra_func_summary
*ifs
= func_sums
->get (v
);
3942 if (!ifs
|| !ifs
->m_candidate
)
3946 = (ifs
->m_returns_value
3947 && (!dbg_cnt (ipa_sra_retvalues
)
3948 || v
->call_for_symbol_and_aliases (retval_used_p
,
3950 ifs
->m_return_ignored
= !return_needed
;
3952 isra_push_node_to_stack (v
, ifs
, &stack
);
3955 while (!stack
.is_empty ())
3957 cgraph_node
*node
= stack
.pop ();
3958 isra_func_summary
*ifs
= func_sums
->get (node
);
3959 gcc_checking_assert (ifs
&& ifs
->m_queued
);
3960 ifs
->m_queued
= false;
3962 for (cgraph_edge
*cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
3963 if (ipa_edge_within_scc (cs
)
3964 && call_sums
->get (cs
)->m_return_returned
)
3966 enum availability av
;
3967 cgraph_node
*callee
= cs
->callee
->function_symbol (&av
);
3968 isra_func_summary
*to_ifs
= func_sums
->get (callee
);
3969 if (to_ifs
&& to_ifs
->m_return_ignored
)
3971 to_ifs
->m_return_ignored
= false;
3972 isra_push_node_to_stack (callee
, to_ifs
, &stack
);
3976 cycle_nodes
.release ();
3979 ipa_free_postorder_info ();
3984 if (dump_flags
& TDF_DETAILS
)
3986 fprintf (dump_file
, "\n========== IPA-SRA propagation final state "
3988 ipa_sra_dump_all_summaries (dump_file
);
3990 fprintf (dump_file
, "\n========== IPA-SRA decisions ==========\n");
3993 hash_map
<const char *, unsigned> *clone_num_suffixes
3994 = new hash_map
<const char *, unsigned>;
3997 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node
)
3998 process_isra_node_results (node
, clone_num_suffixes
);
4000 delete clone_num_suffixes
;
4001 ggc_delete (func_sums
);
4007 fprintf (dump_file
, "\n========== IPA SRA IPA analysis done "
4013 const pass_data pass_data_ipa_sra
=
4015 IPA_PASS
, /* type */
4017 OPTGROUP_NONE
, /* optinfo_flags */
4018 TV_IPA_SRA
, /* tv_id */
4019 0, /* properties_required */
4020 0, /* properties_provided */
4021 0, /* properties_destroyed */
4022 0, /* todo_flags_start */
4023 ( TODO_dump_symtab
| TODO_remove_functions
), /* todo_flags_finish */
4026 class pass_ipa_sra
: public ipa_opt_pass_d
4029 pass_ipa_sra (gcc::context
*ctxt
)
4030 : ipa_opt_pass_d (pass_data_ipa_sra
, ctxt
,
4031 ipa_sra_generate_summary
, /* generate_summary */
4032 ipa_sra_write_summary
, /* write_summary */
4033 ipa_sra_read_summary
, /* read_summary */
4034 NULL
, /* write_optimization_summary */
4035 NULL
, /* read_optimization_summary */
4036 NULL
, /* stmt_fixup */
4037 0, /* function_transform_todo_flags_start */
4038 NULL
, /* function_transform */
4039 NULL
) /* variable_transform */
4042 /* opt_pass methods: */
4043 virtual bool gate (function
*)
4045 /* TODO: We should remove the optimize check after we ensure we never run
4046 IPA passes when not optimizing. */
4047 return (flag_ipa_sra
&& optimize
);
4050 virtual unsigned int execute (function
*) { return ipa_sra_analysis (); }
4052 }; // class pass_ipa_sra
4056 /* Intraprocedural part of IPA-SRA analysis. Scan function body of NODE and
4057 create a summary structure describing IPA-SRA opportunities and constraints
4061 ipa_sra_summarize_function (cgraph_node
*node
)
4064 fprintf (dump_file
, "Creating summary for %s/%i:\n", node
->name (),
4066 if (!ipa_sra_preliminary_function_checks (node
))
4068 gcc_obstack_init (&gensum_obstack
);
4069 isra_func_summary
*ifs
= func_sums
->get_create (node
);
4070 ifs
->m_candidate
= true;
4071 tree ret
= TREE_TYPE (TREE_TYPE (node
->decl
));
4072 ifs
->m_returns_value
= (TREE_CODE (ret
) != VOID_TYPE
);
4074 decl2desc
= new hash_map
<tree
, gensum_param_desc
*>;
4076 for (tree parm
= DECL_ARGUMENTS (node
->decl
); parm
; parm
= DECL_CHAIN (parm
))
4081 auto_vec
<gensum_param_desc
, 16> param_descriptions (count
);
4082 param_descriptions
.reserve_exact (count
);
4083 param_descriptions
.quick_grow_cleared (count
);
4085 bool cfun_pushed
= false;
4086 struct function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4087 if (create_parameter_descriptors (node
, ¶m_descriptions
))
4091 final_bbs
= BITMAP_ALLOC (NULL
);
4092 bb_dereferences
= XCNEWVEC (HOST_WIDE_INT
,
4094 * last_basic_block_for_fn (fun
));
4095 aa_walking_limit
= opt_for_fn (node
->decl
, param_ipa_max_aa_steps
);
4096 scan_function (node
, fun
);
4100 dump_gensum_param_descriptors (dump_file
, node
->decl
,
4101 ¶m_descriptions
);
4102 fprintf (dump_file
, "----------------------------------------\n");
4105 process_scan_results (node
, fun
, ifs
, ¶m_descriptions
);
4109 if (bb_dereferences
)
4111 free (bb_dereferences
);
4112 bb_dereferences
= NULL
;
4113 BITMAP_FREE (final_bbs
);
4117 isra_analyze_all_outgoing_calls (node
);
4121 obstack_free (&gensum_obstack
, NULL
);
4123 fprintf (dump_file
, "\n\n");
4125 verify_splitting_accesses (node
, false);
4130 make_pass_ipa_sra (gcc::context
*ctxt
)
4132 return new pass_ipa_sra (ctxt
);
4136 #include "gt-ipa-sra.h"