|
131
|
1 /* Manipulation of formal and actual parameters of functions and function
|
|
|
2 calls.
|
|
|
3 Copyright (C) 2017-2018 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #include "config.h"
|
|
|
22 #include "system.h"
|
|
|
23 #include "coretypes.h"
|
|
|
24 #include "backend.h"
|
|
|
25 #include "rtl.h"
|
|
|
26 #include "tree.h"
|
|
|
27 #include "gimple.h"
|
|
|
28 #include "ssa.h"
|
|
|
29 #include "cgraph.h"
|
|
|
30 #include "fold-const.h"
|
|
|
31 #include "stor-layout.h"
|
|
|
32 #include "gimplify.h"
|
|
|
33 #include "gimple-iterator.h"
|
|
|
34 #include "gimplify-me.h"
|
|
|
35 #include "tree-dfa.h"
|
|
|
36 #include "ipa-param-manipulation.h"
|
|
|
37 #include "print-tree.h"
|
|
|
38 #include "gimple-pretty-print.h"
|
|
|
39 #include "builtins.h"
|
|
|
40
|
|
|
41 /* Return a heap allocated vector containing formal parameters of FNDECL. */
|
|
|
42
|
|
|
43 vec<tree>
|
|
|
44 ipa_get_vector_of_formal_parms (tree fndecl)
|
|
|
45 {
|
|
|
46 vec<tree> args;
|
|
|
47 int count;
|
|
|
48 tree parm;
|
|
|
49
|
|
|
50 gcc_assert (!flag_wpa);
|
|
|
51 count = 0;
|
|
|
52 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
|
|
|
53 count++;
|
|
|
54
|
|
|
55 args.create (count);
|
|
|
56 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
|
|
|
57 args.quick_push (parm);
|
|
|
58
|
|
|
59 return args;
|
|
|
60 }
|
|
|
61
|
|
|
62 /* Return a heap allocated vector containing types of formal parameters of
|
|
|
63 function type FNTYPE. */
|
|
|
64
|
|
|
65 vec<tree>
|
|
|
66 ipa_get_vector_of_formal_parm_types (tree fntype)
|
|
|
67 {
|
|
|
68 vec<tree> types;
|
|
|
69 int count = 0;
|
|
|
70 tree t;
|
|
|
71
|
|
|
72 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
|
|
|
73 count++;
|
|
|
74
|
|
|
75 types.create (count);
|
|
|
76 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
|
|
|
77 types.quick_push (TREE_VALUE (t));
|
|
|
78
|
|
|
79 return types;
|
|
|
80 }
|
|
|
81
|
|
|
82 /* Modify the function declaration FNDECL and its type according to the plan in
|
|
|
83 ADJUSTMENTS. It also sets base fields of individual adjustments structures
|
|
|
84 to reflect the actual parameters being modified which are determined by the
|
|
|
85 base_index field. */
|
|
|
86
|
|
|
87 void
|
|
|
88 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments)
|
|
|
89 {
|
|
|
90 vec<tree> oparms = ipa_get_vector_of_formal_parms (fndecl);
|
|
|
91 tree orig_type = TREE_TYPE (fndecl);
|
|
|
92 tree old_arg_types = TYPE_ARG_TYPES (orig_type);
|
|
|
93
|
|
|
94 /* The following test is an ugly hack, some functions simply don't have any
|
|
|
95 arguments in their type. This is probably a bug but well... */
|
|
|
96 bool care_for_types = (old_arg_types != NULL_TREE);
|
|
|
97 bool last_parm_void;
|
|
|
98 vec<tree> otypes;
|
|
|
99 if (care_for_types)
|
|
|
100 {
|
|
|
101 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
|
|
|
102 == void_type_node);
|
|
|
103 otypes = ipa_get_vector_of_formal_parm_types (orig_type);
|
|
|
104 if (last_parm_void)
|
|
|
105 gcc_assert (oparms.length () + 1 == otypes.length ());
|
|
|
106 else
|
|
|
107 gcc_assert (oparms.length () == otypes.length ());
|
|
|
108 }
|
|
|
109 else
|
|
|
110 {
|
|
|
111 last_parm_void = false;
|
|
|
112 otypes.create (0);
|
|
|
113 }
|
|
|
114
|
|
|
115 int len = adjustments.length ();
|
|
|
116 tree *link = &DECL_ARGUMENTS (fndecl);
|
|
|
117 tree new_arg_types = NULL;
|
|
|
118 for (int i = 0; i < len; i++)
|
|
|
119 {
|
|
|
120 struct ipa_parm_adjustment *adj;
|
|
|
121 gcc_assert (link);
|
|
|
122
|
|
|
123 adj = &adjustments[i];
|
|
|
124 tree parm;
|
|
|
125 if (adj->op == IPA_PARM_OP_NEW)
|
|
|
126 parm = NULL;
|
|
|
127 else
|
|
|
128 parm = oparms[adj->base_index];
|
|
|
129 adj->base = parm;
|
|
|
130
|
|
|
131 if (adj->op == IPA_PARM_OP_COPY)
|
|
|
132 {
|
|
|
133 if (care_for_types)
|
|
|
134 new_arg_types = tree_cons (NULL_TREE, otypes[adj->base_index],
|
|
|
135 new_arg_types);
|
|
|
136 *link = parm;
|
|
|
137 link = &DECL_CHAIN (parm);
|
|
|
138 }
|
|
|
139 else if (adj->op != IPA_PARM_OP_REMOVE)
|
|
|
140 {
|
|
|
141 tree new_parm;
|
|
|
142 tree ptype;
|
|
|
143
|
|
|
144 if (adj->by_ref)
|
|
|
145 ptype = build_pointer_type (adj->type);
|
|
|
146 else
|
|
|
147 {
|
|
|
148 ptype = adj->type;
|
|
|
149 if (is_gimple_reg_type (ptype)
|
|
|
150 && TYPE_MODE (ptype) != BLKmode)
|
|
|
151 {
|
|
|
152 unsigned malign = GET_MODE_ALIGNMENT (TYPE_MODE (ptype));
|
|
|
153 if (TYPE_ALIGN (ptype) != malign)
|
|
|
154 ptype = build_aligned_type (ptype, malign);
|
|
|
155 }
|
|
|
156 }
|
|
|
157
|
|
|
158 if (care_for_types)
|
|
|
159 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
|
|
|
160
|
|
|
161 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
|
|
|
162 ptype);
|
|
|
163 const char *prefix = adj->arg_prefix ? adj->arg_prefix : "SYNTH";
|
|
|
164 DECL_NAME (new_parm) = create_tmp_var_name (prefix);
|
|
|
165 DECL_ARTIFICIAL (new_parm) = 1;
|
|
|
166 DECL_ARG_TYPE (new_parm) = ptype;
|
|
|
167 DECL_CONTEXT (new_parm) = fndecl;
|
|
|
168 TREE_USED (new_parm) = 1;
|
|
|
169 DECL_IGNORED_P (new_parm) = 1;
|
|
|
170 layout_decl (new_parm, 0);
|
|
|
171
|
|
|
172 if (adj->op == IPA_PARM_OP_NEW)
|
|
|
173 adj->base = NULL;
|
|
|
174 else
|
|
|
175 adj->base = parm;
|
|
|
176 adj->new_decl = new_parm;
|
|
|
177
|
|
|
178 *link = new_parm;
|
|
|
179 link = &DECL_CHAIN (new_parm);
|
|
|
180 }
|
|
|
181 }
|
|
|
182
|
|
|
183 *link = NULL_TREE;
|
|
|
184
|
|
|
185 tree new_reversed = NULL;
|
|
|
186 if (care_for_types)
|
|
|
187 {
|
|
|
188 new_reversed = nreverse (new_arg_types);
|
|
|
189 if (last_parm_void)
|
|
|
190 {
|
|
|
191 if (new_reversed)
|
|
|
192 TREE_CHAIN (new_arg_types) = void_list_node;
|
|
|
193 else
|
|
|
194 new_reversed = void_list_node;
|
|
|
195 }
|
|
|
196 }
|
|
|
197
|
|
|
198 /* Use copy_node to preserve as much as possible from original type
|
|
|
199 (debug info, attribute lists etc.)
|
|
|
200 Exception is METHOD_TYPEs must have THIS argument.
|
|
|
201 When we are asked to remove it, we need to build new FUNCTION_TYPE
|
|
|
202 instead. */
|
|
|
203 tree new_type = NULL;
|
|
|
204 if (TREE_CODE (orig_type) != METHOD_TYPE
|
|
|
205 || (adjustments[0].op == IPA_PARM_OP_COPY
|
|
|
206 && adjustments[0].base_index == 0))
|
|
|
207 {
|
|
|
208 new_type = build_distinct_type_copy (orig_type);
|
|
|
209 TYPE_ARG_TYPES (new_type) = new_reversed;
|
|
|
210 }
|
|
|
211 else
|
|
|
212 {
|
|
|
213 new_type
|
|
|
214 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
|
|
|
215 new_reversed));
|
|
|
216 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
|
|
|
217 DECL_VINDEX (fndecl) = NULL_TREE;
|
|
|
218 }
|
|
|
219
|
|
|
220 /* When signature changes, we need to clear builtin info. */
|
|
|
221 if (fndecl_built_in_p (fndecl))
|
|
|
222 {
|
|
|
223 DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN;
|
|
|
224 DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0;
|
|
|
225 }
|
|
|
226
|
|
|
227 TREE_TYPE (fndecl) = new_type;
|
|
|
228 DECL_VIRTUAL_P (fndecl) = 0;
|
|
|
229 DECL_LANG_SPECIFIC (fndecl) = NULL;
|
|
|
230 otypes.release ();
|
|
|
231 oparms.release ();
|
|
|
232 }
|
|
|
233
|
|
|
234 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
|
|
|
235 If this is a directly recursive call, CS must be NULL. Otherwise it must
|
|
|
236 contain the corresponding call graph edge. */
|
|
|
237
|
|
|
238 void
|
|
|
239 ipa_modify_call_arguments (struct cgraph_edge *cs, gcall *stmt,
|
|
|
240 ipa_parm_adjustment_vec adjustments)
|
|
|
241 {
|
|
|
242 struct cgraph_node *current_node = cgraph_node::get (current_function_decl);
|
|
|
243 vec<tree> vargs;
|
|
|
244 vec<tree, va_gc> **debug_args = NULL;
|
|
|
245 gcall *new_stmt;
|
|
|
246 gimple_stmt_iterator gsi, prev_gsi;
|
|
|
247 tree callee_decl;
|
|
|
248 int i, len;
|
|
|
249
|
|
|
250 len = adjustments.length ();
|
|
|
251 vargs.create (len);
|
|
|
252 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
|
|
|
253 current_node->remove_stmt_references (stmt);
|
|
|
254
|
|
|
255 gsi = gsi_for_stmt (stmt);
|
|
|
256 prev_gsi = gsi;
|
|
|
257 gsi_prev (&prev_gsi);
|
|
|
258 for (i = 0; i < len; i++)
|
|
|
259 {
|
|
|
260 struct ipa_parm_adjustment *adj;
|
|
|
261
|
|
|
262 adj = &adjustments[i];
|
|
|
263
|
|
|
264 if (adj->op == IPA_PARM_OP_COPY)
|
|
|
265 {
|
|
|
266 tree arg = gimple_call_arg (stmt, adj->base_index);
|
|
|
267
|
|
|
268 vargs.quick_push (arg);
|
|
|
269 }
|
|
|
270 else if (adj->op != IPA_PARM_OP_REMOVE)
|
|
|
271 {
|
|
|
272 tree expr, base, off;
|
|
|
273 location_t loc;
|
|
|
274 unsigned int deref_align = 0;
|
|
|
275 bool deref_base = false;
|
|
|
276
|
|
|
277 /* We create a new parameter out of the value of the old one, we can
|
|
|
278 do the following kind of transformations:
|
|
|
279
|
|
|
280 - A scalar passed by reference is converted to a scalar passed by
|
|
|
281 value. (adj->by_ref is false and the type of the original
|
|
|
282 actual argument is a pointer to a scalar).
|
|
|
283
|
|
|
284 - A part of an aggregate is passed instead of the whole aggregate.
|
|
|
285 The part can be passed either by value or by reference, this is
|
|
|
286 determined by value of adj->by_ref. Moreover, the code below
|
|
|
287 handles both situations when the original aggregate is passed by
|
|
|
288 value (its type is not a pointer) and when it is passed by
|
|
|
289 reference (it is a pointer to an aggregate).
|
|
|
290
|
|
|
291 When the new argument is passed by reference (adj->by_ref is true)
|
|
|
292 it must be a part of an aggregate and therefore we form it by
|
|
|
293 simply taking the address of a reference inside the original
|
|
|
294 aggregate. */
|
|
|
295
|
|
|
296 poly_int64 byte_offset = exact_div (adj->offset, BITS_PER_UNIT);
|
|
|
297 base = gimple_call_arg (stmt, adj->base_index);
|
|
|
298 loc = gimple_location (stmt);
|
|
|
299
|
|
|
300 if (TREE_CODE (base) != ADDR_EXPR
|
|
|
301 && POINTER_TYPE_P (TREE_TYPE (base)))
|
|
|
302 off = build_int_cst (adj->alias_ptr_type, byte_offset);
|
|
|
303 else
|
|
|
304 {
|
|
|
305 poly_int64 base_offset;
|
|
|
306 tree prev_base;
|
|
|
307 bool addrof;
|
|
|
308
|
|
|
309 if (TREE_CODE (base) == ADDR_EXPR)
|
|
|
310 {
|
|
|
311 base = TREE_OPERAND (base, 0);
|
|
|
312 addrof = true;
|
|
|
313 }
|
|
|
314 else
|
|
|
315 addrof = false;
|
|
|
316 prev_base = base;
|
|
|
317 base = get_addr_base_and_unit_offset (base, &base_offset);
|
|
|
318 /* Aggregate arguments can have non-invariant addresses. */
|
|
|
319 if (!base)
|
|
|
320 {
|
|
|
321 base = build_fold_addr_expr (prev_base);
|
|
|
322 off = build_int_cst (adj->alias_ptr_type, byte_offset);
|
|
|
323 }
|
|
|
324 else if (TREE_CODE (base) == MEM_REF)
|
|
|
325 {
|
|
|
326 if (!addrof)
|
|
|
327 {
|
|
|
328 deref_base = true;
|
|
|
329 deref_align = TYPE_ALIGN (TREE_TYPE (base));
|
|
|
330 }
|
|
|
331 off = build_int_cst (adj->alias_ptr_type,
|
|
|
332 base_offset + byte_offset);
|
|
|
333 off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1),
|
|
|
334 off);
|
|
|
335 base = TREE_OPERAND (base, 0);
|
|
|
336 }
|
|
|
337 else
|
|
|
338 {
|
|
|
339 off = build_int_cst (adj->alias_ptr_type,
|
|
|
340 base_offset + byte_offset);
|
|
|
341 base = build_fold_addr_expr (base);
|
|
|
342 }
|
|
|
343 }
|
|
|
344
|
|
|
345 if (!adj->by_ref)
|
|
|
346 {
|
|
|
347 tree type = adj->type;
|
|
|
348 unsigned int align;
|
|
|
349 unsigned HOST_WIDE_INT misalign;
|
|
|
350
|
|
|
351 if (deref_base)
|
|
|
352 {
|
|
|
353 align = deref_align;
|
|
|
354 misalign = 0;
|
|
|
355 }
|
|
|
356 else
|
|
|
357 {
|
|
|
358 get_pointer_alignment_1 (base, &align, &misalign);
|
|
|
359 if (TYPE_ALIGN (type) > align)
|
|
|
360 align = TYPE_ALIGN (type);
|
|
|
361 }
|
|
|
362 misalign += (offset_int::from (wi::to_wide (off),
|
|
|
363 SIGNED).to_short_addr ()
|
|
|
364 * BITS_PER_UNIT);
|
|
|
365 misalign = misalign & (align - 1);
|
|
|
366 if (misalign != 0)
|
|
|
367 align = least_bit_hwi (misalign);
|
|
|
368 if (align < TYPE_ALIGN (type))
|
|
|
369 type = build_aligned_type (type, align);
|
|
|
370 base = force_gimple_operand_gsi (&gsi, base,
|
|
|
371 true, NULL, true, GSI_SAME_STMT);
|
|
|
372 expr = fold_build2_loc (loc, MEM_REF, type, base, off);
|
|
|
373 REF_REVERSE_STORAGE_ORDER (expr) = adj->reverse;
|
|
|
374 /* If expr is not a valid gimple call argument emit
|
|
|
375 a load into a temporary. */
|
|
|
376 if (is_gimple_reg_type (TREE_TYPE (expr)))
|
|
|
377 {
|
|
|
378 gimple *tem = gimple_build_assign (NULL_TREE, expr);
|
|
|
379 if (gimple_in_ssa_p (cfun))
|
|
|
380 {
|
|
|
381 gimple_set_vuse (tem, gimple_vuse (stmt));
|
|
|
382 expr = make_ssa_name (TREE_TYPE (expr), tem);
|
|
|
383 }
|
|
|
384 else
|
|
|
385 expr = create_tmp_reg (TREE_TYPE (expr));
|
|
|
386 gimple_assign_set_lhs (tem, expr);
|
|
|
387 gimple_set_location (tem, loc);
|
|
|
388 gsi_insert_before (&gsi, tem, GSI_SAME_STMT);
|
|
|
389 }
|
|
|
390 }
|
|
|
391 else
|
|
|
392 {
|
|
|
393 expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off);
|
|
|
394 REF_REVERSE_STORAGE_ORDER (expr) = adj->reverse;
|
|
|
395 expr = build_fold_addr_expr (expr);
|
|
|
396 expr = force_gimple_operand_gsi (&gsi, expr,
|
|
|
397 true, NULL, true, GSI_SAME_STMT);
|
|
|
398 }
|
|
|
399 vargs.quick_push (expr);
|
|
|
400 }
|
|
|
401 if (adj->op != IPA_PARM_OP_COPY && MAY_HAVE_DEBUG_BIND_STMTS)
|
|
|
402 {
|
|
|
403 unsigned int ix;
|
|
|
404 tree ddecl = NULL_TREE, origin = DECL_ORIGIN (adj->base), arg;
|
|
|
405 gimple *def_temp;
|
|
|
406
|
|
|
407 arg = gimple_call_arg (stmt, adj->base_index);
|
|
|
408 if (!useless_type_conversion_p (TREE_TYPE (origin), TREE_TYPE (arg)))
|
|
|
409 {
|
|
|
410 if (!fold_convertible_p (TREE_TYPE (origin), arg))
|
|
|
411 continue;
|
|
|
412 arg = fold_convert_loc (gimple_location (stmt),
|
|
|
413 TREE_TYPE (origin), arg);
|
|
|
414 }
|
|
|
415 if (debug_args == NULL)
|
|
|
416 debug_args = decl_debug_args_insert (callee_decl);
|
|
|
417 for (ix = 0; vec_safe_iterate (*debug_args, ix, &ddecl); ix += 2)
|
|
|
418 if (ddecl == origin)
|
|
|
419 {
|
|
|
420 ddecl = (**debug_args)[ix + 1];
|
|
|
421 break;
|
|
|
422 }
|
|
|
423 if (ddecl == NULL)
|
|
|
424 {
|
|
|
425 ddecl = make_node (DEBUG_EXPR_DECL);
|
|
|
426 DECL_ARTIFICIAL (ddecl) = 1;
|
|
|
427 TREE_TYPE (ddecl) = TREE_TYPE (origin);
|
|
|
428 SET_DECL_MODE (ddecl, DECL_MODE (origin));
|
|
|
429
|
|
|
430 vec_safe_push (*debug_args, origin);
|
|
|
431 vec_safe_push (*debug_args, ddecl);
|
|
|
432 }
|
|
|
433 def_temp = gimple_build_debug_bind (ddecl, unshare_expr (arg), stmt);
|
|
|
434 gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT);
|
|
|
435 }
|
|
|
436 }
|
|
|
437
|
|
|
438 if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
439 {
|
|
|
440 fprintf (dump_file, "replacing stmt:");
|
|
|
441 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0);
|
|
|
442 }
|
|
|
443
|
|
|
444 new_stmt = gimple_build_call_vec (callee_decl, vargs);
|
|
|
445 vargs.release ();
|
|
|
446 if (gimple_call_lhs (stmt))
|
|
|
447 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
|
|
|
448
|
|
|
449 gimple_set_block (new_stmt, gimple_block (stmt));
|
|
|
450 if (gimple_has_location (stmt))
|
|
|
451 gimple_set_location (new_stmt, gimple_location (stmt));
|
|
|
452 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
|
|
|
453 gimple_call_copy_flags (new_stmt, stmt);
|
|
|
454 if (gimple_in_ssa_p (cfun))
|
|
|
455 {
|
|
|
456 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
|
|
|
457 if (gimple_vdef (stmt))
|
|
|
458 {
|
|
|
459 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
|
|
|
460 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
|
|
|
461 }
|
|
|
462 }
|
|
|
463
|
|
|
464 if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
465 {
|
|
|
466 fprintf (dump_file, "with stmt:");
|
|
|
467 print_gimple_stmt (dump_file, new_stmt, 0);
|
|
|
468 fprintf (dump_file, "\n");
|
|
|
469 }
|
|
|
470 gsi_replace (&gsi, new_stmt, true);
|
|
|
471 if (cs)
|
|
|
472 cs->set_call_stmt (new_stmt);
|
|
|
473 do
|
|
|
474 {
|
|
|
475 current_node->record_stmt_references (gsi_stmt (gsi));
|
|
|
476 gsi_prev (&gsi);
|
|
|
477 }
|
|
|
478 while (gsi_stmt (gsi) != gsi_stmt (prev_gsi));
|
|
|
479 }
|
|
|
480
|
|
|
481 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
|
|
|
482
|
|
|
483 static bool
|
|
|
484 index_in_adjustments_multiple_times_p (int base_index,
|
|
|
485 ipa_parm_adjustment_vec adjustments)
|
|
|
486 {
|
|
|
487 int i, len = adjustments.length ();
|
|
|
488 bool one = false;
|
|
|
489
|
|
|
490 for (i = 0; i < len; i++)
|
|
|
491 {
|
|
|
492 struct ipa_parm_adjustment *adj;
|
|
|
493 adj = &adjustments[i];
|
|
|
494
|
|
|
495 if (adj->base_index == base_index)
|
|
|
496 {
|
|
|
497 if (one)
|
|
|
498 return true;
|
|
|
499 else
|
|
|
500 one = true;
|
|
|
501 }
|
|
|
502 }
|
|
|
503 return false;
|
|
|
504 }
|
|
|
505
|
|
|
506 /* Return adjustments that should have the same effect on function parameters
|
|
|
507 and call arguments as if they were first changed according to adjustments in
|
|
|
508 INNER and then by adjustments in OUTER. */
|
|
|
509
|
|
|
510 ipa_parm_adjustment_vec
|
|
|
511 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
|
|
|
512 ipa_parm_adjustment_vec outer)
|
|
|
513 {
|
|
|
514 int i, outlen = outer.length ();
|
|
|
515 int inlen = inner.length ();
|
|
|
516 int removals = 0;
|
|
|
517 ipa_parm_adjustment_vec adjustments, tmp;
|
|
|
518
|
|
|
519 tmp.create (inlen);
|
|
|
520 for (i = 0; i < inlen; i++)
|
|
|
521 {
|
|
|
522 struct ipa_parm_adjustment *n;
|
|
|
523 n = &inner[i];
|
|
|
524
|
|
|
525 if (n->op == IPA_PARM_OP_REMOVE)
|
|
|
526 removals++;
|
|
|
527 else
|
|
|
528 {
|
|
|
529 /* FIXME: Handling of new arguments are not implemented yet. */
|
|
|
530 gcc_assert (n->op != IPA_PARM_OP_NEW);
|
|
|
531 tmp.quick_push (*n);
|
|
|
532 }
|
|
|
533 }
|
|
|
534
|
|
|
535 adjustments.create (outlen + removals);
|
|
|
536 for (i = 0; i < outlen; i++)
|
|
|
537 {
|
|
|
538 struct ipa_parm_adjustment r;
|
|
|
539 struct ipa_parm_adjustment *out = &outer[i];
|
|
|
540 struct ipa_parm_adjustment *in = &tmp[out->base_index];
|
|
|
541
|
|
|
542 memset (&r, 0, sizeof (r));
|
|
|
543 gcc_assert (in->op != IPA_PARM_OP_REMOVE);
|
|
|
544 if (out->op == IPA_PARM_OP_REMOVE)
|
|
|
545 {
|
|
|
546 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
|
|
|
547 {
|
|
|
548 r.op = IPA_PARM_OP_REMOVE;
|
|
|
549 adjustments.quick_push (r);
|
|
|
550 }
|
|
|
551 continue;
|
|
|
552 }
|
|
|
553 else
|
|
|
554 {
|
|
|
555 /* FIXME: Handling of new arguments are not implemented yet. */
|
|
|
556 gcc_assert (out->op != IPA_PARM_OP_NEW);
|
|
|
557 }
|
|
|
558
|
|
|
559 r.base_index = in->base_index;
|
|
|
560 r.type = out->type;
|
|
|
561
|
|
|
562 /* FIXME: Create nonlocal value too. */
|
|
|
563
|
|
|
564 if (in->op == IPA_PARM_OP_COPY && out->op == IPA_PARM_OP_COPY)
|
|
|
565 r.op = IPA_PARM_OP_COPY;
|
|
|
566 else if (in->op == IPA_PARM_OP_COPY)
|
|
|
567 r.offset = out->offset;
|
|
|
568 else if (out->op == IPA_PARM_OP_COPY)
|
|
|
569 r.offset = in->offset;
|
|
|
570 else
|
|
|
571 r.offset = in->offset + out->offset;
|
|
|
572 adjustments.quick_push (r);
|
|
|
573 }
|
|
|
574
|
|
|
575 for (i = 0; i < inlen; i++)
|
|
|
576 {
|
|
|
577 struct ipa_parm_adjustment *n = &inner[i];
|
|
|
578
|
|
|
579 if (n->op == IPA_PARM_OP_REMOVE)
|
|
|
580 adjustments.quick_push (*n);
|
|
|
581 }
|
|
|
582
|
|
|
583 tmp.release ();
|
|
|
584 return adjustments;
|
|
|
585 }
|
|
|
586
|
|
|
587 /* If T is an SSA_NAME, return NULL if it is not a default def or
|
|
|
588 return its base variable if it is. If IGNORE_DEFAULT_DEF is true,
|
|
|
589 the base variable is always returned, regardless if it is a default
|
|
|
590 def. Return T if it is not an SSA_NAME. */
|
|
|
591
|
|
|
592 static tree
|
|
|
593 get_ssa_base_param (tree t, bool ignore_default_def)
|
|
|
594 {
|
|
|
595 if (TREE_CODE (t) == SSA_NAME)
|
|
|
596 {
|
|
|
597 if (ignore_default_def || SSA_NAME_IS_DEFAULT_DEF (t))
|
|
|
598 return SSA_NAME_VAR (t);
|
|
|
599 else
|
|
|
600 return NULL_TREE;
|
|
|
601 }
|
|
|
602 return t;
|
|
|
603 }
|
|
|
604
|
|
|
605 /* Given an expression, return an adjustment entry specifying the
|
|
|
606 transformation to be done on EXPR. If no suitable adjustment entry
|
|
|
607 was found, returns NULL.
|
|
|
608
|
|
|
609 If IGNORE_DEFAULT_DEF is set, consider SSA_NAMEs which are not a
|
|
|
610 default def, otherwise bail on them.
|
|
|
611
|
|
|
612 If CONVERT is non-NULL, this function will set *CONVERT if the
|
|
|
613 expression provided is a component reference. ADJUSTMENTS is the
|
|
|
614 adjustments vector. */
|
|
|
615
|
|
|
616 ipa_parm_adjustment *
|
|
|
617 ipa_get_adjustment_candidate (tree **expr, bool *convert,
|
|
|
618 ipa_parm_adjustment_vec adjustments,
|
|
|
619 bool ignore_default_def)
|
|
|
620 {
|
|
|
621 if (TREE_CODE (**expr) == BIT_FIELD_REF
|
|
|
622 || TREE_CODE (**expr) == IMAGPART_EXPR
|
|
|
623 || TREE_CODE (**expr) == REALPART_EXPR)
|
|
|
624 {
|
|
|
625 *expr = &TREE_OPERAND (**expr, 0);
|
|
|
626 if (convert)
|
|
|
627 *convert = true;
|
|
|
628 }
|
|
|
629
|
|
|
630 poly_int64 offset, size, max_size;
|
|
|
631 bool reverse;
|
|
|
632 tree base
|
|
|
633 = get_ref_base_and_extent (**expr, &offset, &size, &max_size, &reverse);
|
|
|
634 if (!base || !known_size_p (size) || !known_size_p (max_size))
|
|
|
635 return NULL;
|
|
|
636
|
|
|
637 if (TREE_CODE (base) == MEM_REF)
|
|
|
638 {
|
|
|
639 offset += mem_ref_offset (base).force_shwi () * BITS_PER_UNIT;
|
|
|
640 base = TREE_OPERAND (base, 0);
|
|
|
641 }
|
|
|
642
|
|
|
643 base = get_ssa_base_param (base, ignore_default_def);
|
|
|
644 if (!base || TREE_CODE (base) != PARM_DECL)
|
|
|
645 return NULL;
|
|
|
646
|
|
|
647 struct ipa_parm_adjustment *cand = NULL;
|
|
|
648 unsigned int len = adjustments.length ();
|
|
|
649 for (unsigned i = 0; i < len; i++)
|
|
|
650 {
|
|
|
651 struct ipa_parm_adjustment *adj = &adjustments[i];
|
|
|
652
|
|
|
653 if (adj->base == base
|
|
|
654 && (known_eq (adj->offset, offset) || adj->op == IPA_PARM_OP_REMOVE))
|
|
|
655 {
|
|
|
656 cand = adj;
|
|
|
657 break;
|
|
|
658 }
|
|
|
659 }
|
|
|
660
|
|
|
661 if (!cand || cand->op == IPA_PARM_OP_COPY || cand->op == IPA_PARM_OP_REMOVE)
|
|
|
662 return NULL;
|
|
|
663 return cand;
|
|
|
664 }
|
|
|
665
|
|
|
666 /* If the expression *EXPR should be replaced by a reduction of a parameter, do
|
|
|
667 so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT
|
|
|
668 specifies whether the function should care about type incompatibility the
|
|
|
669 current and new expressions. If it is false, the function will leave
|
|
|
670 incompatibility issues to the caller. Return true iff the expression
|
|
|
671 was modified. */
|
|
|
672
|
|
|
673 bool
|
|
|
674 ipa_modify_expr (tree *expr, bool convert,
|
|
|
675 ipa_parm_adjustment_vec adjustments)
|
|
|
676 {
|
|
|
677 struct ipa_parm_adjustment *cand
|
|
|
678 = ipa_get_adjustment_candidate (&expr, &convert, adjustments, false);
|
|
|
679 if (!cand)
|
|
|
680 return false;
|
|
|
681
|
|
|
682 tree src;
|
|
|
683 if (cand->by_ref)
|
|
|
684 {
|
|
|
685 src = build_simple_mem_ref (cand->new_decl);
|
|
|
686 REF_REVERSE_STORAGE_ORDER (src) = cand->reverse;
|
|
|
687 }
|
|
|
688 else
|
|
|
689 src = cand->new_decl;
|
|
|
690
|
|
|
691 if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
692 {
|
|
|
693 fprintf (dump_file, "About to replace expr ");
|
|
|
694 print_generic_expr (dump_file, *expr);
|
|
|
695 fprintf (dump_file, " with ");
|
|
|
696 print_generic_expr (dump_file, src);
|
|
|
697 fprintf (dump_file, "\n");
|
|
|
698 }
|
|
|
699
|
|
|
700 if (convert && !useless_type_conversion_p (TREE_TYPE (*expr), cand->type))
|
|
|
701 {
|
|
|
702 tree vce = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*expr), src);
|
|
|
703 *expr = vce;
|
|
|
704 }
|
|
|
705 else
|
|
|
706 *expr = src;
|
|
|
707 return true;
|
|
|
708 }
|
|
|
709
|
|
|
710 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
|
|
|
711 friendly way, assuming they are meant to be applied to FNDECL. */
|
|
|
712
|
|
|
713 void
|
|
|
714 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
|
|
|
715 tree fndecl)
|
|
|
716 {
|
|
|
717 int i, len = adjustments.length ();
|
|
|
718 bool first = true;
|
|
|
719 vec<tree> parms = ipa_get_vector_of_formal_parms (fndecl);
|
|
|
720
|
|
|
721 fprintf (file, "IPA param adjustments: ");
|
|
|
722 for (i = 0; i < len; i++)
|
|
|
723 {
|
|
|
724 struct ipa_parm_adjustment *adj;
|
|
|
725 adj = &adjustments[i];
|
|
|
726
|
|
|
727 if (!first)
|
|
|
728 fprintf (file, " ");
|
|
|
729 else
|
|
|
730 first = false;
|
|
|
731
|
|
|
732 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
|
|
|
733 print_generic_expr (file, parms[adj->base_index]);
|
|
|
734 if (adj->base)
|
|
|
735 {
|
|
|
736 fprintf (file, ", base: ");
|
|
|
737 print_generic_expr (file, adj->base);
|
|
|
738 }
|
|
|
739 if (adj->new_decl)
|
|
|
740 {
|
|
|
741 fprintf (file, ", new_decl: ");
|
|
|
742 print_generic_expr (file, adj->new_decl);
|
|
|
743 }
|
|
|
744 if (adj->new_ssa_base)
|
|
|
745 {
|
|
|
746 fprintf (file, ", new_ssa_base: ");
|
|
|
747 print_generic_expr (file, adj->new_ssa_base);
|
|
|
748 }
|
|
|
749
|
|
|
750 if (adj->op == IPA_PARM_OP_COPY)
|
|
|
751 fprintf (file, ", copy_param");
|
|
|
752 else if (adj->op == IPA_PARM_OP_REMOVE)
|
|
|
753 fprintf (file, ", remove_param");
|
|
|
754 else
|
|
|
755 {
|
|
|
756 fprintf (file, ", offset ");
|
|
|
757 print_dec (adj->offset, file);
|
|
|
758 }
|
|
|
759 if (adj->by_ref)
|
|
|
760 fprintf (file, ", by_ref");
|
|
|
761 print_node_brief (file, ", type: ", adj->type, 0);
|
|
|
762 fprintf (file, "\n");
|
|
|
763 }
|
|
|
764 parms.release ();
|
|
|
765 }
|
|
|
766
|
