1/* Manipulation of formal and actual parameters of functions and function 2 calls. 3 Copyright (C) 2017-2020 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#include "config.h" 22#include "system.h" 23#include "coretypes.h" 24#include "backend.h" 25#include "tree.h" 26#include "gimple.h" 27#include "ssa.h" 28#include "cgraph.h" 29#include "fold-const.h" 30#include "tree-eh.h" 31#include "stor-layout.h" 32#include "gimplify.h" 33#include "gimple-iterator.h" 34#include "gimplify-me.h" 35#include "tree-cfg.h" 36#include "tree-dfa.h" 37#include "ipa-param-manipulation.h" 38#include "print-tree.h" 39#include "gimple-pretty-print.h" 40#include "builtins.h" 41#include "tree-ssa.h" 42#include "tree-inline.h" 43 44 45/* Actual prefixes of different newly synthetized parameters. Keep in sync 46 with IPA_PARAM_PREFIX_* defines. */ 47 48static const char *ipa_param_prefixes[IPA_PARAM_PREFIX_COUNT] 49 = {"SYNTH", 50 "ISRA", 51 "simd", 52 "mask"}; 53 54/* Names of parameters for dumping. Keep in sync with enum ipa_parm_op. */ 55 56static const char *ipa_param_op_names[IPA_PARAM_PREFIX_COUNT] 57 = {"IPA_PARAM_OP_UNDEFINED", 58 "IPA_PARAM_OP_COPY", 59 "IPA_PARAM_OP_NEW", 60 "IPA_PARAM_OP_SPLIT"}; 61 62/* Fill an empty vector ARGS with PARM_DECLs representing formal parameters of 63 FNDECL. The function should not be called during LTO WPA phase except for 64 thunks (or functions with bodies streamed in). */ 65 66void 67push_function_arg_decls (vec<tree> *args, tree fndecl) 68{ 69 int count; 70 tree parm; 71 72 /* Safety check that we do not attempt to use the function in WPA, except 73 when the function is a thunk and then we have DECL_ARGUMENTS or when we 74 have already explicitely loaded its body. */ 75 gcc_assert (!flag_wpa 76 || DECL_ARGUMENTS (fndecl) 77 || gimple_has_body_p (fndecl)); 78 count = 0; 79 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm)) 80 count++; 81 82 args->reserve_exact (count); 83 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm)) 84 args->quick_push (parm); 85} 86 87/* Fill an empty vector TYPES with trees representing formal parameters of 88 function type FNTYPE. */ 89 90void 91push_function_arg_types (vec<tree> *types, tree fntype) 92{ 93 int count = 0; 94 tree t; 95 96 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t)) 97 count++; 98 99 types->reserve_exact (count); 100 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t)) 101 types->quick_push (TREE_VALUE (t)); 102} 103 104/* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human 105 friendly way, assuming they are meant to be applied to FNDECL. */ 106 107void 108ipa_dump_adjusted_parameters (FILE *f, 109 vec<ipa_adjusted_param, va_gc> *adj_params) 110{ 111 unsigned i, len = vec_safe_length (adj_params); 112 bool first = true; 113 114 fprintf (f, " IPA adjusted parameters: "); 115 for (i = 0; i < len; i++) 116 { 117 struct ipa_adjusted_param *apm; 118 apm = &(*adj_params)[i]; 119 120 if (!first) 121 fprintf (f, " "); 122 else 123 first = false; 124 125 fprintf (f, "%i. %s %s", i, ipa_param_op_names[apm->op], 126 apm->prev_clone_adjustment ? "prev_clone_adjustment " : ""); 127 switch (apm->op) 128 { 129 case IPA_PARAM_OP_UNDEFINED: 130 break; 131 132 case IPA_PARAM_OP_COPY: 133 fprintf (f, ", base_index: %u", apm->base_index); 134 fprintf (f, ", prev_clone_index: %u", apm->prev_clone_index); 135 break; 136 137 case IPA_PARAM_OP_SPLIT: 138 fprintf (f, ", offset: %u", apm->unit_offset); 139 /* fall-through */ 140 case IPA_PARAM_OP_NEW: 141 fprintf (f, ", base_index: %u", apm->base_index); 142 fprintf (f, ", prev_clone_index: %u", apm->prev_clone_index); 143 print_node_brief (f, ", type: ", apm->type, 0); 144 print_node_brief (f, ", alias type: ", apm->alias_ptr_type, 0); 145 fprintf (f, " prefix: %s", 146 ipa_param_prefixes[apm->param_prefix_index]); 147 if (apm->reverse) 148 fprintf (f, ", reverse"); 149 break; 150 } 151 fprintf (f, "\n"); 152 } 153} 154 155/* Fill NEW_TYPES with types of a function after its current OTYPES have been 156 modified as described in ADJ_PARAMS. When USE_PREV_INDICES is true, use 157 prev_clone_index from ADJ_PARAMS as opposed to base_index when the parameter 158 is false. */ 159 160static void 161fill_vector_of_new_param_types (vec<tree> *new_types, vec<tree> *otypes, 162 vec<ipa_adjusted_param, va_gc> *adj_params, 163 bool use_prev_indices) 164{ 165 unsigned adj_len = vec_safe_length (adj_params); 166 new_types->reserve_exact (adj_len); 167 for (unsigned i = 0; i < adj_len ; i++) 168 { 169 ipa_adjusted_param *apm = &(*adj_params)[i]; 170 if (apm->op == IPA_PARAM_OP_COPY) 171 { 172 unsigned index 173 = use_prev_indices ? apm->prev_clone_index : apm->base_index; 174 /* The following needs to be handled gracefully because of type 175 mismatches. This happens with LTO but apparently also in Fortran 176 with -fcoarray=lib -O2 -lcaf_single -latomic. */ 177 if (index >= otypes->length ()) 178 continue; 179 new_types->quick_push ((*otypes)[index]); 180 } 181 else if (apm->op == IPA_PARAM_OP_NEW 182 || apm->op == IPA_PARAM_OP_SPLIT) 183 { 184 tree ntype = apm->type; 185 if (is_gimple_reg_type (ntype) 186 && TYPE_MODE (ntype) != BLKmode) 187 { 188 unsigned malign = GET_MODE_ALIGNMENT (TYPE_MODE (ntype)); 189 if (TYPE_ALIGN (ntype) != malign) 190 ntype = build_aligned_type (ntype, malign); 191 } 192 new_types->quick_push (ntype); 193 } 194 else 195 gcc_unreachable (); 196 } 197} 198 199/* Build and return a function type just like ORIG_TYPE but with parameter 200 types given in NEW_PARAM_TYPES - which can be NULL if, but only if, 201 ORIG_TYPE itself has NULL TREE_ARG_TYPEs. If METHOD2FUNC is true, also make 202 it a FUNCTION_TYPE instead of FUNCTION_TYPE. */ 203 204static tree 205build_adjusted_function_type (tree orig_type, vec<tree> *new_param_types, 206 bool method2func, bool skip_return) 207{ 208 tree new_arg_types = NULL; 209 if (TYPE_ARG_TYPES (orig_type)) 210 { 211 gcc_checking_assert (new_param_types); 212 bool last_parm_void = (TREE_VALUE (tree_last (TYPE_ARG_TYPES (orig_type))) 213 == void_type_node); 214 unsigned len = new_param_types->length (); 215 for (unsigned i = 0; i < len; i++) 216 new_arg_types = tree_cons (NULL_TREE, (*new_param_types)[i], 217 new_arg_types); 218 219 tree new_reversed = nreverse (new_arg_types); 220 if (last_parm_void) 221 { 222 if (new_reversed) 223 TREE_CHAIN (new_arg_types) = void_list_node; 224 else 225 new_reversed = void_list_node; 226 } 227 new_arg_types = new_reversed; 228 } 229 230 /* Use build_distinct_type_copy to preserve as much as possible from original 231 type (debug info, attribute lists etc.). The one exception is 232 METHOD_TYPEs which must have THIS argument and when we are asked to remove 233 it, we need to build new FUNCTION_TYPE instead. */ 234 tree new_type = NULL; 235 if (method2func) 236 { 237 tree ret_type; 238 if (skip_return) 239 ret_type = void_type_node; 240 else 241 ret_type = TREE_TYPE (orig_type); 242 243 new_type 244 = build_distinct_type_copy (build_function_type (ret_type, 245 new_arg_types)); 246 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type); 247 } 248 else 249 { 250 new_type = build_distinct_type_copy (orig_type); 251 TYPE_ARG_TYPES (new_type) = new_arg_types; 252 if (skip_return) 253 TREE_TYPE (new_type) = void_type_node; 254 } 255 256 return new_type; 257} 258 259/* Return the maximum index in any IPA_PARAM_OP_COPY adjustment or -1 if there 260 is none. */ 261 262int 263ipa_param_adjustments::get_max_base_index () 264{ 265 unsigned adj_len = vec_safe_length (m_adj_params); 266 int max_index = -1; 267 for (unsigned i = 0; i < adj_len ; i++) 268 { 269 ipa_adjusted_param *apm = &(*m_adj_params)[i]; 270 if (apm->op == IPA_PARAM_OP_COPY 271 && max_index < apm->base_index) 272 max_index = apm->base_index; 273 } 274 return max_index; 275} 276 277 278/* Fill SURVIVING_PARAMS with an array of bools where each one says whether a 279 parameter that originally was at that position still survives in the given 280 clone or is removed/replaced. If the final array is smaller than an index 281 of an original parameter, that parameter also did not survive. That a 282 parameter survives does not mean it has the same index as before. */ 283 284void 285ipa_param_adjustments::get_surviving_params (vec<bool> *surviving_params) 286{ 287 unsigned adj_len = vec_safe_length (m_adj_params); 288 int max_index = get_max_base_index (); 289 290 if (max_index < 0) 291 return; 292 surviving_params->reserve_exact (max_index + 1); 293 surviving_params->quick_grow_cleared (max_index + 1); 294 for (unsigned i = 0; i < adj_len ; i++) 295 { 296 ipa_adjusted_param *apm = &(*m_adj_params)[i]; 297 if (apm->op == IPA_PARAM_OP_COPY) 298 (*surviving_params)[apm->base_index] = true; 299 } 300} 301 302/* Fill NEW_INDICES with new indices of each surviving parameter or -1 for 303 those which do not survive. Any parameter outside of lenght of the vector 304 does not survive. There is currently no support for a parameter to be 305 copied to two distinct new parameters. */ 306 307void 308ipa_param_adjustments::get_updated_indices (vec<int> *new_indices) 309{ 310 unsigned adj_len = vec_safe_length (m_adj_params); 311 int max_index = get_max_base_index (); 312 313 if (max_index < 0) 314 return; 315 unsigned res_len = max_index + 1; 316 new_indices->reserve_exact (res_len); 317 for (unsigned i = 0; i < res_len ; i++) 318 new_indices->quick_push (-1); 319 for (unsigned i = 0; i < adj_len ; i++) 320 { 321 ipa_adjusted_param *apm = &(*m_adj_params)[i]; 322 if (apm->op == IPA_PARAM_OP_COPY) 323 (*new_indices)[apm->base_index] = i; 324 } 325} 326 327/* Return the original index for the given new parameter index. Return a 328 negative number if not available. */ 329 330int 331ipa_param_adjustments::get_original_index (int newidx) 332{ 333 const ipa_adjusted_param *adj = &(*m_adj_params)[newidx]; 334 if (adj->op != IPA_PARAM_OP_COPY) 335 return -1; 336 return adj->base_index; 337} 338 339/* Return true if the first parameter (assuming there was one) survives the 340 transformation intact and remains the first one. */ 341 342bool 343ipa_param_adjustments::first_param_intact_p () 344{ 345 return (!vec_safe_is_empty (m_adj_params) 346 && (*m_adj_params)[0].op == IPA_PARAM_OP_COPY 347 && (*m_adj_params)[0].base_index == 0); 348} 349 350/* Return true if we have to change what has formerly been a method into a 351 function. */ 352 353bool 354ipa_param_adjustments::method2func_p (tree orig_type) 355{ 356 return ((TREE_CODE (orig_type) == METHOD_TYPE) && !first_param_intact_p ()); 357} 358 359/* Given function type OLD_TYPE, return a new type derived from it after 360 performing all atored modifications. TYPE_ORIGINAL_P should be true when 361 OLD_TYPE refers to the type before any IPA transformations, as opposed to a 362 type that can be an intermediate one in between various IPA 363 transformations. */ 364 365tree 366ipa_param_adjustments::build_new_function_type (tree old_type, 367 bool type_original_p) 368{ 369 auto_vec<tree,16> new_param_types, *new_param_types_p; 370 if (prototype_p (old_type)) 371 { 372 auto_vec<tree, 16> otypes; 373 push_function_arg_types (&otypes, old_type); 374 fill_vector_of_new_param_types (&new_param_types, &otypes, m_adj_params, 375 !type_original_p); 376 new_param_types_p = &new_param_types; 377 } 378 else 379 new_param_types_p = NULL; 380 381 return build_adjusted_function_type (old_type, new_param_types_p, 382 method2func_p (old_type), m_skip_return); 383} 384 385/* Build variant of function decl ORIG_DECL which has no return value if 386 M_SKIP_RETURN is true and, if ORIG_DECL's types or parameters is known, has 387 this type adjusted as indicated in M_ADJ_PARAMS. Arguments from 388 DECL_ARGUMENTS list are not processed now, since they are linked by 389 TREE_CHAIN directly and not accessible in LTO during WPA. The caller is 390 responsible for eliminating them when clones are properly materialized. */ 391 392tree 393ipa_param_adjustments::adjust_decl (tree orig_decl) 394{ 395 tree new_decl = copy_node (orig_decl); 396 tree orig_type = TREE_TYPE (orig_decl); 397 if (prototype_p (orig_type) 398 || (m_skip_return && !VOID_TYPE_P (TREE_TYPE (orig_type)))) 399 { 400 tree new_type = build_new_function_type (orig_type, false); 401 TREE_TYPE (new_decl) = new_type; 402 } 403 if (method2func_p (orig_type)) 404 DECL_VINDEX (new_decl) = NULL_TREE; 405 406 /* When signature changes, we need to clear builtin info. */ 407 if (fndecl_built_in_p (new_decl)) 408 set_decl_built_in_function (new_decl, NOT_BUILT_IN, 0); 409 410 DECL_VIRTUAL_P (new_decl) = 0; 411 DECL_LANG_SPECIFIC (new_decl) = NULL; 412 413 /* Drop MALLOC attribute for a void function. */ 414 if (m_skip_return) 415 DECL_IS_MALLOC (new_decl) = 0; 416 417 return new_decl; 418} 419 420/* Wrapper around get_base_ref_and_offset for cases interesting for IPA-SRA 421 transformations. Return true if EXPR has an interesting form and fill in 422 *BASE_P and *UNIT_OFFSET_P with the appropriate info. */ 423 424static bool 425isra_get_ref_base_and_offset (tree expr, tree *base_p, unsigned *unit_offset_p) 426{ 427 HOST_WIDE_INT offset, size; 428 bool reverse; 429 tree base 430 = get_ref_base_and_extent_hwi (expr, &offset, &size, &reverse); 431 if (!base || size < 0) 432 return false; 433 434 if ((offset % BITS_PER_UNIT) != 0) 435 return false; 436 437 if (TREE_CODE (base) == MEM_REF) 438 { 439 poly_int64 plmoff = mem_ref_offset (base).force_shwi (); 440 HOST_WIDE_INT moff; 441 bool is_cst = plmoff.is_constant (&moff); 442 if (!is_cst) 443 return false; 444 offset += moff * BITS_PER_UNIT; 445 base = TREE_OPERAND (base, 0); 446 } 447 448 if (offset < 0 || (offset / BITS_PER_UNIT) > UINT_MAX) 449 return false; 450 451 *base_p = base; 452 *unit_offset_p = offset / BITS_PER_UNIT; 453 return true; 454} 455 456/* Return true if EXPR describes a transitive split (i.e. one that happened for 457 both the caller and the callee) as recorded in PERFORMED_SPLITS. In that 458 case, store index of the respective record in PERFORMED_SPLITS into 459 *SM_IDX_P and the unit offset from all handled components in EXPR into 460 *UNIT_OFFSET_P. */ 461 462static bool 463transitive_split_p (vec<ipa_param_performed_split, va_gc> *performed_splits, 464 tree expr, unsigned *sm_idx_p, unsigned *unit_offset_p) 465{ 466 tree base; 467 if (!isra_get_ref_base_and_offset (expr, &base, unit_offset_p)) 468 return false; 469 470 if (TREE_CODE (base) == SSA_NAME) 471 { 472 base = SSA_NAME_VAR (base); 473 if (!base) 474 return false; 475 } 476 477 unsigned len = vec_safe_length (performed_splits); 478 for (unsigned i = 0 ; i < len; i++) 479 { 480 ipa_param_performed_split *sm = &(*performed_splits)[i]; 481 if (sm->dummy_decl == base) 482 { 483 *sm_idx_p = i; 484 return true; 485 } 486 } 487 return false; 488} 489 490/* Structure to hold declarations representing transitive IPA-SRA splits. In 491 essence, if we need to pass UNIT_OFFSET of a parameter which originally has 492 number BASE_INDEX, we should pass down REPL. */ 493 494struct transitive_split_map 495{ 496 tree repl; 497 unsigned base_index; 498 unsigned unit_offset; 499}; 500 501/* If call STMT contains any parameters representing transitive splits as 502 described by PERFORMED_SPLITS, return the number of extra parameters that 503 were addded during clone materialization and fill in INDEX_MAP with adjusted 504 indices of corresponding original parameters and TRANS_MAP with description 505 of all transitive replacement descriptions. Otherwise return zero. */ 506 507static unsigned 508init_transitive_splits (vec<ipa_param_performed_split, va_gc> *performed_splits, 509 gcall *stmt, vec <unsigned> *index_map, 510 auto_vec <transitive_split_map> *trans_map) 511{ 512 unsigned phony_arguments = 0; 513 unsigned stmt_idx = 0, base_index = 0; 514 unsigned nargs = gimple_call_num_args (stmt); 515 while (stmt_idx < nargs) 516 { 517 unsigned unit_offset_delta; 518 tree base_arg = gimple_call_arg (stmt, stmt_idx); 519 520 if (phony_arguments > 0) 521 index_map->safe_push (stmt_idx); 522 523 unsigned sm_idx; 524 stmt_idx++; 525 if (transitive_split_p (performed_splits, base_arg, &sm_idx, 526 &unit_offset_delta)) 527 { 528 if (phony_arguments == 0) 529 /* We have optimistically avoided constructing index_map do far but 530 now it is clear it will be necessary, so let's create the easy 531 bit we skipped until now. */ 532 for (unsigned k = 0; k < stmt_idx; k++) 533 index_map->safe_push (k); 534 535 tree dummy = (*performed_splits)[sm_idx].dummy_decl; 536 for (unsigned j = sm_idx; j < performed_splits->length (); j++) 537 { 538 ipa_param_performed_split *caller_split 539 = &(*performed_splits)[j]; 540 if (caller_split->dummy_decl != dummy) 541 break; 542 543 tree arg = gimple_call_arg (stmt, stmt_idx); 544 struct transitive_split_map tsm; 545 tsm.repl = arg; 546 tsm.base_index = base_index; 547 if (caller_split->unit_offset >= unit_offset_delta) 548 { 549 tsm.unit_offset 550 = (caller_split->unit_offset - unit_offset_delta); 551 trans_map->safe_push (tsm); 552 } 553 554 phony_arguments++; 555 stmt_idx++; 556 } 557 } 558 base_index++; 559 } 560 return phony_arguments; 561} 562 563/* Modify actual arguments of a function call in statement STMT, assuming it 564 calls CALLEE_DECL. CALLER_ADJ must be the description of parameter 565 adjustments of the caller or NULL if there are none. Return the new 566 statement that replaced the old one. When invoked, cfun and 567 current_function_decl have to be set to the caller. */ 568 569gcall * 570ipa_param_adjustments::modify_call (gcall *stmt, 571 vec<ipa_param_performed_split, 572 va_gc> *performed_splits, 573 tree callee_decl, bool update_references) 574{ 575 unsigned len = vec_safe_length (m_adj_params); 576 auto_vec<tree, 16> vargs (len); 577 tree old_decl = gimple_call_fndecl (stmt); 578 unsigned old_nargs = gimple_call_num_args (stmt); 579 auto_vec<bool, 16> kept (old_nargs); 580 kept.quick_grow_cleared (old_nargs); 581 582 auto_vec <unsigned, 16> index_map; 583 auto_vec <transitive_split_map> trans_map; 584 bool transitive_remapping = false; 585 586 if (performed_splits) 587 { 588 unsigned removed = init_transitive_splits (performed_splits, 589 stmt, &index_map, &trans_map); 590 if (removed > 0) 591 { 592 transitive_remapping = true; 593 old_nargs -= removed; 594 } 595 } 596 597 cgraph_node *current_node = cgraph_node::get (current_function_decl); 598 if (update_references) 599 current_node->remove_stmt_references (stmt); 600 601 gimple_stmt_iterator gsi = gsi_for_stmt (stmt); 602 gimple_stmt_iterator prev_gsi = gsi; 603 gsi_prev (&prev_gsi); 604 for (unsigned i = 0; i < len; i++) 605 { 606 ipa_adjusted_param *apm = &(*m_adj_params)[i]; 607 if (apm->op == IPA_PARAM_OP_COPY) 608 { 609 unsigned index = apm->base_index; 610 if (index >= old_nargs) 611 /* Can happen if the original call has argument mismatch, 612 ignore. */ 613 continue; 614 if (transitive_remapping) 615 index = index_map[apm->base_index]; 616 617 tree arg = gimple_call_arg (stmt, index); 618 619 vargs.quick_push (arg); 620 kept[index] = true; 621 continue; 622 } 623 624 /* At the moment the only user of IPA_PARAM_OP_NEW modifies calls itself. 625 If we ever want to support it during WPA IPA stage, we'll need a 626 mechanism to call into the IPA passes that introduced them. Currently 627 we simply mandate that IPA infrastructure understands all argument 628 modifications. Remember, edge redirection/modification is done only 629 once, not in steps for each pass modifying the callee like clone 630 materialization. */ 631 gcc_assert (apm->op == IPA_PARAM_OP_SPLIT); 632 633 /* We have to handle transitive changes differently using the maps we 634 have created before. So look into them first. */ 635 tree repl = NULL_TREE; 636 for (unsigned j = 0; j < trans_map.length (); j++) 637 if (trans_map[j].base_index == apm->base_index 638 && trans_map[j].unit_offset == apm->unit_offset) 639 { 640 repl = trans_map[j].repl; 641 break; 642 } 643 if (repl) 644 { 645 vargs.quick_push (repl); 646 continue; 647 } 648 649 unsigned index = apm->base_index; 650 if (index >= old_nargs) 651 /* Can happen if the original call has argument mismatch, ignore. */ 652 continue; 653 if (transitive_remapping) 654 index = index_map[apm->base_index]; 655 tree base = gimple_call_arg (stmt, index); 656 657 /* We create a new parameter out of the value of the old one, we can 658 do the following kind of transformations: 659 660 - A scalar passed by reference, potentially as a part of a larger 661 aggregate, is converted to a scalar passed by value. 662 663 - A part of an aggregate is passed instead of the whole aggregate. */ 664 665 location_t loc = gimple_location (stmt); 666 tree off; 667 bool deref_base = false; 668 unsigned int deref_align = 0; 669 if (TREE_CODE (base) != ADDR_EXPR 670 && is_gimple_reg_type (TREE_TYPE (base))) 671 { 672 /* Detect type mismatches in calls in invalid programs and make a 673 poor attempt to gracefully convert them so that we don't ICE. */ 674 if (!POINTER_TYPE_P (TREE_TYPE (base))) 675 base = force_value_to_type (ptr_type_node, base); 676 677 off = build_int_cst (apm->alias_ptr_type, apm->unit_offset); 678 } 679 else 680 { 681 bool addrof; 682 if (TREE_CODE (base) == ADDR_EXPR) 683 { 684 base = TREE_OPERAND (base, 0); 685 addrof = true; 686 } 687 else 688 addrof = false; 689 690 tree prev_base = base; 691 poly_int64 base_offset; 692 base = get_addr_base_and_unit_offset (base, &base_offset); 693 694 /* Aggregate arguments can have non-invariant addresses. */ 695 if (!base) 696 { 697 base = build_fold_addr_expr (prev_base); 698 off = build_int_cst (apm->alias_ptr_type, apm->unit_offset); 699 } 700 else if (TREE_CODE (base) == MEM_REF) 701 { 702 if (!addrof) 703 { 704 deref_base = true; 705 deref_align = TYPE_ALIGN (TREE_TYPE (base)); 706 } 707 off = build_int_cst (apm->alias_ptr_type, 708 base_offset + apm->unit_offset); 709 off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1), 710 off); 711 base = TREE_OPERAND (base, 0); 712 } 713 else 714 { 715 off = build_int_cst (apm->alias_ptr_type, 716 base_offset + apm->unit_offset); 717 base = build_fold_addr_expr (base); 718 } 719 } 720 721 tree type = apm->type; 722 unsigned int align; 723 unsigned HOST_WIDE_INT misalign; 724 725 if (deref_base) 726 { 727 align = deref_align; 728 misalign = 0; 729 } 730 else 731 { 732 get_pointer_alignment_1 (base, &align, &misalign); 733 /* All users must make sure that we can be optimistic when it 734 comes to alignment in this case (by inspecting the final users 735 of these new parameters). */ 736 if (TYPE_ALIGN (type) > align) 737 align = TYPE_ALIGN (type); 738 } 739 misalign 740 += (offset_int::from (wi::to_wide (off), SIGNED).to_short_addr () 741 * BITS_PER_UNIT); 742 misalign = misalign & (align - 1); 743 if (misalign != 0) 744 align = least_bit_hwi (misalign); 745 if (align < TYPE_ALIGN (type)) 746 type = build_aligned_type (type, align); 747 base = force_gimple_operand_gsi (&gsi, base, 748 true, NULL, true, GSI_SAME_STMT); 749 tree expr = fold_build2_loc (loc, MEM_REF, type, base, off); 750 REF_REVERSE_STORAGE_ORDER (expr) = apm->reverse; 751 /* If expr is not a valid gimple call argument emit 752 a load into a temporary. */ 753 if (is_gimple_reg_type (TREE_TYPE (expr))) 754 { 755 gimple *tem = gimple_build_assign (NULL_TREE, expr); 756 if (gimple_in_ssa_p (cfun)) 757 { 758 gimple_set_vuse (tem, gimple_vuse (stmt)); 759 expr = make_ssa_name (TREE_TYPE (expr), tem); 760 } 761 else 762 expr = create_tmp_reg (TREE_TYPE (expr)); 763 gimple_assign_set_lhs (tem, expr); 764 gsi_insert_before (&gsi, tem, GSI_SAME_STMT); 765 } 766 vargs.quick_push (expr); 767 } 768 769 if (m_always_copy_start >= 0) 770 for (unsigned i = m_always_copy_start; i < old_nargs; i++) 771 vargs.safe_push (gimple_call_arg (stmt, i)); 772 773 /* For optimized away parameters, add on the caller side 774 before the call 775 DEBUG D#X => parm_Y(D) 776 stmts and associate D#X with parm in decl_debug_args_lookup 777 vector to say for debug info that if parameter parm had been passed, 778 it would have value parm_Y(D). */ 779 if (MAY_HAVE_DEBUG_BIND_STMTS && old_decl && callee_decl) 780 { 781 vec<tree, va_gc> **debug_args = NULL; 782 unsigned i = 0; 783 for (tree old_parm = DECL_ARGUMENTS (old_decl); 784 old_parm && i < old_nargs && ((int) i) < m_always_copy_start; 785 old_parm = DECL_CHAIN (old_parm), i++) 786 { 787 if (!is_gimple_reg (old_parm) || kept[i]) 788 continue; 789 tree origin = DECL_ORIGIN (old_parm); 790 tree arg; 791 if (transitive_remapping) 792 arg = gimple_call_arg (stmt, index_map[i]); 793 else 794 arg = gimple_call_arg (stmt, i); 795 796 if (!useless_type_conversion_p (TREE_TYPE (origin), TREE_TYPE (arg))) 797 { 798 if (!fold_convertible_p (TREE_TYPE (origin), arg)) 799 continue; 800 tree rhs1; 801 if (TREE_CODE (arg) == SSA_NAME 802 && gimple_assign_cast_p (SSA_NAME_DEF_STMT (arg)) 803 && (rhs1 804 = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (arg))) 805 && useless_type_conversion_p (TREE_TYPE (origin), 806 TREE_TYPE (rhs1))) 807 arg = rhs1; 808 else 809 arg = fold_convert_loc (gimple_location (stmt), 810 TREE_TYPE (origin), arg); 811 } 812 if (debug_args == NULL) 813 debug_args = decl_debug_args_insert (callee_decl); 814 unsigned int ix; 815 tree ddecl = NULL_TREE; 816 for (ix = 0; vec_safe_iterate (*debug_args, ix, &ddecl); ix += 2) 817 if (ddecl == origin) 818 { 819 ddecl = (**debug_args)[ix + 1]; 820 break; 821 } 822 if (ddecl == NULL) 823 { 824 ddecl = make_node (DEBUG_EXPR_DECL); 825 DECL_ARTIFICIAL (ddecl) = 1; 826 TREE_TYPE (ddecl) = TREE_TYPE (origin); 827 SET_DECL_MODE (ddecl, DECL_MODE (origin)); 828 829 vec_safe_push (*debug_args, origin); 830 vec_safe_push (*debug_args, ddecl); 831 } 832 gimple *def_temp = gimple_build_debug_bind (ddecl, 833 unshare_expr (arg), stmt); 834 gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT); 835 } 836 } 837 838 if (dump_file && (dump_flags & TDF_DETAILS)) 839 { 840 fprintf (dump_file, "replacing stmt:"); 841 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0); 842 } 843 844 gcall *new_stmt = gimple_build_call_vec (callee_decl, vargs); 845 846 if (tree lhs = gimple_call_lhs (stmt)) 847 { 848 if (!m_skip_return) 849 gimple_call_set_lhs (new_stmt, lhs); 850 else if (TREE_CODE (lhs) == SSA_NAME) 851 { 852 /* LHS should now by a default-def SSA. Unfortunately default-def 853 SSA_NAMEs need a backing variable (or at least some code examining 854 SSAs assumes it is non-NULL). So we either have to re-use the 855 decl we have at hand or introdice a new one. */ 856 tree repl = create_tmp_var (TREE_TYPE (lhs), "removed_return"); 857 repl = get_or_create_ssa_default_def (cfun, repl); 858 SSA_NAME_IS_DEFAULT_DEF (repl) = true; 859 imm_use_iterator ui; 860 use_operand_p use_p; 861 gimple *using_stmt; 862 FOR_EACH_IMM_USE_STMT (using_stmt, ui, lhs) 863 { 864 FOR_EACH_IMM_USE_ON_STMT (use_p, ui) 865 { 866 SET_USE (use_p, repl); 867 } 868 update_stmt (using_stmt); 869 } 870 } 871 } 872 873 gimple_set_block (new_stmt, gimple_block (stmt)); 874 if (gimple_has_location (stmt)) 875 gimple_set_location (new_stmt, gimple_location (stmt)); 876 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt)); 877 gimple_call_copy_flags (new_stmt, stmt); 878 if (gimple_in_ssa_p (cfun)) 879 gimple_move_vops (new_stmt, stmt); 880 881 if (dump_file && (dump_flags & TDF_DETAILS)) 882 { 883 fprintf (dump_file, "with stmt:"); 884 print_gimple_stmt (dump_file, new_stmt, 0); 885 fprintf (dump_file, "\n"); 886 } 887 gsi_replace (&gsi, new_stmt, true); 888 if (update_references) 889 do 890 { 891 current_node->record_stmt_references (gsi_stmt (gsi)); 892 gsi_prev (&gsi); 893 } 894 while (gsi_stmt (gsi) != gsi_stmt (prev_gsi)); 895 return new_stmt; 896} 897 898/* Dump information contained in the object in textual form to F. */ 899 900void 901ipa_param_adjustments::dump (FILE *f) 902{ 903 fprintf (f, " m_always_copy_start: %i\n", m_always_copy_start); 904 ipa_dump_adjusted_parameters (f, m_adj_params); 905 if (m_skip_return) 906 fprintf (f, " Will SKIP return.\n"); 907} 908 909/* Dump information contained in the object in textual form to stderr. */ 910 911void 912ipa_param_adjustments::debug () 913{ 914 dump (stderr); 915} 916 917/* Register that REPLACEMENT should replace parameter described in APM and 918 optionally as DUMMY to mark transitive splits across calls. */ 919 920void 921ipa_param_body_adjustments::register_replacement (ipa_adjusted_param *apm, 922 tree replacement, 923 tree dummy) 924{ 925 gcc_checking_assert (apm->op == IPA_PARAM_OP_SPLIT 926 || apm->op == IPA_PARAM_OP_NEW); 927 gcc_checking_assert (!apm->prev_clone_adjustment); 928 ipa_param_body_replacement psr; 929 psr.base = m_oparms[apm->prev_clone_index]; 930 psr.repl = replacement; 931 psr.dummy = dummy; 932 psr.unit_offset = apm->unit_offset; 933 m_replacements.safe_push (psr); 934} 935 936/* Copy or not, as appropriate given m_id and decl context, a pre-existing 937 PARM_DECL T so that it can be included in the parameters of the modified 938 function. */ 939 940tree 941ipa_param_body_adjustments::carry_over_param (tree t) 942{ 943 tree new_parm; 944 if (m_id) 945 { 946 new_parm = remap_decl (t, m_id); 947 if (TREE_CODE (new_parm) != PARM_DECL) 948 new_parm = m_id->copy_decl (t, m_id); 949 } 950 else if (DECL_CONTEXT (t) != m_fndecl) 951 { 952 new_parm = copy_node (t); 953 DECL_CONTEXT (new_parm) = m_fndecl; 954 } 955 else 956 new_parm = t; 957 return new_parm; 958} 959 960/* Common initialization performed by all ipa_param_body_adjustments 961 constructors. OLD_FNDECL is the declaration we take original arguments 962 from, (it may be the same as M_FNDECL). VARS, if non-NULL, is a pointer to 963 a chained list of new local variables. TREE_MAP is the IPA-CP produced 964 mapping of trees to constants. 965 966 The function is rather long but it really onlu initializes all data members 967 of the class. It creates new param DECLs, finds their new types, */ 968 969void 970ipa_param_body_adjustments::common_initialization (tree old_fndecl, 971 tree *vars, 972 vec<ipa_replace_map *, 973 va_gc> *tree_map) 974{ 975 push_function_arg_decls (&m_oparms, old_fndecl); 976 auto_vec<tree,16> otypes; 977 if (TYPE_ARG_TYPES (TREE_TYPE (old_fndecl)) != NULL_TREE) 978 push_function_arg_types (&otypes, TREE_TYPE (old_fndecl)); 979 else 980 { 981 auto_vec<tree,16> oparms; 982 push_function_arg_decls (&oparms, old_fndecl); 983 unsigned ocount = oparms.length (); 984 otypes.reserve_exact (ocount); 985 for (unsigned i = 0; i < ocount; i++) 986 otypes.quick_push (TREE_TYPE (oparms[i])); 987 } 988 fill_vector_of_new_param_types (&m_new_types, &otypes, m_adj_params, true); 989 990 auto_vec<bool, 16> kept; 991 kept.reserve_exact (m_oparms.length ()); 992 kept.quick_grow_cleared (m_oparms.length ()); 993 auto_vec<tree, 16> isra_dummy_decls; 994 isra_dummy_decls.reserve_exact (m_oparms.length ()); 995 isra_dummy_decls.quick_grow_cleared (m_oparms.length ()); 996 997 unsigned adj_len = vec_safe_length (m_adj_params); 998 m_method2func = ((TREE_CODE (TREE_TYPE (m_fndecl)) == METHOD_TYPE) 999 && (adj_len == 0 1000 || (*m_adj_params)[0].op != IPA_PARAM_OP_COPY 1001 || (*m_adj_params)[0].base_index != 0)); 1002 1003 /* The main job of the this function is to go over the vector of adjusted 1004 parameters and create declarations or find corresponding old ones and push 1005 them to m_new_decls. For IPA-SRA replacements it also creates 1006 corresponding m_id->dst_node->clone.performed_splits entries. */ 1007 1008 m_new_decls.reserve_exact (adj_len); 1009 for (unsigned i = 0; i < adj_len ; i++) 1010 { 1011 ipa_adjusted_param *apm = &(*m_adj_params)[i]; 1012 unsigned prev_index = apm->prev_clone_index; 1013 tree new_parm; 1014 if (apm->op == IPA_PARAM_OP_COPY 1015 || apm->prev_clone_adjustment) 1016 { 1017 kept[prev_index] = true; 1018 new_parm = carry_over_param (m_oparms[prev_index]); 1019 m_new_decls.quick_push (new_parm); 1020 } 1021 else if (apm->op == IPA_PARAM_OP_NEW 1022 || apm->op == IPA_PARAM_OP_SPLIT) 1023 { 1024 tree new_type = m_new_types[i]; 1025 gcc_checking_assert (new_type); 1026 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE, 1027 new_type); 1028 const char *prefix = ipa_param_prefixes[apm->param_prefix_index]; 1029 DECL_NAME (new_parm) = create_tmp_var_name (prefix); 1030 DECL_ARTIFICIAL (new_parm) = 1; 1031 DECL_ARG_TYPE (new_parm) = new_type; 1032 DECL_CONTEXT (new_parm) = m_fndecl; 1033 TREE_USED (new_parm) = 1; 1034 DECL_IGNORED_P (new_parm) = 1; 1035 /* We assume all newly created arguments are not addressable. */ 1036 if (TREE_CODE (new_type) == COMPLEX_TYPE 1037 || TREE_CODE (new_type) == VECTOR_TYPE) 1038 DECL_GIMPLE_REG_P (new_parm) = 1; 1039 layout_decl (new_parm, 0); 1040 m_new_decls.quick_push (new_parm); 1041 1042 if (apm->op == IPA_PARAM_OP_SPLIT) 1043 { 1044 m_split_modifications_p = true; 1045 1046 if (m_id) 1047 { 1048 tree dummy_decl; 1049 if (!isra_dummy_decls[prev_index]) 1050 { 1051 dummy_decl = copy_decl_to_var (m_oparms[prev_index], 1052 m_id); 1053 /* Any attempt to remap this dummy in this particular 1054 instance of clone materialization should yield 1055 itself. */ 1056 insert_decl_map (m_id, dummy_decl, dummy_decl); 1057 1058 DECL_CHAIN (dummy_decl) = *vars; 1059 *vars = dummy_decl; 1060 isra_dummy_decls[prev_index] = dummy_decl; 1061 } 1062 else 1063 dummy_decl = isra_dummy_decls[prev_index]; 1064 1065 register_replacement (apm, new_parm, dummy_decl); 1066 ipa_param_performed_split ps; 1067 ps.dummy_decl = dummy_decl; 1068 ps.unit_offset = apm->unit_offset; 1069 vec_safe_push (m_id->dst_node->clone.performed_splits, ps); 1070 } 1071 else 1072 register_replacement (apm, new_parm); 1073 } 1074 } 1075 else 1076 gcc_unreachable (); 1077 } 1078 1079 1080 /* As part of body modifications, we will also have to replace remaining uses 1081 of remaining uses of removed PARM_DECLs (which do not however use the 1082 initial value) with their VAR_DECL copies. 1083 1084 We do this differently with and without m_id. With m_id, we rely on its 1085 mapping and create a replacement straight away. Without it, we have our 1086 own mechanism for which we have to populate m_removed_decls vector. Just 1087 don't mix them, that is why you should not call 1088 replace_removed_params_ssa_names or perform_cfun_body_modifications when 1089 you construct with ID not equal to NULL. */ 1090 1091 unsigned op_len = m_oparms.length (); 1092 for (unsigned i = 0; i < op_len; i++) 1093 if (!kept[i]) 1094 { 1095 if (m_id) 1096 { 1097 if (!m_id->decl_map->get (m_oparms[i])) 1098 { 1099 /* TODO: Perhaps at least aggregate-type params could re-use 1100 their isra_dummy_decl here? */ 1101 tree var = copy_decl_to_var (m_oparms[i], m_id); 1102 insert_decl_map (m_id, m_oparms[i], var); 1103 /* Declare this new variable. */ 1104 DECL_CHAIN (var) = *vars; 1105 *vars = var; 1106 } 1107 } 1108 else 1109 { 1110 m_removed_decls.safe_push (m_oparms[i]); 1111 m_removed_map.put (m_oparms[i], m_removed_decls.length () - 1); 1112 } 1113 } 1114 1115 if (!MAY_HAVE_DEBUG_STMTS) 1116 return; 1117 1118 /* Finally, when generating debug info, we fill vector m_reset_debug_decls 1119 with removed parameters declarations. We do this in order to re-map their 1120 debug bind statements and create debug decls for them. */ 1121 1122 if (tree_map) 1123 { 1124 /* Do not output debuginfo for parameter declarations as if they vanished 1125 when they were in fact replaced by a constant. */ 1126 auto_vec <int, 16> index_mapping; 1127 bool need_remap = false; 1128 1129 if (m_id && m_id->src_node->clone.param_adjustments) 1130 { 1131 ipa_param_adjustments *prev_adjustments 1132 = m_id->src_node->clone.param_adjustments; 1133 prev_adjustments->get_updated_indices (&index_mapping); 1134 need_remap = true; 1135 } 1136 1137 for (unsigned i = 0; i < tree_map->length (); i++) 1138 { 1139 int parm_num = (*tree_map)[i]->parm_num; 1140 gcc_assert (parm_num >= 0); 1141 if (need_remap) 1142 parm_num = index_mapping[parm_num]; 1143 kept[parm_num] = true; 1144 } 1145 } 1146 1147 for (unsigned i = 0; i < op_len; i++) 1148 if (!kept[i] && is_gimple_reg (m_oparms[i])) 1149 m_reset_debug_decls.safe_push (m_oparms[i]); 1150} 1151 1152/* Constructor of ipa_param_body_adjustments from a simple list of 1153 modifications to parameters listed in ADJ_PARAMS which will prepare ground 1154 for modification of parameters of fndecl. Return value of the function will 1155 not be removed and the object will assume it does not run as a part of 1156 tree-function_versioning. */ 1157 1158ipa_param_body_adjustments 1159::ipa_param_body_adjustments (vec<ipa_adjusted_param, va_gc> *adj_params, 1160 tree fndecl) 1161 : m_adj_params (adj_params), m_adjustments (NULL), m_reset_debug_decls (), 1162 m_split_modifications_p (false), m_fndecl (fndecl), m_id (NULL), 1163 m_oparms (), m_new_decls (), m_new_types (), m_replacements (), 1164 m_removed_decls (), m_removed_map (), m_method2func (false) 1165{ 1166 common_initialization (fndecl, NULL, NULL); 1167} 1168 1169/* Constructor of ipa_param_body_adjustments from ipa_param_adjustments in 1170 ADJUSTMENTS which will prepare ground for modification of parameters of 1171 fndecl. The object will assume it does not run as a part of 1172 tree-function_versioning. */ 1173 1174ipa_param_body_adjustments 1175::ipa_param_body_adjustments (ipa_param_adjustments *adjustments, 1176 tree fndecl) 1177 : m_adj_params (adjustments->m_adj_params), m_adjustments (adjustments), 1178 m_reset_debug_decls (), m_split_modifications_p (false), m_fndecl (fndecl), 1179 m_id (NULL), m_oparms (), m_new_decls (), m_new_types (), 1180 m_replacements (), m_removed_decls (), m_removed_map (), 1181 m_method2func (false) 1182{ 1183 common_initialization (fndecl, NULL, NULL); 1184} 1185 1186/* Constructor of ipa_param_body_adjustments which sets it up as a part of 1187 running tree_function_versioning. Planned modifications to the function are 1188 in ADJUSTMENTS. FNDECL designates the new function clone which is being 1189 modified. OLD_FNDECL is the function of which FNDECL is a clone (and which 1190 at the time of invocation still share DECL_ARGUMENTS). ID is the 1191 copy_body_data structure driving the wholy body copying process. VARS is a 1192 pointer to the head of the list of new local variables, TREE_MAP is the map 1193 that drives tree substitution in the cloning process. */ 1194 1195ipa_param_body_adjustments 1196::ipa_param_body_adjustments (ipa_param_adjustments *adjustments, 1197 tree fndecl, tree old_fndecl, 1198 copy_body_data *id, tree *vars, 1199 vec<ipa_replace_map *, va_gc> *tree_map) 1200 : m_adj_params (adjustments->m_adj_params), m_adjustments (adjustments), 1201 m_reset_debug_decls (), m_split_modifications_p (false), m_fndecl (fndecl), 1202 m_id (id), m_oparms (), m_new_decls (), m_new_types (), m_replacements (), 1203 m_removed_decls (), m_removed_map (), m_method2func (false) 1204{ 1205 common_initialization (old_fndecl, vars, tree_map); 1206} 1207 1208/* Chain new param decls up and return them. */ 1209 1210tree 1211ipa_param_body_adjustments::get_new_param_chain () 1212{ 1213 tree result; 1214 tree *link = &result; 1215 1216 unsigned len = vec_safe_length (m_adj_params); 1217 for (unsigned i = 0; i < len; i++) 1218 { 1219 tree new_decl = m_new_decls[i]; 1220 *link = new_decl; 1221 link = &DECL_CHAIN (new_decl); 1222 } 1223 *link = NULL_TREE; 1224 return result; 1225} 1226 1227/* Modify the function parameters FNDECL and its type according to the plan in 1228 ADJUSTMENTS. This function needs to be called when the decl has not already 1229 been processed with ipa_param_adjustments::adjust_decl, otherwise just 1230 seting DECL_ARGUMENTS to whatever get_new_param_chain will do is enough. */ 1231 1232void 1233ipa_param_body_adjustments::modify_formal_parameters () 1234{ 1235 tree orig_type = TREE_TYPE (m_fndecl); 1236 DECL_ARGUMENTS (m_fndecl) = get_new_param_chain (); 1237 1238 /* When signature changes, we need to clear builtin info. */ 1239 if (fndecl_built_in_p (m_fndecl)) 1240 set_decl_built_in_function (m_fndecl, NOT_BUILT_IN, 0); 1241 1242 /* At this point, removing return value is only implemented when going 1243 through tree_function_versioning, not when modifying function body 1244 directly. */ 1245 gcc_assert (!m_adjustments || !m_adjustments->m_skip_return); 1246 tree new_type = build_adjusted_function_type (orig_type, &m_new_types, 1247 m_method2func, false); 1248 1249 TREE_TYPE (m_fndecl) = new_type; 1250 DECL_VIRTUAL_P (m_fndecl) = 0; 1251 DECL_LANG_SPECIFIC (m_fndecl) = NULL; 1252 if (m_method2func) 1253 DECL_VINDEX (m_fndecl) = NULL_TREE; 1254} 1255 1256/* Given BASE and UNIT_OFFSET, find the corresponding record among replacement 1257 structures. */ 1258 1259ipa_param_body_replacement * 1260ipa_param_body_adjustments::lookup_replacement_1 (tree base, 1261 unsigned unit_offset) 1262{ 1263 unsigned int len = m_replacements.length (); 1264 for (unsigned i = 0; i < len; i++) 1265 { 1266 ipa_param_body_replacement *pbr = &m_replacements[i]; 1267 1268 if (pbr->base == base 1269 && (pbr->unit_offset == unit_offset)) 1270 return pbr; 1271 } 1272 return NULL; 1273} 1274 1275/* Given BASE and UNIT_OFFSET, find the corresponding replacement expression 1276 and return it, assuming it is known it does not hold value by reference or 1277 in reverse storage order. */ 1278 1279tree 1280ipa_param_body_adjustments::lookup_replacement (tree base, unsigned unit_offset) 1281{ 1282 ipa_param_body_replacement *pbr = lookup_replacement_1 (base, unit_offset); 1283 if (!pbr) 1284 return NULL; 1285 return pbr->repl; 1286} 1287 1288/* If T is an SSA_NAME, return NULL if it is not a default def or 1289 return its base variable if it is. If IGNORE_DEFAULT_DEF is true, 1290 the base variable is always returned, regardless if it is a default 1291 def. Return T if it is not an SSA_NAME. */ 1292 1293static tree 1294get_ssa_base_param (tree t, bool ignore_default_def) 1295{ 1296 if (TREE_CODE (t) == SSA_NAME) 1297 { 1298 if (ignore_default_def || SSA_NAME_IS_DEFAULT_DEF (t)) 1299 return SSA_NAME_VAR (t); 1300 else 1301 return NULL_TREE; 1302 } 1303 return t; 1304} 1305 1306/* Given an expression, return the structure describing how it should be 1307 replaced if it accesses a part of a split parameter or NULL otherwise. 1308 1309 Do not free the result, it will be deallocated when the object is destroyed. 1310 1311 If IGNORE_DEFAULT_DEF is cleared, consider only SSA_NAMEs of PARM_DECLs 1312 which are default definitions, if set, consider all SSA_NAMEs of 1313 PARM_DECLs. */ 1314 1315ipa_param_body_replacement * 1316ipa_param_body_adjustments::get_expr_replacement (tree expr, 1317 bool ignore_default_def) 1318{ 1319 tree base; 1320 unsigned unit_offset; 1321 1322 if (!isra_get_ref_base_and_offset (expr, &base, &unit_offset)) 1323 return NULL; 1324 1325 base = get_ssa_base_param (base, ignore_default_def); 1326 if (!base || TREE_CODE (base) != PARM_DECL) 1327 return NULL; 1328 return lookup_replacement_1 (base, unit_offset); 1329} 1330 1331/* Given OLD_DECL, which is a PARM_DECL of a parameter that is being removed 1332 (which includes it being split or replaced), return a new variable that 1333 should be used for any SSA names that will remain in the function that 1334 previously belonged to OLD_DECL. */ 1335 1336tree 1337ipa_param_body_adjustments::get_replacement_ssa_base (tree old_decl) 1338{ 1339 unsigned *idx = m_removed_map.get (old_decl); 1340 if (!idx) 1341 return NULL; 1342 1343 tree repl; 1344 if (TREE_CODE (m_removed_decls[*idx]) == PARM_DECL) 1345 { 1346 gcc_assert (m_removed_decls[*idx] == old_decl); 1347 repl = copy_var_decl (old_decl, DECL_NAME (old_decl), 1348 TREE_TYPE (old_decl)); 1349 m_removed_decls[*idx] = repl; 1350 } 1351 else 1352 repl = m_removed_decls[*idx]; 1353 return repl; 1354} 1355 1356/* If OLD_NAME, which is being defined by statement STMT, is an SSA_NAME of a 1357 parameter which is to be removed because its value is not used, create a new 1358 SSA_NAME relating to a replacement VAR_DECL, replace all uses of the 1359 original with it and return it. If there is no need to re-map, return NULL. 1360 ADJUSTMENTS is a pointer to a vector of IPA-SRA adjustments. */ 1361 1362tree 1363ipa_param_body_adjustments::replace_removed_params_ssa_names (tree old_name, 1364 gimple *stmt) 1365{ 1366 gcc_assert (!m_id); 1367 if (TREE_CODE (old_name) != SSA_NAME) 1368 return NULL; 1369 1370 tree decl = SSA_NAME_VAR (old_name); 1371 if (decl == NULL_TREE 1372 || TREE_CODE (decl) != PARM_DECL) 1373 return NULL; 1374 1375 tree repl = get_replacement_ssa_base (decl); 1376 if (!repl) 1377 return NULL; 1378 1379 tree new_name = make_ssa_name (repl, stmt); 1380 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_name) 1381 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (old_name); 1382 1383 if (dump_file && (dump_flags & TDF_DETAILS)) 1384 { 1385 fprintf (dump_file, "replacing an SSA name of a removed param "); 1386 print_generic_expr (dump_file, old_name); 1387 fprintf (dump_file, " with "); 1388 print_generic_expr (dump_file, new_name); 1389 fprintf (dump_file, "\n"); 1390 } 1391 1392 replace_uses_by (old_name, new_name); 1393 return new_name; 1394} 1395 1396/* If the expression *EXPR_P should be replaced, do so. CONVERT specifies 1397 whether the function should care about type incompatibility of the current 1398 and new expressions. If it is false, the function will leave 1399 incompatibility issues to the caller - note that when the function 1400 encounters a BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR, it will modify 1401 their bases instead of the expressions themselves and then also performs any 1402 necessary conversions. */ 1403 1404bool 1405ipa_param_body_adjustments::modify_expression (tree *expr_p, bool convert) 1406{ 1407 tree expr = *expr_p; 1408 1409 if (TREE_CODE (expr) == BIT_FIELD_REF 1410 || TREE_CODE (expr) == IMAGPART_EXPR 1411 || TREE_CODE (expr) == REALPART_EXPR) 1412 { 1413 expr_p = &TREE_OPERAND (expr, 0); 1414 expr = *expr_p; 1415 convert = true; 1416 } 1417 1418 ipa_param_body_replacement *pbr = get_expr_replacement (expr, false); 1419 if (!pbr) 1420 return false; 1421 1422 tree repl = pbr->repl; 1423 if (dump_file && (dump_flags & TDF_DETAILS)) 1424 { 1425 fprintf (dump_file, "About to replace expr "); 1426 print_generic_expr (dump_file, expr); 1427 fprintf (dump_file, " with "); 1428 print_generic_expr (dump_file, repl); 1429 fprintf (dump_file, "\n"); 1430 } 1431 1432 if (convert && !useless_type_conversion_p (TREE_TYPE (expr), 1433 TREE_TYPE (repl))) 1434 { 1435 tree vce = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (expr), repl); 1436 *expr_p = vce; 1437 } 1438 else 1439 *expr_p = repl; 1440 return true; 1441} 1442 1443/* If the assignment statement STMT contains any expressions that need to 1444 replaced with a different one as noted by ADJUSTMENTS, do so. Handle any 1445 potential type incompatibilities. If any conversion sttements have to be 1446 pre-pended to STMT, they will be added to EXTRA_STMTS. Return true iff the 1447 statement was modified. */ 1448 1449bool 1450ipa_param_body_adjustments::modify_assignment (gimple *stmt, 1451 gimple_seq *extra_stmts) 1452{ 1453 tree *lhs_p, *rhs_p; 1454 bool any; 1455 1456 if (!gimple_assign_single_p (stmt)) 1457 return false; 1458 1459 rhs_p = gimple_assign_rhs1_ptr (stmt); 1460 lhs_p = gimple_assign_lhs_ptr (stmt); 1461 1462 any = modify_expression (lhs_p, false); 1463 any |= modify_expression (rhs_p, false); 1464 if (any 1465 && !useless_type_conversion_p (TREE_TYPE (*lhs_p), TREE_TYPE (*rhs_p))) 1466 { 1467 if (TREE_CODE (*rhs_p) == CONSTRUCTOR) 1468 { 1469 /* V_C_Es of constructors can cause trouble (PR 42714). */ 1470 if (is_gimple_reg_type (TREE_TYPE (*lhs_p))) 1471 *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p)); 1472 else 1473 *rhs_p = build_constructor (TREE_TYPE (*lhs_p), 1474 NULL); 1475 } 1476 else 1477 { 1478 tree new_rhs = fold_build1_loc (gimple_location (stmt), 1479 VIEW_CONVERT_EXPR, TREE_TYPE (*lhs_p), 1480 *rhs_p); 1481 tree tmp = force_gimple_operand (new_rhs, extra_stmts, true, 1482 NULL_TREE); 1483 gimple_assign_set_rhs1 (stmt, tmp); 1484 } 1485 return true; 1486 } 1487 1488 return any; 1489} 1490 1491/* Data passed to remap_split_decl_to_dummy through walk_tree. */ 1492 1493struct simple_tree_swap_info 1494{ 1495 /* Change FROM to TO. */ 1496 tree from, to; 1497 /* And set DONE to true when doing so. */ 1498 bool done; 1499}; 1500 1501/* Simple remapper to remap a split parameter to the same expression based on a 1502 special dummy decl so that edge redirections can detect transitive splitting 1503 and finish them. */ 1504 1505static tree 1506remap_split_decl_to_dummy (tree *tp, int *walk_subtrees, void *data) 1507{ 1508 tree t = *tp; 1509 1510 if (DECL_P (t) || TREE_CODE (t) == SSA_NAME) 1511 { 1512 struct simple_tree_swap_info *swapinfo 1513 = (struct simple_tree_swap_info *) data; 1514 if (t == swapinfo->from 1515 || (TREE_CODE (t) == SSA_NAME 1516 && SSA_NAME_VAR (t) == swapinfo->from)) 1517 { 1518 *tp = swapinfo->to; 1519 swapinfo->done = true; 1520 } 1521 *walk_subtrees = 0; 1522 } 1523 else if (TYPE_P (t)) 1524 *walk_subtrees = 0; 1525 else 1526 *walk_subtrees = 1; 1527 return NULL_TREE; 1528} 1529 1530 1531/* If the call statement pointed at by STMT_P contains any expressions that 1532 need to replaced with a different one as noted by ADJUSTMENTS, do so. f the 1533 statement needs to be rebuilt, do so. Return true if any modifications have 1534 been performed. 1535 1536 If the method is invoked as a part of IPA clone materialization and if any 1537 parameter split is transitive, i.e. it applies to the functin that is being 1538 modified and also to the callee of the statement, replace the parameter 1539 passed to old callee with an equivalent expression based on a dummy decl 1540 followed by PARM_DECLs representing the actual replacements. The actual 1541 replacements will be then converted into SSA_NAMEs and then 1542 ipa_param_adjustments::modify_call will find the appropriate ones and leave 1543 only those in the call. */ 1544 1545bool 1546ipa_param_body_adjustments::modify_call_stmt (gcall **stmt_p) 1547{ 1548 gcall *stmt = *stmt_p; 1549 auto_vec <unsigned, 4> pass_through_args; 1550 auto_vec <unsigned, 4> pass_through_pbr_indices; 1551 1552 if (m_split_modifications_p && m_id) 1553 { 1554 for (unsigned i = 0; i < gimple_call_num_args (stmt); i++) 1555 { 1556 tree t = gimple_call_arg (stmt, i); 1557 gcc_assert (TREE_CODE (t) != BIT_FIELD_REF 1558 && TREE_CODE (t) != IMAGPART_EXPR 1559 && TREE_CODE (t) != REALPART_EXPR); 1560 1561 tree base; 1562 unsigned unit_offset; 1563 if (!isra_get_ref_base_and_offset (t, &base, &unit_offset)) 1564 continue; 1565 1566 bool by_ref = false; 1567 if (TREE_CODE (base) == SSA_NAME) 1568 { 1569 if (!SSA_NAME_IS_DEFAULT_DEF (base)) 1570 continue; 1571 base = SSA_NAME_VAR (base); 1572 gcc_checking_assert (base); 1573 by_ref = true; 1574 } 1575 if (TREE_CODE (base) != PARM_DECL) 1576 continue; 1577 1578 bool base_among_replacements = false; 1579 unsigned j, repl_list_len = m_replacements.length (); 1580 for (j = 0; j < repl_list_len; j++) 1581 { 1582 ipa_param_body_replacement *pbr = &m_replacements[j]; 1583 if (pbr->base == base) 1584 { 1585 base_among_replacements = true; 1586 break; 1587 } 1588 } 1589 if (!base_among_replacements) 1590 continue; 1591 1592 /* We still have to distinguish between an end-use that we have to 1593 transform now and a pass-through, which happens in the following 1594 two cases. */ 1595 1596 /* TODO: After we adjust ptr_parm_has_nonarg_uses to also consider 1597 &MEM_REF[ssa_name + offset], we will also have to detect that case 1598 here. */ 1599 1600 if (TREE_CODE (t) == SSA_NAME 1601 && SSA_NAME_IS_DEFAULT_DEF (t) 1602 && SSA_NAME_VAR (t) 1603 && TREE_CODE (SSA_NAME_VAR (t)) == PARM_DECL) 1604 { 1605 /* This must be a by_reference pass-through. */ 1606 gcc_assert (POINTER_TYPE_P (TREE_TYPE (t))); 1607 pass_through_args.safe_push (i); 1608 pass_through_pbr_indices.safe_push (j); 1609 } 1610 else if (!by_ref && AGGREGATE_TYPE_P (TREE_TYPE (t))) 1611 { 1612 /* Currently IPA-SRA guarantees the aggregate access type 1613 exactly matches in this case. So if it does not match, it is 1614 a pass-through argument that will be sorted out at edge 1615 redirection time. */ 1616 ipa_param_body_replacement *pbr 1617 = lookup_replacement_1 (base, unit_offset); 1618 1619 if (!pbr 1620 || (TYPE_MAIN_VARIANT (TREE_TYPE (t)) 1621 != TYPE_MAIN_VARIANT (TREE_TYPE (pbr->repl)))) 1622 { 1623 pass_through_args.safe_push (i); 1624 pass_through_pbr_indices.safe_push (j); 1625 } 1626 } 1627 } 1628 } 1629 1630 unsigned nargs = gimple_call_num_args (stmt); 1631 if (!pass_through_args.is_empty ()) 1632 { 1633 auto_vec<tree, 16> vargs; 1634 unsigned pt_idx = 0; 1635 for (unsigned i = 0; i < nargs; i++) 1636 { 1637 if (pt_idx < pass_through_args.length () 1638 && i == pass_through_args[pt_idx]) 1639 { 1640 unsigned j = pass_through_pbr_indices[pt_idx]; 1641 pt_idx++; 1642 tree base = m_replacements[j].base; 1643 1644 /* Map base will get mapped to the special transitive-isra marker 1645 dummy decl. */ 1646 struct simple_tree_swap_info swapinfo; 1647 swapinfo.from = base; 1648 swapinfo.to = m_replacements[j].dummy; 1649 swapinfo.done = false; 1650 tree arg = gimple_call_arg (stmt, i); 1651 walk_tree (&arg, remap_split_decl_to_dummy, &swapinfo, NULL); 1652 gcc_assert (swapinfo.done); 1653 vargs.safe_push (arg); 1654 /* Now let's push all replacements pertaining to this parameter 1655 so that all gimple register ones get correct SSA_NAMES. Edge 1656 redirection will weed out the dummy argument as well as all 1657 unused replacements later. */ 1658 unsigned int repl_list_len = m_replacements.length (); 1659 for (; j < repl_list_len; j++) 1660 { 1661 if (m_replacements[j].base != base) 1662 break; 1663 vargs.safe_push (m_replacements[j].repl); 1664 } 1665 } 1666 else 1667 { 1668 tree t = gimple_call_arg (stmt, i); 1669 modify_expression (&t, true); 1670 vargs.safe_push (t); 1671 } 1672 } 1673 gcall *new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs); 1674 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt)); 1675 gimple_call_copy_flags (new_stmt, stmt); 1676 if (tree lhs = gimple_call_lhs (stmt)) 1677 { 1678 modify_expression (&lhs, false); 1679 /* Avoid adjusting SSA_NAME_DEF_STMT of a SSA lhs, SSA names 1680 have not yet been remapped. */ 1681 *gimple_call_lhs_ptr (new_stmt) = lhs; 1682 } 1683 *stmt_p = new_stmt; 1684 return true; 1685 } 1686 1687 /* Otherwise, no need to rebuild the statement, let's just modify arguments 1688 and the LHS if/as appropriate. */ 1689 bool modified = false; 1690 for (unsigned i = 0; i < nargs; i++) 1691 { 1692 tree *t = gimple_call_arg_ptr (stmt, i); 1693 modified |= modify_expression (t, true); 1694 } 1695 1696 if (gimple_call_lhs (stmt)) 1697 { 1698 tree *t = gimple_call_lhs_ptr (stmt); 1699 modified |= modify_expression (t, false); 1700 } 1701 1702 return modified; 1703} 1704 1705/* If the statement STMT contains any expressions that need to replaced with a 1706 different one as noted by ADJUSTMENTS, do so. Handle any potential type 1707 incompatibilities. If any conversion sttements have to be pre-pended to 1708 STMT, they will be added to EXTRA_STMTS. Return true iff the statement was 1709 modified. */ 1710 1711bool 1712ipa_param_body_adjustments::modify_gimple_stmt (gimple **stmt, 1713 gimple_seq *extra_stmts) 1714{ 1715 bool modified = false; 1716 tree *t; 1717 1718 switch (gimple_code (*stmt)) 1719 { 1720 case GIMPLE_RETURN: 1721 t = gimple_return_retval_ptr (as_a <greturn *> (*stmt)); 1722 if (m_adjustments && m_adjustments->m_skip_return) 1723 *t = NULL_TREE; 1724 else if (*t != NULL_TREE) 1725 modified |= modify_expression (t, true); 1726 break; 1727 1728 case GIMPLE_ASSIGN: 1729 modified |= modify_assignment (*stmt, extra_stmts); 1730 break; 1731 1732 case GIMPLE_CALL: 1733 modified |= modify_call_stmt ((gcall **) stmt); 1734 break; 1735 1736 case GIMPLE_ASM: 1737 { 1738 gasm *asm_stmt = as_a <gasm *> (*stmt); 1739 for (unsigned i = 0; i < gimple_asm_ninputs (asm_stmt); i++) 1740 { 1741 t = &TREE_VALUE (gimple_asm_input_op (asm_stmt, i)); 1742 modified |= modify_expression (t, true); 1743 } 1744 for (unsigned i = 0; i < gimple_asm_noutputs (asm_stmt); i++) 1745 { 1746 t = &TREE_VALUE (gimple_asm_output_op (asm_stmt, i)); 1747 modified |= modify_expression (t, false); 1748 } 1749 } 1750 break; 1751 1752 default: 1753 break; 1754 } 1755 return modified; 1756} 1757 1758 1759/* Traverse body of the current function and perform the requested adjustments 1760 on its statements. Return true iff the CFG has been changed. */ 1761 1762bool 1763ipa_param_body_adjustments::modify_cfun_body () 1764{ 1765 bool cfg_changed = false; 1766 basic_block bb; 1767 1768 FOR_EACH_BB_FN (bb, cfun) 1769 { 1770 gimple_stmt_iterator gsi; 1771 1772 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 1773 { 1774 gphi *phi = as_a <gphi *> (gsi_stmt (gsi)); 1775 tree new_lhs, old_lhs = gimple_phi_result (phi); 1776 new_lhs = replace_removed_params_ssa_names (old_lhs, phi); 1777 if (new_lhs) 1778 { 1779 gimple_phi_set_result (phi, new_lhs); 1780 release_ssa_name (old_lhs); 1781 } 1782 } 1783 1784 gsi = gsi_start_bb (bb); 1785 while (!gsi_end_p (gsi)) 1786 { 1787 gimple *stmt = gsi_stmt (gsi); 1788 gimple *stmt_copy = stmt; 1789 gimple_seq extra_stmts = NULL; 1790 bool modified = modify_gimple_stmt (&stmt, &extra_stmts); 1791 if (stmt != stmt_copy) 1792 { 1793 gcc_checking_assert (modified); 1794 gsi_replace (&gsi, stmt, false); 1795 } 1796 if (!gimple_seq_empty_p (extra_stmts)) 1797 gsi_insert_seq_before (&gsi, extra_stmts, GSI_SAME_STMT); 1798 1799 def_operand_p defp; 1800 ssa_op_iter iter; 1801 FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_DEF) 1802 { 1803 tree old_def = DEF_FROM_PTR (defp); 1804 if (tree new_def = replace_removed_params_ssa_names (old_def, 1805 stmt)) 1806 { 1807 SET_DEF (defp, new_def); 1808 release_ssa_name (old_def); 1809 modified = true; 1810 } 1811 } 1812 1813 if (modified) 1814 { 1815 update_stmt (stmt); 1816 if (maybe_clean_eh_stmt (stmt) 1817 && gimple_purge_dead_eh_edges (gimple_bb (stmt))) 1818 cfg_changed = true; 1819 } 1820 gsi_next (&gsi); 1821 } 1822 } 1823 1824 return cfg_changed; 1825} 1826 1827/* Call gimple_debug_bind_reset_value on all debug statements describing 1828 gimple register parameters that are being removed or replaced. */ 1829 1830void 1831ipa_param_body_adjustments::reset_debug_stmts () 1832{ 1833 int i, len; 1834 gimple_stmt_iterator *gsip = NULL, gsi; 1835 1836 if (MAY_HAVE_DEBUG_STMTS && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun))) 1837 { 1838 gsi = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun))); 1839 gsip = &gsi; 1840 } 1841 len = m_reset_debug_decls.length (); 1842 for (i = 0; i < len; i++) 1843 { 1844 imm_use_iterator ui; 1845 gimple *stmt; 1846 gdebug *def_temp; 1847 tree name, vexpr, copy = NULL_TREE; 1848 use_operand_p use_p; 1849 tree decl = m_reset_debug_decls[i]; 1850 1851 gcc_checking_assert (is_gimple_reg (decl)); 1852 name = ssa_default_def (cfun, decl); 1853 vexpr = NULL; 1854 if (name) 1855 FOR_EACH_IMM_USE_STMT (stmt, ui, name) 1856 { 1857 if (gimple_clobber_p (stmt)) 1858 { 1859 gimple_stmt_iterator cgsi = gsi_for_stmt (stmt); 1860 unlink_stmt_vdef (stmt); 1861 gsi_remove (&cgsi, true); 1862 release_defs (stmt); 1863 continue; 1864 } 1865 /* All other users must have been removed by function body 1866 modification. */ 1867 gcc_assert (is_gimple_debug (stmt)); 1868 if (vexpr == NULL && gsip != NULL) 1869 { 1870 vexpr = make_node (DEBUG_EXPR_DECL); 1871 def_temp = gimple_build_debug_source_bind (vexpr, decl, NULL); 1872 DECL_ARTIFICIAL (vexpr) = 1; 1873 TREE_TYPE (vexpr) = TREE_TYPE (name); 1874 SET_DECL_MODE (vexpr, DECL_MODE (decl)); 1875 gsi_insert_before (gsip, def_temp, GSI_SAME_STMT); 1876 } 1877 if (vexpr) 1878 { 1879 FOR_EACH_IMM_USE_ON_STMT (use_p, ui) 1880 SET_USE (use_p, vexpr); 1881 } 1882 else 1883 gimple_debug_bind_reset_value (stmt); 1884 update_stmt (stmt); 1885 } 1886 /* Create a VAR_DECL for debug info purposes. */ 1887 if (!DECL_IGNORED_P (decl)) 1888 { 1889 copy = build_decl (DECL_SOURCE_LOCATION (current_function_decl), 1890 VAR_DECL, DECL_NAME (decl), 1891 TREE_TYPE (decl)); 1892 if (DECL_PT_UID_SET_P (decl)) 1893 SET_DECL_PT_UID (copy, DECL_PT_UID (decl)); 1894 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl); 1895 TREE_READONLY (copy) = TREE_READONLY (decl); 1896 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl); 1897 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl); 1898 DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl); 1899 DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl); 1900 DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl); 1901 DECL_SEEN_IN_BIND_EXPR_P (copy) = 1; 1902 SET_DECL_RTL (copy, 0); 1903 TREE_USED (copy) = 1; 1904 DECL_CONTEXT (copy) = current_function_decl; 1905 add_local_decl (cfun, copy); 1906 DECL_CHAIN (copy) 1907 = BLOCK_VARS (DECL_INITIAL (current_function_decl)); 1908 BLOCK_VARS (DECL_INITIAL (current_function_decl)) = copy; 1909 } 1910 if (gsip != NULL && copy && target_for_debug_bind (decl)) 1911 { 1912 gcc_assert (TREE_CODE (decl) == PARM_DECL); 1913 if (vexpr) 1914 def_temp = gimple_build_debug_bind (copy, vexpr, NULL); 1915 else 1916 def_temp = gimple_build_debug_source_bind (copy, decl, 1917 NULL); 1918 gsi_insert_before (gsip, def_temp, GSI_SAME_STMT); 1919 } 1920 } 1921} 1922 1923/* Perform all necessary body changes to change signature, body and debug info 1924 of fun according to adjustments passed at construction. Return true if CFG 1925 was changed in any way. The main entry point for modification of standalone 1926 functions that is not part of IPA clone materialization. */ 1927 1928bool 1929ipa_param_body_adjustments::perform_cfun_body_modifications () 1930{ 1931 bool cfg_changed; 1932 modify_formal_parameters (); 1933 cfg_changed = modify_cfun_body (); 1934 reset_debug_stmts (); 1935 1936 return cfg_changed; 1937} 1938 1939