1 /* Tree inlining. 2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 3 2012 Free Software Foundation, Inc. 4 Contributed by Alexandre Oliva <aoliva@redhat.com> 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 GCC is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "tm.h" 26 #include "diagnostic-core.h" 27 #include "tree.h" 28 #include "tree-inline.h" 29 #include "flags.h" 30 #include "params.h" 31 #include "input.h" 32 #include "insn-config.h" 33 #include "hashtab.h" 34 #include "langhooks.h" 35 #include "basic-block.h" 36 #include "tree-iterator.h" 37 #include "cgraph.h" 38 #include "intl.h" 39 #include "tree-mudflap.h" 40 #include "tree-flow.h" 41 #include "function.h" 42 #include "tree-flow.h" 43 #include "tree-pretty-print.h" 44 #include "except.h" 45 #include "debug.h" 46 #include "pointer-set.h" 47 #include "ipa-prop.h" 48 #include "value-prof.h" 49 #include "tree-pass.h" 50 #include "target.h" 51 #include "integrate.h" 52 53 #include "rtl.h" /* FIXME: For asm_str_count. */ 54 55 /* I'm not real happy about this, but we need to handle gimple and 56 non-gimple trees. */ 57 #include "gimple.h" 58 59 /* Inlining, Cloning, Versioning, Parallelization 60 61 Inlining: a function body is duplicated, but the PARM_DECLs are 62 remapped into VAR_DECLs, and non-void RETURN_EXPRs become 63 MODIFY_EXPRs that store to a dedicated returned-value variable. 64 The duplicated eh_region info of the copy will later be appended 65 to the info for the caller; the eh_region info in copied throwing 66 statements and RESX statements are adjusted accordingly. 67 68 Cloning: (only in C++) We have one body for a con/de/structor, and 69 multiple function decls, each with a unique parameter list. 70 Duplicate the body, using the given splay tree; some parameters 71 will become constants (like 0 or 1). 72 73 Versioning: a function body is duplicated and the result is a new 74 function rather than into blocks of an existing function as with 75 inlining. Some parameters will become constants. 76 77 Parallelization: a region of a function is duplicated resulting in 78 a new function. Variables may be replaced with complex expressions 79 to enable shared variable semantics. 80 81 All of these will simultaneously lookup any callgraph edges. If 82 we're going to inline the duplicated function body, and the given 83 function has some cloned callgraph nodes (one for each place this 84 function will be inlined) those callgraph edges will be duplicated. 85 If we're cloning the body, those callgraph edges will be 86 updated to point into the new body. (Note that the original 87 callgraph node and edge list will not be altered.) 88 89 See the CALL_EXPR handling case in copy_tree_body_r (). */ 90 91 /* To Do: 92 93 o In order to make inlining-on-trees work, we pessimized 94 function-local static constants. In particular, they are now 95 always output, even when not addressed. Fix this by treating 96 function-local static constants just like global static 97 constants; the back-end already knows not to output them if they 98 are not needed. 99 100 o Provide heuristics to clamp inlining of recursive template 101 calls? */ 102 103 104 /* Weights that estimate_num_insns uses to estimate the size of the 105 produced code. */ 106 107 eni_weights eni_size_weights; 108 109 /* Weights that estimate_num_insns uses to estimate the time necessary 110 to execute the produced code. */ 111 112 eni_weights eni_time_weights; 113 114 /* Prototypes. */ 115 116 static tree declare_return_variable (copy_body_data *, tree, tree, basic_block); 117 static void remap_block (tree *, copy_body_data *); 118 static void copy_bind_expr (tree *, int *, copy_body_data *); 119 static tree mark_local_for_remap_r (tree *, int *, void *); 120 static void unsave_expr_1 (tree); 121 static tree unsave_r (tree *, int *, void *); 122 static void declare_inline_vars (tree, tree); 123 static void remap_save_expr (tree *, void *, int *); 124 static void prepend_lexical_block (tree current_block, tree new_block); 125 static tree copy_decl_to_var (tree, copy_body_data *); 126 static tree copy_result_decl_to_var (tree, copy_body_data *); 127 static tree copy_decl_maybe_to_var (tree, copy_body_data *); 128 static gimple remap_gimple_stmt (gimple, copy_body_data *); 129 static bool delete_unreachable_blocks_update_callgraph (copy_body_data *id); 130 131 /* Insert a tree->tree mapping for ID. Despite the name suggests 132 that the trees should be variables, it is used for more than that. */ 133 134 void 135 insert_decl_map (copy_body_data *id, tree key, tree value) 136 { 137 *pointer_map_insert (id->decl_map, key) = value; 138 139 /* Always insert an identity map as well. If we see this same new 140 node again, we won't want to duplicate it a second time. */ 141 if (key != value) 142 *pointer_map_insert (id->decl_map, value) = value; 143 } 144 145 /* Insert a tree->tree mapping for ID. This is only used for 146 variables. */ 147 148 static void 149 insert_debug_decl_map (copy_body_data *id, tree key, tree value) 150 { 151 if (!gimple_in_ssa_p (id->src_cfun)) 152 return; 153 154 if (!MAY_HAVE_DEBUG_STMTS) 155 return; 156 157 if (!target_for_debug_bind (key)) 158 return; 159 160 gcc_assert (TREE_CODE (key) == PARM_DECL); 161 gcc_assert (TREE_CODE (value) == VAR_DECL); 162 163 if (!id->debug_map) 164 id->debug_map = pointer_map_create (); 165 166 *pointer_map_insert (id->debug_map, key) = value; 167 } 168 169 /* If nonzero, we're remapping the contents of inlined debug 170 statements. If negative, an error has occurred, such as a 171 reference to a variable that isn't available in the inlined 172 context. */ 173 static int processing_debug_stmt = 0; 174 175 /* Construct new SSA name for old NAME. ID is the inline context. */ 176 177 static tree 178 remap_ssa_name (tree name, copy_body_data *id) 179 { 180 tree new_tree; 181 tree *n; 182 183 gcc_assert (TREE_CODE (name) == SSA_NAME); 184 185 n = (tree *) pointer_map_contains (id->decl_map, name); 186 if (n) 187 return unshare_expr (*n); 188 189 if (processing_debug_stmt) 190 { 191 if (TREE_CODE (SSA_NAME_VAR (name)) == PARM_DECL 192 && SSA_NAME_IS_DEFAULT_DEF (name) 193 && id->entry_bb == NULL 194 && single_succ_p (ENTRY_BLOCK_PTR)) 195 { 196 tree vexpr = make_node (DEBUG_EXPR_DECL); 197 gimple def_temp; 198 gimple_stmt_iterator gsi; 199 tree val = SSA_NAME_VAR (name); 200 201 n = (tree *) pointer_map_contains (id->decl_map, val); 202 if (n != NULL) 203 val = *n; 204 if (TREE_CODE (val) != PARM_DECL) 205 { 206 processing_debug_stmt = -1; 207 return name; 208 } 209 def_temp = gimple_build_debug_source_bind (vexpr, val, NULL); 210 DECL_ARTIFICIAL (vexpr) = 1; 211 TREE_TYPE (vexpr) = TREE_TYPE (name); 212 DECL_MODE (vexpr) = DECL_MODE (SSA_NAME_VAR (name)); 213 gsi = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR)); 214 gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT); 215 return vexpr; 216 } 217 218 processing_debug_stmt = -1; 219 return name; 220 } 221 222 /* Do not set DEF_STMT yet as statement is not copied yet. We do that 223 in copy_bb. */ 224 new_tree = remap_decl (SSA_NAME_VAR (name), id); 225 226 /* We might've substituted constant or another SSA_NAME for 227 the variable. 228 229 Replace the SSA name representing RESULT_DECL by variable during 230 inlining: this saves us from need to introduce PHI node in a case 231 return value is just partly initialized. */ 232 if ((TREE_CODE (new_tree) == VAR_DECL || TREE_CODE (new_tree) == PARM_DECL) 233 && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL 234 || !id->transform_return_to_modify)) 235 { 236 struct ptr_info_def *pi; 237 new_tree = make_ssa_name (new_tree, NULL); 238 insert_decl_map (id, name, new_tree); 239 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree) 240 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name); 241 TREE_TYPE (new_tree) = TREE_TYPE (SSA_NAME_VAR (new_tree)); 242 /* At least IPA points-to info can be directly transferred. */ 243 if (id->src_cfun->gimple_df 244 && id->src_cfun->gimple_df->ipa_pta 245 && (pi = SSA_NAME_PTR_INFO (name)) 246 && !pi->pt.anything) 247 { 248 struct ptr_info_def *new_pi = get_ptr_info (new_tree); 249 new_pi->pt = pi->pt; 250 } 251 if (gimple_nop_p (SSA_NAME_DEF_STMT (name))) 252 { 253 /* By inlining function having uninitialized variable, we might 254 extend the lifetime (variable might get reused). This cause 255 ICE in the case we end up extending lifetime of SSA name across 256 abnormal edge, but also increase register pressure. 257 258 We simply initialize all uninitialized vars by 0 except 259 for case we are inlining to very first BB. We can avoid 260 this for all BBs that are not inside strongly connected 261 regions of the CFG, but this is expensive to test. */ 262 if (id->entry_bb 263 && is_gimple_reg (SSA_NAME_VAR (name)) 264 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name) 265 && TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL 266 && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest 267 || EDGE_COUNT (id->entry_bb->preds) != 1)) 268 { 269 gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb); 270 gimple init_stmt; 271 tree zero = build_zero_cst (TREE_TYPE (new_tree)); 272 273 init_stmt = gimple_build_assign (new_tree, zero); 274 gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT); 275 SSA_NAME_IS_DEFAULT_DEF (new_tree) = 0; 276 } 277 else 278 { 279 SSA_NAME_DEF_STMT (new_tree) = gimple_build_nop (); 280 if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name)) 281 == name) 282 set_default_def (SSA_NAME_VAR (new_tree), new_tree); 283 } 284 } 285 } 286 else 287 insert_decl_map (id, name, new_tree); 288 return new_tree; 289 } 290 291 /* Remap DECL during the copying of the BLOCK tree for the function. */ 292 293 tree 294 remap_decl (tree decl, copy_body_data *id) 295 { 296 tree *n; 297 298 /* We only remap local variables in the current function. */ 299 300 /* See if we have remapped this declaration. */ 301 302 n = (tree *) pointer_map_contains (id->decl_map, decl); 303 304 if (!n && processing_debug_stmt) 305 { 306 processing_debug_stmt = -1; 307 return decl; 308 } 309 310 /* If we didn't already have an equivalent for this declaration, 311 create one now. */ 312 if (!n) 313 { 314 /* Make a copy of the variable or label. */ 315 tree t = id->copy_decl (decl, id); 316 317 /* Remember it, so that if we encounter this local entity again 318 we can reuse this copy. Do this early because remap_type may 319 need this decl for TYPE_STUB_DECL. */ 320 insert_decl_map (id, decl, t); 321 322 if (!DECL_P (t)) 323 return t; 324 325 /* Remap types, if necessary. */ 326 TREE_TYPE (t) = remap_type (TREE_TYPE (t), id); 327 if (TREE_CODE (t) == TYPE_DECL) 328 DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id); 329 330 /* Remap sizes as necessary. */ 331 walk_tree (&DECL_SIZE (t), copy_tree_body_r, id, NULL); 332 walk_tree (&DECL_SIZE_UNIT (t), copy_tree_body_r, id, NULL); 333 334 /* If fields, do likewise for offset and qualifier. */ 335 if (TREE_CODE (t) == FIELD_DECL) 336 { 337 walk_tree (&DECL_FIELD_OFFSET (t), copy_tree_body_r, id, NULL); 338 if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE) 339 walk_tree (&DECL_QUALIFIER (t), copy_tree_body_r, id, NULL); 340 } 341 342 if ((TREE_CODE (t) == VAR_DECL 343 || TREE_CODE (t) == RESULT_DECL 344 || TREE_CODE (t) == PARM_DECL) 345 && id->src_fn && DECL_STRUCT_FUNCTION (id->src_fn) 346 && gimple_referenced_vars (DECL_STRUCT_FUNCTION (id->src_fn)) 347 /* We don't want to mark as referenced VAR_DECLs that were 348 not marked as such in the src function. */ 349 && (TREE_CODE (decl) != VAR_DECL 350 || referenced_var_lookup (DECL_STRUCT_FUNCTION (id->src_fn), 351 DECL_UID (decl)))) 352 add_referenced_var (t); 353 return t; 354 } 355 356 if (id->do_not_unshare) 357 return *n; 358 else 359 return unshare_expr (*n); 360 } 361 362 static tree 363 remap_type_1 (tree type, copy_body_data *id) 364 { 365 tree new_tree, t; 366 367 /* We do need a copy. build and register it now. If this is a pointer or 368 reference type, remap the designated type and make a new pointer or 369 reference type. */ 370 if (TREE_CODE (type) == POINTER_TYPE) 371 { 372 new_tree = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id), 373 TYPE_MODE (type), 374 TYPE_REF_CAN_ALIAS_ALL (type)); 375 if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type)) 376 new_tree = build_type_attribute_qual_variant (new_tree, 377 TYPE_ATTRIBUTES (type), 378 TYPE_QUALS (type)); 379 insert_decl_map (id, type, new_tree); 380 return new_tree; 381 } 382 else if (TREE_CODE (type) == REFERENCE_TYPE) 383 { 384 new_tree = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id), 385 TYPE_MODE (type), 386 TYPE_REF_CAN_ALIAS_ALL (type)); 387 if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type)) 388 new_tree = build_type_attribute_qual_variant (new_tree, 389 TYPE_ATTRIBUTES (type), 390 TYPE_QUALS (type)); 391 insert_decl_map (id, type, new_tree); 392 return new_tree; 393 } 394 else 395 new_tree = copy_node (type); 396 397 insert_decl_map (id, type, new_tree); 398 399 /* This is a new type, not a copy of an old type. Need to reassociate 400 variants. We can handle everything except the main variant lazily. */ 401 t = TYPE_MAIN_VARIANT (type); 402 if (type != t) 403 { 404 t = remap_type (t, id); 405 TYPE_MAIN_VARIANT (new_tree) = t; 406 TYPE_NEXT_VARIANT (new_tree) = TYPE_NEXT_VARIANT (t); 407 TYPE_NEXT_VARIANT (t) = new_tree; 408 } 409 else 410 { 411 TYPE_MAIN_VARIANT (new_tree) = new_tree; 412 TYPE_NEXT_VARIANT (new_tree) = NULL; 413 } 414 415 if (TYPE_STUB_DECL (type)) 416 TYPE_STUB_DECL (new_tree) = remap_decl (TYPE_STUB_DECL (type), id); 417 418 /* Lazily create pointer and reference types. */ 419 TYPE_POINTER_TO (new_tree) = NULL; 420 TYPE_REFERENCE_TO (new_tree) = NULL; 421 422 switch (TREE_CODE (new_tree)) 423 { 424 case INTEGER_TYPE: 425 case REAL_TYPE: 426 case FIXED_POINT_TYPE: 427 case ENUMERAL_TYPE: 428 case BOOLEAN_TYPE: 429 t = TYPE_MIN_VALUE (new_tree); 430 if (t && TREE_CODE (t) != INTEGER_CST) 431 walk_tree (&TYPE_MIN_VALUE (new_tree), copy_tree_body_r, id, NULL); 432 433 t = TYPE_MAX_VALUE (new_tree); 434 if (t && TREE_CODE (t) != INTEGER_CST) 435 walk_tree (&TYPE_MAX_VALUE (new_tree), copy_tree_body_r, id, NULL); 436 return new_tree; 437 438 case FUNCTION_TYPE: 439 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id); 440 walk_tree (&TYPE_ARG_TYPES (new_tree), copy_tree_body_r, id, NULL); 441 return new_tree; 442 443 case ARRAY_TYPE: 444 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id); 445 TYPE_DOMAIN (new_tree) = remap_type (TYPE_DOMAIN (new_tree), id); 446 break; 447 448 case RECORD_TYPE: 449 case UNION_TYPE: 450 case QUAL_UNION_TYPE: 451 { 452 tree f, nf = NULL; 453 454 for (f = TYPE_FIELDS (new_tree); f ; f = DECL_CHAIN (f)) 455 { 456 t = remap_decl (f, id); 457 DECL_CONTEXT (t) = new_tree; 458 DECL_CHAIN (t) = nf; 459 nf = t; 460 } 461 TYPE_FIELDS (new_tree) = nreverse (nf); 462 } 463 break; 464 465 case OFFSET_TYPE: 466 default: 467 /* Shouldn't have been thought variable sized. */ 468 gcc_unreachable (); 469 } 470 471 walk_tree (&TYPE_SIZE (new_tree), copy_tree_body_r, id, NULL); 472 walk_tree (&TYPE_SIZE_UNIT (new_tree), copy_tree_body_r, id, NULL); 473 474 return new_tree; 475 } 476 477 tree 478 remap_type (tree type, copy_body_data *id) 479 { 480 tree *node; 481 tree tmp; 482 483 if (type == NULL) 484 return type; 485 486 /* See if we have remapped this type. */ 487 node = (tree *) pointer_map_contains (id->decl_map, type); 488 if (node) 489 return *node; 490 491 /* The type only needs remapping if it's variably modified. */ 492 if (! variably_modified_type_p (type, id->src_fn)) 493 { 494 insert_decl_map (id, type, type); 495 return type; 496 } 497 498 id->remapping_type_depth++; 499 tmp = remap_type_1 (type, id); 500 id->remapping_type_depth--; 501 502 return tmp; 503 } 504 505 /* Return previously remapped type of TYPE in ID. Return NULL if TYPE 506 is NULL or TYPE has not been remapped before. */ 507 508 static tree 509 remapped_type (tree type, copy_body_data *id) 510 { 511 tree *node; 512 513 if (type == NULL) 514 return type; 515 516 /* See if we have remapped this type. */ 517 node = (tree *) pointer_map_contains (id->decl_map, type); 518 if (node) 519 return *node; 520 else 521 return NULL; 522 } 523 524 /* The type only needs remapping if it's variably modified. */ 525 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */ 526 527 static bool 528 can_be_nonlocal (tree decl, copy_body_data *id) 529 { 530 /* We can not duplicate function decls. */ 531 if (TREE_CODE (decl) == FUNCTION_DECL) 532 return true; 533 534 /* Local static vars must be non-local or we get multiple declaration 535 problems. */ 536 if (TREE_CODE (decl) == VAR_DECL 537 && !auto_var_in_fn_p (decl, id->src_fn)) 538 return true; 539 540 /* At the moment dwarf2out can handle only these types of nodes. We 541 can support more later. */ 542 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL) 543 return false; 544 545 /* We must use global type. We call remapped_type instead of 546 remap_type since we don't want to remap this type here if it 547 hasn't been remapped before. */ 548 if (TREE_TYPE (decl) != remapped_type (TREE_TYPE (decl), id)) 549 return false; 550 551 /* Wihtout SSA we can't tell if variable is used. */ 552 if (!gimple_in_ssa_p (cfun)) 553 return false; 554 555 /* Live variables must be copied so we can attach DECL_RTL. */ 556 if (var_ann (decl)) 557 return false; 558 559 return true; 560 } 561 562 static tree 563 remap_decls (tree decls, VEC(tree,gc) **nonlocalized_list, copy_body_data *id) 564 { 565 tree old_var; 566 tree new_decls = NULL_TREE; 567 568 /* Remap its variables. */ 569 for (old_var = decls; old_var; old_var = DECL_CHAIN (old_var)) 570 { 571 tree new_var; 572 573 if (can_be_nonlocal (old_var, id)) 574 { 575 if (TREE_CODE (old_var) == VAR_DECL 576 && ! DECL_EXTERNAL (old_var) 577 && (var_ann (old_var) || !gimple_in_ssa_p (cfun))) 578 add_local_decl (cfun, old_var); 579 if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE) 580 && !DECL_IGNORED_P (old_var) 581 && nonlocalized_list) 582 VEC_safe_push (tree, gc, *nonlocalized_list, old_var); 583 continue; 584 } 585 586 /* Remap the variable. */ 587 new_var = remap_decl (old_var, id); 588 589 /* If we didn't remap this variable, we can't mess with its 590 TREE_CHAIN. If we remapped this variable to the return slot, it's 591 already declared somewhere else, so don't declare it here. */ 592 593 if (new_var == id->retvar) 594 ; 595 else if (!new_var) 596 { 597 if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE) 598 && !DECL_IGNORED_P (old_var) 599 && nonlocalized_list) 600 VEC_safe_push (tree, gc, *nonlocalized_list, old_var); 601 } 602 else 603 { 604 gcc_assert (DECL_P (new_var)); 605 DECL_CHAIN (new_var) = new_decls; 606 new_decls = new_var; 607 608 /* Also copy value-expressions. */ 609 if (TREE_CODE (new_var) == VAR_DECL 610 && DECL_HAS_VALUE_EXPR_P (new_var)) 611 { 612 tree tem = DECL_VALUE_EXPR (new_var); 613 bool old_regimplify = id->regimplify; 614 id->remapping_type_depth++; 615 walk_tree (&tem, copy_tree_body_r, id, NULL); 616 id->remapping_type_depth--; 617 id->regimplify = old_regimplify; 618 SET_DECL_VALUE_EXPR (new_var, tem); 619 } 620 } 621 } 622 623 return nreverse (new_decls); 624 } 625 626 /* Copy the BLOCK to contain remapped versions of the variables 627 therein. And hook the new block into the block-tree. */ 628 629 static void 630 remap_block (tree *block, copy_body_data *id) 631 { 632 tree old_block; 633 tree new_block; 634 635 /* Make the new block. */ 636 old_block = *block; 637 new_block = make_node (BLOCK); 638 TREE_USED (new_block) = TREE_USED (old_block); 639 BLOCK_ABSTRACT_ORIGIN (new_block) = old_block; 640 BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block); 641 BLOCK_NONLOCALIZED_VARS (new_block) 642 = VEC_copy (tree, gc, BLOCK_NONLOCALIZED_VARS (old_block)); 643 *block = new_block; 644 645 /* Remap its variables. */ 646 BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block), 647 &BLOCK_NONLOCALIZED_VARS (new_block), 648 id); 649 650 if (id->transform_lang_insert_block) 651 id->transform_lang_insert_block (new_block); 652 653 /* Remember the remapped block. */ 654 insert_decl_map (id, old_block, new_block); 655 } 656 657 /* Copy the whole block tree and root it in id->block. */ 658 static tree 659 remap_blocks (tree block, copy_body_data *id) 660 { 661 tree t; 662 tree new_tree = block; 663 664 if (!block) 665 return NULL; 666 667 remap_block (&new_tree, id); 668 gcc_assert (new_tree != block); 669 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t)) 670 prepend_lexical_block (new_tree, remap_blocks (t, id)); 671 /* Blocks are in arbitrary order, but make things slightly prettier and do 672 not swap order when producing a copy. */ 673 BLOCK_SUBBLOCKS (new_tree) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree)); 674 return new_tree; 675 } 676 677 static void 678 copy_statement_list (tree *tp) 679 { 680 tree_stmt_iterator oi, ni; 681 tree new_tree; 682 683 new_tree = alloc_stmt_list (); 684 ni = tsi_start (new_tree); 685 oi = tsi_start (*tp); 686 TREE_TYPE (new_tree) = TREE_TYPE (*tp); 687 *tp = new_tree; 688 689 for (; !tsi_end_p (oi); tsi_next (&oi)) 690 { 691 tree stmt = tsi_stmt (oi); 692 if (TREE_CODE (stmt) == STATEMENT_LIST) 693 /* This copy is not redundant; tsi_link_after will smash this 694 STATEMENT_LIST into the end of the one we're building, and we 695 don't want to do that with the original. */ 696 copy_statement_list (&stmt); 697 tsi_link_after (&ni, stmt, TSI_CONTINUE_LINKING); 698 } 699 } 700 701 static void 702 copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id) 703 { 704 tree block = BIND_EXPR_BLOCK (*tp); 705 /* Copy (and replace) the statement. */ 706 copy_tree_r (tp, walk_subtrees, NULL); 707 if (block) 708 { 709 remap_block (&block, id); 710 BIND_EXPR_BLOCK (*tp) = block; 711 } 712 713 if (BIND_EXPR_VARS (*tp)) 714 /* This will remap a lot of the same decls again, but this should be 715 harmless. */ 716 BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id); 717 } 718 719 720 /* Create a new gimple_seq by remapping all the statements in BODY 721 using the inlining information in ID. */ 722 723 static gimple_seq 724 remap_gimple_seq (gimple_seq body, copy_body_data *id) 725 { 726 gimple_stmt_iterator si; 727 gimple_seq new_body = NULL; 728 729 for (si = gsi_start (body); !gsi_end_p (si); gsi_next (&si)) 730 { 731 gimple new_stmt = remap_gimple_stmt (gsi_stmt (si), id); 732 gimple_seq_add_stmt (&new_body, new_stmt); 733 } 734 735 return new_body; 736 } 737 738 739 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its 740 block using the mapping information in ID. */ 741 742 static gimple 743 copy_gimple_bind (gimple stmt, copy_body_data *id) 744 { 745 gimple new_bind; 746 tree new_block, new_vars; 747 gimple_seq body, new_body; 748 749 /* Copy the statement. Note that we purposely don't use copy_stmt 750 here because we need to remap statements as we copy. */ 751 body = gimple_bind_body (stmt); 752 new_body = remap_gimple_seq (body, id); 753 754 new_block = gimple_bind_block (stmt); 755 if (new_block) 756 remap_block (&new_block, id); 757 758 /* This will remap a lot of the same decls again, but this should be 759 harmless. */ 760 new_vars = gimple_bind_vars (stmt); 761 if (new_vars) 762 new_vars = remap_decls (new_vars, NULL, id); 763 764 new_bind = gimple_build_bind (new_vars, new_body, new_block); 765 766 return new_bind; 767 } 768 769 770 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a 771 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'. 772 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep 773 recursing into the children nodes of *TP. */ 774 775 static tree 776 remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data) 777 { 778 struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data; 779 copy_body_data *id = (copy_body_data *) wi_p->info; 780 tree fn = id->src_fn; 781 782 if (TREE_CODE (*tp) == SSA_NAME) 783 { 784 *tp = remap_ssa_name (*tp, id); 785 *walk_subtrees = 0; 786 return NULL; 787 } 788 else if (auto_var_in_fn_p (*tp, fn)) 789 { 790 /* Local variables and labels need to be replaced by equivalent 791 variables. We don't want to copy static variables; there's 792 only one of those, no matter how many times we inline the 793 containing function. Similarly for globals from an outer 794 function. */ 795 tree new_decl; 796 797 /* Remap the declaration. */ 798 new_decl = remap_decl (*tp, id); 799 gcc_assert (new_decl); 800 /* Replace this variable with the copy. */ 801 STRIP_TYPE_NOPS (new_decl); 802 /* ??? The C++ frontend uses void * pointer zero to initialize 803 any other type. This confuses the middle-end type verification. 804 As cloned bodies do not go through gimplification again the fixup 805 there doesn't trigger. */ 806 if (TREE_CODE (new_decl) == INTEGER_CST 807 && !useless_type_conversion_p (TREE_TYPE (*tp), TREE_TYPE (new_decl))) 808 new_decl = fold_convert (TREE_TYPE (*tp), new_decl); 809 *tp = new_decl; 810 *walk_subtrees = 0; 811 } 812 else if (TREE_CODE (*tp) == STATEMENT_LIST) 813 gcc_unreachable (); 814 else if (TREE_CODE (*tp) == SAVE_EXPR) 815 gcc_unreachable (); 816 else if (TREE_CODE (*tp) == LABEL_DECL 817 && (!DECL_CONTEXT (*tp) 818 || decl_function_context (*tp) == id->src_fn)) 819 /* These may need to be remapped for EH handling. */ 820 *tp = remap_decl (*tp, id); 821 else if (TREE_CODE (*tp) == FIELD_DECL) 822 { 823 /* If the enclosing record type is variably_modified_type_p, the field 824 has already been remapped. Otherwise, it need not be. */ 825 tree *n = (tree *) pointer_map_contains (id->decl_map, *tp); 826 if (n) 827 *tp = *n; 828 *walk_subtrees = 0; 829 } 830 else if (TYPE_P (*tp)) 831 /* Types may need remapping as well. */ 832 *tp = remap_type (*tp, id); 833 else if (CONSTANT_CLASS_P (*tp)) 834 { 835 /* If this is a constant, we have to copy the node iff the type 836 will be remapped. copy_tree_r will not copy a constant. */ 837 tree new_type = remap_type (TREE_TYPE (*tp), id); 838 839 if (new_type == TREE_TYPE (*tp)) 840 *walk_subtrees = 0; 841 842 else if (TREE_CODE (*tp) == INTEGER_CST) 843 *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp), 844 TREE_INT_CST_HIGH (*tp)); 845 else 846 { 847 *tp = copy_node (*tp); 848 TREE_TYPE (*tp) = new_type; 849 } 850 } 851 else 852 { 853 /* Otherwise, just copy the node. Note that copy_tree_r already 854 knows not to copy VAR_DECLs, etc., so this is safe. */ 855 856 /* We should never have TREE_BLOCK set on non-statements. */ 857 if (EXPR_P (*tp)) 858 gcc_assert (!TREE_BLOCK (*tp)); 859 860 if (TREE_CODE (*tp) == MEM_REF) 861 { 862 tree ptr = TREE_OPERAND (*tp, 0); 863 tree type = remap_type (TREE_TYPE (*tp), id); 864 tree old = *tp; 865 866 /* We need to re-canonicalize MEM_REFs from inline substitutions 867 that can happen when a pointer argument is an ADDR_EXPR. 868 Recurse here manually to allow that. */ 869 walk_tree (&ptr, remap_gimple_op_r, data, NULL); 870 *tp = fold_build2 (MEM_REF, type, 871 ptr, TREE_OPERAND (*tp, 1)); 872 TREE_THIS_NOTRAP (*tp) = TREE_THIS_NOTRAP (old); 873 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); 874 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old); 875 TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old); 876 *walk_subtrees = 0; 877 return NULL; 878 } 879 880 /* Here is the "usual case". Copy this tree node, and then 881 tweak some special cases. */ 882 copy_tree_r (tp, walk_subtrees, NULL); 883 884 if (TREE_CODE (*tp) != OMP_CLAUSE) 885 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id); 886 887 /* Global variables we haven't seen yet need to go into referenced 888 vars. If not referenced from types only. */ 889 if (gimple_in_ssa_p (cfun) 890 && TREE_CODE (*tp) == VAR_DECL 891 && id->remapping_type_depth == 0 892 && !processing_debug_stmt) 893 add_referenced_var (*tp); 894 895 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3)) 896 { 897 /* The copied TARGET_EXPR has never been expanded, even if the 898 original node was expanded already. */ 899 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3); 900 TREE_OPERAND (*tp, 3) = NULL_TREE; 901 } 902 else if (TREE_CODE (*tp) == ADDR_EXPR) 903 { 904 /* Variable substitution need not be simple. In particular, 905 the MEM_REF substitution above. Make sure that 906 TREE_CONSTANT and friends are up-to-date. But make sure 907 to not improperly set TREE_BLOCK on some sub-expressions. */ 908 int invariant = is_gimple_min_invariant (*tp); 909 tree block = id->block; 910 id->block = NULL_TREE; 911 walk_tree (&TREE_OPERAND (*tp, 0), remap_gimple_op_r, data, NULL); 912 id->block = block; 913 recompute_tree_invariant_for_addr_expr (*tp); 914 915 /* If this used to be invariant, but is not any longer, 916 then regimplification is probably needed. */ 917 if (invariant && !is_gimple_min_invariant (*tp)) 918 id->regimplify = true; 919 920 *walk_subtrees = 0; 921 } 922 } 923 924 /* Keep iterating. */ 925 return NULL_TREE; 926 } 927 928 929 /* Called from copy_body_id via walk_tree. DATA is really a 930 `copy_body_data *'. */ 931 932 tree 933 copy_tree_body_r (tree *tp, int *walk_subtrees, void *data) 934 { 935 copy_body_data *id = (copy_body_data *) data; 936 tree fn = id->src_fn; 937 tree new_block; 938 939 /* Begin by recognizing trees that we'll completely rewrite for the 940 inlining context. Our output for these trees is completely 941 different from out input (e.g. RETURN_EXPR is deleted, and morphs 942 into an edge). Further down, we'll handle trees that get 943 duplicated and/or tweaked. */ 944 945 /* When requested, RETURN_EXPRs should be transformed to just the 946 contained MODIFY_EXPR. The branch semantics of the return will 947 be handled elsewhere by manipulating the CFG rather than a statement. */ 948 if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify) 949 { 950 tree assignment = TREE_OPERAND (*tp, 0); 951 952 /* If we're returning something, just turn that into an 953 assignment into the equivalent of the original RESULT_DECL. 954 If the "assignment" is just the result decl, the result 955 decl has already been set (e.g. a recent "foo (&result_decl, 956 ...)"); just toss the entire RETURN_EXPR. */ 957 if (assignment && TREE_CODE (assignment) == MODIFY_EXPR) 958 { 959 /* Replace the RETURN_EXPR with (a copy of) the 960 MODIFY_EXPR hanging underneath. */ 961 *tp = copy_node (assignment); 962 } 963 else /* Else the RETURN_EXPR returns no value. */ 964 { 965 *tp = NULL; 966 return (tree) (void *)1; 967 } 968 } 969 else if (TREE_CODE (*tp) == SSA_NAME) 970 { 971 *tp = remap_ssa_name (*tp, id); 972 *walk_subtrees = 0; 973 return NULL; 974 } 975 976 /* Local variables and labels need to be replaced by equivalent 977 variables. We don't want to copy static variables; there's only 978 one of those, no matter how many times we inline the containing 979 function. Similarly for globals from an outer function. */ 980 else if (auto_var_in_fn_p (*tp, fn)) 981 { 982 tree new_decl; 983 984 /* Remap the declaration. */ 985 new_decl = remap_decl (*tp, id); 986 gcc_assert (new_decl); 987 /* Replace this variable with the copy. */ 988 STRIP_TYPE_NOPS (new_decl); 989 *tp = new_decl; 990 *walk_subtrees = 0; 991 } 992 else if (TREE_CODE (*tp) == STATEMENT_LIST) 993 copy_statement_list (tp); 994 else if (TREE_CODE (*tp) == SAVE_EXPR 995 || TREE_CODE (*tp) == TARGET_EXPR) 996 remap_save_expr (tp, id->decl_map, walk_subtrees); 997 else if (TREE_CODE (*tp) == LABEL_DECL 998 && (! DECL_CONTEXT (*tp) 999 || decl_function_context (*tp) == id->src_fn)) 1000 /* These may need to be remapped for EH handling. */ 1001 *tp = remap_decl (*tp, id); 1002 else if (TREE_CODE (*tp) == BIND_EXPR) 1003 copy_bind_expr (tp, walk_subtrees, id); 1004 /* Types may need remapping as well. */ 1005 else if (TYPE_P (*tp)) 1006 *tp = remap_type (*tp, id); 1007 1008 /* If this is a constant, we have to copy the node iff the type will be 1009 remapped. copy_tree_r will not copy a constant. */ 1010 else if (CONSTANT_CLASS_P (*tp)) 1011 { 1012 tree new_type = remap_type (TREE_TYPE (*tp), id); 1013 1014 if (new_type == TREE_TYPE (*tp)) 1015 *walk_subtrees = 0; 1016 1017 else if (TREE_CODE (*tp) == INTEGER_CST) 1018 *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp), 1019 TREE_INT_CST_HIGH (*tp)); 1020 else 1021 { 1022 *tp = copy_node (*tp); 1023 TREE_TYPE (*tp) = new_type; 1024 } 1025 } 1026 1027 /* Otherwise, just copy the node. Note that copy_tree_r already 1028 knows not to copy VAR_DECLs, etc., so this is safe. */ 1029 else 1030 { 1031 /* Here we handle trees that are not completely rewritten. 1032 First we detect some inlining-induced bogosities for 1033 discarding. */ 1034 if (TREE_CODE (*tp) == MODIFY_EXPR 1035 && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1) 1036 && (auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn))) 1037 { 1038 /* Some assignments VAR = VAR; don't generate any rtl code 1039 and thus don't count as variable modification. Avoid 1040 keeping bogosities like 0 = 0. */ 1041 tree decl = TREE_OPERAND (*tp, 0), value; 1042 tree *n; 1043 1044 n = (tree *) pointer_map_contains (id->decl_map, decl); 1045 if (n) 1046 { 1047 value = *n; 1048 STRIP_TYPE_NOPS (value); 1049 if (TREE_CONSTANT (value) || TREE_READONLY (value)) 1050 { 1051 *tp = build_empty_stmt (EXPR_LOCATION (*tp)); 1052 return copy_tree_body_r (tp, walk_subtrees, data); 1053 } 1054 } 1055 } 1056 else if (TREE_CODE (*tp) == INDIRECT_REF) 1057 { 1058 /* Get rid of *& from inline substitutions that can happen when a 1059 pointer argument is an ADDR_EXPR. */ 1060 tree decl = TREE_OPERAND (*tp, 0); 1061 tree *n; 1062 1063 n = (tree *) pointer_map_contains (id->decl_map, decl); 1064 if (n) 1065 { 1066 tree new_tree; 1067 tree old; 1068 /* If we happen to get an ADDR_EXPR in n->value, strip 1069 it manually here as we'll eventually get ADDR_EXPRs 1070 which lie about their types pointed to. In this case 1071 build_fold_indirect_ref wouldn't strip the INDIRECT_REF, 1072 but we absolutely rely on that. As fold_indirect_ref 1073 does other useful transformations, try that first, though. */ 1074 tree type = TREE_TYPE (TREE_TYPE (*n)); 1075 if (id->do_not_unshare) 1076 new_tree = *n; 1077 else 1078 new_tree = unshare_expr (*n); 1079 old = *tp; 1080 *tp = gimple_fold_indirect_ref (new_tree); 1081 if (! *tp) 1082 { 1083 if (TREE_CODE (new_tree) == ADDR_EXPR) 1084 { 1085 *tp = fold_indirect_ref_1 (EXPR_LOCATION (new_tree), 1086 type, new_tree); 1087 /* ??? We should either assert here or build 1088 a VIEW_CONVERT_EXPR instead of blindly leaking 1089 incompatible types to our IL. */ 1090 if (! *tp) 1091 *tp = TREE_OPERAND (new_tree, 0); 1092 } 1093 else 1094 { 1095 *tp = build1 (INDIRECT_REF, type, new_tree); 1096 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); 1097 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old); 1098 TREE_READONLY (*tp) = TREE_READONLY (old); 1099 TREE_THIS_NOTRAP (*tp) = TREE_THIS_NOTRAP (old); 1100 } 1101 } 1102 *walk_subtrees = 0; 1103 return NULL; 1104 } 1105 } 1106 else if (TREE_CODE (*tp) == MEM_REF) 1107 { 1108 /* We need to re-canonicalize MEM_REFs from inline substitutions 1109 that can happen when a pointer argument is an ADDR_EXPR. */ 1110 tree decl = TREE_OPERAND (*tp, 0); 1111 tree *n; 1112 1113 n = (tree *) pointer_map_contains (id->decl_map, decl); 1114 if (n) 1115 { 1116 tree old = *tp; 1117 *tp = fold_build2 (MEM_REF, TREE_TYPE (*tp), 1118 unshare_expr (*n), TREE_OPERAND (*tp, 1)); 1119 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); 1120 TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old); 1121 *walk_subtrees = 0; 1122 return NULL; 1123 } 1124 } 1125 1126 /* Here is the "usual case". Copy this tree node, and then 1127 tweak some special cases. */ 1128 copy_tree_r (tp, walk_subtrees, NULL); 1129 1130 /* Global variables we haven't seen yet needs to go into referenced 1131 vars. If not referenced from types or debug stmts only. */ 1132 if (gimple_in_ssa_p (cfun) 1133 && TREE_CODE (*tp) == VAR_DECL 1134 && id->remapping_type_depth == 0 1135 && !processing_debug_stmt) 1136 add_referenced_var (*tp); 1137 1138 /* If EXPR has block defined, map it to newly constructed block. 1139 When inlining we want EXPRs without block appear in the block 1140 of function call if we are not remapping a type. */ 1141 if (EXPR_P (*tp)) 1142 { 1143 new_block = id->remapping_type_depth == 0 ? id->block : NULL; 1144 if (TREE_BLOCK (*tp)) 1145 { 1146 tree *n; 1147 n = (tree *) pointer_map_contains (id->decl_map, 1148 TREE_BLOCK (*tp)); 1149 gcc_assert (n || id->remapping_type_depth != 0); 1150 if (n) 1151 new_block = *n; 1152 } 1153 TREE_BLOCK (*tp) = new_block; 1154 } 1155 1156 if (TREE_CODE (*tp) != OMP_CLAUSE) 1157 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id); 1158 1159 /* The copied TARGET_EXPR has never been expanded, even if the 1160 original node was expanded already. */ 1161 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3)) 1162 { 1163 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3); 1164 TREE_OPERAND (*tp, 3) = NULL_TREE; 1165 } 1166 1167 /* Variable substitution need not be simple. In particular, the 1168 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT 1169 and friends are up-to-date. */ 1170 else if (TREE_CODE (*tp) == ADDR_EXPR) 1171 { 1172 int invariant = is_gimple_min_invariant (*tp); 1173 walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL); 1174 1175 /* Handle the case where we substituted an INDIRECT_REF 1176 into the operand of the ADDR_EXPR. */ 1177 if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF) 1178 *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0); 1179 else 1180 recompute_tree_invariant_for_addr_expr (*tp); 1181 1182 /* If this used to be invariant, but is not any longer, 1183 then regimplification is probably needed. */ 1184 if (invariant && !is_gimple_min_invariant (*tp)) 1185 id->regimplify = true; 1186 1187 *walk_subtrees = 0; 1188 } 1189 } 1190 1191 /* Keep iterating. */ 1192 return NULL_TREE; 1193 } 1194 1195 /* Helper for remap_gimple_stmt. Given an EH region number for the 1196 source function, map that to the duplicate EH region number in 1197 the destination function. */ 1198 1199 static int 1200 remap_eh_region_nr (int old_nr, copy_body_data *id) 1201 { 1202 eh_region old_r, new_r; 1203 void **slot; 1204 1205 old_r = get_eh_region_from_number_fn (id->src_cfun, old_nr); 1206 slot = pointer_map_contains (id->eh_map, old_r); 1207 new_r = (eh_region) *slot; 1208 1209 return new_r->index; 1210 } 1211 1212 /* Similar, but operate on INTEGER_CSTs. */ 1213 1214 static tree 1215 remap_eh_region_tree_nr (tree old_t_nr, copy_body_data *id) 1216 { 1217 int old_nr, new_nr; 1218 1219 old_nr = tree_low_cst (old_t_nr, 0); 1220 new_nr = remap_eh_region_nr (old_nr, id); 1221 1222 return build_int_cst (integer_type_node, new_nr); 1223 } 1224 1225 /* Helper for copy_bb. Remap statement STMT using the inlining 1226 information in ID. Return the new statement copy. */ 1227 1228 static gimple 1229 remap_gimple_stmt (gimple stmt, copy_body_data *id) 1230 { 1231 gimple copy = NULL; 1232 struct walk_stmt_info wi; 1233 tree new_block; 1234 bool skip_first = false; 1235 1236 /* Begin by recognizing trees that we'll completely rewrite for the 1237 inlining context. Our output for these trees is completely 1238 different from out input (e.g. RETURN_EXPR is deleted, and morphs 1239 into an edge). Further down, we'll handle trees that get 1240 duplicated and/or tweaked. */ 1241 1242 /* When requested, GIMPLE_RETURNs should be transformed to just the 1243 contained GIMPLE_ASSIGN. The branch semantics of the return will 1244 be handled elsewhere by manipulating the CFG rather than the 1245 statement. */ 1246 if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify) 1247 { 1248 tree retval = gimple_return_retval (stmt); 1249 1250 /* If we're returning something, just turn that into an 1251 assignment into the equivalent of the original RESULT_DECL. 1252 If RETVAL is just the result decl, the result decl has 1253 already been set (e.g. a recent "foo (&result_decl, ...)"); 1254 just toss the entire GIMPLE_RETURN. */ 1255 if (retval 1256 && (TREE_CODE (retval) != RESULT_DECL 1257 && (TREE_CODE (retval) != SSA_NAME 1258 || TREE_CODE (SSA_NAME_VAR (retval)) != RESULT_DECL))) 1259 { 1260 copy = gimple_build_assign (id->retvar, retval); 1261 /* id->retvar is already substituted. Skip it on later remapping. */ 1262 skip_first = true; 1263 } 1264 else 1265 return gimple_build_nop (); 1266 } 1267 else if (gimple_has_substatements (stmt)) 1268 { 1269 gimple_seq s1, s2; 1270 1271 /* When cloning bodies from the C++ front end, we will be handed bodies 1272 in High GIMPLE form. Handle here all the High GIMPLE statements that 1273 have embedded statements. */ 1274 switch (gimple_code (stmt)) 1275 { 1276 case GIMPLE_BIND: 1277 copy = copy_gimple_bind (stmt, id); 1278 break; 1279 1280 case GIMPLE_CATCH: 1281 s1 = remap_gimple_seq (gimple_catch_handler (stmt), id); 1282 copy = gimple_build_catch (gimple_catch_types (stmt), s1); 1283 break; 1284 1285 case GIMPLE_EH_FILTER: 1286 s1 = remap_gimple_seq (gimple_eh_filter_failure (stmt), id); 1287 copy = gimple_build_eh_filter (gimple_eh_filter_types (stmt), s1); 1288 break; 1289 1290 case GIMPLE_TRY: 1291 s1 = remap_gimple_seq (gimple_try_eval (stmt), id); 1292 s2 = remap_gimple_seq (gimple_try_cleanup (stmt), id); 1293 copy = gimple_build_try (s1, s2, gimple_try_kind (stmt)); 1294 break; 1295 1296 case GIMPLE_WITH_CLEANUP_EXPR: 1297 s1 = remap_gimple_seq (gimple_wce_cleanup (stmt), id); 1298 copy = gimple_build_wce (s1); 1299 break; 1300 1301 case GIMPLE_OMP_PARALLEL: 1302 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); 1303 copy = gimple_build_omp_parallel 1304 (s1, 1305 gimple_omp_parallel_clauses (stmt), 1306 gimple_omp_parallel_child_fn (stmt), 1307 gimple_omp_parallel_data_arg (stmt)); 1308 break; 1309 1310 case GIMPLE_OMP_TASK: 1311 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); 1312 copy = gimple_build_omp_task 1313 (s1, 1314 gimple_omp_task_clauses (stmt), 1315 gimple_omp_task_child_fn (stmt), 1316 gimple_omp_task_data_arg (stmt), 1317 gimple_omp_task_copy_fn (stmt), 1318 gimple_omp_task_arg_size (stmt), 1319 gimple_omp_task_arg_align (stmt)); 1320 break; 1321 1322 case GIMPLE_OMP_FOR: 1323 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); 1324 s2 = remap_gimple_seq (gimple_omp_for_pre_body (stmt), id); 1325 copy = gimple_build_omp_for (s1, gimple_omp_for_clauses (stmt), 1326 gimple_omp_for_collapse (stmt), s2); 1327 { 1328 size_t i; 1329 for (i = 0; i < gimple_omp_for_collapse (stmt); i++) 1330 { 1331 gimple_omp_for_set_index (copy, i, 1332 gimple_omp_for_index (stmt, i)); 1333 gimple_omp_for_set_initial (copy, i, 1334 gimple_omp_for_initial (stmt, i)); 1335 gimple_omp_for_set_final (copy, i, 1336 gimple_omp_for_final (stmt, i)); 1337 gimple_omp_for_set_incr (copy, i, 1338 gimple_omp_for_incr (stmt, i)); 1339 gimple_omp_for_set_cond (copy, i, 1340 gimple_omp_for_cond (stmt, i)); 1341 } 1342 } 1343 break; 1344 1345 case GIMPLE_OMP_MASTER: 1346 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); 1347 copy = gimple_build_omp_master (s1); 1348 break; 1349 1350 case GIMPLE_OMP_ORDERED: 1351 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); 1352 copy = gimple_build_omp_ordered (s1); 1353 break; 1354 1355 case GIMPLE_OMP_SECTION: 1356 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); 1357 copy = gimple_build_omp_section (s1); 1358 break; 1359 1360 case GIMPLE_OMP_SECTIONS: 1361 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); 1362 copy = gimple_build_omp_sections 1363 (s1, gimple_omp_sections_clauses (stmt)); 1364 break; 1365 1366 case GIMPLE_OMP_SINGLE: 1367 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); 1368 copy = gimple_build_omp_single 1369 (s1, gimple_omp_single_clauses (stmt)); 1370 break; 1371 1372 case GIMPLE_OMP_CRITICAL: 1373 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); 1374 copy 1375 = gimple_build_omp_critical (s1, gimple_omp_critical_name (stmt)); 1376 break; 1377 1378 case GIMPLE_TRANSACTION: 1379 s1 = remap_gimple_seq (gimple_transaction_body (stmt), id); 1380 copy = gimple_build_transaction (s1, gimple_transaction_label (stmt)); 1381 gimple_transaction_set_subcode (copy, gimple_transaction_subcode (stmt)); 1382 break; 1383 1384 default: 1385 gcc_unreachable (); 1386 } 1387 } 1388 else 1389 { 1390 if (gimple_assign_copy_p (stmt) 1391 && gimple_assign_lhs (stmt) == gimple_assign_rhs1 (stmt) 1392 && auto_var_in_fn_p (gimple_assign_lhs (stmt), id->src_fn)) 1393 { 1394 /* Here we handle statements that are not completely rewritten. 1395 First we detect some inlining-induced bogosities for 1396 discarding. */ 1397 1398 /* Some assignments VAR = VAR; don't generate any rtl code 1399 and thus don't count as variable modification. Avoid 1400 keeping bogosities like 0 = 0. */ 1401 tree decl = gimple_assign_lhs (stmt), value; 1402 tree *n; 1403 1404 n = (tree *) pointer_map_contains (id->decl_map, decl); 1405 if (n) 1406 { 1407 value = *n; 1408 STRIP_TYPE_NOPS (value); 1409 if (TREE_CONSTANT (value) || TREE_READONLY (value)) 1410 return gimple_build_nop (); 1411 } 1412 } 1413 1414 if (gimple_debug_bind_p (stmt)) 1415 { 1416 copy = gimple_build_debug_bind (gimple_debug_bind_get_var (stmt), 1417 gimple_debug_bind_get_value (stmt), 1418 stmt); 1419 VEC_safe_push (gimple, heap, id->debug_stmts, copy); 1420 return copy; 1421 } 1422 if (gimple_debug_source_bind_p (stmt)) 1423 { 1424 copy = gimple_build_debug_source_bind 1425 (gimple_debug_source_bind_get_var (stmt), 1426 gimple_debug_source_bind_get_value (stmt), stmt); 1427 VEC_safe_push (gimple, heap, id->debug_stmts, copy); 1428 return copy; 1429 } 1430 1431 /* Create a new deep copy of the statement. */ 1432 copy = gimple_copy (stmt); 1433 1434 /* Remap the region numbers for __builtin_eh_{pointer,filter}, 1435 RESX and EH_DISPATCH. */ 1436 if (id->eh_map) 1437 switch (gimple_code (copy)) 1438 { 1439 case GIMPLE_CALL: 1440 { 1441 tree r, fndecl = gimple_call_fndecl (copy); 1442 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL) 1443 switch (DECL_FUNCTION_CODE (fndecl)) 1444 { 1445 case BUILT_IN_EH_COPY_VALUES: 1446 r = gimple_call_arg (copy, 1); 1447 r = remap_eh_region_tree_nr (r, id); 1448 gimple_call_set_arg (copy, 1, r); 1449 /* FALLTHRU */ 1450 1451 case BUILT_IN_EH_POINTER: 1452 case BUILT_IN_EH_FILTER: 1453 r = gimple_call_arg (copy, 0); 1454 r = remap_eh_region_tree_nr (r, id); 1455 gimple_call_set_arg (copy, 0, r); 1456 break; 1457 1458 default: 1459 break; 1460 } 1461 1462 /* Reset alias info if we didn't apply measures to 1463 keep it valid over inlining by setting DECL_PT_UID. */ 1464 if (!id->src_cfun->gimple_df 1465 || !id->src_cfun->gimple_df->ipa_pta) 1466 gimple_call_reset_alias_info (copy); 1467 } 1468 break; 1469 1470 case GIMPLE_RESX: 1471 { 1472 int r = gimple_resx_region (copy); 1473 r = remap_eh_region_nr (r, id); 1474 gimple_resx_set_region (copy, r); 1475 } 1476 break; 1477 1478 case GIMPLE_EH_DISPATCH: 1479 { 1480 int r = gimple_eh_dispatch_region (copy); 1481 r = remap_eh_region_nr (r, id); 1482 gimple_eh_dispatch_set_region (copy, r); 1483 } 1484 break; 1485 1486 default: 1487 break; 1488 } 1489 } 1490 1491 /* If STMT has a block defined, map it to the newly constructed 1492 block. When inlining we want statements without a block to 1493 appear in the block of the function call. */ 1494 new_block = id->block; 1495 if (gimple_block (copy)) 1496 { 1497 tree *n; 1498 n = (tree *) pointer_map_contains (id->decl_map, gimple_block (copy)); 1499 gcc_assert (n); 1500 new_block = *n; 1501 } 1502 1503 gimple_set_block (copy, new_block); 1504 1505 if (gimple_debug_bind_p (copy) || gimple_debug_source_bind_p (copy)) 1506 return copy; 1507 1508 /* Remap all the operands in COPY. */ 1509 memset (&wi, 0, sizeof (wi)); 1510 wi.info = id; 1511 if (skip_first) 1512 walk_tree (gimple_op_ptr (copy, 1), remap_gimple_op_r, &wi, NULL); 1513 else 1514 walk_gimple_op (copy, remap_gimple_op_r, &wi); 1515 1516 /* Clear the copied virtual operands. We are not remapping them here 1517 but are going to recreate them from scratch. */ 1518 if (gimple_has_mem_ops (copy)) 1519 { 1520 gimple_set_vdef (copy, NULL_TREE); 1521 gimple_set_vuse (copy, NULL_TREE); 1522 } 1523 1524 return copy; 1525 } 1526 1527 1528 /* Copy basic block, scale profile accordingly. Edges will be taken care of 1529 later */ 1530 1531 static basic_block 1532 copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, 1533 gcov_type count_scale) 1534 { 1535 gimple_stmt_iterator gsi, copy_gsi, seq_gsi; 1536 basic_block copy_basic_block; 1537 tree decl; 1538 gcov_type freq; 1539 basic_block prev; 1540 1541 /* Search for previous copied basic block. */ 1542 prev = bb->prev_bb; 1543 while (!prev->aux) 1544 prev = prev->prev_bb; 1545 1546 /* create_basic_block() will append every new block to 1547 basic_block_info automatically. */ 1548 copy_basic_block = create_basic_block (NULL, (void *) 0, 1549 (basic_block) prev->aux); 1550 copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE; 1551 1552 /* We are going to rebuild frequencies from scratch. These values 1553 have just small importance to drive canonicalize_loop_headers. */ 1554 freq = ((gcov_type)bb->frequency * frequency_scale / REG_BR_PROB_BASE); 1555 1556 /* We recompute frequencies after inlining, so this is quite safe. */ 1557 if (freq > BB_FREQ_MAX) 1558 freq = BB_FREQ_MAX; 1559 copy_basic_block->frequency = freq; 1560 1561 copy_gsi = gsi_start_bb (copy_basic_block); 1562 1563 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 1564 { 1565 gimple stmt = gsi_stmt (gsi); 1566 gimple orig_stmt = stmt; 1567 1568 id->regimplify = false; 1569 stmt = remap_gimple_stmt (stmt, id); 1570 if (gimple_nop_p (stmt)) 1571 continue; 1572 1573 gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt); 1574 seq_gsi = copy_gsi; 1575 1576 /* With return slot optimization we can end up with 1577 non-gimple (foo *)&this->m, fix that here. */ 1578 if (is_gimple_assign (stmt) 1579 && gimple_assign_rhs_code (stmt) == NOP_EXPR 1580 && !is_gimple_val (gimple_assign_rhs1 (stmt))) 1581 { 1582 tree new_rhs; 1583 new_rhs = force_gimple_operand_gsi (&seq_gsi, 1584 gimple_assign_rhs1 (stmt), 1585 true, NULL, false, 1586 GSI_CONTINUE_LINKING); 1587 gimple_assign_set_rhs1 (stmt, new_rhs); 1588 id->regimplify = false; 1589 } 1590 1591 gsi_insert_after (&seq_gsi, stmt, GSI_NEW_STMT); 1592 1593 if (id->regimplify) 1594 gimple_regimplify_operands (stmt, &seq_gsi); 1595 1596 /* If copy_basic_block has been empty at the start of this iteration, 1597 call gsi_start_bb again to get at the newly added statements. */ 1598 if (gsi_end_p (copy_gsi)) 1599 copy_gsi = gsi_start_bb (copy_basic_block); 1600 else 1601 gsi_next (©_gsi); 1602 1603 /* Process the new statement. The call to gimple_regimplify_operands 1604 possibly turned the statement into multiple statements, we 1605 need to process all of them. */ 1606 do 1607 { 1608 tree fn; 1609 1610 stmt = gsi_stmt (copy_gsi); 1611 if (is_gimple_call (stmt) 1612 && gimple_call_va_arg_pack_p (stmt) 1613 && id->gimple_call) 1614 { 1615 /* __builtin_va_arg_pack () should be replaced by 1616 all arguments corresponding to ... in the caller. */ 1617 tree p; 1618 gimple new_call; 1619 VEC(tree, heap) *argarray; 1620 size_t nargs = gimple_call_num_args (id->gimple_call); 1621 size_t n; 1622 1623 for (p = DECL_ARGUMENTS (id->src_fn); p; p = DECL_CHAIN (p)) 1624 nargs--; 1625 1626 /* Create the new array of arguments. */ 1627 n = nargs + gimple_call_num_args (stmt); 1628 argarray = VEC_alloc (tree, heap, n); 1629 VEC_safe_grow (tree, heap, argarray, n); 1630 1631 /* Copy all the arguments before '...' */ 1632 memcpy (VEC_address (tree, argarray), 1633 gimple_call_arg_ptr (stmt, 0), 1634 gimple_call_num_args (stmt) * sizeof (tree)); 1635 1636 /* Append the arguments passed in '...' */ 1637 memcpy (VEC_address(tree, argarray) + gimple_call_num_args (stmt), 1638 gimple_call_arg_ptr (id->gimple_call, 0) 1639 + (gimple_call_num_args (id->gimple_call) - nargs), 1640 nargs * sizeof (tree)); 1641 1642 new_call = gimple_build_call_vec (gimple_call_fn (stmt), 1643 argarray); 1644 1645 VEC_free (tree, heap, argarray); 1646 1647 /* Copy all GIMPLE_CALL flags, location and block, except 1648 GF_CALL_VA_ARG_PACK. */ 1649 gimple_call_copy_flags (new_call, stmt); 1650 gimple_call_set_va_arg_pack (new_call, false); 1651 gimple_set_location (new_call, gimple_location (stmt)); 1652 gimple_set_block (new_call, gimple_block (stmt)); 1653 gimple_call_set_lhs (new_call, gimple_call_lhs (stmt)); 1654 1655 gsi_replace (©_gsi, new_call, false); 1656 stmt = new_call; 1657 } 1658 else if (is_gimple_call (stmt) 1659 && id->gimple_call 1660 && (decl = gimple_call_fndecl (stmt)) 1661 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL 1662 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_ARG_PACK_LEN) 1663 { 1664 /* __builtin_va_arg_pack_len () should be replaced by 1665 the number of anonymous arguments. */ 1666 size_t nargs = gimple_call_num_args (id->gimple_call); 1667 tree count, p; 1668 gimple new_stmt; 1669 1670 for (p = DECL_ARGUMENTS (id->src_fn); p; p = DECL_CHAIN (p)) 1671 nargs--; 1672 1673 count = build_int_cst (integer_type_node, nargs); 1674 new_stmt = gimple_build_assign (gimple_call_lhs (stmt), count); 1675 gsi_replace (©_gsi, new_stmt, false); 1676 stmt = new_stmt; 1677 } 1678 1679 /* Statements produced by inlining can be unfolded, especially 1680 when we constant propagated some operands. We can't fold 1681 them right now for two reasons: 1682 1) folding require SSA_NAME_DEF_STMTs to be correct 1683 2) we can't change function calls to builtins. 1684 So we just mark statement for later folding. We mark 1685 all new statements, instead just statements that has changed 1686 by some nontrivial substitution so even statements made 1687 foldable indirectly are updated. If this turns out to be 1688 expensive, copy_body can be told to watch for nontrivial 1689 changes. */ 1690 if (id->statements_to_fold) 1691 pointer_set_insert (id->statements_to_fold, stmt); 1692 1693 /* We're duplicating a CALL_EXPR. Find any corresponding 1694 callgraph edges and update or duplicate them. */ 1695 if (is_gimple_call (stmt)) 1696 { 1697 struct cgraph_edge *edge; 1698 int flags; 1699 1700 switch (id->transform_call_graph_edges) 1701 { 1702 case CB_CGE_DUPLICATE: 1703 edge = cgraph_edge (id->src_node, orig_stmt); 1704 if (edge) 1705 { 1706 int edge_freq = edge->frequency; 1707 edge = cgraph_clone_edge (edge, id->dst_node, stmt, 1708 gimple_uid (stmt), 1709 REG_BR_PROB_BASE, CGRAPH_FREQ_BASE, 1710 true); 1711 /* We could also just rescale the frequency, but 1712 doing so would introduce roundoff errors and make 1713 verifier unhappy. */ 1714 edge->frequency 1715 = compute_call_stmt_bb_frequency (id->dst_node->decl, 1716 copy_basic_block); 1717 if (dump_file 1718 && profile_status_for_function (cfun) != PROFILE_ABSENT 1719 && (edge_freq > edge->frequency + 10 1720 || edge_freq < edge->frequency - 10)) 1721 { 1722 fprintf (dump_file, "Edge frequency estimated by " 1723 "cgraph %i diverge from inliner's estimate %i\n", 1724 edge_freq, 1725 edge->frequency); 1726 fprintf (dump_file, 1727 "Orig bb: %i, orig bb freq %i, new bb freq %i\n", 1728 bb->index, 1729 bb->frequency, 1730 copy_basic_block->frequency); 1731 } 1732 stmt = cgraph_redirect_edge_call_stmt_to_callee (edge); 1733 } 1734 break; 1735 1736 case CB_CGE_MOVE_CLONES: 1737 cgraph_set_call_stmt_including_clones (id->dst_node, 1738 orig_stmt, stmt); 1739 edge = cgraph_edge (id->dst_node, stmt); 1740 break; 1741 1742 case CB_CGE_MOVE: 1743 edge = cgraph_edge (id->dst_node, orig_stmt); 1744 if (edge) 1745 cgraph_set_call_stmt (edge, stmt); 1746 break; 1747 1748 default: 1749 gcc_unreachable (); 1750 } 1751 1752 /* Constant propagation on argument done during inlining 1753 may create new direct call. Produce an edge for it. */ 1754 if ((!edge 1755 || (edge->indirect_inlining_edge 1756 && id->transform_call_graph_edges == CB_CGE_MOVE_CLONES)) 1757 && id->dst_node->analyzed 1758 && (fn = gimple_call_fndecl (stmt)) != NULL) 1759 { 1760 struct cgraph_node *dest = cgraph_get_node (fn); 1761 1762 /* We have missing edge in the callgraph. This can happen 1763 when previous inlining turned an indirect call into a 1764 direct call by constant propagating arguments or we are 1765 producing dead clone (for further cloning). In all 1766 other cases we hit a bug (incorrect node sharing is the 1767 most common reason for missing edges). */ 1768 gcc_assert (dest->needed || !dest->analyzed 1769 || dest->address_taken 1770 || !id->src_node->analyzed 1771 || !id->dst_node->analyzed); 1772 if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES) 1773 cgraph_create_edge_including_clones 1774 (id->dst_node, dest, orig_stmt, stmt, bb->count, 1775 compute_call_stmt_bb_frequency (id->dst_node->decl, 1776 copy_basic_block), 1777 CIF_ORIGINALLY_INDIRECT_CALL); 1778 else 1779 cgraph_create_edge (id->dst_node, dest, stmt, 1780 bb->count, 1781 compute_call_stmt_bb_frequency 1782 (id->dst_node->decl, copy_basic_block))->inline_failed 1783 = CIF_ORIGINALLY_INDIRECT_CALL; 1784 if (dump_file) 1785 { 1786 fprintf (dump_file, "Created new direct edge to %s\n", 1787 cgraph_node_name (dest)); 1788 } 1789 } 1790 1791 flags = gimple_call_flags (stmt); 1792 if (flags & ECF_MAY_BE_ALLOCA) 1793 cfun->calls_alloca = true; 1794 if (flags & ECF_RETURNS_TWICE) 1795 cfun->calls_setjmp = true; 1796 } 1797 1798 maybe_duplicate_eh_stmt_fn (cfun, stmt, id->src_cfun, orig_stmt, 1799 id->eh_map, id->eh_lp_nr); 1800 1801 if (gimple_in_ssa_p (cfun) && !is_gimple_debug (stmt)) 1802 { 1803 ssa_op_iter i; 1804 tree def; 1805 1806 find_new_referenced_vars (gsi_stmt (copy_gsi)); 1807 FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF) 1808 if (TREE_CODE (def) == SSA_NAME) 1809 SSA_NAME_DEF_STMT (def) = stmt; 1810 } 1811 1812 gsi_next (©_gsi); 1813 } 1814 while (!gsi_end_p (copy_gsi)); 1815 1816 copy_gsi = gsi_last_bb (copy_basic_block); 1817 } 1818 1819 return copy_basic_block; 1820 } 1821 1822 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA 1823 form is quite easy, since dominator relationship for old basic blocks does 1824 not change. 1825 1826 There is however exception where inlining might change dominator relation 1827 across EH edges from basic block within inlined functions destinating 1828 to landing pads in function we inline into. 1829 1830 The function fills in PHI_RESULTs of such PHI nodes if they refer 1831 to gimple regs. Otherwise, the function mark PHI_RESULT of such 1832 PHI nodes for renaming. For non-gimple regs, renaming is safe: the 1833 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be 1834 set, and this means that there will be no overlapping live ranges 1835 for the underlying symbol. 1836 1837 This might change in future if we allow redirecting of EH edges and 1838 we might want to change way build CFG pre-inlining to include 1839 all the possible edges then. */ 1840 static void 1841 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb, 1842 bool can_throw, bool nonlocal_goto) 1843 { 1844 edge e; 1845 edge_iterator ei; 1846 1847 FOR_EACH_EDGE (e, ei, bb->succs) 1848 if (!e->dest->aux 1849 || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK) 1850 { 1851 gimple phi; 1852 gimple_stmt_iterator si; 1853 1854 if (!nonlocal_goto) 1855 gcc_assert (e->flags & EDGE_EH); 1856 1857 if (!can_throw) 1858 gcc_assert (!(e->flags & EDGE_EH)); 1859 1860 for (si = gsi_start_phis (e->dest); !gsi_end_p (si); gsi_next (&si)) 1861 { 1862 edge re; 1863 1864 phi = gsi_stmt (si); 1865 1866 /* There shouldn't be any PHI nodes in the ENTRY_BLOCK. */ 1867 gcc_assert (!e->dest->aux); 1868 1869 gcc_assert ((e->flags & EDGE_EH) 1870 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi))); 1871 1872 if (!is_gimple_reg (PHI_RESULT (phi))) 1873 { 1874 mark_sym_for_renaming (SSA_NAME_VAR (PHI_RESULT (phi))); 1875 continue; 1876 } 1877 1878 re = find_edge (ret_bb, e->dest); 1879 gcc_assert (re); 1880 gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL)) 1881 == (e->flags & (EDGE_EH | EDGE_ABNORMAL))); 1882 1883 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e), 1884 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re))); 1885 } 1886 } 1887 } 1888 1889 1890 /* Copy edges from BB into its copy constructed earlier, scale profile 1891 accordingly. Edges will be taken care of later. Assume aux 1892 pointers to point to the copies of each BB. Return true if any 1893 debug stmts are left after a statement that must end the basic block. */ 1894 1895 static bool 1896 copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb) 1897 { 1898 basic_block new_bb = (basic_block) bb->aux; 1899 edge_iterator ei; 1900 edge old_edge; 1901 gimple_stmt_iterator si; 1902 int flags; 1903 bool need_debug_cleanup = false; 1904 1905 /* Use the indices from the original blocks to create edges for the 1906 new ones. */ 1907 FOR_EACH_EDGE (old_edge, ei, bb->succs) 1908 if (!(old_edge->flags & EDGE_EH)) 1909 { 1910 edge new_edge; 1911 1912 flags = old_edge->flags; 1913 1914 /* Return edges do get a FALLTHRU flag when the get inlined. */ 1915 if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags 1916 && old_edge->dest->aux != EXIT_BLOCK_PTR) 1917 flags |= EDGE_FALLTHRU; 1918 new_edge = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags); 1919 new_edge->count = old_edge->count * count_scale / REG_BR_PROB_BASE; 1920 new_edge->probability = old_edge->probability; 1921 } 1922 1923 if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK) 1924 return false; 1925 1926 for (si = gsi_start_bb (new_bb); !gsi_end_p (si);) 1927 { 1928 gimple copy_stmt; 1929 bool can_throw, nonlocal_goto; 1930 1931 copy_stmt = gsi_stmt (si); 1932 if (!is_gimple_debug (copy_stmt)) 1933 { 1934 update_stmt (copy_stmt); 1935 if (gimple_in_ssa_p (cfun)) 1936 mark_symbols_for_renaming (copy_stmt); 1937 } 1938 1939 /* Do this before the possible split_block. */ 1940 gsi_next (&si); 1941 1942 /* If this tree could throw an exception, there are two 1943 cases where we need to add abnormal edge(s): the 1944 tree wasn't in a region and there is a "current 1945 region" in the caller; or the original tree had 1946 EH edges. In both cases split the block after the tree, 1947 and add abnormal edge(s) as needed; we need both 1948 those from the callee and the caller. 1949 We check whether the copy can throw, because the const 1950 propagation can change an INDIRECT_REF which throws 1951 into a COMPONENT_REF which doesn't. If the copy 1952 can throw, the original could also throw. */ 1953 can_throw = stmt_can_throw_internal (copy_stmt); 1954 nonlocal_goto = stmt_can_make_abnormal_goto (copy_stmt); 1955 1956 if (can_throw || nonlocal_goto) 1957 { 1958 if (!gsi_end_p (si)) 1959 { 1960 while (!gsi_end_p (si) && is_gimple_debug (gsi_stmt (si))) 1961 gsi_next (&si); 1962 if (gsi_end_p (si)) 1963 need_debug_cleanup = true; 1964 } 1965 if (!gsi_end_p (si)) 1966 /* Note that bb's predecessor edges aren't necessarily 1967 right at this point; split_block doesn't care. */ 1968 { 1969 edge e = split_block (new_bb, copy_stmt); 1970 1971 new_bb = e->dest; 1972 new_bb->aux = e->src->aux; 1973 si = gsi_start_bb (new_bb); 1974 } 1975 } 1976 1977 if (gimple_code (copy_stmt) == GIMPLE_EH_DISPATCH) 1978 make_eh_dispatch_edges (copy_stmt); 1979 else if (can_throw) 1980 make_eh_edges (copy_stmt); 1981 1982 if (nonlocal_goto) 1983 make_abnormal_goto_edges (gimple_bb (copy_stmt), true); 1984 1985 if ((can_throw || nonlocal_goto) 1986 && gimple_in_ssa_p (cfun)) 1987 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt), ret_bb, 1988 can_throw, nonlocal_goto); 1989 } 1990 return need_debug_cleanup; 1991 } 1992 1993 /* Copy the PHIs. All blocks and edges are copied, some blocks 1994 was possibly split and new outgoing EH edges inserted. 1995 BB points to the block of original function and AUX pointers links 1996 the original and newly copied blocks. */ 1997 1998 static void 1999 copy_phis_for_bb (basic_block bb, copy_body_data *id) 2000 { 2001 basic_block const new_bb = (basic_block) bb->aux; 2002 edge_iterator ei; 2003 gimple phi; 2004 gimple_stmt_iterator si; 2005 edge new_edge; 2006 bool inserted = false; 2007 2008 for (si = gsi_start (phi_nodes (bb)); !gsi_end_p (si); gsi_next (&si)) 2009 { 2010 tree res, new_res; 2011 gimple new_phi; 2012 2013 phi = gsi_stmt (si); 2014 res = PHI_RESULT (phi); 2015 new_res = res; 2016 if (is_gimple_reg (res)) 2017 { 2018 walk_tree (&new_res, copy_tree_body_r, id, NULL); 2019 SSA_NAME_DEF_STMT (new_res) 2020 = new_phi = create_phi_node (new_res, new_bb); 2021 FOR_EACH_EDGE (new_edge, ei, new_bb->preds) 2022 { 2023 edge old_edge = find_edge ((basic_block) new_edge->src->aux, bb); 2024 tree arg; 2025 tree new_arg; 2026 tree block = id->block; 2027 edge_iterator ei2; 2028 2029 /* When doing partial cloning, we allow PHIs on the entry block 2030 as long as all the arguments are the same. Find any input 2031 edge to see argument to copy. */ 2032 if (!old_edge) 2033 FOR_EACH_EDGE (old_edge, ei2, bb->preds) 2034 if (!old_edge->src->aux) 2035 break; 2036 2037 arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge); 2038 new_arg = arg; 2039 id->block = NULL_TREE; 2040 walk_tree (&new_arg, copy_tree_body_r, id, NULL); 2041 id->block = block; 2042 gcc_assert (new_arg); 2043 /* With return slot optimization we can end up with 2044 non-gimple (foo *)&this->m, fix that here. */ 2045 if (TREE_CODE (new_arg) != SSA_NAME 2046 && TREE_CODE (new_arg) != FUNCTION_DECL 2047 && !is_gimple_val (new_arg)) 2048 { 2049 gimple_seq stmts = NULL; 2050 new_arg = force_gimple_operand (new_arg, &stmts, true, NULL); 2051 gsi_insert_seq_on_edge (new_edge, stmts); 2052 inserted = true; 2053 } 2054 add_phi_arg (new_phi, new_arg, new_edge, 2055 gimple_phi_arg_location_from_edge (phi, old_edge)); 2056 } 2057 } 2058 } 2059 2060 /* Commit the delayed edge insertions. */ 2061 if (inserted) 2062 FOR_EACH_EDGE (new_edge, ei, new_bb->preds) 2063 gsi_commit_one_edge_insert (new_edge, NULL); 2064 } 2065 2066 2067 /* Wrapper for remap_decl so it can be used as a callback. */ 2068 2069 static tree 2070 remap_decl_1 (tree decl, void *data) 2071 { 2072 return remap_decl (decl, (copy_body_data *) data); 2073 } 2074 2075 /* Build struct function and associated datastructures for the new clone 2076 NEW_FNDECL to be build. CALLEE_FNDECL is the original */ 2077 2078 static void 2079 initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count) 2080 { 2081 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl); 2082 gcov_type count_scale; 2083 2084 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count) 2085 count_scale = (REG_BR_PROB_BASE * count 2086 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count); 2087 else 2088 count_scale = REG_BR_PROB_BASE; 2089 2090 /* Register specific tree functions. */ 2091 gimple_register_cfg_hooks (); 2092 2093 /* Get clean struct function. */ 2094 push_struct_function (new_fndecl); 2095 2096 /* We will rebuild these, so just sanity check that they are empty. */ 2097 gcc_assert (VALUE_HISTOGRAMS (cfun) == NULL); 2098 gcc_assert (cfun->local_decls == NULL); 2099 gcc_assert (cfun->cfg == NULL); 2100 gcc_assert (cfun->decl == new_fndecl); 2101 2102 /* Copy items we preserve during cloning. */ 2103 cfun->static_chain_decl = src_cfun->static_chain_decl; 2104 cfun->nonlocal_goto_save_area = src_cfun->nonlocal_goto_save_area; 2105 cfun->function_end_locus = src_cfun->function_end_locus; 2106 cfun->curr_properties = src_cfun->curr_properties; 2107 cfun->last_verified = src_cfun->last_verified; 2108 cfun->va_list_gpr_size = src_cfun->va_list_gpr_size; 2109 cfun->va_list_fpr_size = src_cfun->va_list_fpr_size; 2110 cfun->has_nonlocal_label = src_cfun->has_nonlocal_label; 2111 cfun->stdarg = src_cfun->stdarg; 2112 cfun->after_inlining = src_cfun->after_inlining; 2113 cfun->can_throw_non_call_exceptions 2114 = src_cfun->can_throw_non_call_exceptions; 2115 cfun->returns_struct = src_cfun->returns_struct; 2116 cfun->returns_pcc_struct = src_cfun->returns_pcc_struct; 2117 cfun->after_tree_profile = src_cfun->after_tree_profile; 2118 2119 init_empty_tree_cfg (); 2120 2121 profile_status_for_function (cfun) = profile_status_for_function (src_cfun); 2122 ENTRY_BLOCK_PTR->count = 2123 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale / 2124 REG_BR_PROB_BASE); 2125 ENTRY_BLOCK_PTR->frequency 2126 = ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency; 2127 EXIT_BLOCK_PTR->count = 2128 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale / 2129 REG_BR_PROB_BASE); 2130 EXIT_BLOCK_PTR->frequency = 2131 EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency; 2132 if (src_cfun->eh) 2133 init_eh_for_function (); 2134 2135 if (src_cfun->gimple_df) 2136 { 2137 init_tree_ssa (cfun); 2138 cfun->gimple_df->in_ssa_p = true; 2139 init_ssa_operands (); 2140 } 2141 pop_cfun (); 2142 } 2143 2144 /* Helper function for copy_cfg_body. Move debug stmts from the end 2145 of NEW_BB to the beginning of successor basic blocks when needed. If the 2146 successor has multiple predecessors, reset them, otherwise keep 2147 their value. */ 2148 2149 static void 2150 maybe_move_debug_stmts_to_successors (copy_body_data *id, basic_block new_bb) 2151 { 2152 edge e; 2153 edge_iterator ei; 2154 gimple_stmt_iterator si = gsi_last_nondebug_bb (new_bb); 2155 2156 if (gsi_end_p (si) 2157 || gsi_one_before_end_p (si) 2158 || !(stmt_can_throw_internal (gsi_stmt (si)) 2159 || stmt_can_make_abnormal_goto (gsi_stmt (si)))) 2160 return; 2161 2162 FOR_EACH_EDGE (e, ei, new_bb->succs) 2163 { 2164 gimple_stmt_iterator ssi = gsi_last_bb (new_bb); 2165 gimple_stmt_iterator dsi = gsi_after_labels (e->dest); 2166 while (is_gimple_debug (gsi_stmt (ssi))) 2167 { 2168 gimple stmt = gsi_stmt (ssi), new_stmt; 2169 tree var; 2170 tree value; 2171 2172 /* For the last edge move the debug stmts instead of copying 2173 them. */ 2174 if (ei_one_before_end_p (ei)) 2175 { 2176 si = ssi; 2177 gsi_prev (&ssi); 2178 if (!single_pred_p (e->dest) && gimple_debug_bind_p (stmt)) 2179 gimple_debug_bind_reset_value (stmt); 2180 gsi_remove (&si, false); 2181 gsi_insert_before (&dsi, stmt, GSI_SAME_STMT); 2182 continue; 2183 } 2184 2185 if (gimple_debug_bind_p (stmt)) 2186 { 2187 var = gimple_debug_bind_get_var (stmt); 2188 if (single_pred_p (e->dest)) 2189 { 2190 value = gimple_debug_bind_get_value (stmt); 2191 value = unshare_expr (value); 2192 } 2193 else 2194 value = NULL_TREE; 2195 new_stmt = gimple_build_debug_bind (var, value, stmt); 2196 } 2197 else if (gimple_debug_source_bind_p (stmt)) 2198 { 2199 var = gimple_debug_source_bind_get_var (stmt); 2200 value = gimple_debug_source_bind_get_value (stmt); 2201 new_stmt = gimple_build_debug_source_bind (var, value, stmt); 2202 } 2203 else 2204 gcc_unreachable (); 2205 gsi_insert_before (&dsi, new_stmt, GSI_SAME_STMT); 2206 VEC_safe_push (gimple, heap, id->debug_stmts, new_stmt); 2207 gsi_prev (&ssi); 2208 } 2209 } 2210 } 2211 2212 /* Make a copy of the body of FN so that it can be inserted inline in 2213 another function. Walks FN via CFG, returns new fndecl. */ 2214 2215 static tree 2216 copy_cfg_body (copy_body_data * id, gcov_type count, int frequency_scale, 2217 basic_block entry_block_map, basic_block exit_block_map, 2218 bitmap blocks_to_copy, basic_block new_entry) 2219 { 2220 tree callee_fndecl = id->src_fn; 2221 /* Original cfun for the callee, doesn't change. */ 2222 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl); 2223 struct function *cfun_to_copy; 2224 basic_block bb; 2225 tree new_fndecl = NULL; 2226 bool need_debug_cleanup = false; 2227 gcov_type count_scale; 2228 int last; 2229 int incoming_frequency = 0; 2230 gcov_type incoming_count = 0; 2231 2232 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count) 2233 count_scale = (REG_BR_PROB_BASE * count 2234 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count); 2235 else 2236 count_scale = REG_BR_PROB_BASE; 2237 2238 /* Register specific tree functions. */ 2239 gimple_register_cfg_hooks (); 2240 2241 /* If we are inlining just region of the function, make sure to connect new entry 2242 to ENTRY_BLOCK_PTR. Since new entry can be part of loop, we must compute 2243 frequency and probability of ENTRY_BLOCK_PTR based on the frequencies and 2244 probabilities of edges incoming from nonduplicated region. */ 2245 if (new_entry) 2246 { 2247 edge e; 2248 edge_iterator ei; 2249 2250 FOR_EACH_EDGE (e, ei, new_entry->preds) 2251 if (!e->src->aux) 2252 { 2253 incoming_frequency += EDGE_FREQUENCY (e); 2254 incoming_count += e->count; 2255 } 2256 incoming_count = incoming_count * count_scale / REG_BR_PROB_BASE; 2257 incoming_frequency 2258 = incoming_frequency * frequency_scale / REG_BR_PROB_BASE; 2259 ENTRY_BLOCK_PTR->count = incoming_count; 2260 ENTRY_BLOCK_PTR->frequency = incoming_frequency; 2261 } 2262 2263 /* Must have a CFG here at this point. */ 2264 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION 2265 (DECL_STRUCT_FUNCTION (callee_fndecl))); 2266 2267 cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl); 2268 2269 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map; 2270 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map; 2271 entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy); 2272 exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy); 2273 2274 /* Duplicate any exception-handling regions. */ 2275 if (cfun->eh) 2276 id->eh_map = duplicate_eh_regions (cfun_to_copy, NULL, id->eh_lp_nr, 2277 remap_decl_1, id); 2278 2279 /* Use aux pointers to map the original blocks to copy. */ 2280 FOR_EACH_BB_FN (bb, cfun_to_copy) 2281 if (!blocks_to_copy || bitmap_bit_p (blocks_to_copy, bb->index)) 2282 { 2283 basic_block new_bb = copy_bb (id, bb, frequency_scale, count_scale); 2284 bb->aux = new_bb; 2285 new_bb->aux = bb; 2286 } 2287 2288 last = last_basic_block; 2289 2290 /* Now that we've duplicated the blocks, duplicate their edges. */ 2291 FOR_ALL_BB_FN (bb, cfun_to_copy) 2292 if (!blocks_to_copy 2293 || (bb->index > 0 && bitmap_bit_p (blocks_to_copy, bb->index))) 2294 need_debug_cleanup |= copy_edges_for_bb (bb, count_scale, exit_block_map); 2295 2296 if (new_entry) 2297 { 2298 edge e = make_edge (entry_block_map, (basic_block)new_entry->aux, EDGE_FALLTHRU); 2299 e->probability = REG_BR_PROB_BASE; 2300 e->count = incoming_count; 2301 } 2302 2303 if (gimple_in_ssa_p (cfun)) 2304 FOR_ALL_BB_FN (bb, cfun_to_copy) 2305 if (!blocks_to_copy 2306 || (bb->index > 0 && bitmap_bit_p (blocks_to_copy, bb->index))) 2307 copy_phis_for_bb (bb, id); 2308 2309 FOR_ALL_BB_FN (bb, cfun_to_copy) 2310 if (bb->aux) 2311 { 2312 if (need_debug_cleanup 2313 && bb->index != ENTRY_BLOCK 2314 && bb->index != EXIT_BLOCK) 2315 maybe_move_debug_stmts_to_successors (id, (basic_block) bb->aux); 2316 ((basic_block)bb->aux)->aux = NULL; 2317 bb->aux = NULL; 2318 } 2319 2320 /* Zero out AUX fields of newly created block during EH edge 2321 insertion. */ 2322 for (; last < last_basic_block; last++) 2323 { 2324 if (need_debug_cleanup) 2325 maybe_move_debug_stmts_to_successors (id, BASIC_BLOCK (last)); 2326 BASIC_BLOCK (last)->aux = NULL; 2327 } 2328 entry_block_map->aux = NULL; 2329 exit_block_map->aux = NULL; 2330 2331 if (id->eh_map) 2332 { 2333 pointer_map_destroy (id->eh_map); 2334 id->eh_map = NULL; 2335 } 2336 2337 return new_fndecl; 2338 } 2339 2340 /* Copy the debug STMT using ID. We deal with these statements in a 2341 special way: if any variable in their VALUE expression wasn't 2342 remapped yet, we won't remap it, because that would get decl uids 2343 out of sync, causing codegen differences between -g and -g0. If 2344 this arises, we drop the VALUE expression altogether. */ 2345 2346 static void 2347 copy_debug_stmt (gimple stmt, copy_body_data *id) 2348 { 2349 tree t, *n; 2350 struct walk_stmt_info wi; 2351 2352 t = id->block; 2353 if (gimple_block (stmt)) 2354 { 2355 n = (tree *) pointer_map_contains (id->decl_map, gimple_block (stmt)); 2356 if (n) 2357 t = *n; 2358 } 2359 gimple_set_block (stmt, t); 2360 2361 /* Remap all the operands in COPY. */ 2362 memset (&wi, 0, sizeof (wi)); 2363 wi.info = id; 2364 2365 processing_debug_stmt = 1; 2366 2367 if (gimple_debug_source_bind_p (stmt)) 2368 t = gimple_debug_source_bind_get_var (stmt); 2369 else 2370 t = gimple_debug_bind_get_var (stmt); 2371 2372 if (TREE_CODE (t) == PARM_DECL && id->debug_map 2373 && (n = (tree *) pointer_map_contains (id->debug_map, t))) 2374 { 2375 gcc_assert (TREE_CODE (*n) == VAR_DECL); 2376 t = *n; 2377 } 2378 else if (TREE_CODE (t) == VAR_DECL 2379 && !TREE_STATIC (t) 2380 && gimple_in_ssa_p (cfun) 2381 && !pointer_map_contains (id->decl_map, t) 2382 && !var_ann (t)) 2383 /* T is a non-localized variable. */; 2384 else 2385 walk_tree (&t, remap_gimple_op_r, &wi, NULL); 2386 2387 if (gimple_debug_bind_p (stmt)) 2388 { 2389 gimple_debug_bind_set_var (stmt, t); 2390 2391 if (gimple_debug_bind_has_value_p (stmt)) 2392 walk_tree (gimple_debug_bind_get_value_ptr (stmt), 2393 remap_gimple_op_r, &wi, NULL); 2394 2395 /* Punt if any decl couldn't be remapped. */ 2396 if (processing_debug_stmt < 0) 2397 gimple_debug_bind_reset_value (stmt); 2398 } 2399 else if (gimple_debug_source_bind_p (stmt)) 2400 { 2401 gimple_debug_source_bind_set_var (stmt, t); 2402 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt), 2403 remap_gimple_op_r, &wi, NULL); 2404 } 2405 2406 processing_debug_stmt = 0; 2407 2408 update_stmt (stmt); 2409 if (gimple_in_ssa_p (cfun)) 2410 mark_symbols_for_renaming (stmt); 2411 } 2412 2413 /* Process deferred debug stmts. In order to give values better odds 2414 of being successfully remapped, we delay the processing of debug 2415 stmts until all other stmts that might require remapping are 2416 processed. */ 2417 2418 static void 2419 copy_debug_stmts (copy_body_data *id) 2420 { 2421 size_t i; 2422 gimple stmt; 2423 2424 if (!id->debug_stmts) 2425 return; 2426 2427 FOR_EACH_VEC_ELT (gimple, id->debug_stmts, i, stmt) 2428 copy_debug_stmt (stmt, id); 2429 2430 VEC_free (gimple, heap, id->debug_stmts); 2431 } 2432 2433 /* Make a copy of the body of SRC_FN so that it can be inserted inline in 2434 another function. */ 2435 2436 static tree 2437 copy_tree_body (copy_body_data *id) 2438 { 2439 tree fndecl = id->src_fn; 2440 tree body = DECL_SAVED_TREE (fndecl); 2441 2442 walk_tree (&body, copy_tree_body_r, id, NULL); 2443 2444 return body; 2445 } 2446 2447 /* Make a copy of the body of FN so that it can be inserted inline in 2448 another function. */ 2449 2450 static tree 2451 copy_body (copy_body_data *id, gcov_type count, int frequency_scale, 2452 basic_block entry_block_map, basic_block exit_block_map, 2453 bitmap blocks_to_copy, basic_block new_entry) 2454 { 2455 tree fndecl = id->src_fn; 2456 tree body; 2457 2458 /* If this body has a CFG, walk CFG and copy. */ 2459 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl))); 2460 body = copy_cfg_body (id, count, frequency_scale, entry_block_map, exit_block_map, 2461 blocks_to_copy, new_entry); 2462 copy_debug_stmts (id); 2463 2464 return body; 2465 } 2466 2467 /* Return true if VALUE is an ADDR_EXPR of an automatic variable 2468 defined in function FN, or of a data member thereof. */ 2469 2470 static bool 2471 self_inlining_addr_expr (tree value, tree fn) 2472 { 2473 tree var; 2474 2475 if (TREE_CODE (value) != ADDR_EXPR) 2476 return false; 2477 2478 var = get_base_address (TREE_OPERAND (value, 0)); 2479 2480 return var && auto_var_in_fn_p (var, fn); 2481 } 2482 2483 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting 2484 lexical block and line number information from base_stmt, if given, 2485 or from the last stmt of the block otherwise. */ 2486 2487 static gimple 2488 insert_init_debug_bind (copy_body_data *id, 2489 basic_block bb, tree var, tree value, 2490 gimple base_stmt) 2491 { 2492 gimple note; 2493 gimple_stmt_iterator gsi; 2494 tree tracked_var; 2495 2496 if (!gimple_in_ssa_p (id->src_cfun)) 2497 return NULL; 2498 2499 if (!MAY_HAVE_DEBUG_STMTS) 2500 return NULL; 2501 2502 tracked_var = target_for_debug_bind (var); 2503 if (!tracked_var) 2504 return NULL; 2505 2506 if (bb) 2507 { 2508 gsi = gsi_last_bb (bb); 2509 if (!base_stmt && !gsi_end_p (gsi)) 2510 base_stmt = gsi_stmt (gsi); 2511 } 2512 2513 note = gimple_build_debug_bind (tracked_var, value, base_stmt); 2514 2515 if (bb) 2516 { 2517 if (!gsi_end_p (gsi)) 2518 gsi_insert_after (&gsi, note, GSI_SAME_STMT); 2519 else 2520 gsi_insert_before (&gsi, note, GSI_SAME_STMT); 2521 } 2522 2523 return note; 2524 } 2525 2526 static void 2527 insert_init_stmt (copy_body_data *id, basic_block bb, gimple init_stmt) 2528 { 2529 /* If VAR represents a zero-sized variable, it's possible that the 2530 assignment statement may result in no gimple statements. */ 2531 if (init_stmt) 2532 { 2533 gimple_stmt_iterator si = gsi_last_bb (bb); 2534 2535 /* We can end up with init statements that store to a non-register 2536 from a rhs with a conversion. Handle that here by forcing the 2537 rhs into a temporary. gimple_regimplify_operands is not 2538 prepared to do this for us. */ 2539 if (!is_gimple_debug (init_stmt) 2540 && !is_gimple_reg (gimple_assign_lhs (init_stmt)) 2541 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt))) 2542 && gimple_assign_rhs_class (init_stmt) == GIMPLE_UNARY_RHS) 2543 { 2544 tree rhs = build1 (gimple_assign_rhs_code (init_stmt), 2545 gimple_expr_type (init_stmt), 2546 gimple_assign_rhs1 (init_stmt)); 2547 rhs = force_gimple_operand_gsi (&si, rhs, true, NULL_TREE, false, 2548 GSI_NEW_STMT); 2549 gimple_assign_set_rhs_code (init_stmt, TREE_CODE (rhs)); 2550 gimple_assign_set_rhs1 (init_stmt, rhs); 2551 } 2552 gsi_insert_after (&si, init_stmt, GSI_NEW_STMT); 2553 gimple_regimplify_operands (init_stmt, &si); 2554 mark_symbols_for_renaming (init_stmt); 2555 2556 if (!is_gimple_debug (init_stmt) && MAY_HAVE_DEBUG_STMTS) 2557 { 2558 tree var, def = gimple_assign_lhs (init_stmt); 2559 2560 if (TREE_CODE (def) == SSA_NAME) 2561 var = SSA_NAME_VAR (def); 2562 else 2563 var = def; 2564 2565 insert_init_debug_bind (id, bb, var, def, init_stmt); 2566 } 2567 } 2568 } 2569 2570 /* Initialize parameter P with VALUE. If needed, produce init statement 2571 at the end of BB. When BB is NULL, we return init statement to be 2572 output later. */ 2573 static gimple 2574 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn, 2575 basic_block bb, tree *vars) 2576 { 2577 gimple init_stmt = NULL; 2578 tree var; 2579 tree rhs = value; 2580 tree def = (gimple_in_ssa_p (cfun) 2581 ? gimple_default_def (id->src_cfun, p) : NULL); 2582 2583 if (value 2584 && value != error_mark_node 2585 && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value))) 2586 { 2587 /* If we can match up types by promotion/demotion do so. */ 2588 if (fold_convertible_p (TREE_TYPE (p), value)) 2589 rhs = fold_convert (TREE_TYPE (p), value); 2590 else 2591 { 2592 /* ??? For valid programs we should not end up here. 2593 Still if we end up with truly mismatched types here, fall back 2594 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid 2595 GIMPLE to the following passes. */ 2596 if (!is_gimple_reg_type (TREE_TYPE (value)) 2597 || TYPE_SIZE (TREE_TYPE (p)) == TYPE_SIZE (TREE_TYPE (value))) 2598 rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (p), value); 2599 else 2600 rhs = build_zero_cst (TREE_TYPE (p)); 2601 } 2602 } 2603 2604 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type 2605 here since the type of this decl must be visible to the calling 2606 function. */ 2607 var = copy_decl_to_var (p, id); 2608 2609 /* We're actually using the newly-created var. */ 2610 if (gimple_in_ssa_p (cfun) && TREE_CODE (var) == VAR_DECL) 2611 add_referenced_var (var); 2612 2613 /* Declare this new variable. */ 2614 DECL_CHAIN (var) = *vars; 2615 *vars = var; 2616 2617 /* Make gimplifier happy about this variable. */ 2618 DECL_SEEN_IN_BIND_EXPR_P (var) = 1; 2619 2620 /* We are eventually using the value - make sure all variables 2621 referenced therein are properly recorded. */ 2622 if (value 2623 && gimple_in_ssa_p (cfun) 2624 && TREE_CODE (value) == ADDR_EXPR) 2625 { 2626 tree base = get_base_address (TREE_OPERAND (value, 0)); 2627 if (base && TREE_CODE (base) == VAR_DECL) 2628 add_referenced_var (base); 2629 } 2630 2631 /* If the parameter is never assigned to, has no SSA_NAMEs created, 2632 we would not need to create a new variable here at all, if it 2633 weren't for debug info. Still, we can just use the argument 2634 value. */ 2635 if (TREE_READONLY (p) 2636 && !TREE_ADDRESSABLE (p) 2637 && value && !TREE_SIDE_EFFECTS (value) 2638 && !def) 2639 { 2640 /* We may produce non-gimple trees by adding NOPs or introduce 2641 invalid sharing when operand is not really constant. 2642 It is not big deal to prohibit constant propagation here as 2643 we will constant propagate in DOM1 pass anyway. */ 2644 if (is_gimple_min_invariant (value) 2645 && useless_type_conversion_p (TREE_TYPE (p), 2646 TREE_TYPE (value)) 2647 /* We have to be very careful about ADDR_EXPR. Make sure 2648 the base variable isn't a local variable of the inlined 2649 function, e.g., when doing recursive inlining, direct or 2650 mutually-recursive or whatever, which is why we don't 2651 just test whether fn == current_function_decl. */ 2652 && ! self_inlining_addr_expr (value, fn)) 2653 { 2654 insert_decl_map (id, p, value); 2655 insert_debug_decl_map (id, p, var); 2656 return insert_init_debug_bind (id, bb, var, value, NULL); 2657 } 2658 } 2659 2660 /* Register the VAR_DECL as the equivalent for the PARM_DECL; 2661 that way, when the PARM_DECL is encountered, it will be 2662 automatically replaced by the VAR_DECL. */ 2663 insert_decl_map (id, p, var); 2664 2665 /* Even if P was TREE_READONLY, the new VAR should not be. 2666 In the original code, we would have constructed a 2667 temporary, and then the function body would have never 2668 changed the value of P. However, now, we will be 2669 constructing VAR directly. The constructor body may 2670 change its value multiple times as it is being 2671 constructed. Therefore, it must not be TREE_READONLY; 2672 the back-end assumes that TREE_READONLY variable is 2673 assigned to only once. */ 2674 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p))) 2675 TREE_READONLY (var) = 0; 2676 2677 /* If there is no setup required and we are in SSA, take the easy route 2678 replacing all SSA names representing the function parameter by the 2679 SSA name passed to function. 2680 2681 We need to construct map for the variable anyway as it might be used 2682 in different SSA names when parameter is set in function. 2683 2684 Do replacement at -O0 for const arguments replaced by constant. 2685 This is important for builtin_constant_p and other construct requiring 2686 constant argument to be visible in inlined function body. */ 2687 if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p) 2688 && (optimize 2689 || (TREE_READONLY (p) 2690 && is_gimple_min_invariant (rhs))) 2691 && (TREE_CODE (rhs) == SSA_NAME 2692 || is_gimple_min_invariant (rhs)) 2693 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def)) 2694 { 2695 insert_decl_map (id, def, rhs); 2696 return insert_init_debug_bind (id, bb, var, rhs, NULL); 2697 } 2698 2699 /* If the value of argument is never used, don't care about initializing 2700 it. */ 2701 if (optimize && gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p)) 2702 { 2703 gcc_assert (!value || !TREE_SIDE_EFFECTS (value)); 2704 return insert_init_debug_bind (id, bb, var, rhs, NULL); 2705 } 2706 2707 /* Initialize this VAR_DECL from the equivalent argument. Convert 2708 the argument to the proper type in case it was promoted. */ 2709 if (value) 2710 { 2711 if (rhs == error_mark_node) 2712 { 2713 insert_decl_map (id, p, var); 2714 return insert_init_debug_bind (id, bb, var, rhs, NULL); 2715 } 2716 2717 STRIP_USELESS_TYPE_CONVERSION (rhs); 2718 2719 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we 2720 keep our trees in gimple form. */ 2721 if (def && gimple_in_ssa_p (cfun) && is_gimple_reg (p)) 2722 { 2723 def = remap_ssa_name (def, id); 2724 init_stmt = gimple_build_assign (def, rhs); 2725 SSA_NAME_IS_DEFAULT_DEF (def) = 0; 2726 set_default_def (var, NULL); 2727 } 2728 else 2729 init_stmt = gimple_build_assign (var, rhs); 2730 2731 if (bb && init_stmt) 2732 insert_init_stmt (id, bb, init_stmt); 2733 } 2734 return init_stmt; 2735 } 2736 2737 /* Generate code to initialize the parameters of the function at the 2738 top of the stack in ID from the GIMPLE_CALL STMT. */ 2739 2740 static void 2741 initialize_inlined_parameters (copy_body_data *id, gimple stmt, 2742 tree fn, basic_block bb) 2743 { 2744 tree parms; 2745 size_t i; 2746 tree p; 2747 tree vars = NULL_TREE; 2748 tree static_chain = gimple_call_chain (stmt); 2749 2750 /* Figure out what the parameters are. */ 2751 parms = DECL_ARGUMENTS (fn); 2752 2753 /* Loop through the parameter declarations, replacing each with an 2754 equivalent VAR_DECL, appropriately initialized. */ 2755 for (p = parms, i = 0; p; p = DECL_CHAIN (p), i++) 2756 { 2757 tree val; 2758 val = i < gimple_call_num_args (stmt) ? gimple_call_arg (stmt, i) : NULL; 2759 setup_one_parameter (id, p, val, fn, bb, &vars); 2760 } 2761 /* After remapping parameters remap their types. This has to be done 2762 in a second loop over all parameters to appropriately remap 2763 variable sized arrays when the size is specified in a 2764 parameter following the array. */ 2765 for (p = parms, i = 0; p; p = DECL_CHAIN (p), i++) 2766 { 2767 tree *varp = (tree *) pointer_map_contains (id->decl_map, p); 2768 if (varp 2769 && TREE_CODE (*varp) == VAR_DECL) 2770 { 2771 tree def = (gimple_in_ssa_p (cfun) && is_gimple_reg (p) 2772 ? gimple_default_def (id->src_cfun, p) : NULL); 2773 tree var = *varp; 2774 TREE_TYPE (var) = remap_type (TREE_TYPE (var), id); 2775 /* Also remap the default definition if it was remapped 2776 to the default definition of the parameter replacement 2777 by the parameter setup. */ 2778 if (def) 2779 { 2780 tree *defp = (tree *) pointer_map_contains (id->decl_map, def); 2781 if (defp 2782 && TREE_CODE (*defp) == SSA_NAME 2783 && SSA_NAME_VAR (*defp) == var) 2784 TREE_TYPE (*defp) = TREE_TYPE (var); 2785 } 2786 } 2787 } 2788 2789 /* Initialize the static chain. */ 2790 p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl; 2791 gcc_assert (fn != current_function_decl); 2792 if (p) 2793 { 2794 /* No static chain? Seems like a bug in tree-nested.c. */ 2795 gcc_assert (static_chain); 2796 2797 setup_one_parameter (id, p, static_chain, fn, bb, &vars); 2798 } 2799 2800 declare_inline_vars (id->block, vars); 2801 } 2802 2803 2804 /* Declare a return variable to replace the RESULT_DECL for the 2805 function we are calling. An appropriate DECL_STMT is returned. 2806 The USE_STMT is filled to contain a use of the declaration to 2807 indicate the return value of the function. 2808 2809 RETURN_SLOT, if non-null is place where to store the result. It 2810 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null, 2811 was the LHS of the MODIFY_EXPR to which this call is the RHS. 2812 2813 The return value is a (possibly null) value that holds the result 2814 as seen by the caller. */ 2815 2816 static tree 2817 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest, 2818 basic_block entry_bb) 2819 { 2820 tree callee = id->src_fn; 2821 tree result = DECL_RESULT (callee); 2822 tree callee_type = TREE_TYPE (result); 2823 tree caller_type; 2824 tree var, use; 2825 2826 /* Handle type-mismatches in the function declaration return type 2827 vs. the call expression. */ 2828 if (modify_dest) 2829 caller_type = TREE_TYPE (modify_dest); 2830 else 2831 caller_type = TREE_TYPE (TREE_TYPE (callee)); 2832 2833 /* We don't need to do anything for functions that don't return anything. */ 2834 if (VOID_TYPE_P (callee_type)) 2835 return NULL_TREE; 2836 2837 /* If there was a return slot, then the return value is the 2838 dereferenced address of that object. */ 2839 if (return_slot) 2840 { 2841 /* The front end shouldn't have used both return_slot and 2842 a modify expression. */ 2843 gcc_assert (!modify_dest); 2844 if (DECL_BY_REFERENCE (result)) 2845 { 2846 tree return_slot_addr = build_fold_addr_expr (return_slot); 2847 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr); 2848 2849 /* We are going to construct *&return_slot and we can't do that 2850 for variables believed to be not addressable. 2851 2852 FIXME: This check possibly can match, because values returned 2853 via return slot optimization are not believed to have address 2854 taken by alias analysis. */ 2855 gcc_assert (TREE_CODE (return_slot) != SSA_NAME); 2856 var = return_slot_addr; 2857 } 2858 else 2859 { 2860 var = return_slot; 2861 gcc_assert (TREE_CODE (var) != SSA_NAME); 2862 TREE_ADDRESSABLE (var) |= TREE_ADDRESSABLE (result); 2863 } 2864 if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE 2865 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE) 2866 && !DECL_GIMPLE_REG_P (result) 2867 && DECL_P (var)) 2868 DECL_GIMPLE_REG_P (var) = 0; 2869 use = NULL; 2870 goto done; 2871 } 2872 2873 /* All types requiring non-trivial constructors should have been handled. */ 2874 gcc_assert (!TREE_ADDRESSABLE (callee_type)); 2875 2876 /* Attempt to avoid creating a new temporary variable. */ 2877 if (modify_dest 2878 && TREE_CODE (modify_dest) != SSA_NAME) 2879 { 2880 bool use_it = false; 2881 2882 /* We can't use MODIFY_DEST if there's type promotion involved. */ 2883 if (!useless_type_conversion_p (callee_type, caller_type)) 2884 use_it = false; 2885 2886 /* ??? If we're assigning to a variable sized type, then we must 2887 reuse the destination variable, because we've no good way to 2888 create variable sized temporaries at this point. */ 2889 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST) 2890 use_it = true; 2891 2892 /* If the callee cannot possibly modify MODIFY_DEST, then we can 2893 reuse it as the result of the call directly. Don't do this if 2894 it would promote MODIFY_DEST to addressable. */ 2895 else if (TREE_ADDRESSABLE (result)) 2896 use_it = false; 2897 else 2898 { 2899 tree base_m = get_base_address (modify_dest); 2900 2901 /* If the base isn't a decl, then it's a pointer, and we don't 2902 know where that's going to go. */ 2903 if (!DECL_P (base_m)) 2904 use_it = false; 2905 else if (is_global_var (base_m)) 2906 use_it = false; 2907 else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE 2908 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE) 2909 && !DECL_GIMPLE_REG_P (result) 2910 && DECL_GIMPLE_REG_P (base_m)) 2911 use_it = false; 2912 else if (!TREE_ADDRESSABLE (base_m)) 2913 use_it = true; 2914 } 2915 2916 if (use_it) 2917 { 2918 var = modify_dest; 2919 use = NULL; 2920 goto done; 2921 } 2922 } 2923 2924 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST); 2925 2926 var = copy_result_decl_to_var (result, id); 2927 if (gimple_in_ssa_p (cfun)) 2928 add_referenced_var (var); 2929 2930 DECL_SEEN_IN_BIND_EXPR_P (var) = 1; 2931 2932 /* Do not have the rest of GCC warn about this variable as it should 2933 not be visible to the user. */ 2934 TREE_NO_WARNING (var) = 1; 2935 2936 declare_inline_vars (id->block, var); 2937 2938 /* Build the use expr. If the return type of the function was 2939 promoted, convert it back to the expected type. */ 2940 use = var; 2941 if (!useless_type_conversion_p (caller_type, TREE_TYPE (var))) 2942 { 2943 /* If we can match up types by promotion/demotion do so. */ 2944 if (fold_convertible_p (caller_type, var)) 2945 use = fold_convert (caller_type, var); 2946 else 2947 { 2948 /* ??? For valid programs we should not end up here. 2949 Still if we end up with truly mismatched types here, fall back 2950 to using a MEM_REF to not leak invalid GIMPLE to the following 2951 passes. */ 2952 /* Prevent var from being written into SSA form. */ 2953 if (TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE 2954 || TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE) 2955 DECL_GIMPLE_REG_P (var) = false; 2956 else if (is_gimple_reg_type (TREE_TYPE (var))) 2957 TREE_ADDRESSABLE (var) = true; 2958 use = fold_build2 (MEM_REF, caller_type, 2959 build_fold_addr_expr (var), 2960 build_int_cst (ptr_type_node, 0)); 2961 } 2962 } 2963 2964 STRIP_USELESS_TYPE_CONVERSION (use); 2965 2966 if (DECL_BY_REFERENCE (result)) 2967 { 2968 TREE_ADDRESSABLE (var) = 1; 2969 var = build_fold_addr_expr (var); 2970 } 2971 2972 done: 2973 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that 2974 way, when the RESULT_DECL is encountered, it will be 2975 automatically replaced by the VAR_DECL. 2976 2977 When returning by reference, ensure that RESULT_DECL remaps to 2978 gimple_val. */ 2979 if (DECL_BY_REFERENCE (result) 2980 && !is_gimple_val (var)) 2981 { 2982 tree temp = create_tmp_var (TREE_TYPE (result), "retvalptr"); 2983 if (gimple_in_ssa_p (id->src_cfun)) 2984 add_referenced_var (temp); 2985 insert_decl_map (id, result, temp); 2986 /* When RESULT_DECL is in SSA form, we need to use it's default_def 2987 SSA_NAME. */ 2988 if (gimple_in_ssa_p (id->src_cfun) && gimple_default_def (id->src_cfun, result)) 2989 temp = remap_ssa_name (gimple_default_def (id->src_cfun, result), id); 2990 insert_init_stmt (id, entry_bb, gimple_build_assign (temp, var)); 2991 } 2992 else 2993 insert_decl_map (id, result, var); 2994 2995 /* Remember this so we can ignore it in remap_decls. */ 2996 id->retvar = var; 2997 2998 return use; 2999 } 3000 3001 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference 3002 to a local label. */ 3003 3004 static tree 3005 has_label_address_in_static_1 (tree *nodep, int *walk_subtrees, void *fnp) 3006 { 3007 tree node = *nodep; 3008 tree fn = (tree) fnp; 3009 3010 if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn) 3011 return node; 3012 3013 if (TYPE_P (node)) 3014 *walk_subtrees = 0; 3015 3016 return NULL_TREE; 3017 } 3018 3019 /* Determine if the function can be copied. If so return NULL. If 3020 not return a string describng the reason for failure. */ 3021 3022 static const char * 3023 copy_forbidden (struct function *fun, tree fndecl) 3024 { 3025 const char *reason = fun->cannot_be_copied_reason; 3026 tree decl; 3027 unsigned ix; 3028 3029 /* Only examine the function once. */ 3030 if (fun->cannot_be_copied_set) 3031 return reason; 3032 3033 /* We cannot copy a function that receives a non-local goto 3034 because we cannot remap the destination label used in the 3035 function that is performing the non-local goto. */ 3036 /* ??? Actually, this should be possible, if we work at it. 3037 No doubt there's just a handful of places that simply 3038 assume it doesn't happen and don't substitute properly. */ 3039 if (fun->has_nonlocal_label) 3040 { 3041 reason = G_("function %q+F can never be copied " 3042 "because it receives a non-local goto"); 3043 goto fail; 3044 } 3045 3046 FOR_EACH_LOCAL_DECL (fun, ix, decl) 3047 if (TREE_CODE (decl) == VAR_DECL 3048 && TREE_STATIC (decl) 3049 && !DECL_EXTERNAL (decl) 3050 && DECL_INITIAL (decl) 3051 && walk_tree_without_duplicates (&DECL_INITIAL (decl), 3052 has_label_address_in_static_1, 3053 fndecl)) 3054 { 3055 reason = G_("function %q+F can never be copied because it saves " 3056 "address of local label in a static variable"); 3057 goto fail; 3058 } 3059 3060 fail: 3061 fun->cannot_be_copied_reason = reason; 3062 fun->cannot_be_copied_set = true; 3063 return reason; 3064 } 3065 3066 3067 static const char *inline_forbidden_reason; 3068 3069 /* A callback for walk_gimple_seq to handle statements. Returns non-null 3070 iff a function can not be inlined. Also sets the reason why. */ 3071 3072 static tree 3073 inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p, 3074 struct walk_stmt_info *wip) 3075 { 3076 tree fn = (tree) wip->info; 3077 tree t; 3078 gimple stmt = gsi_stmt (*gsi); 3079 3080 switch (gimple_code (stmt)) 3081 { 3082 case GIMPLE_CALL: 3083 /* Refuse to inline alloca call unless user explicitly forced so as 3084 this may change program's memory overhead drastically when the 3085 function using alloca is called in loop. In GCC present in 3086 SPEC2000 inlining into schedule_block cause it to require 2GB of 3087 RAM instead of 256MB. Don't do so for alloca calls emitted for 3088 VLA objects as those can't cause unbounded growth (they're always 3089 wrapped inside stack_save/stack_restore regions. */ 3090 if (gimple_alloca_call_p (stmt) 3091 && !gimple_call_alloca_for_var_p (stmt) 3092 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))) 3093 { 3094 inline_forbidden_reason 3095 = G_("function %q+F can never be inlined because it uses " 3096 "alloca (override using the always_inline attribute)"); 3097 *handled_ops_p = true; 3098 return fn; 3099 } 3100 3101 t = gimple_call_fndecl (stmt); 3102 if (t == NULL_TREE) 3103 break; 3104 3105 /* We cannot inline functions that call setjmp. */ 3106 if (setjmp_call_p (t)) 3107 { 3108 inline_forbidden_reason 3109 = G_("function %q+F can never be inlined because it uses setjmp"); 3110 *handled_ops_p = true; 3111 return t; 3112 } 3113 3114 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL) 3115 switch (DECL_FUNCTION_CODE (t)) 3116 { 3117 /* We cannot inline functions that take a variable number of 3118 arguments. */ 3119 case BUILT_IN_VA_START: 3120 case BUILT_IN_NEXT_ARG: 3121 case BUILT_IN_VA_END: 3122 inline_forbidden_reason 3123 = G_("function %q+F can never be inlined because it " 3124 "uses variable argument lists"); 3125 *handled_ops_p = true; 3126 return t; 3127 3128 case BUILT_IN_LONGJMP: 3129 /* We can't inline functions that call __builtin_longjmp at 3130 all. The non-local goto machinery really requires the 3131 destination be in a different function. If we allow the 3132 function calling __builtin_longjmp to be inlined into the 3133 function calling __builtin_setjmp, Things will Go Awry. */ 3134 inline_forbidden_reason 3135 = G_("function %q+F can never be inlined because " 3136 "it uses setjmp-longjmp exception handling"); 3137 *handled_ops_p = true; 3138 return t; 3139 3140 case BUILT_IN_NONLOCAL_GOTO: 3141 /* Similarly. */ 3142 inline_forbidden_reason 3143 = G_("function %q+F can never be inlined because " 3144 "it uses non-local goto"); 3145 *handled_ops_p = true; 3146 return t; 3147 3148 case BUILT_IN_RETURN: 3149 case BUILT_IN_APPLY_ARGS: 3150 /* If a __builtin_apply_args caller would be inlined, 3151 it would be saving arguments of the function it has 3152 been inlined into. Similarly __builtin_return would 3153 return from the function the inline has been inlined into. */ 3154 inline_forbidden_reason 3155 = G_("function %q+F can never be inlined because " 3156 "it uses __builtin_return or __builtin_apply_args"); 3157 *handled_ops_p = true; 3158 return t; 3159 3160 default: 3161 break; 3162 } 3163 break; 3164 3165 case GIMPLE_GOTO: 3166 t = gimple_goto_dest (stmt); 3167 3168 /* We will not inline a function which uses computed goto. The 3169 addresses of its local labels, which may be tucked into 3170 global storage, are of course not constant across 3171 instantiations, which causes unexpected behavior. */ 3172 if (TREE_CODE (t) != LABEL_DECL) 3173 { 3174 inline_forbidden_reason 3175 = G_("function %q+F can never be inlined " 3176 "because it contains a computed goto"); 3177 *handled_ops_p = true; 3178 return t; 3179 } 3180 break; 3181 3182 default: 3183 break; 3184 } 3185 3186 *handled_ops_p = false; 3187 return NULL_TREE; 3188 } 3189 3190 /* Return true if FNDECL is a function that cannot be inlined into 3191 another one. */ 3192 3193 static bool 3194 inline_forbidden_p (tree fndecl) 3195 { 3196 struct function *fun = DECL_STRUCT_FUNCTION (fndecl); 3197 struct walk_stmt_info wi; 3198 struct pointer_set_t *visited_nodes; 3199 basic_block bb; 3200 bool forbidden_p = false; 3201 3202 /* First check for shared reasons not to copy the code. */ 3203 inline_forbidden_reason = copy_forbidden (fun, fndecl); 3204 if (inline_forbidden_reason != NULL) 3205 return true; 3206 3207 /* Next, walk the statements of the function looking for 3208 constraucts we can't handle, or are non-optimal for inlining. */ 3209 visited_nodes = pointer_set_create (); 3210 memset (&wi, 0, sizeof (wi)); 3211 wi.info = (void *) fndecl; 3212 wi.pset = visited_nodes; 3213 3214 FOR_EACH_BB_FN (bb, fun) 3215 { 3216 gimple ret; 3217 gimple_seq seq = bb_seq (bb); 3218 ret = walk_gimple_seq (seq, inline_forbidden_p_stmt, NULL, &wi); 3219 forbidden_p = (ret != NULL); 3220 if (forbidden_p) 3221 break; 3222 } 3223 3224 pointer_set_destroy (visited_nodes); 3225 return forbidden_p; 3226 } 3227 3228 /* Returns nonzero if FN is a function that does not have any 3229 fundamental inline blocking properties. */ 3230 3231 bool 3232 tree_inlinable_function_p (tree fn) 3233 { 3234 bool inlinable = true; 3235 bool do_warning; 3236 tree always_inline; 3237 3238 /* If we've already decided this function shouldn't be inlined, 3239 there's no need to check again. */ 3240 if (DECL_UNINLINABLE (fn)) 3241 return false; 3242 3243 /* We only warn for functions declared `inline' by the user. */ 3244 do_warning = (warn_inline 3245 && DECL_DECLARED_INLINE_P (fn) 3246 && !DECL_NO_INLINE_WARNING_P (fn) 3247 && !DECL_IN_SYSTEM_HEADER (fn)); 3248 3249 always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)); 3250 3251 if (flag_no_inline 3252 && always_inline == NULL) 3253 { 3254 if (do_warning) 3255 warning (OPT_Winline, "function %q+F can never be inlined because it " 3256 "is suppressed using -fno-inline", fn); 3257 inlinable = false; 3258 } 3259 3260 else if (!function_attribute_inlinable_p (fn)) 3261 { 3262 if (do_warning) 3263 warning (OPT_Winline, "function %q+F can never be inlined because it " 3264 "uses attributes conflicting with inlining", fn); 3265 inlinable = false; 3266 } 3267 3268 else if (inline_forbidden_p (fn)) 3269 { 3270 /* See if we should warn about uninlinable functions. Previously, 3271 some of these warnings would be issued while trying to expand 3272 the function inline, but that would cause multiple warnings 3273 about functions that would for example call alloca. But since 3274 this a property of the function, just one warning is enough. 3275 As a bonus we can now give more details about the reason why a 3276 function is not inlinable. */ 3277 if (always_inline) 3278 error (inline_forbidden_reason, fn); 3279 else if (do_warning) 3280 warning (OPT_Winline, inline_forbidden_reason, fn); 3281 3282 inlinable = false; 3283 } 3284 3285 /* Squirrel away the result so that we don't have to check again. */ 3286 DECL_UNINLINABLE (fn) = !inlinable; 3287 3288 return inlinable; 3289 } 3290 3291 /* Estimate the cost of a memory move. Use machine dependent 3292 word size and take possible memcpy call into account. */ 3293 3294 int 3295 estimate_move_cost (tree type) 3296 { 3297 HOST_WIDE_INT size; 3298 3299 gcc_assert (!VOID_TYPE_P (type)); 3300 3301 if (TREE_CODE (type) == VECTOR_TYPE) 3302 { 3303 enum machine_mode inner = TYPE_MODE (TREE_TYPE (type)); 3304 enum machine_mode simd 3305 = targetm.vectorize.preferred_simd_mode (inner); 3306 int simd_mode_size = GET_MODE_SIZE (simd); 3307 return ((GET_MODE_SIZE (TYPE_MODE (type)) + simd_mode_size - 1) 3308 / simd_mode_size); 3309 } 3310 3311 size = int_size_in_bytes (type); 3312 3313 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO (!optimize_size)) 3314 /* Cost of a memcpy call, 3 arguments and the call. */ 3315 return 4; 3316 else 3317 return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES); 3318 } 3319 3320 /* Returns cost of operation CODE, according to WEIGHTS */ 3321 3322 static int 3323 estimate_operator_cost (enum tree_code code, eni_weights *weights, 3324 tree op1 ATTRIBUTE_UNUSED, tree op2) 3325 { 3326 switch (code) 3327 { 3328 /* These are "free" conversions, or their presumed cost 3329 is folded into other operations. */ 3330 case RANGE_EXPR: 3331 CASE_CONVERT: 3332 case COMPLEX_EXPR: 3333 case PAREN_EXPR: 3334 case VIEW_CONVERT_EXPR: 3335 return 0; 3336 3337 /* Assign cost of 1 to usual operations. 3338 ??? We may consider mapping RTL costs to this. */ 3339 case COND_EXPR: 3340 case VEC_COND_EXPR: 3341 case VEC_PERM_EXPR: 3342 3343 case PLUS_EXPR: 3344 case POINTER_PLUS_EXPR: 3345 case MINUS_EXPR: 3346 case MULT_EXPR: 3347 case FMA_EXPR: 3348 3349 case ADDR_SPACE_CONVERT_EXPR: 3350 case FIXED_CONVERT_EXPR: 3351 case FIX_TRUNC_EXPR: 3352 3353 case NEGATE_EXPR: 3354 case FLOAT_EXPR: 3355 case MIN_EXPR: 3356 case MAX_EXPR: 3357 case ABS_EXPR: 3358 3359 case LSHIFT_EXPR: 3360 case RSHIFT_EXPR: 3361 case LROTATE_EXPR: 3362 case RROTATE_EXPR: 3363 case VEC_LSHIFT_EXPR: 3364 case VEC_RSHIFT_EXPR: 3365 3366 case BIT_IOR_EXPR: 3367 case BIT_XOR_EXPR: 3368 case BIT_AND_EXPR: 3369 case BIT_NOT_EXPR: 3370 3371 case TRUTH_ANDIF_EXPR: 3372 case TRUTH_ORIF_EXPR: 3373 case TRUTH_AND_EXPR: 3374 case TRUTH_OR_EXPR: 3375 case TRUTH_XOR_EXPR: 3376 case TRUTH_NOT_EXPR: 3377 3378 case LT_EXPR: 3379 case LE_EXPR: 3380 case GT_EXPR: 3381 case GE_EXPR: 3382 case EQ_EXPR: 3383 case NE_EXPR: 3384 case ORDERED_EXPR: 3385 case UNORDERED_EXPR: 3386 3387 case UNLT_EXPR: 3388 case UNLE_EXPR: 3389 case UNGT_EXPR: 3390 case UNGE_EXPR: 3391 case UNEQ_EXPR: 3392 case LTGT_EXPR: 3393 3394 case CONJ_EXPR: 3395 3396 case PREDECREMENT_EXPR: 3397 case PREINCREMENT_EXPR: 3398 case POSTDECREMENT_EXPR: 3399 case POSTINCREMENT_EXPR: 3400 3401 case REALIGN_LOAD_EXPR: 3402 3403 case REDUC_MAX_EXPR: 3404 case REDUC_MIN_EXPR: 3405 case REDUC_PLUS_EXPR: 3406 case WIDEN_SUM_EXPR: 3407 case WIDEN_MULT_EXPR: 3408 case DOT_PROD_EXPR: 3409 case WIDEN_MULT_PLUS_EXPR: 3410 case WIDEN_MULT_MINUS_EXPR: 3411 case WIDEN_LSHIFT_EXPR: 3412 3413 case VEC_WIDEN_MULT_HI_EXPR: 3414 case VEC_WIDEN_MULT_LO_EXPR: 3415 case VEC_UNPACK_HI_EXPR: 3416 case VEC_UNPACK_LO_EXPR: 3417 case VEC_UNPACK_FLOAT_HI_EXPR: 3418 case VEC_UNPACK_FLOAT_LO_EXPR: 3419 case VEC_PACK_TRUNC_EXPR: 3420 case VEC_PACK_SAT_EXPR: 3421 case VEC_PACK_FIX_TRUNC_EXPR: 3422 case VEC_WIDEN_LSHIFT_HI_EXPR: 3423 case VEC_WIDEN_LSHIFT_LO_EXPR: 3424 3425 return 1; 3426 3427 /* Few special cases of expensive operations. This is useful 3428 to avoid inlining on functions having too many of these. */ 3429 case TRUNC_DIV_EXPR: 3430 case CEIL_DIV_EXPR: 3431 case FLOOR_DIV_EXPR: 3432 case ROUND_DIV_EXPR: 3433 case EXACT_DIV_EXPR: 3434 case TRUNC_MOD_EXPR: 3435 case CEIL_MOD_EXPR: 3436 case FLOOR_MOD_EXPR: 3437 case ROUND_MOD_EXPR: 3438 case RDIV_EXPR: 3439 if (TREE_CODE (op2) != INTEGER_CST) 3440 return weights->div_mod_cost; 3441 return 1; 3442 3443 default: 3444 /* We expect a copy assignment with no operator. */ 3445 gcc_assert (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS); 3446 return 0; 3447 } 3448 } 3449 3450 3451 /* Estimate number of instructions that will be created by expanding 3452 the statements in the statement sequence STMTS. 3453 WEIGHTS contains weights attributed to various constructs. */ 3454 3455 static 3456 int estimate_num_insns_seq (gimple_seq stmts, eni_weights *weights) 3457 { 3458 int cost; 3459 gimple_stmt_iterator gsi; 3460 3461 cost = 0; 3462 for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi)) 3463 cost += estimate_num_insns (gsi_stmt (gsi), weights); 3464 3465 return cost; 3466 } 3467 3468 3469 /* Estimate number of instructions that will be created by expanding STMT. 3470 WEIGHTS contains weights attributed to various constructs. */ 3471 3472 int 3473 estimate_num_insns (gimple stmt, eni_weights *weights) 3474 { 3475 unsigned cost, i; 3476 enum gimple_code code = gimple_code (stmt); 3477 tree lhs; 3478 tree rhs; 3479 3480 switch (code) 3481 { 3482 case GIMPLE_ASSIGN: 3483 /* Try to estimate the cost of assignments. We have three cases to 3484 deal with: 3485 1) Simple assignments to registers; 3486 2) Stores to things that must live in memory. This includes 3487 "normal" stores to scalars, but also assignments of large 3488 structures, or constructors of big arrays; 3489 3490 Let us look at the first two cases, assuming we have "a = b + C": 3491 <GIMPLE_ASSIGN <var_decl "a"> 3492 <plus_expr <var_decl "b"> <constant C>> 3493 If "a" is a GIMPLE register, the assignment to it is free on almost 3494 any target, because "a" usually ends up in a real register. Hence 3495 the only cost of this expression comes from the PLUS_EXPR, and we 3496 can ignore the GIMPLE_ASSIGN. 3497 If "a" is not a GIMPLE register, the assignment to "a" will most 3498 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost 3499 of moving something into "a", which we compute using the function 3500 estimate_move_cost. */ 3501 if (gimple_clobber_p (stmt)) 3502 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */ 3503 3504 lhs = gimple_assign_lhs (stmt); 3505 rhs = gimple_assign_rhs1 (stmt); 3506 3507 if (is_gimple_reg (lhs)) 3508 cost = 0; 3509 else 3510 cost = estimate_move_cost (TREE_TYPE (lhs)); 3511 3512 if (!is_gimple_reg (rhs) && !is_gimple_min_invariant (rhs)) 3513 cost += estimate_move_cost (TREE_TYPE (rhs)); 3514 3515 cost += estimate_operator_cost (gimple_assign_rhs_code (stmt), weights, 3516 gimple_assign_rhs1 (stmt), 3517 get_gimple_rhs_class (gimple_assign_rhs_code (stmt)) 3518 == GIMPLE_BINARY_RHS 3519 ? gimple_assign_rhs2 (stmt) : NULL); 3520 break; 3521 3522 case GIMPLE_COND: 3523 cost = 1 + estimate_operator_cost (gimple_cond_code (stmt), weights, 3524 gimple_op (stmt, 0), 3525 gimple_op (stmt, 1)); 3526 break; 3527 3528 case GIMPLE_SWITCH: 3529 /* Take into account cost of the switch + guess 2 conditional jumps for 3530 each case label. 3531 3532 TODO: once the switch expansion logic is sufficiently separated, we can 3533 do better job on estimating cost of the switch. */ 3534 if (weights->time_based) 3535 cost = floor_log2 (gimple_switch_num_labels (stmt)) * 2; 3536 else 3537 cost = gimple_switch_num_labels (stmt) * 2; 3538 break; 3539 3540 case GIMPLE_CALL: 3541 { 3542 tree decl = gimple_call_fndecl (stmt); 3543 struct cgraph_node *node = NULL; 3544 3545 /* Do not special case builtins where we see the body. 3546 This just confuse inliner. */ 3547 if (!decl || !(node = cgraph_get_node (decl)) || node->analyzed) 3548 ; 3549 /* For buitins that are likely expanded to nothing or 3550 inlined do not account operand costs. */ 3551 else if (is_simple_builtin (decl)) 3552 return 0; 3553 else if (is_inexpensive_builtin (decl)) 3554 return weights->target_builtin_call_cost; 3555 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL) 3556 { 3557 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so 3558 specialize the cheap expansion we do here. 3559 ??? This asks for a more general solution. */ 3560 switch (DECL_FUNCTION_CODE (decl)) 3561 { 3562 case BUILT_IN_POW: 3563 case BUILT_IN_POWF: 3564 case BUILT_IN_POWL: 3565 if (TREE_CODE (gimple_call_arg (stmt, 1)) == REAL_CST 3566 && REAL_VALUES_EQUAL 3567 (TREE_REAL_CST (gimple_call_arg (stmt, 1)), dconst2)) 3568 return estimate_operator_cost (MULT_EXPR, weights, 3569 gimple_call_arg (stmt, 0), 3570 gimple_call_arg (stmt, 0)); 3571 break; 3572 3573 default: 3574 break; 3575 } 3576 } 3577 3578 cost = node ? weights->call_cost : weights->indirect_call_cost; 3579 if (gimple_call_lhs (stmt)) 3580 cost += estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt))); 3581 for (i = 0; i < gimple_call_num_args (stmt); i++) 3582 { 3583 tree arg = gimple_call_arg (stmt, i); 3584 cost += estimate_move_cost (TREE_TYPE (arg)); 3585 } 3586 break; 3587 } 3588 3589 case GIMPLE_RETURN: 3590 return weights->return_cost; 3591 3592 case GIMPLE_GOTO: 3593 case GIMPLE_LABEL: 3594 case GIMPLE_NOP: 3595 case GIMPLE_PHI: 3596 case GIMPLE_PREDICT: 3597 case GIMPLE_DEBUG: 3598 return 0; 3599 3600 case GIMPLE_ASM: 3601 return asm_str_count (gimple_asm_string (stmt)); 3602 3603 case GIMPLE_RESX: 3604 /* This is either going to be an external function call with one 3605 argument, or two register copy statements plus a goto. */ 3606 return 2; 3607 3608 case GIMPLE_EH_DISPATCH: 3609 /* ??? This is going to turn into a switch statement. Ideally 3610 we'd have a look at the eh region and estimate the number of 3611 edges involved. */ 3612 return 10; 3613 3614 case GIMPLE_BIND: 3615 return estimate_num_insns_seq (gimple_bind_body (stmt), weights); 3616 3617 case GIMPLE_EH_FILTER: 3618 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt), weights); 3619 3620 case GIMPLE_CATCH: 3621 return estimate_num_insns_seq (gimple_catch_handler (stmt), weights); 3622 3623 case GIMPLE_TRY: 3624 return (estimate_num_insns_seq (gimple_try_eval (stmt), weights) 3625 + estimate_num_insns_seq (gimple_try_cleanup (stmt), weights)); 3626 3627 /* OpenMP directives are generally very expensive. */ 3628 3629 case GIMPLE_OMP_RETURN: 3630 case GIMPLE_OMP_SECTIONS_SWITCH: 3631 case GIMPLE_OMP_ATOMIC_STORE: 3632 case GIMPLE_OMP_CONTINUE: 3633 /* ...except these, which are cheap. */ 3634 return 0; 3635 3636 case GIMPLE_OMP_ATOMIC_LOAD: 3637 return weights->omp_cost; 3638 3639 case GIMPLE_OMP_FOR: 3640 return (weights->omp_cost 3641 + estimate_num_insns_seq (gimple_omp_body (stmt), weights) 3642 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt), weights)); 3643 3644 case GIMPLE_OMP_PARALLEL: 3645 case GIMPLE_OMP_TASK: 3646 case GIMPLE_OMP_CRITICAL: 3647 case GIMPLE_OMP_MASTER: 3648 case GIMPLE_OMP_ORDERED: 3649 case GIMPLE_OMP_SECTION: 3650 case GIMPLE_OMP_SECTIONS: 3651 case GIMPLE_OMP_SINGLE: 3652 return (weights->omp_cost 3653 + estimate_num_insns_seq (gimple_omp_body (stmt), weights)); 3654 3655 case GIMPLE_TRANSACTION: 3656 return (weights->tm_cost 3657 + estimate_num_insns_seq (gimple_transaction_body (stmt), 3658 weights)); 3659 3660 default: 3661 gcc_unreachable (); 3662 } 3663 3664 return cost; 3665 } 3666 3667 /* Estimate number of instructions that will be created by expanding 3668 function FNDECL. WEIGHTS contains weights attributed to various 3669 constructs. */ 3670 3671 int 3672 estimate_num_insns_fn (tree fndecl, eni_weights *weights) 3673 { 3674 struct function *my_function = DECL_STRUCT_FUNCTION (fndecl); 3675 gimple_stmt_iterator bsi; 3676 basic_block bb; 3677 int n = 0; 3678 3679 gcc_assert (my_function && my_function->cfg); 3680 FOR_EACH_BB_FN (bb, my_function) 3681 { 3682 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) 3683 n += estimate_num_insns (gsi_stmt (bsi), weights); 3684 } 3685 3686 return n; 3687 } 3688 3689 3690 /* Initializes weights used by estimate_num_insns. */ 3691 3692 void 3693 init_inline_once (void) 3694 { 3695 eni_size_weights.call_cost = 1; 3696 eni_size_weights.indirect_call_cost = 3; 3697 eni_size_weights.target_builtin_call_cost = 1; 3698 eni_size_weights.div_mod_cost = 1; 3699 eni_size_weights.omp_cost = 40; 3700 eni_size_weights.tm_cost = 10; 3701 eni_size_weights.time_based = false; 3702 eni_size_weights.return_cost = 1; 3703 3704 /* Estimating time for call is difficult, since we have no idea what the 3705 called function does. In the current uses of eni_time_weights, 3706 underestimating the cost does less harm than overestimating it, so 3707 we choose a rather small value here. */ 3708 eni_time_weights.call_cost = 10; 3709 eni_time_weights.indirect_call_cost = 15; 3710 eni_time_weights.target_builtin_call_cost = 1; 3711 eni_time_weights.div_mod_cost = 10; 3712 eni_time_weights.omp_cost = 40; 3713 eni_time_weights.tm_cost = 40; 3714 eni_time_weights.time_based = true; 3715 eni_time_weights.return_cost = 2; 3716 } 3717 3718 /* Estimate the number of instructions in a gimple_seq. */ 3719 3720 int 3721 count_insns_seq (gimple_seq seq, eni_weights *weights) 3722 { 3723 gimple_stmt_iterator gsi; 3724 int n = 0; 3725 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi)) 3726 n += estimate_num_insns (gsi_stmt (gsi), weights); 3727 3728 return n; 3729 } 3730 3731 3732 /* Install new lexical TREE_BLOCK underneath 'current_block'. */ 3733 3734 static void 3735 prepend_lexical_block (tree current_block, tree new_block) 3736 { 3737 BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (current_block); 3738 BLOCK_SUBBLOCKS (current_block) = new_block; 3739 BLOCK_SUPERCONTEXT (new_block) = current_block; 3740 } 3741 3742 /* Add local variables from CALLEE to CALLER. */ 3743 3744 static inline void 3745 add_local_variables (struct function *callee, struct function *caller, 3746 copy_body_data *id, bool check_var_ann) 3747 { 3748 tree var; 3749 unsigned ix; 3750 3751 FOR_EACH_LOCAL_DECL (callee, ix, var) 3752 if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var)) 3753 { 3754 if (!check_var_ann 3755 || (var_ann (var) && add_referenced_var (var))) 3756 add_local_decl (caller, var); 3757 } 3758 else if (!can_be_nonlocal (var, id)) 3759 { 3760 tree new_var = remap_decl (var, id); 3761 3762 /* Remap debug-expressions. */ 3763 if (TREE_CODE (new_var) == VAR_DECL 3764 && DECL_DEBUG_EXPR_IS_FROM (new_var) 3765 && new_var != var) 3766 { 3767 tree tem = DECL_DEBUG_EXPR (var); 3768 bool old_regimplify = id->regimplify; 3769 id->remapping_type_depth++; 3770 walk_tree (&tem, copy_tree_body_r, id, NULL); 3771 id->remapping_type_depth--; 3772 id->regimplify = old_regimplify; 3773 SET_DECL_DEBUG_EXPR (new_var, tem); 3774 } 3775 add_local_decl (caller, new_var); 3776 } 3777 } 3778 3779 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */ 3780 3781 static bool 3782 expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id) 3783 { 3784 tree use_retvar; 3785 tree fn; 3786 struct pointer_map_t *st, *dst; 3787 tree return_slot; 3788 tree modify_dest; 3789 location_t saved_location; 3790 struct cgraph_edge *cg_edge; 3791 cgraph_inline_failed_t reason; 3792 basic_block return_block; 3793 edge e; 3794 gimple_stmt_iterator gsi, stmt_gsi; 3795 bool successfully_inlined = FALSE; 3796 bool purge_dead_abnormal_edges; 3797 3798 /* Set input_location here so we get the right instantiation context 3799 if we call instantiate_decl from inlinable_function_p. */ 3800 saved_location = input_location; 3801 if (gimple_has_location (stmt)) 3802 input_location = gimple_location (stmt); 3803 3804 /* From here on, we're only interested in CALL_EXPRs. */ 3805 if (gimple_code (stmt) != GIMPLE_CALL) 3806 goto egress; 3807 3808 cg_edge = cgraph_edge (id->dst_node, stmt); 3809 gcc_checking_assert (cg_edge); 3810 /* First, see if we can figure out what function is being called. 3811 If we cannot, then there is no hope of inlining the function. */ 3812 if (cg_edge->indirect_unknown_callee) 3813 goto egress; 3814 fn = cg_edge->callee->decl; 3815 gcc_checking_assert (fn); 3816 3817 /* If FN is a declaration of a function in a nested scope that was 3818 globally declared inline, we don't set its DECL_INITIAL. 3819 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the 3820 C++ front-end uses it for cdtors to refer to their internal 3821 declarations, that are not real functions. Fortunately those 3822 don't have trees to be saved, so we can tell by checking their 3823 gimple_body. */ 3824 if (!DECL_INITIAL (fn) 3825 && DECL_ABSTRACT_ORIGIN (fn) 3826 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn))) 3827 fn = DECL_ABSTRACT_ORIGIN (fn); 3828 3829 /* Don't try to inline functions that are not well-suited to inlining. */ 3830 if (!cgraph_inline_p (cg_edge, &reason)) 3831 { 3832 /* If this call was originally indirect, we do not want to emit any 3833 inlining related warnings or sorry messages because there are no 3834 guarantees regarding those. */ 3835 if (cg_edge->indirect_inlining_edge) 3836 goto egress; 3837 3838 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) 3839 /* Avoid warnings during early inline pass. */ 3840 && cgraph_global_info_ready 3841 /* PR 20090218-1_0.c. Body can be provided by another module. */ 3842 && (reason != CIF_BODY_NOT_AVAILABLE || !flag_generate_lto)) 3843 { 3844 error ("inlining failed in call to always_inline %q+F: %s", fn, 3845 cgraph_inline_failed_string (reason)); 3846 error ("called from here"); 3847 } 3848 else if (warn_inline 3849 && DECL_DECLARED_INLINE_P (fn) 3850 && !DECL_NO_INLINE_WARNING_P (fn) 3851 && !DECL_IN_SYSTEM_HEADER (fn) 3852 && reason != CIF_UNSPECIFIED 3853 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn)) 3854 /* Do not warn about not inlined recursive calls. */ 3855 && !cgraph_edge_recursive_p (cg_edge) 3856 /* Avoid warnings during early inline pass. */ 3857 && cgraph_global_info_ready 3858 && reason != CIF_UNLIKELY_CALL) 3859 { 3860 warning (OPT_Winline, "inlining failed in call to %q+F: %s", 3861 fn, _(cgraph_inline_failed_string (reason))); 3862 warning (OPT_Winline, "called from here"); 3863 } 3864 goto egress; 3865 } 3866 fn = cg_edge->callee->decl; 3867 3868 #ifdef ENABLE_CHECKING 3869 if (cg_edge->callee->decl != id->dst_node->decl) 3870 verify_cgraph_node (cg_edge->callee); 3871 #endif 3872 3873 /* We will be inlining this callee. */ 3874 id->eh_lp_nr = lookup_stmt_eh_lp (stmt); 3875 3876 /* Update the callers EH personality. */ 3877 if (DECL_FUNCTION_PERSONALITY (cg_edge->callee->decl)) 3878 DECL_FUNCTION_PERSONALITY (cg_edge->caller->decl) 3879 = DECL_FUNCTION_PERSONALITY (cg_edge->callee->decl); 3880 3881 /* Split the block holding the GIMPLE_CALL. */ 3882 e = split_block (bb, stmt); 3883 bb = e->src; 3884 return_block = e->dest; 3885 remove_edge (e); 3886 3887 /* split_block splits after the statement; work around this by 3888 moving the call into the second block manually. Not pretty, 3889 but seems easier than doing the CFG manipulation by hand 3890 when the GIMPLE_CALL is in the last statement of BB. */ 3891 stmt_gsi = gsi_last_bb (bb); 3892 gsi_remove (&stmt_gsi, false); 3893 3894 /* If the GIMPLE_CALL was in the last statement of BB, it may have 3895 been the source of abnormal edges. In this case, schedule 3896 the removal of dead abnormal edges. */ 3897 gsi = gsi_start_bb (return_block); 3898 if (gsi_end_p (gsi)) 3899 { 3900 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT); 3901 purge_dead_abnormal_edges = true; 3902 } 3903 else 3904 { 3905 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT); 3906 purge_dead_abnormal_edges = false; 3907 } 3908 3909 stmt_gsi = gsi_start_bb (return_block); 3910 3911 /* Build a block containing code to initialize the arguments, the 3912 actual inline expansion of the body, and a label for the return 3913 statements within the function to jump to. The type of the 3914 statement expression is the return type of the function call. */ 3915 id->block = make_node (BLOCK); 3916 BLOCK_ABSTRACT_ORIGIN (id->block) = fn; 3917 BLOCK_SOURCE_LOCATION (id->block) = input_location; 3918 prepend_lexical_block (gimple_block (stmt), id->block); 3919 3920 /* Local declarations will be replaced by their equivalents in this 3921 map. */ 3922 st = id->decl_map; 3923 id->decl_map = pointer_map_create (); 3924 dst = id->debug_map; 3925 id->debug_map = NULL; 3926 3927 /* Record the function we are about to inline. */ 3928 id->src_fn = fn; 3929 id->src_node = cg_edge->callee; 3930 id->src_cfun = DECL_STRUCT_FUNCTION (fn); 3931 id->gimple_call = stmt; 3932 3933 gcc_assert (!id->src_cfun->after_inlining); 3934 3935 id->entry_bb = bb; 3936 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn))) 3937 { 3938 gimple_stmt_iterator si = gsi_last_bb (bb); 3939 gsi_insert_after (&si, gimple_build_predict (PRED_COLD_FUNCTION, 3940 NOT_TAKEN), 3941 GSI_NEW_STMT); 3942 } 3943 initialize_inlined_parameters (id, stmt, fn, bb); 3944 3945 if (DECL_INITIAL (fn)) 3946 prepend_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id)); 3947 3948 /* Return statements in the function body will be replaced by jumps 3949 to the RET_LABEL. */ 3950 gcc_assert (DECL_INITIAL (fn)); 3951 gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK); 3952 3953 /* Find the LHS to which the result of this call is assigned. */ 3954 return_slot = NULL; 3955 if (gimple_call_lhs (stmt)) 3956 { 3957 modify_dest = gimple_call_lhs (stmt); 3958 3959 /* The function which we are inlining might not return a value, 3960 in which case we should issue a warning that the function 3961 does not return a value. In that case the optimizers will 3962 see that the variable to which the value is assigned was not 3963 initialized. We do not want to issue a warning about that 3964 uninitialized variable. */ 3965 if (DECL_P (modify_dest)) 3966 TREE_NO_WARNING (modify_dest) = 1; 3967 3968 if (gimple_call_return_slot_opt_p (stmt)) 3969 { 3970 return_slot = modify_dest; 3971 modify_dest = NULL; 3972 } 3973 } 3974 else 3975 modify_dest = NULL; 3976 3977 /* If we are inlining a call to the C++ operator new, we don't want 3978 to use type based alias analysis on the return value. Otherwise 3979 we may get confused if the compiler sees that the inlined new 3980 function returns a pointer which was just deleted. See bug 3981 33407. */ 3982 if (DECL_IS_OPERATOR_NEW (fn)) 3983 { 3984 return_slot = NULL; 3985 modify_dest = NULL; 3986 } 3987 3988 /* Declare the return variable for the function. */ 3989 use_retvar = declare_return_variable (id, return_slot, modify_dest, bb); 3990 3991 /* Add local vars in this inlined callee to caller. */ 3992 add_local_variables (id->src_cfun, cfun, id, true); 3993 3994 if (dump_file && (dump_flags & TDF_DETAILS)) 3995 { 3996 fprintf (dump_file, "Inlining "); 3997 print_generic_expr (dump_file, id->src_fn, 0); 3998 fprintf (dump_file, " to "); 3999 print_generic_expr (dump_file, id->dst_fn, 0); 4000 fprintf (dump_file, " with frequency %i\n", cg_edge->frequency); 4001 } 4002 4003 /* This is it. Duplicate the callee body. Assume callee is 4004 pre-gimplified. Note that we must not alter the caller 4005 function in any way before this point, as this CALL_EXPR may be 4006 a self-referential call; if we're calling ourselves, we need to 4007 duplicate our body before altering anything. */ 4008 copy_body (id, bb->count, 4009 cg_edge->frequency * REG_BR_PROB_BASE / CGRAPH_FREQ_BASE, 4010 bb, return_block, NULL, NULL); 4011 4012 /* Reset the escaped solution. */ 4013 if (cfun->gimple_df) 4014 pt_solution_reset (&cfun->gimple_df->escaped); 4015 4016 /* Clean up. */ 4017 if (id->debug_map) 4018 { 4019 pointer_map_destroy (id->debug_map); 4020 id->debug_map = dst; 4021 } 4022 pointer_map_destroy (id->decl_map); 4023 id->decl_map = st; 4024 4025 /* Unlink the calls virtual operands before replacing it. */ 4026 unlink_stmt_vdef (stmt); 4027 4028 /* If the inlined function returns a result that we care about, 4029 substitute the GIMPLE_CALL with an assignment of the return 4030 variable to the LHS of the call. That is, if STMT was 4031 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */ 4032 if (use_retvar && gimple_call_lhs (stmt)) 4033 { 4034 gimple old_stmt = stmt; 4035 stmt = gimple_build_assign (gimple_call_lhs (stmt), use_retvar); 4036 gsi_replace (&stmt_gsi, stmt, false); 4037 if (gimple_in_ssa_p (cfun)) 4038 mark_symbols_for_renaming (stmt); 4039 maybe_clean_or_replace_eh_stmt (old_stmt, stmt); 4040 } 4041 else 4042 { 4043 /* Handle the case of inlining a function with no return 4044 statement, which causes the return value to become undefined. */ 4045 if (gimple_call_lhs (stmt) 4046 && TREE_CODE (gimple_call_lhs (stmt)) == SSA_NAME) 4047 { 4048 tree name = gimple_call_lhs (stmt); 4049 tree var = SSA_NAME_VAR (name); 4050 tree def = gimple_default_def (cfun, var); 4051 4052 if (def) 4053 { 4054 /* If the variable is used undefined, make this name 4055 undefined via a move. */ 4056 stmt = gimple_build_assign (gimple_call_lhs (stmt), def); 4057 gsi_replace (&stmt_gsi, stmt, true); 4058 } 4059 else 4060 { 4061 /* Otherwise make this variable undefined. */ 4062 gsi_remove (&stmt_gsi, true); 4063 set_default_def (var, name); 4064 SSA_NAME_DEF_STMT (name) = gimple_build_nop (); 4065 } 4066 } 4067 else 4068 gsi_remove (&stmt_gsi, true); 4069 } 4070 4071 if (purge_dead_abnormal_edges) 4072 { 4073 gimple_purge_dead_eh_edges (return_block); 4074 gimple_purge_dead_abnormal_call_edges (return_block); 4075 } 4076 4077 /* If the value of the new expression is ignored, that's OK. We 4078 don't warn about this for CALL_EXPRs, so we shouldn't warn about 4079 the equivalent inlined version either. */ 4080 if (is_gimple_assign (stmt)) 4081 { 4082 gcc_assert (gimple_assign_single_p (stmt) 4083 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))); 4084 TREE_USED (gimple_assign_rhs1 (stmt)) = 1; 4085 } 4086 4087 /* Output the inlining info for this abstract function, since it has been 4088 inlined. If we don't do this now, we can lose the information about the 4089 variables in the function when the blocks get blown away as soon as we 4090 remove the cgraph node. */ 4091 (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl); 4092 4093 /* Update callgraph if needed. */ 4094 cgraph_remove_node (cg_edge->callee); 4095 4096 id->block = NULL_TREE; 4097 successfully_inlined = TRUE; 4098 4099 egress: 4100 input_location = saved_location; 4101 return successfully_inlined; 4102 } 4103 4104 /* Expand call statements reachable from STMT_P. 4105 We can only have CALL_EXPRs as the "toplevel" tree code or nested 4106 in a MODIFY_EXPR. */ 4107 4108 static bool 4109 gimple_expand_calls_inline (basic_block bb, copy_body_data *id) 4110 { 4111 gimple_stmt_iterator gsi; 4112 4113 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 4114 { 4115 gimple stmt = gsi_stmt (gsi); 4116 4117 if (is_gimple_call (stmt) 4118 && expand_call_inline (bb, stmt, id)) 4119 return true; 4120 } 4121 4122 return false; 4123 } 4124 4125 4126 /* Walk all basic blocks created after FIRST and try to fold every statement 4127 in the STATEMENTS pointer set. */ 4128 4129 static void 4130 fold_marked_statements (int first, struct pointer_set_t *statements) 4131 { 4132 for (; first < n_basic_blocks; first++) 4133 if (BASIC_BLOCK (first)) 4134 { 4135 gimple_stmt_iterator gsi; 4136 4137 for (gsi = gsi_start_bb (BASIC_BLOCK (first)); 4138 !gsi_end_p (gsi); 4139 gsi_next (&gsi)) 4140 if (pointer_set_contains (statements, gsi_stmt (gsi))) 4141 { 4142 gimple old_stmt = gsi_stmt (gsi); 4143 tree old_decl = is_gimple_call (old_stmt) ? gimple_call_fndecl (old_stmt) : 0; 4144 4145 if (old_decl && DECL_BUILT_IN (old_decl)) 4146 { 4147 /* Folding builtins can create multiple instructions, 4148 we need to look at all of them. */ 4149 gimple_stmt_iterator i2 = gsi; 4150 gsi_prev (&i2); 4151 if (fold_stmt (&gsi)) 4152 { 4153 gimple new_stmt; 4154 /* If a builtin at the end of a bb folded into nothing, 4155 the following loop won't work. */ 4156 if (gsi_end_p (gsi)) 4157 { 4158 cgraph_update_edges_for_call_stmt (old_stmt, 4159 old_decl, NULL); 4160 break; 4161 } 4162 if (gsi_end_p (i2)) 4163 i2 = gsi_start_bb (BASIC_BLOCK (first)); 4164 else 4165 gsi_next (&i2); 4166 while (1) 4167 { 4168 new_stmt = gsi_stmt (i2); 4169 update_stmt (new_stmt); 4170 cgraph_update_edges_for_call_stmt (old_stmt, old_decl, 4171 new_stmt); 4172 4173 if (new_stmt == gsi_stmt (gsi)) 4174 { 4175 /* It is okay to check only for the very last 4176 of these statements. If it is a throwing 4177 statement nothing will change. If it isn't 4178 this can remove EH edges. If that weren't 4179 correct then because some intermediate stmts 4180 throw, but not the last one. That would mean 4181 we'd have to split the block, which we can't 4182 here and we'd loose anyway. And as builtins 4183 probably never throw, this all 4184 is mood anyway. */ 4185 if (maybe_clean_or_replace_eh_stmt (old_stmt, 4186 new_stmt)) 4187 gimple_purge_dead_eh_edges (BASIC_BLOCK (first)); 4188 break; 4189 } 4190 gsi_next (&i2); 4191 } 4192 } 4193 } 4194 else if (fold_stmt (&gsi)) 4195 { 4196 /* Re-read the statement from GSI as fold_stmt() may 4197 have changed it. */ 4198 gimple new_stmt = gsi_stmt (gsi); 4199 update_stmt (new_stmt); 4200 4201 if (is_gimple_call (old_stmt) 4202 || is_gimple_call (new_stmt)) 4203 cgraph_update_edges_for_call_stmt (old_stmt, old_decl, 4204 new_stmt); 4205 4206 if (maybe_clean_or_replace_eh_stmt (old_stmt, new_stmt)) 4207 gimple_purge_dead_eh_edges (BASIC_BLOCK (first)); 4208 } 4209 } 4210 } 4211 } 4212 4213 /* Return true if BB has at least one abnormal outgoing edge. */ 4214 4215 static inline bool 4216 has_abnormal_outgoing_edge_p (basic_block bb) 4217 { 4218 edge e; 4219 edge_iterator ei; 4220 4221 FOR_EACH_EDGE (e, ei, bb->succs) 4222 if (e->flags & EDGE_ABNORMAL) 4223 return true; 4224 4225 return false; 4226 } 4227 4228 /* Expand calls to inline functions in the body of FN. */ 4229 4230 unsigned int 4231 optimize_inline_calls (tree fn) 4232 { 4233 copy_body_data id; 4234 basic_block bb; 4235 int last = n_basic_blocks; 4236 struct gimplify_ctx gctx; 4237 bool inlined_p = false; 4238 4239 /* Clear out ID. */ 4240 memset (&id, 0, sizeof (id)); 4241 4242 id.src_node = id.dst_node = cgraph_get_node (fn); 4243 gcc_assert (id.dst_node->analyzed); 4244 id.dst_fn = fn; 4245 /* Or any functions that aren't finished yet. */ 4246 if (current_function_decl) 4247 id.dst_fn = current_function_decl; 4248 4249 id.copy_decl = copy_decl_maybe_to_var; 4250 id.transform_call_graph_edges = CB_CGE_DUPLICATE; 4251 id.transform_new_cfg = false; 4252 id.transform_return_to_modify = true; 4253 id.transform_lang_insert_block = NULL; 4254 id.statements_to_fold = pointer_set_create (); 4255 4256 push_gimplify_context (&gctx); 4257 4258 /* We make no attempts to keep dominance info up-to-date. */ 4259 free_dominance_info (CDI_DOMINATORS); 4260 free_dominance_info (CDI_POST_DOMINATORS); 4261 4262 /* Register specific gimple functions. */ 4263 gimple_register_cfg_hooks (); 4264 4265 /* Reach the trees by walking over the CFG, and note the 4266 enclosing basic-blocks in the call edges. */ 4267 /* We walk the blocks going forward, because inlined function bodies 4268 will split id->current_basic_block, and the new blocks will 4269 follow it; we'll trudge through them, processing their CALL_EXPRs 4270 along the way. */ 4271 FOR_EACH_BB (bb) 4272 inlined_p |= gimple_expand_calls_inline (bb, &id); 4273 4274 pop_gimplify_context (NULL); 4275 4276 #ifdef ENABLE_CHECKING 4277 { 4278 struct cgraph_edge *e; 4279 4280 verify_cgraph_node (id.dst_node); 4281 4282 /* Double check that we inlined everything we are supposed to inline. */ 4283 for (e = id.dst_node->callees; e; e = e->next_callee) 4284 gcc_assert (e->inline_failed); 4285 } 4286 #endif 4287 4288 /* Fold queued statements. */ 4289 fold_marked_statements (last, id.statements_to_fold); 4290 pointer_set_destroy (id.statements_to_fold); 4291 4292 gcc_assert (!id.debug_stmts); 4293 4294 /* If we didn't inline into the function there is nothing to do. */ 4295 if (!inlined_p) 4296 return 0; 4297 4298 /* Renumber the lexical scoping (non-code) blocks consecutively. */ 4299 number_blocks (fn); 4300 4301 delete_unreachable_blocks_update_callgraph (&id); 4302 #ifdef ENABLE_CHECKING 4303 verify_cgraph_node (id.dst_node); 4304 #endif 4305 4306 /* It would be nice to check SSA/CFG/statement consistency here, but it is 4307 not possible yet - the IPA passes might make various functions to not 4308 throw and they don't care to proactively update local EH info. This is 4309 done later in fixup_cfg pass that also execute the verification. */ 4310 return (TODO_update_ssa 4311 | TODO_cleanup_cfg 4312 | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0) 4313 | (gimple_in_ssa_p (cfun) ? TODO_update_address_taken : 0) 4314 | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0)); 4315 } 4316 4317 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */ 4318 4319 tree 4320 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) 4321 { 4322 enum tree_code code = TREE_CODE (*tp); 4323 enum tree_code_class cl = TREE_CODE_CLASS (code); 4324 4325 /* We make copies of most nodes. */ 4326 if (IS_EXPR_CODE_CLASS (cl) 4327 || code == TREE_LIST 4328 || code == TREE_VEC 4329 || code == TYPE_DECL 4330 || code == OMP_CLAUSE) 4331 { 4332 /* Because the chain gets clobbered when we make a copy, we save it 4333 here. */ 4334 tree chain = NULL_TREE, new_tree; 4335 4336 if (CODE_CONTAINS_STRUCT (code, TS_COMMON)) 4337 chain = TREE_CHAIN (*tp); 4338 4339 /* Copy the node. */ 4340 new_tree = copy_node (*tp); 4341 4342 /* Propagate mudflap marked-ness. */ 4343 if (flag_mudflap && mf_marked_p (*tp)) 4344 mf_mark (new_tree); 4345 4346 *tp = new_tree; 4347 4348 /* Now, restore the chain, if appropriate. That will cause 4349 walk_tree to walk into the chain as well. */ 4350 if (code == PARM_DECL 4351 || code == TREE_LIST 4352 || code == OMP_CLAUSE) 4353 TREE_CHAIN (*tp) = chain; 4354 4355 /* For now, we don't update BLOCKs when we make copies. So, we 4356 have to nullify all BIND_EXPRs. */ 4357 if (TREE_CODE (*tp) == BIND_EXPR) 4358 BIND_EXPR_BLOCK (*tp) = NULL_TREE; 4359 } 4360 else if (code == CONSTRUCTOR) 4361 { 4362 /* CONSTRUCTOR nodes need special handling because 4363 we need to duplicate the vector of elements. */ 4364 tree new_tree; 4365 4366 new_tree = copy_node (*tp); 4367 4368 /* Propagate mudflap marked-ness. */ 4369 if (flag_mudflap && mf_marked_p (*tp)) 4370 mf_mark (new_tree); 4371 4372 CONSTRUCTOR_ELTS (new_tree) = VEC_copy (constructor_elt, gc, 4373 CONSTRUCTOR_ELTS (*tp)); 4374 *tp = new_tree; 4375 } 4376 else if (code == STATEMENT_LIST) 4377 /* We used to just abort on STATEMENT_LIST, but we can run into them 4378 with statement-expressions (c++/40975). */ 4379 copy_statement_list (tp); 4380 else if (TREE_CODE_CLASS (code) == tcc_type) 4381 *walk_subtrees = 0; 4382 else if (TREE_CODE_CLASS (code) == tcc_declaration) 4383 *walk_subtrees = 0; 4384 else if (TREE_CODE_CLASS (code) == tcc_constant) 4385 *walk_subtrees = 0; 4386 return NULL_TREE; 4387 } 4388 4389 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains 4390 information indicating to what new SAVE_EXPR this one should be mapped, 4391 use that one. Otherwise, create a new node and enter it in ST. FN is 4392 the function into which the copy will be placed. */ 4393 4394 static void 4395 remap_save_expr (tree *tp, void *st_, int *walk_subtrees) 4396 { 4397 struct pointer_map_t *st = (struct pointer_map_t *) st_; 4398 tree *n; 4399 tree t; 4400 4401 /* See if we already encountered this SAVE_EXPR. */ 4402 n = (tree *) pointer_map_contains (st, *tp); 4403 4404 /* If we didn't already remap this SAVE_EXPR, do so now. */ 4405 if (!n) 4406 { 4407 t = copy_node (*tp); 4408 4409 /* Remember this SAVE_EXPR. */ 4410 *pointer_map_insert (st, *tp) = t; 4411 /* Make sure we don't remap an already-remapped SAVE_EXPR. */ 4412 *pointer_map_insert (st, t) = t; 4413 } 4414 else 4415 { 4416 /* We've already walked into this SAVE_EXPR; don't do it again. */ 4417 *walk_subtrees = 0; 4418 t = *n; 4419 } 4420 4421 /* Replace this SAVE_EXPR with the copy. */ 4422 *tp = t; 4423 } 4424 4425 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label, 4426 copies the declaration and enters it in the splay_tree in DATA (which is 4427 really an `copy_body_data *'). */ 4428 4429 static tree 4430 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, 4431 void *data) 4432 { 4433 copy_body_data *id = (copy_body_data *) data; 4434 4435 /* Don't walk into types. */ 4436 if (TYPE_P (*tp)) 4437 *walk_subtrees = 0; 4438 4439 else if (TREE_CODE (*tp) == LABEL_EXPR) 4440 { 4441 tree decl = TREE_OPERAND (*tp, 0); 4442 4443 /* Copy the decl and remember the copy. */ 4444 insert_decl_map (id, decl, id->copy_decl (decl, id)); 4445 } 4446 4447 return NULL_TREE; 4448 } 4449 4450 /* Perform any modifications to EXPR required when it is unsaved. Does 4451 not recurse into EXPR's subtrees. */ 4452 4453 static void 4454 unsave_expr_1 (tree expr) 4455 { 4456 switch (TREE_CODE (expr)) 4457 { 4458 case TARGET_EXPR: 4459 /* Don't mess with a TARGET_EXPR that hasn't been expanded. 4460 It's OK for this to happen if it was part of a subtree that 4461 isn't immediately expanded, such as operand 2 of another 4462 TARGET_EXPR. */ 4463 if (TREE_OPERAND (expr, 1)) 4464 break; 4465 4466 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3); 4467 TREE_OPERAND (expr, 3) = NULL_TREE; 4468 break; 4469 4470 default: 4471 break; 4472 } 4473 } 4474 4475 /* Called via walk_tree when an expression is unsaved. Using the 4476 splay_tree pointed to by ST (which is really a `splay_tree'), 4477 remaps all local declarations to appropriate replacements. */ 4478 4479 static tree 4480 unsave_r (tree *tp, int *walk_subtrees, void *data) 4481 { 4482 copy_body_data *id = (copy_body_data *) data; 4483 struct pointer_map_t *st = id->decl_map; 4484 tree *n; 4485 4486 /* Only a local declaration (variable or label). */ 4487 if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp)) 4488 || TREE_CODE (*tp) == LABEL_DECL) 4489 { 4490 /* Lookup the declaration. */ 4491 n = (tree *) pointer_map_contains (st, *tp); 4492 4493 /* If it's there, remap it. */ 4494 if (n) 4495 *tp = *n; 4496 } 4497 4498 else if (TREE_CODE (*tp) == STATEMENT_LIST) 4499 gcc_unreachable (); 4500 else if (TREE_CODE (*tp) == BIND_EXPR) 4501 copy_bind_expr (tp, walk_subtrees, id); 4502 else if (TREE_CODE (*tp) == SAVE_EXPR 4503 || TREE_CODE (*tp) == TARGET_EXPR) 4504 remap_save_expr (tp, st, walk_subtrees); 4505 else 4506 { 4507 copy_tree_r (tp, walk_subtrees, NULL); 4508 4509 /* Do whatever unsaving is required. */ 4510 unsave_expr_1 (*tp); 4511 } 4512 4513 /* Keep iterating. */ 4514 return NULL_TREE; 4515 } 4516 4517 /* Copies everything in EXPR and replaces variables, labels 4518 and SAVE_EXPRs local to EXPR. */ 4519 4520 tree 4521 unsave_expr_now (tree expr) 4522 { 4523 copy_body_data id; 4524 4525 /* There's nothing to do for NULL_TREE. */ 4526 if (expr == 0) 4527 return expr; 4528 4529 /* Set up ID. */ 4530 memset (&id, 0, sizeof (id)); 4531 id.src_fn = current_function_decl; 4532 id.dst_fn = current_function_decl; 4533 id.decl_map = pointer_map_create (); 4534 id.debug_map = NULL; 4535 4536 id.copy_decl = copy_decl_no_change; 4537 id.transform_call_graph_edges = CB_CGE_DUPLICATE; 4538 id.transform_new_cfg = false; 4539 id.transform_return_to_modify = false; 4540 id.transform_lang_insert_block = NULL; 4541 4542 /* Walk the tree once to find local labels. */ 4543 walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id); 4544 4545 /* Walk the tree again, copying, remapping, and unsaving. */ 4546 walk_tree (&expr, unsave_r, &id, NULL); 4547 4548 /* Clean up. */ 4549 pointer_map_destroy (id.decl_map); 4550 if (id.debug_map) 4551 pointer_map_destroy (id.debug_map); 4552 4553 return expr; 4554 } 4555 4556 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local 4557 label, copies the declaration and enters it in the splay_tree in DATA (which 4558 is really a 'copy_body_data *'. */ 4559 4560 static tree 4561 mark_local_labels_stmt (gimple_stmt_iterator *gsip, 4562 bool *handled_ops_p ATTRIBUTE_UNUSED, 4563 struct walk_stmt_info *wi) 4564 { 4565 copy_body_data *id = (copy_body_data *) wi->info; 4566 gimple stmt = gsi_stmt (*gsip); 4567 4568 if (gimple_code (stmt) == GIMPLE_LABEL) 4569 { 4570 tree decl = gimple_label_label (stmt); 4571 4572 /* Copy the decl and remember the copy. */ 4573 insert_decl_map (id, decl, id->copy_decl (decl, id)); 4574 } 4575 4576 return NULL_TREE; 4577 } 4578 4579 4580 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local. 4581 Using the splay_tree pointed to by ST (which is really a `splay_tree'), 4582 remaps all local declarations to appropriate replacements in gimple 4583 operands. */ 4584 4585 static tree 4586 replace_locals_op (tree *tp, int *walk_subtrees, void *data) 4587 { 4588 struct walk_stmt_info *wi = (struct walk_stmt_info*) data; 4589 copy_body_data *id = (copy_body_data *) wi->info; 4590 struct pointer_map_t *st = id->decl_map; 4591 tree *n; 4592 tree expr = *tp; 4593 4594 /* Only a local declaration (variable or label). */ 4595 if ((TREE_CODE (expr) == VAR_DECL 4596 && !TREE_STATIC (expr)) 4597 || TREE_CODE (expr) == LABEL_DECL) 4598 { 4599 /* Lookup the declaration. */ 4600 n = (tree *) pointer_map_contains (st, expr); 4601 4602 /* If it's there, remap it. */ 4603 if (n) 4604 *tp = *n; 4605 *walk_subtrees = 0; 4606 } 4607 else if (TREE_CODE (expr) == STATEMENT_LIST 4608 || TREE_CODE (expr) == BIND_EXPR 4609 || TREE_CODE (expr) == SAVE_EXPR) 4610 gcc_unreachable (); 4611 else if (TREE_CODE (expr) == TARGET_EXPR) 4612 { 4613 /* Don't mess with a TARGET_EXPR that hasn't been expanded. 4614 It's OK for this to happen if it was part of a subtree that 4615 isn't immediately expanded, such as operand 2 of another 4616 TARGET_EXPR. */ 4617 if (!TREE_OPERAND (expr, 1)) 4618 { 4619 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3); 4620 TREE_OPERAND (expr, 3) = NULL_TREE; 4621 } 4622 } 4623 4624 /* Keep iterating. */ 4625 return NULL_TREE; 4626 } 4627 4628 4629 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local. 4630 Using the splay_tree pointed to by ST (which is really a `splay_tree'), 4631 remaps all local declarations to appropriate replacements in gimple 4632 statements. */ 4633 4634 static tree 4635 replace_locals_stmt (gimple_stmt_iterator *gsip, 4636 bool *handled_ops_p ATTRIBUTE_UNUSED, 4637 struct walk_stmt_info *wi) 4638 { 4639 copy_body_data *id = (copy_body_data *) wi->info; 4640 gimple stmt = gsi_stmt (*gsip); 4641 4642 if (gimple_code (stmt) == GIMPLE_BIND) 4643 { 4644 tree block = gimple_bind_block (stmt); 4645 4646 if (block) 4647 { 4648 remap_block (&block, id); 4649 gimple_bind_set_block (stmt, block); 4650 } 4651 4652 /* This will remap a lot of the same decls again, but this should be 4653 harmless. */ 4654 if (gimple_bind_vars (stmt)) 4655 gimple_bind_set_vars (stmt, remap_decls (gimple_bind_vars (stmt), NULL, id)); 4656 } 4657 4658 /* Keep iterating. */ 4659 return NULL_TREE; 4660 } 4661 4662 4663 /* Copies everything in SEQ and replaces variables and labels local to 4664 current_function_decl. */ 4665 4666 gimple_seq 4667 copy_gimple_seq_and_replace_locals (gimple_seq seq) 4668 { 4669 copy_body_data id; 4670 struct walk_stmt_info wi; 4671 struct pointer_set_t *visited; 4672 gimple_seq copy; 4673 4674 /* There's nothing to do for NULL_TREE. */ 4675 if (seq == NULL) 4676 return seq; 4677 4678 /* Set up ID. */ 4679 memset (&id, 0, sizeof (id)); 4680 id.src_fn = current_function_decl; 4681 id.dst_fn = current_function_decl; 4682 id.decl_map = pointer_map_create (); 4683 id.debug_map = NULL; 4684 4685 id.copy_decl = copy_decl_no_change; 4686 id.transform_call_graph_edges = CB_CGE_DUPLICATE; 4687 id.transform_new_cfg = false; 4688 id.transform_return_to_modify = false; 4689 id.transform_lang_insert_block = NULL; 4690 4691 /* Walk the tree once to find local labels. */ 4692 memset (&wi, 0, sizeof (wi)); 4693 visited = pointer_set_create (); 4694 wi.info = &id; 4695 wi.pset = visited; 4696 walk_gimple_seq (seq, mark_local_labels_stmt, NULL, &wi); 4697 pointer_set_destroy (visited); 4698 4699 copy = gimple_seq_copy (seq); 4700 4701 /* Walk the copy, remapping decls. */ 4702 memset (&wi, 0, sizeof (wi)); 4703 wi.info = &id; 4704 walk_gimple_seq (copy, replace_locals_stmt, replace_locals_op, &wi); 4705 4706 /* Clean up. */ 4707 pointer_map_destroy (id.decl_map); 4708 if (id.debug_map) 4709 pointer_map_destroy (id.debug_map); 4710 4711 return copy; 4712 } 4713 4714 4715 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */ 4716 4717 static tree 4718 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data) 4719 { 4720 if (*tp == data) 4721 return (tree) data; 4722 else 4723 return NULL; 4724 } 4725 4726 DEBUG_FUNCTION bool 4727 debug_find_tree (tree top, tree search) 4728 { 4729 return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0; 4730 } 4731 4732 4733 /* Declare the variables created by the inliner. Add all the variables in 4734 VARS to BIND_EXPR. */ 4735 4736 static void 4737 declare_inline_vars (tree block, tree vars) 4738 { 4739 tree t; 4740 for (t = vars; t; t = DECL_CHAIN (t)) 4741 { 4742 DECL_SEEN_IN_BIND_EXPR_P (t) = 1; 4743 gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t)); 4744 add_local_decl (cfun, t); 4745 } 4746 4747 if (block) 4748 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars); 4749 } 4750 4751 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN, 4752 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to 4753 VAR_DECL translation. */ 4754 4755 static tree 4756 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy) 4757 { 4758 /* Don't generate debug information for the copy if we wouldn't have 4759 generated it for the copy either. */ 4760 DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl); 4761 DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl); 4762 4763 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what 4764 declaration inspired this copy. */ 4765 DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl); 4766 4767 /* The new variable/label has no RTL, yet. */ 4768 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL) 4769 && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy)) 4770 SET_DECL_RTL (copy, 0); 4771 4772 /* These args would always appear unused, if not for this. */ 4773 TREE_USED (copy) = 1; 4774 4775 /* Set the context for the new declaration. */ 4776 if (!DECL_CONTEXT (decl)) 4777 /* Globals stay global. */ 4778 ; 4779 else if (DECL_CONTEXT (decl) != id->src_fn) 4780 /* Things that weren't in the scope of the function we're inlining 4781 from aren't in the scope we're inlining to, either. */ 4782 ; 4783 else if (TREE_STATIC (decl)) 4784 /* Function-scoped static variables should stay in the original 4785 function. */ 4786 ; 4787 else 4788 /* Ordinary automatic local variables are now in the scope of the 4789 new function. */ 4790 DECL_CONTEXT (copy) = id->dst_fn; 4791 4792 if (TREE_CODE (decl) == VAR_DECL 4793 /* C++ clones functions during parsing, before 4794 referenced_vars. */ 4795 && gimple_referenced_vars (DECL_STRUCT_FUNCTION (id->src_fn)) 4796 && referenced_var_lookup (DECL_STRUCT_FUNCTION (id->src_fn), 4797 DECL_UID (decl))) 4798 add_referenced_var (copy); 4799 4800 return copy; 4801 } 4802 4803 static tree 4804 copy_decl_to_var (tree decl, copy_body_data *id) 4805 { 4806 tree copy, type; 4807 4808 gcc_assert (TREE_CODE (decl) == PARM_DECL 4809 || TREE_CODE (decl) == RESULT_DECL); 4810 4811 type = TREE_TYPE (decl); 4812 4813 copy = build_decl (DECL_SOURCE_LOCATION (id->dst_fn), 4814 VAR_DECL, DECL_NAME (decl), type); 4815 if (DECL_PT_UID_SET_P (decl)) 4816 SET_DECL_PT_UID (copy, DECL_PT_UID (decl)); 4817 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl); 4818 TREE_READONLY (copy) = TREE_READONLY (decl); 4819 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl); 4820 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl); 4821 4822 return copy_decl_for_dup_finish (id, decl, copy); 4823 } 4824 4825 /* Like copy_decl_to_var, but create a return slot object instead of a 4826 pointer variable for return by invisible reference. */ 4827 4828 static tree 4829 copy_result_decl_to_var (tree decl, copy_body_data *id) 4830 { 4831 tree copy, type; 4832 4833 gcc_assert (TREE_CODE (decl) == PARM_DECL 4834 || TREE_CODE (decl) == RESULT_DECL); 4835 4836 type = TREE_TYPE (decl); 4837 if (DECL_BY_REFERENCE (decl)) 4838 type = TREE_TYPE (type); 4839 4840 copy = build_decl (DECL_SOURCE_LOCATION (id->dst_fn), 4841 VAR_DECL, DECL_NAME (decl), type); 4842 if (DECL_PT_UID_SET_P (decl)) 4843 SET_DECL_PT_UID (copy, DECL_PT_UID (decl)); 4844 TREE_READONLY (copy) = TREE_READONLY (decl); 4845 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl); 4846 if (!DECL_BY_REFERENCE (decl)) 4847 { 4848 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl); 4849 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl); 4850 } 4851 4852 return copy_decl_for_dup_finish (id, decl, copy); 4853 } 4854 4855 tree 4856 copy_decl_no_change (tree decl, copy_body_data *id) 4857 { 4858 tree copy; 4859 4860 copy = copy_node (decl); 4861 4862 /* The COPY is not abstract; it will be generated in DST_FN. */ 4863 DECL_ABSTRACT (copy) = 0; 4864 lang_hooks.dup_lang_specific_decl (copy); 4865 4866 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has 4867 been taken; it's for internal bookkeeping in expand_goto_internal. */ 4868 if (TREE_CODE (copy) == LABEL_DECL) 4869 { 4870 TREE_ADDRESSABLE (copy) = 0; 4871 LABEL_DECL_UID (copy) = -1; 4872 } 4873 4874 return copy_decl_for_dup_finish (id, decl, copy); 4875 } 4876 4877 static tree 4878 copy_decl_maybe_to_var (tree decl, copy_body_data *id) 4879 { 4880 if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL) 4881 return copy_decl_to_var (decl, id); 4882 else 4883 return copy_decl_no_change (decl, id); 4884 } 4885 4886 /* Return a copy of the function's argument tree. */ 4887 static tree 4888 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id, 4889 bitmap args_to_skip, tree *vars) 4890 { 4891 tree arg, *parg; 4892 tree new_parm = NULL; 4893 int i = 0; 4894 4895 parg = &new_parm; 4896 4897 for (arg = orig_parm; arg; arg = DECL_CHAIN (arg), i++) 4898 if (!args_to_skip || !bitmap_bit_p (args_to_skip, i)) 4899 { 4900 tree new_tree = remap_decl (arg, id); 4901 if (TREE_CODE (new_tree) != PARM_DECL) 4902 new_tree = id->copy_decl (arg, id); 4903 lang_hooks.dup_lang_specific_decl (new_tree); 4904 *parg = new_tree; 4905 parg = &DECL_CHAIN (new_tree); 4906 } 4907 else if (!pointer_map_contains (id->decl_map, arg)) 4908 { 4909 /* Make an equivalent VAR_DECL. If the argument was used 4910 as temporary variable later in function, the uses will be 4911 replaced by local variable. */ 4912 tree var = copy_decl_to_var (arg, id); 4913 add_referenced_var (var); 4914 insert_decl_map (id, arg, var); 4915 /* Declare this new variable. */ 4916 DECL_CHAIN (var) = *vars; 4917 *vars = var; 4918 } 4919 return new_parm; 4920 } 4921 4922 /* Return a copy of the function's static chain. */ 4923 static tree 4924 copy_static_chain (tree static_chain, copy_body_data * id) 4925 { 4926 tree *chain_copy, *pvar; 4927 4928 chain_copy = &static_chain; 4929 for (pvar = chain_copy; *pvar; pvar = &DECL_CHAIN (*pvar)) 4930 { 4931 tree new_tree = remap_decl (*pvar, id); 4932 lang_hooks.dup_lang_specific_decl (new_tree); 4933 DECL_CHAIN (new_tree) = DECL_CHAIN (*pvar); 4934 *pvar = new_tree; 4935 } 4936 return static_chain; 4937 } 4938 4939 /* Return true if the function is allowed to be versioned. 4940 This is a guard for the versioning functionality. */ 4941 4942 bool 4943 tree_versionable_function_p (tree fndecl) 4944 { 4945 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl)) 4946 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl), fndecl) == NULL); 4947 } 4948 4949 /* Delete all unreachable basic blocks and update callgraph. 4950 Doing so is somewhat nontrivial because we need to update all clones and 4951 remove inline function that become unreachable. */ 4952 4953 static bool 4954 delete_unreachable_blocks_update_callgraph (copy_body_data *id) 4955 { 4956 bool changed = false; 4957 basic_block b, next_bb; 4958 4959 find_unreachable_blocks (); 4960 4961 /* Delete all unreachable basic blocks. */ 4962 4963 for (b = ENTRY_BLOCK_PTR->next_bb; b != EXIT_BLOCK_PTR; b = next_bb) 4964 { 4965 next_bb = b->next_bb; 4966 4967 if (!(b->flags & BB_REACHABLE)) 4968 { 4969 gimple_stmt_iterator bsi; 4970 4971 for (bsi = gsi_start_bb (b); !gsi_end_p (bsi); gsi_next (&bsi)) 4972 if (gimple_code (gsi_stmt (bsi)) == GIMPLE_CALL) 4973 { 4974 struct cgraph_edge *e; 4975 struct cgraph_node *node; 4976 4977 if ((e = cgraph_edge (id->dst_node, gsi_stmt (bsi))) != NULL) 4978 { 4979 if (!e->inline_failed) 4980 cgraph_remove_node_and_inline_clones (e->callee); 4981 else 4982 cgraph_remove_edge (e); 4983 } 4984 if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES 4985 && id->dst_node->clones) 4986 for (node = id->dst_node->clones; node != id->dst_node;) 4987 { 4988 if ((e = cgraph_edge (node, gsi_stmt (bsi))) != NULL) 4989 { 4990 if (!e->inline_failed) 4991 cgraph_remove_node_and_inline_clones (e->callee); 4992 else 4993 cgraph_remove_edge (e); 4994 } 4995 4996 if (node->clones) 4997 node = node->clones; 4998 else if (node->next_sibling_clone) 4999 node = node->next_sibling_clone; 5000 else 5001 { 5002 while (node != id->dst_node && !node->next_sibling_clone) 5003 node = node->clone_of; 5004 if (node != id->dst_node) 5005 node = node->next_sibling_clone; 5006 } 5007 } 5008 } 5009 delete_basic_block (b); 5010 changed = true; 5011 } 5012 } 5013 5014 return changed; 5015 } 5016 5017 /* Update clone info after duplication. */ 5018 5019 static void 5020 update_clone_info (copy_body_data * id) 5021 { 5022 struct cgraph_node *node; 5023 if (!id->dst_node->clones) 5024 return; 5025 for (node = id->dst_node->clones; node != id->dst_node;) 5026 { 5027 /* First update replace maps to match the new body. */ 5028 if (node->clone.tree_map) 5029 { 5030 unsigned int i; 5031 for (i = 0; i < VEC_length (ipa_replace_map_p, node->clone.tree_map); i++) 5032 { 5033 struct ipa_replace_map *replace_info; 5034 replace_info = VEC_index (ipa_replace_map_p, node->clone.tree_map, i); 5035 walk_tree (&replace_info->old_tree, copy_tree_body_r, id, NULL); 5036 walk_tree (&replace_info->new_tree, copy_tree_body_r, id, NULL); 5037 } 5038 } 5039 if (node->clones) 5040 node = node->clones; 5041 else if (node->next_sibling_clone) 5042 node = node->next_sibling_clone; 5043 else 5044 { 5045 while (node != id->dst_node && !node->next_sibling_clone) 5046 node = node->clone_of; 5047 if (node != id->dst_node) 5048 node = node->next_sibling_clone; 5049 } 5050 } 5051 } 5052 5053 /* Create a copy of a function's tree. 5054 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes 5055 of the original function and the new copied function 5056 respectively. In case we want to replace a DECL 5057 tree with another tree while duplicating the function's 5058 body, TREE_MAP represents the mapping between these 5059 trees. If UPDATE_CLONES is set, the call_stmt fields 5060 of edges of clones of the function will be updated. 5061 5062 If non-NULL ARGS_TO_SKIP determine function parameters to remove 5063 from new version. 5064 If SKIP_RETURN is true, the new version will return void. 5065 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy. 5066 If non_NULL NEW_ENTRY determine new entry BB of the clone. 5067 */ 5068 void 5069 tree_function_versioning (tree old_decl, tree new_decl, 5070 VEC(ipa_replace_map_p,gc)* tree_map, 5071 bool update_clones, bitmap args_to_skip, 5072 bool skip_return, bitmap blocks_to_copy, 5073 basic_block new_entry) 5074 { 5075 struct cgraph_node *old_version_node; 5076 struct cgraph_node *new_version_node; 5077 copy_body_data id; 5078 tree p; 5079 unsigned i; 5080 struct ipa_replace_map *replace_info; 5081 basic_block old_entry_block, bb; 5082 VEC (gimple, heap) *init_stmts = VEC_alloc (gimple, heap, 10); 5083 5084 tree old_current_function_decl = current_function_decl; 5085 tree vars = NULL_TREE; 5086 5087 gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL 5088 && TREE_CODE (new_decl) == FUNCTION_DECL); 5089 DECL_POSSIBLY_INLINED (old_decl) = 1; 5090 5091 old_version_node = cgraph_get_node (old_decl); 5092 gcc_checking_assert (old_version_node); 5093 new_version_node = cgraph_get_node (new_decl); 5094 gcc_checking_assert (new_version_node); 5095 5096 /* Copy over debug args. */ 5097 if (DECL_HAS_DEBUG_ARGS_P (old_decl)) 5098 { 5099 VEC(tree, gc) **new_debug_args, **old_debug_args; 5100 gcc_checking_assert (decl_debug_args_lookup (new_decl) == NULL); 5101 DECL_HAS_DEBUG_ARGS_P (new_decl) = 0; 5102 old_debug_args = decl_debug_args_lookup (old_decl); 5103 if (old_debug_args) 5104 { 5105 new_debug_args = decl_debug_args_insert (new_decl); 5106 *new_debug_args = VEC_copy (tree, gc, *old_debug_args); 5107 } 5108 } 5109 5110 /* Output the inlining info for this abstract function, since it has been 5111 inlined. If we don't do this now, we can lose the information about the 5112 variables in the function when the blocks get blown away as soon as we 5113 remove the cgraph node. */ 5114 (*debug_hooks->outlining_inline_function) (old_decl); 5115 5116 DECL_ARTIFICIAL (new_decl) = 1; 5117 DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl); 5118 DECL_FUNCTION_PERSONALITY (new_decl) = DECL_FUNCTION_PERSONALITY (old_decl); 5119 5120 /* Prepare the data structures for the tree copy. */ 5121 memset (&id, 0, sizeof (id)); 5122 5123 /* Generate a new name for the new version. */ 5124 id.statements_to_fold = pointer_set_create (); 5125 5126 id.decl_map = pointer_map_create (); 5127 id.debug_map = NULL; 5128 id.src_fn = old_decl; 5129 id.dst_fn = new_decl; 5130 id.src_node = old_version_node; 5131 id.dst_node = new_version_node; 5132 id.src_cfun = DECL_STRUCT_FUNCTION (old_decl); 5133 if (id.src_node->ipa_transforms_to_apply) 5134 { 5135 VEC(ipa_opt_pass,heap) * old_transforms_to_apply = id.dst_node->ipa_transforms_to_apply; 5136 unsigned int i; 5137 5138 id.dst_node->ipa_transforms_to_apply = VEC_copy (ipa_opt_pass, heap, 5139 id.src_node->ipa_transforms_to_apply); 5140 for (i = 0; i < VEC_length (ipa_opt_pass, old_transforms_to_apply); i++) 5141 VEC_safe_push (ipa_opt_pass, heap, id.dst_node->ipa_transforms_to_apply, 5142 VEC_index (ipa_opt_pass, 5143 old_transforms_to_apply, 5144 i)); 5145 } 5146 5147 id.copy_decl = copy_decl_no_change; 5148 id.transform_call_graph_edges 5149 = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE; 5150 id.transform_new_cfg = true; 5151 id.transform_return_to_modify = false; 5152 id.transform_lang_insert_block = NULL; 5153 5154 current_function_decl = new_decl; 5155 old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION 5156 (DECL_STRUCT_FUNCTION (old_decl)); 5157 initialize_cfun (new_decl, old_decl, 5158 old_entry_block->count); 5159 DECL_STRUCT_FUNCTION (new_decl)->gimple_df->ipa_pta 5160 = id.src_cfun->gimple_df->ipa_pta; 5161 push_cfun (DECL_STRUCT_FUNCTION (new_decl)); 5162 5163 /* Copy the function's static chain. */ 5164 p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl; 5165 if (p) 5166 DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl = 5167 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl, 5168 &id); 5169 5170 /* If there's a tree_map, prepare for substitution. */ 5171 if (tree_map) 5172 for (i = 0; i < VEC_length (ipa_replace_map_p, tree_map); i++) 5173 { 5174 gimple init; 5175 replace_info = VEC_index (ipa_replace_map_p, tree_map, i); 5176 if (replace_info->replace_p) 5177 { 5178 tree op = replace_info->new_tree; 5179 if (!replace_info->old_tree) 5180 { 5181 int i = replace_info->parm_num; 5182 tree parm; 5183 for (parm = DECL_ARGUMENTS (old_decl); i; parm = DECL_CHAIN (parm)) 5184 i --; 5185 replace_info->old_tree = parm; 5186 } 5187 5188 5189 STRIP_NOPS (op); 5190 5191 if (TREE_CODE (op) == VIEW_CONVERT_EXPR) 5192 op = TREE_OPERAND (op, 0); 5193 5194 if (TREE_CODE (op) == ADDR_EXPR) 5195 { 5196 op = TREE_OPERAND (op, 0); 5197 while (handled_component_p (op)) 5198 op = TREE_OPERAND (op, 0); 5199 if (TREE_CODE (op) == VAR_DECL) 5200 add_referenced_var (op); 5201 } 5202 gcc_assert (TREE_CODE (replace_info->old_tree) == PARM_DECL); 5203 init = setup_one_parameter (&id, replace_info->old_tree, 5204 replace_info->new_tree, id.src_fn, 5205 NULL, 5206 &vars); 5207 if (init) 5208 VEC_safe_push (gimple, heap, init_stmts, init); 5209 } 5210 } 5211 /* Copy the function's arguments. */ 5212 if (DECL_ARGUMENTS (old_decl) != NULL_TREE) 5213 DECL_ARGUMENTS (new_decl) = 5214 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id, 5215 args_to_skip, &vars); 5216 5217 DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id); 5218 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl)) = new_decl; 5219 5220 declare_inline_vars (DECL_INITIAL (new_decl), vars); 5221 5222 if (!VEC_empty (tree, DECL_STRUCT_FUNCTION (old_decl)->local_decls)) 5223 /* Add local vars. */ 5224 add_local_variables (DECL_STRUCT_FUNCTION (old_decl), cfun, &id, false); 5225 5226 if (DECL_RESULT (old_decl) == NULL_TREE) 5227 ; 5228 else if (skip_return && !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl)))) 5229 { 5230 DECL_RESULT (new_decl) 5231 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl)), 5232 RESULT_DECL, NULL_TREE, void_type_node); 5233 DECL_CONTEXT (DECL_RESULT (new_decl)) = new_decl; 5234 cfun->returns_struct = 0; 5235 cfun->returns_pcc_struct = 0; 5236 } 5237 else 5238 { 5239 tree old_name; 5240 DECL_RESULT (new_decl) = remap_decl (DECL_RESULT (old_decl), &id); 5241 lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl)); 5242 if (gimple_in_ssa_p (id.src_cfun) 5243 && DECL_BY_REFERENCE (DECL_RESULT (old_decl)) 5244 && (old_name 5245 = gimple_default_def (id.src_cfun, DECL_RESULT (old_decl)))) 5246 { 5247 tree new_name = make_ssa_name (DECL_RESULT (new_decl), NULL); 5248 insert_decl_map (&id, old_name, new_name); 5249 SSA_NAME_DEF_STMT (new_name) = gimple_build_nop (); 5250 set_default_def (DECL_RESULT (new_decl), new_name); 5251 } 5252 } 5253 5254 /* Copy the Function's body. */ 5255 copy_body (&id, old_entry_block->count, REG_BR_PROB_BASE, 5256 ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, blocks_to_copy, new_entry); 5257 5258 /* Renumber the lexical scoping (non-code) blocks consecutively. */ 5259 number_blocks (new_decl); 5260 5261 /* We want to create the BB unconditionally, so that the addition of 5262 debug stmts doesn't affect BB count, which may in the end cause 5263 codegen differences. */ 5264 bb = split_edge (single_succ_edge (ENTRY_BLOCK_PTR)); 5265 while (VEC_length (gimple, init_stmts)) 5266 insert_init_stmt (&id, bb, VEC_pop (gimple, init_stmts)); 5267 update_clone_info (&id); 5268 5269 /* Remap the nonlocal_goto_save_area, if any. */ 5270 if (cfun->nonlocal_goto_save_area) 5271 { 5272 struct walk_stmt_info wi; 5273 5274 memset (&wi, 0, sizeof (wi)); 5275 wi.info = &id; 5276 walk_tree (&cfun->nonlocal_goto_save_area, remap_gimple_op_r, &wi, NULL); 5277 } 5278 5279 /* Clean up. */ 5280 pointer_map_destroy (id.decl_map); 5281 if (id.debug_map) 5282 pointer_map_destroy (id.debug_map); 5283 free_dominance_info (CDI_DOMINATORS); 5284 free_dominance_info (CDI_POST_DOMINATORS); 5285 5286 fold_marked_statements (0, id.statements_to_fold); 5287 pointer_set_destroy (id.statements_to_fold); 5288 fold_cond_expr_cond (); 5289 delete_unreachable_blocks_update_callgraph (&id); 5290 if (id.dst_node->analyzed) 5291 cgraph_rebuild_references (); 5292 update_ssa (TODO_update_ssa); 5293 5294 /* After partial cloning we need to rescale frequencies, so they are 5295 within proper range in the cloned function. */ 5296 if (new_entry) 5297 { 5298 struct cgraph_edge *e; 5299 rebuild_frequencies (); 5300 5301 new_version_node->count = ENTRY_BLOCK_PTR->count; 5302 for (e = new_version_node->callees; e; e = e->next_callee) 5303 { 5304 basic_block bb = gimple_bb (e->call_stmt); 5305 e->frequency = compute_call_stmt_bb_frequency (current_function_decl, 5306 bb); 5307 e->count = bb->count; 5308 } 5309 for (e = new_version_node->indirect_calls; e; e = e->next_callee) 5310 { 5311 basic_block bb = gimple_bb (e->call_stmt); 5312 e->frequency = compute_call_stmt_bb_frequency (current_function_decl, 5313 bb); 5314 e->count = bb->count; 5315 } 5316 } 5317 5318 free_dominance_info (CDI_DOMINATORS); 5319 free_dominance_info (CDI_POST_DOMINATORS); 5320 5321 gcc_assert (!id.debug_stmts); 5322 VEC_free (gimple, heap, init_stmts); 5323 pop_cfun (); 5324 current_function_decl = old_current_function_decl; 5325 gcc_assert (!current_function_decl 5326 || DECL_STRUCT_FUNCTION (current_function_decl) == cfun); 5327 return; 5328 } 5329 5330 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate 5331 the callee and return the inlined body on success. */ 5332 5333 tree 5334 maybe_inline_call_in_expr (tree exp) 5335 { 5336 tree fn = get_callee_fndecl (exp); 5337 5338 /* We can only try to inline "const" functions. */ 5339 if (fn && TREE_READONLY (fn) && DECL_SAVED_TREE (fn)) 5340 { 5341 struct pointer_map_t *decl_map = pointer_map_create (); 5342 call_expr_arg_iterator iter; 5343 copy_body_data id; 5344 tree param, arg, t; 5345 5346 /* Remap the parameters. */ 5347 for (param = DECL_ARGUMENTS (fn), arg = first_call_expr_arg (exp, &iter); 5348 param; 5349 param = DECL_CHAIN (param), arg = next_call_expr_arg (&iter)) 5350 *pointer_map_insert (decl_map, param) = arg; 5351 5352 memset (&id, 0, sizeof (id)); 5353 id.src_fn = fn; 5354 id.dst_fn = current_function_decl; 5355 id.src_cfun = DECL_STRUCT_FUNCTION (fn); 5356 id.decl_map = decl_map; 5357 5358 id.copy_decl = copy_decl_no_change; 5359 id.transform_call_graph_edges = CB_CGE_DUPLICATE; 5360 id.transform_new_cfg = false; 5361 id.transform_return_to_modify = true; 5362 id.transform_lang_insert_block = NULL; 5363 5364 /* Make sure not to unshare trees behind the front-end's back 5365 since front-end specific mechanisms may rely on sharing. */ 5366 id.regimplify = false; 5367 id.do_not_unshare = true; 5368 5369 /* We're not inside any EH region. */ 5370 id.eh_lp_nr = 0; 5371 5372 t = copy_tree_body (&id); 5373 pointer_map_destroy (decl_map); 5374 5375 /* We can only return something suitable for use in a GENERIC 5376 expression tree. */ 5377 if (TREE_CODE (t) == MODIFY_EXPR) 5378 return TREE_OPERAND (t, 1); 5379 } 5380 5381 return NULL_TREE; 5382 } 5383 5384 /* Duplicate a type, fields and all. */ 5385 5386 tree 5387 build_duplicate_type (tree type) 5388 { 5389 struct copy_body_data id; 5390 5391 memset (&id, 0, sizeof (id)); 5392 id.src_fn = current_function_decl; 5393 id.dst_fn = current_function_decl; 5394 id.src_cfun = cfun; 5395 id.decl_map = pointer_map_create (); 5396 id.debug_map = NULL; 5397 id.copy_decl = copy_decl_no_change; 5398 5399 type = remap_type_1 (type, &id); 5400 5401 pointer_map_destroy (id.decl_map); 5402 if (id.debug_map) 5403 pointer_map_destroy (id.debug_map); 5404 5405 TYPE_CANONICAL (type) = type; 5406 5407 return type; 5408 } 5409