1/* Manipulation of formal and actual parameters of functions and function
2 calls.
3 Copyright (C) 2017-2024 Free Software Foundation, Inc.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>.
20
21
22
23This file defines classes and other data structures that are used to manipulate
24the prototype of a function, especially to create, remove or split its formal
25parameters, but also to remove its return value, and also its call statements
26correspondingly.
27
28The most basic one is a vector of structures ipa_adjusted_param. It is simply
29a description how the new parameters should look like after the transformation
30in what way they relate to the previous ones (if in any). Such relation to an
31old parameter can be an outright copy or an IPA-SRA replacement. If an old
32parameter is not listed or otherwise mentioned, it is removed as unused or at
33least unnecessary. Note that this most basic structure does not work for
34modifying calls of functions with variable number of arguments.
35
36Class ipa_param_adjustments is only a little more than a thin encapsulation of
37a vector of ipa_param_adjustments. Along with this vector it contains an index
38of the first potential vararg argument and a boolean flag whether the return
39value should be removed or not. Moreover, the class contains method
40modify_call which can transform a call statement so that it correctly calls a
41modified function. These two data structures were designed to have a small
42memory footprint because they are allocated for each clone of a call graph node
43that has its prototype changed and live until the end of IPA clone
44materialization and call redirection phase.
45
46On the other hand, class ipa_param_body_adjustments can afford to allocate more
47data because its life span is much smaller, it is allocated and destroyed in
48the course of materialization of each single clone that needs it or only when a
49particular pass needs to change a function it is operating on. This class has
50various methods required to change function declaration and the body of the
51function according to instructions given either by class ipa_param_adjustments
52or only a vector of ipa_adjusted_params.
53
54When these classes are used in the context of call graph clone materialization
55and subsequent call statement redirection - which is the point at which we
56modify arguments in call statements - they need to cooperate with each other in
57order to handle what we refer to as pass-through (IPA-SRA) splits. These are
58situations when a formal parameter of one function is split into several
59smaller ones and some of them are then passed on in a call to another function
60because the formal parameter of this callee has also been split.
61
62Consider a simple example:
63
64struct S {int a, b, c;};
65struct Z {int x; S s;};
66
67foo (S s)
68{
69 use (s.b);
70}
71
72bar (Z z)
73{
74 use (z.s.a);
75 foo (z.s);
76}
77
78baz ()
79{
80 bar (*global);
81}
82
83Both bar and foo would have their parameter split. Foo would receive one
84replacement representing s.b. Function bar would see its parameter split into
85one replacement representing z.s.a and another representing z.s.b which would
86be passed on to foo. It would be a so called pass-through split IPA-SRA
87replacement, one which is passed in a call as an actual argument to another
88IPA-SRA replacement in another function.
89
90Note that the call chain the example can be arbitrarily long and recursive and
91that any function in it can be cloned by another IPA pass and any number of
92adjacent functions in the call chain can be inlined into each other. Call
93redirection takes place only after bodies of the function have been modified by
94all of the above.
95
96Call redirection has to be able to find the right decl or SSA_NAME that
97corresponds to the transitive split in the caller. The SSA names are assigned
98right after clone materialization/ modification and cannot be "added" to call
99arguments at any later point. Moreover, if the caller has been inlined the
100SSA_NAMEs in question no longer belong to PARM_DECLs but to VAR_DECLs,
101indistinguishable from any others.
102
103Therefore, when clone materialization finds a call statement which it knows is
104a part of a transitive split, it will simply add as arguments all new "split"
105replacements (that have grater or equal offset than the original call
106argument):
107
108 foo (repl_for_a, repl_for_b, <rest of original arguments>);
109
110It will also store into ipa_edge_modification_info (which is internal to
111ipa-param-modification.c) information about which replacement is which and
112where original arguments are. Call redirection will then invoke
113ipa_param_adjustments::modify_call which will access this information and
114eliminate all replacements which the callee does not expect (repl_for_a in our
115example above). In between these two steps, however, a call statement might
116have extraneous arguments. */
117
118#ifndef IPA_PARAM_MANIPULATION_H
119#define IPA_PARAM_MANIPULATION_H
120
121/* Indices into ipa_param_prefixes to identify a human-readable prefix for newly
122 synthesized parameters. Keep in sync with the array. */
123enum ipa_param_name_prefix_indices
124 {
125 IPA_PARAM_PREFIX_SYNTH,
126 IPA_PARAM_PREFIX_ISRA,
127 IPA_PARAM_PREFIX_SIMD,
128 IPA_PARAM_PREFIX_MASK,
129 IPA_PARAM_PREFIX_COUNT
130};
131
132/* We do not support manipulating functions with more than
133 1<<IPA_PARAM_MAX_INDEX_BITS parameters. */
134#define IPA_PARAM_MAX_INDEX_BITS 16
135
136/* Operation to be performed for the parameter in ipa_parm_adjustment
137 below. */
138
139enum ipa_parm_op
140{
141 /* Do not use or you will trigger an assert. */
142 IPA_PARAM_OP_UNDEFINED,
143
144 /* This new parameter is an unmodified parameter at index base_index. */
145 IPA_PARAM_OP_COPY,
146
147 /* This describes a brand new parameter. If it somehow relates to any
148 original parameters, the user needs to manage the transition itself. */
149 IPA_PARAM_OP_NEW,
150
151 /* Split parameter as indicated by fields base_index, offset and type. */
152 IPA_PARAM_OP_SPLIT
153};
154
155/* Structure that describes one parameter of a function after transformation.
156 Omitted parameters will be removed. */
157
158struct GTY(()) ipa_adjusted_param
159{
160 /* Type of the new parameter. Required for all operations except
161 IPA_PARM_OP_COPY when the original type will be preserved. */
162 tree type;
163
164 /* Alias reference type to be used in MEM_REFs when adjusting caller
165 arguments. Required for IPA_PARM_OP_SPLIT operation. */
166 tree alias_ptr_type;
167
168 /* Offset into the original parameter (for the cases when the new parameter
169 is a component of an original one). Required for IPA_PARM_OP_SPLIT
170 operation. */
171 unsigned unit_offset;
172
173 /* Zero based index of the original parameter this one is based on. Required
174 for IPA_PARAM_OP_COPY and IPA_PARAM_OP_SPLIT, users of IPA_PARAM_OP_NEW
175 only need to specify it if they use replacement lookup provided by
176 ipa_param_body_adjustments. */
177 unsigned base_index : IPA_PARAM_MAX_INDEX_BITS;
178
179 /* Zero based index of the parameter this one is based on in the previous
180 clone. If there is no previous clone, it must be equal to base_index. */
181 unsigned prev_clone_index : IPA_PARAM_MAX_INDEX_BITS;
182
183 /* Specify the operation, if any, to be performed on the parameter. */
184 enum ipa_parm_op op : 2;
185
186 /* If set, this structure describes a parameter copied over from a previous
187 IPA clone, any transformations are thus not to be re-done. */
188 unsigned prev_clone_adjustment : 1;
189
190 /* Index into ipa_param_prefixes specifying a prefix to be used with
191 DECL_NAMEs of newly synthesized parameters. */
192 unsigned param_prefix_index : 2;
193
194 /* Storage order of the original parameter (for the cases when the new
195 parameter is a component of an original one). */
196 unsigned reverse : 1;
197
198 /* A bit free for the user. */
199 unsigned user_flag : 1;
200};
201
202void ipa_dump_adjusted_parameters (FILE *f,
203 vec<ipa_adjusted_param, va_gc> *adj_params);
204
205/* Class used to record planned modifications to parameters of a function and
206 also to perform necessary modifications at the caller side at the gimple
207 level. Used to describe all cgraph node clones that have their parameters
208 changed, therefore the class should only have a small memory footprint. */
209
210class GTY(()) ipa_param_adjustments
211{
212public:
213 /* Constructor from NEW_PARAMS showing how new parameters should look like
214 plus copying any pre-existing actual arguments starting from argument
215 with index ALWAYS_COPY_START (if non-negative, negative means do not copy
216 anything beyond what is described in NEW_PARAMS), and SKIP_RETURN, which
217 indicates that the function should return void after transformation. */
218
219 ipa_param_adjustments (vec<ipa_adjusted_param, va_gc> *new_params,
220 int always_copy_start, bool skip_return)
221 : m_adj_params (new_params), m_always_copy_start (always_copy_start),
222 m_skip_return (skip_return)
223 {}
224
225 /* Modify a call statement arguments (and possibly remove the return value)
226 as described in the data fields of this class. */
227 gcall *modify_call (cgraph_edge *cs, bool update_references,
228 hash_set <tree> *killed_ssas);
229 /* Return if the first parameter is left intact. */
230 bool first_param_intact_p ();
231 /* Build a function type corresponding to the modified call. */
232 tree build_new_function_type (tree old_type, bool type_is_original_p);
233 /* Build a declaration corresponding to the target of the modified call. */
234 tree adjust_decl (tree orig_decl);
235 /* Fill a vector marking which parameters are intact by the described
236 modifications. */
237 void get_surviving_params (vec<bool> *surviving_params);
238 /* Fill a vector with new indices of surviving original parameters. */
239 void get_updated_indices (vec<int> *new_indices);
240 /* Return the original index for the given new parameter index. Return a
241 negative number if not available. */
242 int get_original_index (int newidx);
243
244 void dump (FILE *f);
245 void debug ();
246
247 /* How the known part of arguments should look like. */
248 vec<ipa_adjusted_param, va_gc> *m_adj_params;
249
250 /* If non-negative, copy any arguments starting at this offset without any
251 modifications so that functions with variable number of arguments can be
252 modified. This number should be equal to the number of original forma
253 parameters. */
254 int m_always_copy_start;
255 /* If true, make the function not return any value. */
256 bool m_skip_return;
257
258 static bool type_attribute_allowed_p (tree);
259private:
260 ipa_param_adjustments () {}
261
262 void init (vec<tree> *cur_params);
263 int get_max_base_index ();
264 bool method2func_p (tree orig_type);
265};
266
267/* Structure used to map expressions accessing split or replaced parameters to
268 new PARM_DECLs. */
269
270struct ipa_param_body_replacement
271{
272 /* The old decl of the original parameter. */
273 tree base;
274 /* The new decl it should be replaced with. */
275 tree repl;
276 /* Users of ipa_param_body_adjustments that modify standalone functions
277 outside of IPA clone materialization can use the following field for their
278 internal purposes. */
279 tree dummy;
280 /* The offset within BASE that REPL represents. */
281 unsigned unit_offset;
282};
283
284struct ipa_replace_map;
285
286/* Class used when actually performing adjustments to formal parameters of a
287 function to map accesses that need to be replaced to replacements. The
288 class attempts to work in two very different sets of circumstances: as a
289 part of tree-inine.c's tree_function_versioning machinery to clone functions
290 (when M_ID is not NULL) and in s standalone fashion, modifying an existing
291 function in place (when M_ID is NULL). While a lot of stuff handled in a
292 unified way in both modes, there are many aspects of the processs that
293 requires distinct paths. */
294
295class ipa_param_body_adjustments
296{
297public:
298 /* Constructor to use from within tree-inline. */
299 ipa_param_body_adjustments (ipa_param_adjustments *adjustments,
300 tree fndecl, tree old_fndecl,
301 struct copy_body_data *id, tree *vars,
302 vec<ipa_replace_map *, va_gc> *tree_map);
303 /* Constructor to use for modifying a function outside of tree-inline from an
304 instance of ipa_param_adjustments. */
305 ipa_param_body_adjustments (ipa_param_adjustments *adjustments,
306 tree fndecl);
307 /* Constructor to use for modifying a function outside of tree-inline from a
308 simple vector of desired parameter modification. */
309 ipa_param_body_adjustments (vec<ipa_adjusted_param, va_gc> *adj_params,
310 tree fndecl);
311
312 /* The do-it-all function for modifying a function outside of
313 tree-inline. */
314 bool perform_cfun_body_modifications ();
315
316 /* Change the PARM_DECLs. */
317 void modify_formal_parameters ();
318 /* Register a REPLACEMENT for accesses to BASE at UNIT_OFFSET. */
319 void register_replacement (tree base, unsigned unit_offset, tree replacement);
320 /* Register a replacement decl for the transformation done in APM. */
321 void register_replacement (ipa_adjusted_param *apm, tree replacement);
322 /* Sort m_replacements and set m_sorted_replacements_p to true. Users that
323 call register_replacement themselves must call the method before any
324 lookup and thus also any statement or expression modification. */
325 void sort_replacements ();
326 /* Lookup a replacement for a given offset within a given parameter. */
327 tree lookup_replacement (tree base, unsigned unit_offset);
328 /* Lookup a replacement for an expression, if there is one. */
329 ipa_param_body_replacement *get_expr_replacement (tree expr,
330 bool ignore_default_def);
331 /* Lookup the new base for surviving names previously belonging to a
332 parameter. */
333 tree get_replacement_ssa_base (tree old_decl);
334 /* Modify a statement. */
335 bool modify_gimple_stmt (gimple **stmt, gimple_seq *extra_stmts,
336 gimple *orig_stmt);
337 /* Return the new chain of parameters. */
338 tree get_new_param_chain ();
339 /* Replace all occurances of SSAs in m_dead_ssa_debug_equiv in t with what
340 they are mapped to. */
341 void remap_with_debug_expressions (tree *t);
342
343 /* If there are any initialization statements that need to be emitted into
344 the basic block BB right at ther start of the new function, do so. */
345 void append_init_stmts (basic_block bb);
346
347 /* Pointers to data structures defining how the function should be
348 modified. */
349 vec<ipa_adjusted_param, va_gc> *m_adj_params;
350 ipa_param_adjustments *m_adjustments;
351
352 /* Vector of old parameter declarations that must have their debug bind
353 statements re-mapped and debug decls created. */
354
355 auto_vec<tree, 16> m_reset_debug_decls;
356
357 /* Sets of statements and SSA_NAMEs that only manipulate data from parameters
358 removed because they are not necessary. */
359 hash_set<gimple *> m_dead_stmts;
360 hash_set<tree> m_dead_ssas;
361
362 /* Mapping from DCEd SSAs to what their potential debug_binds should be. */
363 hash_map<tree, tree> m_dead_ssa_debug_equiv;
364 /* Mapping from DCEd statements to debug expressions that will be placed on
365 the RHS of debug statement that will replace this one. */
366 hash_map<gimple *, tree> m_dead_stmt_debug_equiv;
367
368private:
369 void common_initialization (tree old_fndecl, tree *vars,
370 vec<ipa_replace_map *, va_gc> *tree_map);
371 tree carry_over_param (tree t);
372 unsigned get_base_index (ipa_adjusted_param *apm);
373 ipa_param_body_replacement *lookup_replacement_1 (tree base,
374 unsigned unit_offset);
375 ipa_param_body_replacement *lookup_first_base_replacement (tree base);
376 tree replace_removed_params_ssa_names (tree old_name, gimple *stmt);
377 bool modify_expression (tree *expr_p, bool convert, gimple_seq * = nullptr);
378 bool modify_assignment (gimple *stmt, gimple_seq *extra_stmts);
379 bool modify_call_stmt (gcall **stmt_p, gimple *orig_stmt);
380 bool modify_cfun_body ();
381 void reset_debug_stmts ();
382 tree get_ddef_if_exists_and_is_used (tree decl);
383 void mark_dead_statements (tree dead_param, vec<tree> *debugstack);
384 void mark_clobbers_dead (tree dead_param);
385 bool prepare_debug_expressions (tree dead_ssa);
386
387 /* Declaration of the function that is being transformed. */
388
389 tree m_fndecl;
390
391 /* If non-NULL, the tree-inline master data structure guiding materialization
392 of the current clone. */
393 struct copy_body_data *m_id;
394
395 /* Vector of old parameter declarations (before changing them). */
396
397 auto_vec<tree, 16> m_oparms;
398
399 /* Vector of parameter declarations the function will have after
400 transformation. */
401
402 auto_vec<tree, 16> m_new_decls;
403
404 /* If the function type has non-NULL TYPE_ARG_TYPES, this is the vector of
405 these types after transformation, otherwise an empty one. */
406
407 auto_vec<tree, 16> m_new_types;
408
409 /* Vector of structures telling how to replace old parameters in the
410 function body. TODO: Even though there usually be only few, but should we
411 use a hash? */
412
413 auto_vec<ipa_param_body_replacement, 16> m_replacements;
414
415 /* List of initialization assignments to be put at the beginning of the
416 cloned function to deal with split aggregates which however have known
417 constant value and so their PARM_DECL disappears. */
418
419 auto_vec<gimple *, 8> m_split_agg_csts_inits;
420
421 /* Vector for remapping SSA_BASES from old parameter declarations that are
422 being removed as a part of the transformation. Before a new VAR_DECL is
423 created, it holds the old PARM_DECL, once the variable is built it is
424 stored here. */
425
426 auto_vec<tree> m_removed_decls;
427
428 /* Hash to quickly lookup the item in m_removed_decls given the old decl. */
429
430 hash_map<tree, unsigned> m_removed_map;
431
432 /* True iff the transformed function is a class method that is about to loose
433 its this pointer and must be converted to a normal function. */
434
435 bool m_method2func;
436
437 /* True if m_replacements have ben sorted since the last insertion. */
438
439 bool m_sorted_replacements_p;
440};
441
442void push_function_arg_decls (vec<tree> *args, tree fndecl);
443void push_function_arg_types (vec<tree> *types, tree fntype);
444void ipa_verify_edge_has_no_modifications (cgraph_edge *cs);
445void ipa_edge_modifications_finalize ();
446void ipa_release_ssas_in_hash (hash_set <tree> *killed_ssas);
447
448#endif /* IPA_PARAM_MANIPULATION_H */
449

source code of gcc/ipa-param-manipulation.h