1 /* Interprocedural analyses. 2 Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011, 2012 3 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "tree.h" 25 #include "langhooks.h" 26 #include "ggc.h" 27 #include "target.h" 28 #include "cgraph.h" 29 #include "ipa-prop.h" 30 #include "tree-flow.h" 31 #include "tree-pass.h" 32 #include "tree-inline.h" 33 #include "gimple.h" 34 #include "flags.h" 35 #include "timevar.h" 36 #include "flags.h" 37 #include "diagnostic.h" 38 #include "tree-pretty-print.h" 39 #include "gimple-pretty-print.h" 40 #include "lto-streamer.h" 41 #include "data-streamer.h" 42 #include "tree-streamer.h" 43 44 45 /* Intermediate information about a parameter that is only useful during the 46 run of ipa_analyze_node and is not kept afterwards. */ 47 48 struct param_analysis_info 49 { 50 bool modified; 51 bitmap visited_statements; 52 }; 53 54 /* Vector where the parameter infos are actually stored. */ 55 VEC (ipa_node_params_t, heap) *ipa_node_params_vector; 56 /* Vector where the parameter infos are actually stored. */ 57 VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector; 58 59 /* Holders of ipa cgraph hooks: */ 60 static struct cgraph_edge_hook_list *edge_removal_hook_holder; 61 static struct cgraph_node_hook_list *node_removal_hook_holder; 62 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder; 63 static struct cgraph_2node_hook_list *node_duplication_hook_holder; 64 static struct cgraph_node_hook_list *function_insertion_hook_holder; 65 66 /* Return index of the formal whose tree is PTREE in function which corresponds 67 to INFO. */ 68 69 int 70 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree) 71 { 72 int i, count; 73 74 count = ipa_get_param_count (info); 75 for (i = 0; i < count; i++) 76 if (ipa_get_param (info, i) == ptree) 77 return i; 78 79 return -1; 80 } 81 82 /* Populate the param_decl field in parameter descriptors of INFO that 83 corresponds to NODE. */ 84 85 static void 86 ipa_populate_param_decls (struct cgraph_node *node, 87 struct ipa_node_params *info) 88 { 89 tree fndecl; 90 tree fnargs; 91 tree parm; 92 int param_num; 93 94 fndecl = node->decl; 95 fnargs = DECL_ARGUMENTS (fndecl); 96 param_num = 0; 97 for (parm = fnargs; parm; parm = DECL_CHAIN (parm)) 98 { 99 VEC_index (ipa_param_descriptor_t, 100 info->descriptors, param_num)->decl = parm; 101 param_num++; 102 } 103 } 104 105 /* Return how many formal parameters FNDECL has. */ 106 107 static inline int 108 count_formal_params (tree fndecl) 109 { 110 tree parm; 111 int count = 0; 112 113 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm)) 114 count++; 115 116 return count; 117 } 118 119 /* Initialize the ipa_node_params structure associated with NODE by counting 120 the function parameters, creating the descriptors and populating their 121 param_decls. */ 122 123 void 124 ipa_initialize_node_params (struct cgraph_node *node) 125 { 126 struct ipa_node_params *info = IPA_NODE_REF (node); 127 128 if (!info->descriptors) 129 { 130 int param_count; 131 132 param_count = count_formal_params (node->decl); 133 if (param_count) 134 { 135 VEC_safe_grow_cleared (ipa_param_descriptor_t, heap, 136 info->descriptors, param_count); 137 ipa_populate_param_decls (node, info); 138 } 139 } 140 } 141 142 /* Print the jump functions associated with call graph edge CS to file F. */ 143 144 static void 145 ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs) 146 { 147 int i, count; 148 149 count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs)); 150 for (i = 0; i < count; i++) 151 { 152 struct ipa_jump_func *jump_func; 153 enum jump_func_type type; 154 155 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i); 156 type = jump_func->type; 157 158 fprintf (f, " param %d: ", i); 159 if (type == IPA_JF_UNKNOWN) 160 fprintf (f, "UNKNOWN\n"); 161 else if (type == IPA_JF_KNOWN_TYPE) 162 { 163 fprintf (f, "KNOWN TYPE: base "); 164 print_generic_expr (f, jump_func->value.known_type.base_type, 0); 165 fprintf (f, ", offset "HOST_WIDE_INT_PRINT_DEC", component ", 166 jump_func->value.known_type.offset); 167 print_generic_expr (f, jump_func->value.known_type.component_type, 0); 168 fprintf (f, "\n"); 169 } 170 else if (type == IPA_JF_CONST) 171 { 172 tree val = jump_func->value.constant; 173 fprintf (f, "CONST: "); 174 print_generic_expr (f, val, 0); 175 if (TREE_CODE (val) == ADDR_EXPR 176 && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL) 177 { 178 fprintf (f, " -> "); 179 print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)), 180 0); 181 } 182 fprintf (f, "\n"); 183 } 184 else if (type == IPA_JF_CONST_MEMBER_PTR) 185 { 186 fprintf (f, "CONST MEMBER PTR: "); 187 print_generic_expr (f, jump_func->value.member_cst.pfn, 0); 188 fprintf (f, ", "); 189 print_generic_expr (f, jump_func->value.member_cst.delta, 0); 190 fprintf (f, "\n"); 191 } 192 else if (type == IPA_JF_PASS_THROUGH) 193 { 194 fprintf (f, "PASS THROUGH: "); 195 fprintf (f, "%d, op %s ", 196 jump_func->value.pass_through.formal_id, 197 tree_code_name[(int) 198 jump_func->value.pass_through.operation]); 199 if (jump_func->value.pass_through.operation != NOP_EXPR) 200 print_generic_expr (f, 201 jump_func->value.pass_through.operand, 0); 202 fprintf (f, "\n"); 203 } 204 else if (type == IPA_JF_ANCESTOR) 205 { 206 fprintf (f, "ANCESTOR: "); 207 fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ", 208 jump_func->value.ancestor.formal_id, 209 jump_func->value.ancestor.offset); 210 print_generic_expr (f, jump_func->value.ancestor.type, 0); 211 fprintf (f, "\n"); 212 } 213 } 214 } 215 216 217 /* Print the jump functions of all arguments on all call graph edges going from 218 NODE to file F. */ 219 220 void 221 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node) 222 { 223 struct cgraph_edge *cs; 224 int i; 225 226 fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node)); 227 for (cs = node->callees; cs; cs = cs->next_callee) 228 { 229 if (!ipa_edge_args_info_available_for_edge_p (cs)) 230 continue; 231 232 fprintf (f, " callsite %s/%i -> %s/%i : \n", 233 xstrdup (cgraph_node_name (node)), node->uid, 234 xstrdup (cgraph_node_name (cs->callee)), cs->callee->uid); 235 ipa_print_node_jump_functions_for_edge (f, cs); 236 } 237 238 for (cs = node->indirect_calls, i = 0; cs; cs = cs->next_callee, i++) 239 { 240 if (!ipa_edge_args_info_available_for_edge_p (cs)) 241 continue; 242 243 if (cs->call_stmt) 244 { 245 fprintf (f, " indirect callsite %d for stmt ", i); 246 print_gimple_stmt (f, cs->call_stmt, 0, TDF_SLIM); 247 } 248 else 249 fprintf (f, " indirect callsite %d :\n", i); 250 ipa_print_node_jump_functions_for_edge (f, cs); 251 252 } 253 } 254 255 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */ 256 257 void 258 ipa_print_all_jump_functions (FILE *f) 259 { 260 struct cgraph_node *node; 261 262 fprintf (f, "\nJump functions:\n"); 263 for (node = cgraph_nodes; node; node = node->next) 264 { 265 ipa_print_node_jump_functions (f, node); 266 } 267 } 268 269 /* Structure to be passed in between detect_type_change and 270 check_stmt_for_type_change. */ 271 272 struct type_change_info 273 { 274 /* Offset into the object where there is the virtual method pointer we are 275 looking for. */ 276 HOST_WIDE_INT offset; 277 /* The declaration or SSA_NAME pointer of the base that we are checking for 278 type change. */ 279 tree object; 280 /* If we actually can tell the type that the object has changed to, it is 281 stored in this field. Otherwise it remains NULL_TREE. */ 282 tree known_current_type; 283 /* Set to true if dynamic type change has been detected. */ 284 bool type_maybe_changed; 285 /* Set to true if multiple types have been encountered. known_current_type 286 must be disregarded in that case. */ 287 bool multiple_types_encountered; 288 }; 289 290 /* Return true if STMT can modify a virtual method table pointer. 291 292 This function makes special assumptions about both constructors and 293 destructors which are all the functions that are allowed to alter the VMT 294 pointers. It assumes that destructors begin with assignment into all VMT 295 pointers and that constructors essentially look in the following way: 296 297 1) The very first thing they do is that they call constructors of ancestor 298 sub-objects that have them. 299 300 2) Then VMT pointers of this and all its ancestors is set to new values 301 corresponding to the type corresponding to the constructor. 302 303 3) Only afterwards, other stuff such as constructor of member sub-objects 304 and the code written by the user is run. Only this may include calling 305 virtual functions, directly or indirectly. 306 307 There is no way to call a constructor of an ancestor sub-object in any 308 other way. 309 310 This means that we do not have to care whether constructors get the correct 311 type information because they will always change it (in fact, if we define 312 the type to be given by the VMT pointer, it is undefined). 313 314 The most important fact to derive from the above is that if, for some 315 statement in the section 3, we try to detect whether the dynamic type has 316 changed, we can safely ignore all calls as we examine the function body 317 backwards until we reach statements in section 2 because these calls cannot 318 be ancestor constructors or destructors (if the input is not bogus) and so 319 do not change the dynamic type (this holds true only for automatically 320 allocated objects but at the moment we devirtualize only these). We then 321 must detect that statements in section 2 change the dynamic type and can try 322 to derive the new type. That is enough and we can stop, we will never see 323 the calls into constructors of sub-objects in this code. Therefore we can 324 safely ignore all call statements that we traverse. 325 */ 326 327 static bool 328 stmt_may_be_vtbl_ptr_store (gimple stmt) 329 { 330 if (is_gimple_call (stmt)) 331 return false; 332 else if (is_gimple_assign (stmt)) 333 { 334 tree lhs = gimple_assign_lhs (stmt); 335 336 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs))) 337 { 338 if (flag_strict_aliasing 339 && !POINTER_TYPE_P (TREE_TYPE (lhs))) 340 return false; 341 342 if (TREE_CODE (lhs) == COMPONENT_REF 343 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs, 1))) 344 return false; 345 /* In the future we might want to use get_base_ref_and_offset to find 346 if there is a field corresponding to the offset and if so, proceed 347 almost like if it was a component ref. */ 348 } 349 } 350 return true; 351 } 352 353 /* If STMT can be proved to be an assignment to the virtual method table 354 pointer of ANALYZED_OBJ and the type associated with the new table 355 identified, return the type. Otherwise return NULL_TREE. */ 356 357 static tree 358 extr_type_from_vtbl_ptr_store (gimple stmt, struct type_change_info *tci) 359 { 360 HOST_WIDE_INT offset, size, max_size; 361 tree lhs, rhs, base; 362 363 if (!gimple_assign_single_p (stmt)) 364 return NULL_TREE; 365 366 lhs = gimple_assign_lhs (stmt); 367 rhs = gimple_assign_rhs1 (stmt); 368 if (TREE_CODE (lhs) != COMPONENT_REF 369 || !DECL_VIRTUAL_P (TREE_OPERAND (lhs, 1)) 370 || TREE_CODE (rhs) != ADDR_EXPR) 371 return NULL_TREE; 372 rhs = get_base_address (TREE_OPERAND (rhs, 0)); 373 if (!rhs 374 || TREE_CODE (rhs) != VAR_DECL 375 || !DECL_VIRTUAL_P (rhs)) 376 return NULL_TREE; 377 378 base = get_ref_base_and_extent (lhs, &offset, &size, &max_size); 379 if (offset != tci->offset 380 || size != POINTER_SIZE 381 || max_size != POINTER_SIZE) 382 return NULL_TREE; 383 if (TREE_CODE (base) == MEM_REF) 384 { 385 if (TREE_CODE (tci->object) != MEM_REF 386 || TREE_OPERAND (tci->object, 0) != TREE_OPERAND (base, 0) 387 || !tree_int_cst_equal (TREE_OPERAND (tci->object, 1), 388 TREE_OPERAND (base, 1))) 389 return NULL_TREE; 390 } 391 else if (tci->object != base) 392 return NULL_TREE; 393 394 return DECL_CONTEXT (rhs); 395 } 396 397 /* Callback of walk_aliased_vdefs and a helper function for 398 detect_type_change to check whether a particular statement may modify 399 the virtual table pointer, and if possible also determine the new type of 400 the (sub-)object. It stores its result into DATA, which points to a 401 type_change_info structure. */ 402 403 static bool 404 check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data) 405 { 406 gimple stmt = SSA_NAME_DEF_STMT (vdef); 407 struct type_change_info *tci = (struct type_change_info *) data; 408 409 if (stmt_may_be_vtbl_ptr_store (stmt)) 410 { 411 tree type; 412 type = extr_type_from_vtbl_ptr_store (stmt, tci); 413 if (tci->type_maybe_changed 414 && type != tci->known_current_type) 415 tci->multiple_types_encountered = true; 416 tci->known_current_type = type; 417 tci->type_maybe_changed = true; 418 return true; 419 } 420 else 421 return false; 422 } 423 424 425 426 /* Like detect_type_change but with extra argument COMP_TYPE which will become 427 the component type part of new JFUNC of dynamic type change is detected and 428 the new base type is identified. */ 429 430 static bool 431 detect_type_change_1 (tree arg, tree base, tree comp_type, gimple call, 432 struct ipa_jump_func *jfunc, HOST_WIDE_INT offset) 433 { 434 struct type_change_info tci; 435 ao_ref ao; 436 437 gcc_checking_assert (DECL_P (arg) 438 || TREE_CODE (arg) == MEM_REF 439 || handled_component_p (arg)); 440 /* Const calls cannot call virtual methods through VMT and so type changes do 441 not matter. */ 442 if (!flag_devirtualize || !gimple_vuse (call)) 443 return false; 444 445 ao_ref_init (&ao, arg); 446 ao.base = base; 447 ao.offset = offset; 448 ao.size = POINTER_SIZE; 449 ao.max_size = ao.size; 450 451 tci.offset = offset; 452 tci.object = get_base_address (arg); 453 tci.known_current_type = NULL_TREE; 454 tci.type_maybe_changed = false; 455 tci.multiple_types_encountered = false; 456 457 walk_aliased_vdefs (&ao, gimple_vuse (call), check_stmt_for_type_change, 458 &tci, NULL); 459 if (!tci.type_maybe_changed) 460 return false; 461 462 if (!tci.known_current_type 463 || tci.multiple_types_encountered 464 || offset != 0) 465 jfunc->type = IPA_JF_UNKNOWN; 466 else 467 { 468 jfunc->type = IPA_JF_KNOWN_TYPE; 469 jfunc->value.known_type.base_type = tci.known_current_type; 470 jfunc->value.known_type.component_type = comp_type; 471 } 472 473 return true; 474 } 475 476 /* Detect whether the dynamic type of ARG has changed (before callsite CALL) by 477 looking for assignments to its virtual table pointer. If it is, return true 478 and fill in the jump function JFUNC with relevant type information or set it 479 to unknown. ARG is the object itself (not a pointer to it, unless 480 dereferenced). BASE is the base of the memory access as returned by 481 get_ref_base_and_extent, as is the offset. */ 482 483 static bool 484 detect_type_change (tree arg, tree base, gimple call, 485 struct ipa_jump_func *jfunc, HOST_WIDE_INT offset) 486 { 487 return detect_type_change_1 (arg, base, TREE_TYPE (arg), call, jfunc, offset); 488 } 489 490 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer 491 SSA name (its dereference will become the base and the offset is assumed to 492 be zero). */ 493 494 static bool 495 detect_type_change_ssa (tree arg, gimple call, struct ipa_jump_func *jfunc) 496 { 497 tree comp_type; 498 499 gcc_checking_assert (TREE_CODE (arg) == SSA_NAME); 500 if (!flag_devirtualize 501 || !POINTER_TYPE_P (TREE_TYPE (arg)) 502 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != RECORD_TYPE) 503 return false; 504 505 comp_type = TREE_TYPE (TREE_TYPE (arg)); 506 arg = build2 (MEM_REF, ptr_type_node, arg, 507 build_int_cst (ptr_type_node, 0)); 508 509 return detect_type_change_1 (arg, arg, comp_type, call, jfunc, 0); 510 } 511 512 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the 513 boolean variable pointed to by DATA. */ 514 515 static bool 516 mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED, 517 void *data) 518 { 519 bool *b = (bool *) data; 520 *b = true; 521 return true; 522 } 523 524 /* Return true if the formal parameter PARM might have been modified in this 525 function before reaching the statement STMT. PARM_AINFO is a pointer to a 526 structure containing temporary information about PARM. */ 527 528 static bool 529 is_parm_modified_before_stmt (struct param_analysis_info *parm_ainfo, 530 gimple stmt, tree parm) 531 { 532 bool modified = false; 533 ao_ref refd; 534 535 if (parm_ainfo->modified) 536 return true; 537 538 gcc_checking_assert (gimple_vuse (stmt) != NULL_TREE); 539 ao_ref_init (&refd, parm); 540 walk_aliased_vdefs (&refd, gimple_vuse (stmt), mark_modified, 541 &modified, &parm_ainfo->visited_statements); 542 if (modified) 543 { 544 parm_ainfo->modified = true; 545 return true; 546 } 547 return false; 548 } 549 550 /* If STMT is an assignment that loads a value from an parameter declaration, 551 return the index of the parameter in ipa_node_params which has not been 552 modified. Otherwise return -1. */ 553 554 static int 555 load_from_unmodified_param (struct ipa_node_params *info, 556 struct param_analysis_info *parms_ainfo, 557 gimple stmt) 558 { 559 int index; 560 tree op1; 561 562 if (!gimple_assign_single_p (stmt)) 563 return -1; 564 565 op1 = gimple_assign_rhs1 (stmt); 566 if (TREE_CODE (op1) != PARM_DECL) 567 return -1; 568 569 index = ipa_get_param_decl_index (info, op1); 570 if (index < 0 571 || is_parm_modified_before_stmt (&parms_ainfo[index], stmt, op1)) 572 return -1; 573 574 return index; 575 } 576 577 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result 578 of an assignment statement STMT, try to determine whether we are actually 579 handling any of the following cases and construct an appropriate jump 580 function into JFUNC if so: 581 582 1) The passed value is loaded from a formal parameter which is not a gimple 583 register (most probably because it is addressable, the value has to be 584 scalar) and we can guarantee the value has not changed. This case can 585 therefore be described by a simple pass-through jump function. For example: 586 587 foo (int a) 588 { 589 int a.0; 590 591 a.0_2 = a; 592 bar (a.0_2); 593 594 2) The passed value can be described by a simple arithmetic pass-through 595 jump function. E.g. 596 597 foo (int a) 598 { 599 int D.2064; 600 601 D.2064_4 = a.1(D) + 4; 602 bar (D.2064_4); 603 604 This case can also occur in combination of the previous one, e.g.: 605 606 foo (int a, int z) 607 { 608 int a.0; 609 int D.2064; 610 611 a.0_3 = a; 612 D.2064_4 = a.0_3 + 4; 613 foo (D.2064_4); 614 615 3) The passed value is an address of an object within another one (which 616 also passed by reference). Such situations are described by an ancestor 617 jump function and describe situations such as: 618 619 B::foo() (struct B * const this) 620 { 621 struct A * D.1845; 622 623 D.1845_2 = &this_1(D)->D.1748; 624 A::bar (D.1845_2); 625 626 INFO is the structure describing individual parameters access different 627 stages of IPA optimizations. PARMS_AINFO contains the information that is 628 only needed for intraprocedural analysis. */ 629 630 static void 631 compute_complex_assign_jump_func (struct ipa_node_params *info, 632 struct param_analysis_info *parms_ainfo, 633 struct ipa_jump_func *jfunc, 634 gimple call, gimple stmt, tree name) 635 { 636 HOST_WIDE_INT offset, size, max_size; 637 tree op1, tc_ssa, base, ssa; 638 int index; 639 640 op1 = gimple_assign_rhs1 (stmt); 641 642 if (TREE_CODE (op1) == SSA_NAME) 643 { 644 if (SSA_NAME_IS_DEFAULT_DEF (op1)) 645 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1)); 646 else 647 index = load_from_unmodified_param (info, parms_ainfo, 648 SSA_NAME_DEF_STMT (op1)); 649 tc_ssa = op1; 650 } 651 else 652 { 653 index = load_from_unmodified_param (info, parms_ainfo, stmt); 654 tc_ssa = gimple_assign_lhs (stmt); 655 } 656 657 if (index >= 0) 658 { 659 tree op2 = gimple_assign_rhs2 (stmt); 660 661 if (op2) 662 { 663 if (!is_gimple_ip_invariant (op2) 664 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison 665 && !useless_type_conversion_p (TREE_TYPE (name), 666 TREE_TYPE (op1)))) 667 return; 668 669 jfunc->type = IPA_JF_PASS_THROUGH; 670 jfunc->value.pass_through.formal_id = index; 671 jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt); 672 jfunc->value.pass_through.operand = op2; 673 } 674 else if (gimple_assign_single_p (stmt) 675 && !detect_type_change_ssa (tc_ssa, call, jfunc)) 676 { 677 jfunc->type = IPA_JF_PASS_THROUGH; 678 jfunc->value.pass_through.formal_id = index; 679 jfunc->value.pass_through.operation = NOP_EXPR; 680 } 681 return; 682 } 683 684 if (TREE_CODE (op1) != ADDR_EXPR) 685 return; 686 op1 = TREE_OPERAND (op1, 0); 687 if (TREE_CODE (TREE_TYPE (op1)) != RECORD_TYPE) 688 return; 689 base = get_ref_base_and_extent (op1, &offset, &size, &max_size); 690 if (TREE_CODE (base) != MEM_REF 691 /* If this is a varying address, punt. */ 692 || max_size == -1 693 || max_size != size) 694 return; 695 offset += mem_ref_offset (base).low * BITS_PER_UNIT; 696 ssa = TREE_OPERAND (base, 0); 697 if (TREE_CODE (ssa) != SSA_NAME 698 || !SSA_NAME_IS_DEFAULT_DEF (ssa) 699 || offset < 0) 700 return; 701 702 /* Dynamic types are changed only in constructors and destructors and */ 703 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (ssa)); 704 if (index >= 0 705 && !detect_type_change (op1, base, call, jfunc, offset)) 706 { 707 jfunc->type = IPA_JF_ANCESTOR; 708 jfunc->value.ancestor.formal_id = index; 709 jfunc->value.ancestor.offset = offset; 710 jfunc->value.ancestor.type = TREE_TYPE (op1); 711 } 712 } 713 714 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if 715 it looks like: 716 717 iftmp.1_3 = &obj_2(D)->D.1762; 718 719 The base of the MEM_REF must be a default definition SSA NAME of a 720 parameter. Return NULL_TREE if it looks otherwise. If case of success, the 721 whole MEM_REF expression is returned and the offset calculated from any 722 handled components and the MEM_REF itself is stored into *OFFSET. The whole 723 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */ 724 725 static tree 726 get_ancestor_addr_info (gimple assign, tree *obj_p, HOST_WIDE_INT *offset) 727 { 728 HOST_WIDE_INT size, max_size; 729 tree expr, parm, obj; 730 731 if (!gimple_assign_single_p (assign)) 732 return NULL_TREE; 733 expr = gimple_assign_rhs1 (assign); 734 735 if (TREE_CODE (expr) != ADDR_EXPR) 736 return NULL_TREE; 737 expr = TREE_OPERAND (expr, 0); 738 obj = expr; 739 expr = get_ref_base_and_extent (expr, offset, &size, &max_size); 740 741 if (TREE_CODE (expr) != MEM_REF 742 /* If this is a varying address, punt. */ 743 || max_size == -1 744 || max_size != size 745 || *offset < 0) 746 return NULL_TREE; 747 parm = TREE_OPERAND (expr, 0); 748 if (TREE_CODE (parm) != SSA_NAME 749 || !SSA_NAME_IS_DEFAULT_DEF (parm) 750 || TREE_CODE (SSA_NAME_VAR (parm)) != PARM_DECL) 751 return NULL_TREE; 752 753 *offset += mem_ref_offset (expr).low * BITS_PER_UNIT; 754 *obj_p = obj; 755 return expr; 756 } 757 758 759 /* Given that an actual argument is an SSA_NAME that is a result of a phi 760 statement PHI, try to find out whether NAME is in fact a 761 multiple-inheritance typecast from a descendant into an ancestor of a formal 762 parameter and thus can be described by an ancestor jump function and if so, 763 write the appropriate function into JFUNC. 764 765 Essentially we want to match the following pattern: 766 767 if (obj_2(D) != 0B) 768 goto <bb 3>; 769 else 770 goto <bb 4>; 771 772 <bb 3>: 773 iftmp.1_3 = &obj_2(D)->D.1762; 774 775 <bb 4>: 776 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)> 777 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D)); 778 return D.1879_6; */ 779 780 static void 781 compute_complex_ancestor_jump_func (struct ipa_node_params *info, 782 struct ipa_jump_func *jfunc, 783 gimple call, gimple phi) 784 { 785 HOST_WIDE_INT offset; 786 gimple assign, cond; 787 basic_block phi_bb, assign_bb, cond_bb; 788 tree tmp, parm, expr, obj; 789 int index, i; 790 791 if (gimple_phi_num_args (phi) != 2) 792 return; 793 794 if (integer_zerop (PHI_ARG_DEF (phi, 1))) 795 tmp = PHI_ARG_DEF (phi, 0); 796 else if (integer_zerop (PHI_ARG_DEF (phi, 0))) 797 tmp = PHI_ARG_DEF (phi, 1); 798 else 799 return; 800 if (TREE_CODE (tmp) != SSA_NAME 801 || SSA_NAME_IS_DEFAULT_DEF (tmp) 802 || !POINTER_TYPE_P (TREE_TYPE (tmp)) 803 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE) 804 return; 805 806 assign = SSA_NAME_DEF_STMT (tmp); 807 assign_bb = gimple_bb (assign); 808 if (!single_pred_p (assign_bb)) 809 return; 810 expr = get_ancestor_addr_info (assign, &obj, &offset); 811 if (!expr) 812 return; 813 parm = TREE_OPERAND (expr, 0); 814 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm)); 815 gcc_assert (index >= 0); 816 817 cond_bb = single_pred (assign_bb); 818 cond = last_stmt (cond_bb); 819 if (!cond 820 || gimple_code (cond) != GIMPLE_COND 821 || gimple_cond_code (cond) != NE_EXPR 822 || gimple_cond_lhs (cond) != parm 823 || !integer_zerop (gimple_cond_rhs (cond))) 824 return; 825 826 phi_bb = gimple_bb (phi); 827 for (i = 0; i < 2; i++) 828 { 829 basic_block pred = EDGE_PRED (phi_bb, i)->src; 830 if (pred != assign_bb && pred != cond_bb) 831 return; 832 } 833 834 if (!detect_type_change (obj, expr, call, jfunc, offset)) 835 { 836 jfunc->type = IPA_JF_ANCESTOR; 837 jfunc->value.ancestor.formal_id = index; 838 jfunc->value.ancestor.offset = offset; 839 jfunc->value.ancestor.type = TREE_TYPE (obj); 840 } 841 } 842 843 /* Given OP which is passed as an actual argument to a called function, 844 determine if it is possible to construct a KNOWN_TYPE jump function for it 845 and if so, create one and store it to JFUNC. */ 846 847 static void 848 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc, 849 gimple call) 850 { 851 HOST_WIDE_INT offset, size, max_size; 852 tree base; 853 854 if (!flag_devirtualize 855 || TREE_CODE (op) != ADDR_EXPR 856 || TREE_CODE (TREE_TYPE (TREE_TYPE (op))) != RECORD_TYPE) 857 return; 858 859 op = TREE_OPERAND (op, 0); 860 base = get_ref_base_and_extent (op, &offset, &size, &max_size); 861 if (!DECL_P (base) 862 || max_size == -1 863 || max_size != size 864 || TREE_CODE (TREE_TYPE (base)) != RECORD_TYPE 865 || is_global_var (base)) 866 return; 867 868 if (!TYPE_BINFO (TREE_TYPE (base)) 869 || detect_type_change (op, base, call, jfunc, offset)) 870 return; 871 872 jfunc->type = IPA_JF_KNOWN_TYPE; 873 jfunc->value.known_type.base_type = TREE_TYPE (base); 874 jfunc->value.known_type.offset = offset; 875 jfunc->value.known_type.component_type = TREE_TYPE (op); 876 } 877 878 879 /* Determine the jump functions of scalar arguments. Scalar means SSA names 880 and constants of a number of selected types. INFO is the ipa_node_params 881 structure associated with the caller, PARMS_AINFO describes state of 882 analysis with respect to individual formal parameters. ARGS is the 883 ipa_edge_args structure describing the callsite CALL which is the call 884 statement being examined.*/ 885 886 static void 887 compute_scalar_jump_functions (struct ipa_node_params *info, 888 struct param_analysis_info *parms_ainfo, 889 struct ipa_edge_args *args, 890 gimple call) 891 { 892 tree arg; 893 unsigned num = 0; 894 895 for (num = 0; num < gimple_call_num_args (call); num++) 896 { 897 struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, num); 898 arg = gimple_call_arg (call, num); 899 900 if (is_gimple_ip_invariant (arg)) 901 { 902 jfunc->type = IPA_JF_CONST; 903 jfunc->value.constant = arg; 904 } 905 else if (TREE_CODE (arg) == SSA_NAME) 906 { 907 if (SSA_NAME_IS_DEFAULT_DEF (arg)) 908 { 909 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg)); 910 911 if (index >= 0 912 && !detect_type_change_ssa (arg, call, jfunc)) 913 { 914 jfunc->type = IPA_JF_PASS_THROUGH; 915 jfunc->value.pass_through.formal_id = index; 916 jfunc->value.pass_through.operation = NOP_EXPR; 917 } 918 } 919 else 920 { 921 gimple stmt = SSA_NAME_DEF_STMT (arg); 922 if (is_gimple_assign (stmt)) 923 compute_complex_assign_jump_func (info, parms_ainfo, jfunc, 924 call, stmt, arg); 925 else if (gimple_code (stmt) == GIMPLE_PHI) 926 compute_complex_ancestor_jump_func (info, jfunc, call, stmt); 927 } 928 } 929 else 930 compute_known_type_jump_func (arg, jfunc, call); 931 } 932 } 933 934 /* Inspect the given TYPE and return true iff it has the same structure (the 935 same number of fields of the same types) as a C++ member pointer. If 936 METHOD_PTR and DELTA are non-NULL, store the trees representing the 937 corresponding fields there. */ 938 939 static bool 940 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta) 941 { 942 tree fld; 943 944 if (TREE_CODE (type) != RECORD_TYPE) 945 return false; 946 947 fld = TYPE_FIELDS (type); 948 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld)) 949 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE) 950 return false; 951 952 if (method_ptr) 953 *method_ptr = fld; 954 955 fld = DECL_CHAIN (fld); 956 if (!fld || INTEGRAL_TYPE_P (fld)) 957 return false; 958 if (delta) 959 *delta = fld; 960 961 if (DECL_CHAIN (fld)) 962 return false; 963 964 return true; 965 } 966 967 /* Go through arguments of the CALL and for every one that looks like a member 968 pointer, check whether it can be safely declared pass-through and if so, 969 mark that to the corresponding item of jump FUNCTIONS. Return true iff 970 there are non-pass-through member pointers within the arguments. INFO 971 describes formal parameters of the caller. PARMS_INFO is a pointer to a 972 vector containing intermediate information about each formal parameter. */ 973 974 static bool 975 compute_pass_through_member_ptrs (struct ipa_node_params *info, 976 struct param_analysis_info *parms_ainfo, 977 struct ipa_edge_args *args, 978 gimple call) 979 { 980 bool undecided_members = false; 981 unsigned num; 982 tree arg; 983 984 for (num = 0; num < gimple_call_num_args (call); num++) 985 { 986 arg = gimple_call_arg (call, num); 987 988 if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL)) 989 { 990 if (TREE_CODE (arg) == PARM_DECL) 991 { 992 int index = ipa_get_param_decl_index (info, arg); 993 994 gcc_assert (index >=0); 995 if (!is_parm_modified_before_stmt (&parms_ainfo[index], call, 996 arg)) 997 { 998 struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, 999 num); 1000 jfunc->type = IPA_JF_PASS_THROUGH; 1001 jfunc->value.pass_through.formal_id = index; 1002 jfunc->value.pass_through.operation = NOP_EXPR; 1003 } 1004 else 1005 undecided_members = true; 1006 } 1007 else 1008 undecided_members = true; 1009 } 1010 } 1011 1012 return undecided_members; 1013 } 1014 1015 /* Simple function filling in a member pointer constant jump function (with PFN 1016 and DELTA as the constant value) into JFUNC. */ 1017 1018 static void 1019 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc, 1020 tree pfn, tree delta) 1021 { 1022 jfunc->type = IPA_JF_CONST_MEMBER_PTR; 1023 jfunc->value.member_cst.pfn = pfn; 1024 jfunc->value.member_cst.delta = delta; 1025 } 1026 1027 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement, 1028 return the rhs of its defining statement. */ 1029 1030 static inline tree 1031 get_ssa_def_if_simple_copy (tree rhs) 1032 { 1033 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs)) 1034 { 1035 gimple def_stmt = SSA_NAME_DEF_STMT (rhs); 1036 1037 if (gimple_assign_single_p (def_stmt)) 1038 rhs = gimple_assign_rhs1 (def_stmt); 1039 else 1040 break; 1041 } 1042 return rhs; 1043 } 1044 1045 /* Traverse statements from CALL backwards, scanning whether the argument ARG 1046 which is a member pointer is filled in with constant values. If it is, fill 1047 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are 1048 fields of the record type of the member pointer. To give an example, we 1049 look for a pattern looking like the following: 1050 1051 D.2515.__pfn ={v} printStuff; 1052 D.2515.__delta ={v} 0; 1053 i_1 = doprinting (D.2515); */ 1054 1055 static void 1056 determine_cst_member_ptr (gimple call, tree arg, tree method_field, 1057 tree delta_field, struct ipa_jump_func *jfunc) 1058 { 1059 gimple_stmt_iterator gsi; 1060 tree method = NULL_TREE; 1061 tree delta = NULL_TREE; 1062 1063 gsi = gsi_for_stmt (call); 1064 1065 gsi_prev (&gsi); 1066 for (; !gsi_end_p (gsi); gsi_prev (&gsi)) 1067 { 1068 gimple stmt = gsi_stmt (gsi); 1069 tree lhs, rhs, fld; 1070 1071 if (!stmt_may_clobber_ref_p (stmt, arg)) 1072 continue; 1073 if (!gimple_assign_single_p (stmt)) 1074 return; 1075 1076 lhs = gimple_assign_lhs (stmt); 1077 rhs = gimple_assign_rhs1 (stmt); 1078 1079 if (TREE_CODE (lhs) != COMPONENT_REF 1080 || TREE_OPERAND (lhs, 0) != arg) 1081 return; 1082 1083 fld = TREE_OPERAND (lhs, 1); 1084 if (!method && fld == method_field) 1085 { 1086 rhs = get_ssa_def_if_simple_copy (rhs); 1087 if (TREE_CODE (rhs) == ADDR_EXPR 1088 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL 1089 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE) 1090 { 1091 method = TREE_OPERAND (rhs, 0); 1092 if (delta) 1093 { 1094 fill_member_ptr_cst_jump_function (jfunc, rhs, delta); 1095 return; 1096 } 1097 } 1098 else 1099 return; 1100 } 1101 1102 if (!delta && fld == delta_field) 1103 { 1104 rhs = get_ssa_def_if_simple_copy (rhs); 1105 if (TREE_CODE (rhs) == INTEGER_CST) 1106 { 1107 delta = rhs; 1108 if (method) 1109 { 1110 fill_member_ptr_cst_jump_function (jfunc, rhs, delta); 1111 return; 1112 } 1113 } 1114 else 1115 return; 1116 } 1117 } 1118 1119 return; 1120 } 1121 1122 /* Go through the arguments of the CALL and for every member pointer within 1123 tries determine whether it is a constant. If it is, create a corresponding 1124 constant jump function in FUNCTIONS which is an array of jump functions 1125 associated with the call. */ 1126 1127 static void 1128 compute_cst_member_ptr_arguments (struct ipa_edge_args *args, 1129 gimple call) 1130 { 1131 unsigned num; 1132 tree arg, method_field, delta_field; 1133 1134 for (num = 0; num < gimple_call_num_args (call); num++) 1135 { 1136 struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, num); 1137 arg = gimple_call_arg (call, num); 1138 1139 if (jfunc->type == IPA_JF_UNKNOWN 1140 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field, 1141 &delta_field)) 1142 determine_cst_member_ptr (call, arg, method_field, delta_field, jfunc); 1143 } 1144 } 1145 1146 /* Compute jump function for all arguments of callsite CS and insert the 1147 information in the jump_functions array in the ipa_edge_args corresponding 1148 to this callsite. */ 1149 1150 static void 1151 ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_ainfo, 1152 struct cgraph_edge *cs) 1153 { 1154 struct ipa_node_params *info = IPA_NODE_REF (cs->caller); 1155 struct ipa_edge_args *args = IPA_EDGE_REF (cs); 1156 gimple call = cs->call_stmt; 1157 int arg_num = gimple_call_num_args (call); 1158 1159 if (arg_num == 0 || args->jump_functions) 1160 return; 1161 VEC_safe_grow_cleared (ipa_jump_func_t, gc, args->jump_functions, arg_num); 1162 1163 /* We will deal with constants and SSA scalars first: */ 1164 compute_scalar_jump_functions (info, parms_ainfo, args, call); 1165 1166 /* Let's check whether there are any potential member pointers and if so, 1167 whether we can determine their functions as pass_through. */ 1168 if (!compute_pass_through_member_ptrs (info, parms_ainfo, args, call)) 1169 return; 1170 1171 /* Finally, let's check whether we actually pass a new constant member 1172 pointer here... */ 1173 compute_cst_member_ptr_arguments (args, call); 1174 } 1175 1176 /* Compute jump functions for all edges - both direct and indirect - outgoing 1177 from NODE. Also count the actual arguments in the process. */ 1178 1179 static void 1180 ipa_compute_jump_functions (struct cgraph_node *node, 1181 struct param_analysis_info *parms_ainfo) 1182 { 1183 struct cgraph_edge *cs; 1184 1185 for (cs = node->callees; cs; cs = cs->next_callee) 1186 { 1187 struct cgraph_node *callee = cgraph_function_or_thunk_node (cs->callee, 1188 NULL); 1189 /* We do not need to bother analyzing calls to unknown 1190 functions unless they may become known during lto/whopr. */ 1191 if (!callee->analyzed && !flag_lto) 1192 continue; 1193 ipa_compute_jump_functions_for_edge (parms_ainfo, cs); 1194 } 1195 1196 for (cs = node->indirect_calls; cs; cs = cs->next_callee) 1197 ipa_compute_jump_functions_for_edge (parms_ainfo, cs); 1198 } 1199 1200 /* If RHS looks like a rhs of a statement loading pfn from a member 1201 pointer formal parameter, return the parameter, otherwise return 1202 NULL. If USE_DELTA, then we look for a use of the delta field 1203 rather than the pfn. */ 1204 1205 static tree 1206 ipa_get_member_ptr_load_param (tree rhs, bool use_delta) 1207 { 1208 tree rec, ref_field, ref_offset, fld, fld_offset, ptr_field, delta_field; 1209 1210 if (TREE_CODE (rhs) == COMPONENT_REF) 1211 { 1212 ref_field = TREE_OPERAND (rhs, 1); 1213 rhs = TREE_OPERAND (rhs, 0); 1214 } 1215 else 1216 ref_field = NULL_TREE; 1217 if (TREE_CODE (rhs) != MEM_REF) 1218 return NULL_TREE; 1219 rec = TREE_OPERAND (rhs, 0); 1220 if (TREE_CODE (rec) != ADDR_EXPR) 1221 return NULL_TREE; 1222 rec = TREE_OPERAND (rec, 0); 1223 if (TREE_CODE (rec) != PARM_DECL 1224 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field)) 1225 return NULL_TREE; 1226 1227 ref_offset = TREE_OPERAND (rhs, 1); 1228 1229 if (ref_field) 1230 { 1231 if (integer_nonzerop (ref_offset)) 1232 return NULL_TREE; 1233 1234 if (use_delta) 1235 fld = delta_field; 1236 else 1237 fld = ptr_field; 1238 1239 return ref_field == fld ? rec : NULL_TREE; 1240 } 1241 1242 if (use_delta) 1243 fld_offset = byte_position (delta_field); 1244 else 1245 fld_offset = byte_position (ptr_field); 1246 1247 return tree_int_cst_equal (ref_offset, fld_offset) ? rec : NULL_TREE; 1248 } 1249 1250 /* If STMT looks like a statement loading a value from a member pointer formal 1251 parameter, this function returns that parameter. */ 1252 1253 static tree 1254 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta) 1255 { 1256 tree rhs; 1257 1258 if (!gimple_assign_single_p (stmt)) 1259 return NULL_TREE; 1260 1261 rhs = gimple_assign_rhs1 (stmt); 1262 return ipa_get_member_ptr_load_param (rhs, use_delta); 1263 } 1264 1265 /* Returns true iff T is an SSA_NAME defined by a statement. */ 1266 1267 static bool 1268 ipa_is_ssa_with_stmt_def (tree t) 1269 { 1270 if (TREE_CODE (t) == SSA_NAME 1271 && !SSA_NAME_IS_DEFAULT_DEF (t)) 1272 return true; 1273 else 1274 return false; 1275 } 1276 1277 /* Find the indirect call graph edge corresponding to STMT and mark it as a 1278 call to a parameter number PARAM_INDEX. NODE is the caller. Return the 1279 indirect call graph edge. */ 1280 1281 static struct cgraph_edge * 1282 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt) 1283 { 1284 struct cgraph_edge *cs; 1285 1286 cs = cgraph_edge (node, stmt); 1287 cs->indirect_info->param_index = param_index; 1288 cs->indirect_info->anc_offset = 0; 1289 cs->indirect_info->polymorphic = 0; 1290 return cs; 1291 } 1292 1293 /* Analyze the CALL and examine uses of formal parameters of the caller NODE 1294 (described by INFO). PARMS_AINFO is a pointer to a vector containing 1295 intermediate information about each formal parameter. Currently it checks 1296 whether the call calls a pointer that is a formal parameter and if so, the 1297 parameter is marked with the called flag and an indirect call graph edge 1298 describing the call is created. This is very simple for ordinary pointers 1299 represented in SSA but not-so-nice when it comes to member pointers. The 1300 ugly part of this function does nothing more than trying to match the 1301 pattern of such a call. An example of such a pattern is the gimple dump 1302 below, the call is on the last line: 1303 1304 <bb 2>: 1305 f$__delta_5 = f.__delta; 1306 f$__pfn_24 = f.__pfn; 1307 1308 or 1309 <bb 2>: 1310 f$__delta_5 = MEM[(struct *)&f]; 1311 f$__pfn_24 = MEM[(struct *)&f + 4B]; 1312 1313 and a few lines below: 1314 1315 <bb 5> 1316 D.2496_3 = (int) f$__pfn_24; 1317 D.2497_4 = D.2496_3 & 1; 1318 if (D.2497_4 != 0) 1319 goto <bb 3>; 1320 else 1321 goto <bb 4>; 1322 1323 <bb 6>: 1324 D.2500_7 = (unsigned int) f$__delta_5; 1325 D.2501_8 = &S + D.2500_7; 1326 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8; 1327 D.2503_10 = *D.2502_9; 1328 D.2504_12 = f$__pfn_24 + -1; 1329 D.2505_13 = (unsigned int) D.2504_12; 1330 D.2506_14 = D.2503_10 + D.2505_13; 1331 D.2507_15 = *D.2506_14; 1332 iftmp.11_16 = (String:: *) D.2507_15; 1333 1334 <bb 7>: 1335 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)> 1336 D.2500_19 = (unsigned int) f$__delta_5; 1337 D.2508_20 = &S + D.2500_19; 1338 D.2493_21 = iftmp.11_1 (D.2508_20, 4); 1339 1340 Such patterns are results of simple calls to a member pointer: 1341 1342 int doprinting (int (MyString::* f)(int) const) 1343 { 1344 MyString S ("somestring"); 1345 1346 return (S.*f)(4); 1347 } 1348 */ 1349 1350 static void 1351 ipa_analyze_indirect_call_uses (struct cgraph_node *node, 1352 struct ipa_node_params *info, 1353 struct param_analysis_info *parms_ainfo, 1354 gimple call, tree target) 1355 { 1356 gimple def; 1357 tree n1, n2; 1358 gimple d1, d2; 1359 tree rec, rec2, cond; 1360 gimple branch; 1361 int index; 1362 basic_block bb, virt_bb, join; 1363 1364 if (SSA_NAME_IS_DEFAULT_DEF (target)) 1365 { 1366 tree var = SSA_NAME_VAR (target); 1367 index = ipa_get_param_decl_index (info, var); 1368 if (index >= 0) 1369 ipa_note_param_call (node, index, call); 1370 return; 1371 } 1372 1373 /* Now we need to try to match the complex pattern of calling a member 1374 pointer. */ 1375 1376 if (!POINTER_TYPE_P (TREE_TYPE (target)) 1377 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE) 1378 return; 1379 1380 def = SSA_NAME_DEF_STMT (target); 1381 if (gimple_code (def) != GIMPLE_PHI) 1382 return; 1383 1384 if (gimple_phi_num_args (def) != 2) 1385 return; 1386 1387 /* First, we need to check whether one of these is a load from a member 1388 pointer that is a parameter to this function. */ 1389 n1 = PHI_ARG_DEF (def, 0); 1390 n2 = PHI_ARG_DEF (def, 1); 1391 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2)) 1392 return; 1393 d1 = SSA_NAME_DEF_STMT (n1); 1394 d2 = SSA_NAME_DEF_STMT (n2); 1395 1396 join = gimple_bb (def); 1397 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false))) 1398 { 1399 if (ipa_get_stmt_member_ptr_load_param (d2, false)) 1400 return; 1401 1402 bb = EDGE_PRED (join, 0)->src; 1403 virt_bb = gimple_bb (d2); 1404 } 1405 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false))) 1406 { 1407 bb = EDGE_PRED (join, 1)->src; 1408 virt_bb = gimple_bb (d1); 1409 } 1410 else 1411 return; 1412 1413 /* Second, we need to check that the basic blocks are laid out in the way 1414 corresponding to the pattern. */ 1415 1416 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb) 1417 || single_pred (virt_bb) != bb 1418 || single_succ (virt_bb) != join) 1419 return; 1420 1421 /* Third, let's see that the branching is done depending on the least 1422 significant bit of the pfn. */ 1423 1424 branch = last_stmt (bb); 1425 if (!branch || gimple_code (branch) != GIMPLE_COND) 1426 return; 1427 1428 if ((gimple_cond_code (branch) != NE_EXPR 1429 && gimple_cond_code (branch) != EQ_EXPR) 1430 || !integer_zerop (gimple_cond_rhs (branch))) 1431 return; 1432 1433 cond = gimple_cond_lhs (branch); 1434 if (!ipa_is_ssa_with_stmt_def (cond)) 1435 return; 1436 1437 def = SSA_NAME_DEF_STMT (cond); 1438 if (!is_gimple_assign (def) 1439 || gimple_assign_rhs_code (def) != BIT_AND_EXPR 1440 || !integer_onep (gimple_assign_rhs2 (def))) 1441 return; 1442 1443 cond = gimple_assign_rhs1 (def); 1444 if (!ipa_is_ssa_with_stmt_def (cond)) 1445 return; 1446 1447 def = SSA_NAME_DEF_STMT (cond); 1448 1449 if (is_gimple_assign (def) 1450 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def))) 1451 { 1452 cond = gimple_assign_rhs1 (def); 1453 if (!ipa_is_ssa_with_stmt_def (cond)) 1454 return; 1455 def = SSA_NAME_DEF_STMT (cond); 1456 } 1457 1458 rec2 = ipa_get_stmt_member_ptr_load_param (def, 1459 (TARGET_PTRMEMFUNC_VBIT_LOCATION 1460 == ptrmemfunc_vbit_in_delta)); 1461 1462 if (rec != rec2) 1463 return; 1464 1465 index = ipa_get_param_decl_index (info, rec); 1466 if (index >= 0 && !is_parm_modified_before_stmt (&parms_ainfo[index], 1467 call, rec)) 1468 ipa_note_param_call (node, index, call); 1469 1470 return; 1471 } 1472 1473 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the 1474 object referenced in the expression is a formal parameter of the caller 1475 (described by INFO), create a call note for the statement. */ 1476 1477 static void 1478 ipa_analyze_virtual_call_uses (struct cgraph_node *node, 1479 struct ipa_node_params *info, gimple call, 1480 tree target) 1481 { 1482 struct cgraph_edge *cs; 1483 struct cgraph_indirect_call_info *ii; 1484 struct ipa_jump_func jfunc; 1485 tree obj = OBJ_TYPE_REF_OBJECT (target); 1486 int index; 1487 HOST_WIDE_INT anc_offset; 1488 1489 if (!flag_devirtualize) 1490 return; 1491 1492 if (TREE_CODE (obj) != SSA_NAME) 1493 return; 1494 1495 if (SSA_NAME_IS_DEFAULT_DEF (obj)) 1496 { 1497 if (TREE_CODE (SSA_NAME_VAR (obj)) != PARM_DECL) 1498 return; 1499 1500 anc_offset = 0; 1501 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (obj)); 1502 gcc_assert (index >= 0); 1503 if (detect_type_change_ssa (obj, call, &jfunc)) 1504 return; 1505 } 1506 else 1507 { 1508 gimple stmt = SSA_NAME_DEF_STMT (obj); 1509 tree expr; 1510 1511 expr = get_ancestor_addr_info (stmt, &obj, &anc_offset); 1512 if (!expr) 1513 return; 1514 index = ipa_get_param_decl_index (info, 1515 SSA_NAME_VAR (TREE_OPERAND (expr, 0))); 1516 gcc_assert (index >= 0); 1517 if (detect_type_change (obj, expr, call, &jfunc, anc_offset)) 1518 return; 1519 } 1520 1521 cs = ipa_note_param_call (node, index, call); 1522 ii = cs->indirect_info; 1523 ii->anc_offset = anc_offset; 1524 ii->otr_token = tree_low_cst (OBJ_TYPE_REF_TOKEN (target), 1); 1525 ii->otr_type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (target))); 1526 ii->polymorphic = 1; 1527 } 1528 1529 /* Analyze a call statement CALL whether and how it utilizes formal parameters 1530 of the caller (described by INFO). PARMS_AINFO is a pointer to a vector 1531 containing intermediate information about each formal parameter. */ 1532 1533 static void 1534 ipa_analyze_call_uses (struct cgraph_node *node, 1535 struct ipa_node_params *info, 1536 struct param_analysis_info *parms_ainfo, gimple call) 1537 { 1538 tree target = gimple_call_fn (call); 1539 1540 if (!target) 1541 return; 1542 if (TREE_CODE (target) == SSA_NAME) 1543 ipa_analyze_indirect_call_uses (node, info, parms_ainfo, call, target); 1544 else if (TREE_CODE (target) == OBJ_TYPE_REF) 1545 ipa_analyze_virtual_call_uses (node, info, call, target); 1546 } 1547 1548 1549 /* Analyze the call statement STMT with respect to formal parameters (described 1550 in INFO) of caller given by NODE. Currently it only checks whether formal 1551 parameters are called. PARMS_AINFO is a pointer to a vector containing 1552 intermediate information about each formal parameter. */ 1553 1554 static void 1555 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info, 1556 struct param_analysis_info *parms_ainfo, gimple stmt) 1557 { 1558 if (is_gimple_call (stmt)) 1559 ipa_analyze_call_uses (node, info, parms_ainfo, stmt); 1560 } 1561 1562 /* Callback of walk_stmt_load_store_addr_ops for the visit_load. 1563 If OP is a parameter declaration, mark it as used in the info structure 1564 passed in DATA. */ 1565 1566 static bool 1567 visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED, 1568 tree op, void *data) 1569 { 1570 struct ipa_node_params *info = (struct ipa_node_params *) data; 1571 1572 op = get_base_address (op); 1573 if (op 1574 && TREE_CODE (op) == PARM_DECL) 1575 { 1576 int index = ipa_get_param_decl_index (info, op); 1577 gcc_assert (index >= 0); 1578 ipa_set_param_used (info, index, true); 1579 } 1580 1581 return false; 1582 } 1583 1584 /* Scan the function body of NODE and inspect the uses of formal parameters. 1585 Store the findings in various structures of the associated ipa_node_params 1586 structure, such as parameter flags, notes etc. PARMS_AINFO is a pointer to a 1587 vector containing intermediate information about each formal parameter. */ 1588 1589 static void 1590 ipa_analyze_params_uses (struct cgraph_node *node, 1591 struct param_analysis_info *parms_ainfo) 1592 { 1593 tree decl = node->decl; 1594 basic_block bb; 1595 struct function *func; 1596 gimple_stmt_iterator gsi; 1597 struct ipa_node_params *info = IPA_NODE_REF (node); 1598 int i; 1599 1600 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done) 1601 return; 1602 1603 for (i = 0; i < ipa_get_param_count (info); i++) 1604 { 1605 tree parm = ipa_get_param (info, i); 1606 /* For SSA regs see if parameter is used. For non-SSA we compute 1607 the flag during modification analysis. */ 1608 if (is_gimple_reg (parm) 1609 && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm)) 1610 ipa_set_param_used (info, i, true); 1611 } 1612 1613 func = DECL_STRUCT_FUNCTION (decl); 1614 FOR_EACH_BB_FN (bb, func) 1615 { 1616 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 1617 { 1618 gimple stmt = gsi_stmt (gsi); 1619 1620 if (is_gimple_debug (stmt)) 1621 continue; 1622 1623 ipa_analyze_stmt_uses (node, info, parms_ainfo, stmt); 1624 walk_stmt_load_store_addr_ops (stmt, info, 1625 visit_ref_for_mod_analysis, 1626 visit_ref_for_mod_analysis, 1627 visit_ref_for_mod_analysis); 1628 } 1629 for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi)) 1630 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info, 1631 visit_ref_for_mod_analysis, 1632 visit_ref_for_mod_analysis, 1633 visit_ref_for_mod_analysis); 1634 } 1635 1636 info->uses_analysis_done = 1; 1637 } 1638 1639 /* Initialize the array describing properties of of formal parameters 1640 of NODE, analyze their uses and compute jump functions associated 1641 with actual arguments of calls from within NODE. */ 1642 1643 void 1644 ipa_analyze_node (struct cgraph_node *node) 1645 { 1646 struct ipa_node_params *info; 1647 struct param_analysis_info *parms_ainfo; 1648 int i, param_count; 1649 1650 ipa_check_create_node_params (); 1651 ipa_check_create_edge_args (); 1652 info = IPA_NODE_REF (node); 1653 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); 1654 current_function_decl = node->decl; 1655 ipa_initialize_node_params (node); 1656 1657 param_count = ipa_get_param_count (info); 1658 parms_ainfo = XALLOCAVEC (struct param_analysis_info, param_count); 1659 memset (parms_ainfo, 0, sizeof (struct param_analysis_info) * param_count); 1660 1661 ipa_analyze_params_uses (node, parms_ainfo); 1662 ipa_compute_jump_functions (node, parms_ainfo); 1663 1664 for (i = 0; i < param_count; i++) 1665 if (parms_ainfo[i].visited_statements) 1666 BITMAP_FREE (parms_ainfo[i].visited_statements); 1667 1668 current_function_decl = NULL; 1669 pop_cfun (); 1670 } 1671 1672 1673 /* Update the jump function DST when the call graph edge corresponding to SRC is 1674 is being inlined, knowing that DST is of type ancestor and src of known 1675 type. */ 1676 1677 static void 1678 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src, 1679 struct ipa_jump_func *dst) 1680 { 1681 HOST_WIDE_INT combined_offset; 1682 tree combined_type; 1683 1684 combined_offset = src->value.known_type.offset + dst->value.ancestor.offset; 1685 combined_type = dst->value.ancestor.type; 1686 1687 dst->type = IPA_JF_KNOWN_TYPE; 1688 dst->value.known_type.base_type = src->value.known_type.base_type; 1689 dst->value.known_type.offset = combined_offset; 1690 dst->value.known_type.component_type = combined_type; 1691 } 1692 1693 /* Update the jump functions associated with call graph edge E when the call 1694 graph edge CS is being inlined, assuming that E->caller is already (possibly 1695 indirectly) inlined into CS->callee and that E has not been inlined. */ 1696 1697 static void 1698 update_jump_functions_after_inlining (struct cgraph_edge *cs, 1699 struct cgraph_edge *e) 1700 { 1701 struct ipa_edge_args *top = IPA_EDGE_REF (cs); 1702 struct ipa_edge_args *args = IPA_EDGE_REF (e); 1703 int count = ipa_get_cs_argument_count (args); 1704 int i; 1705 1706 for (i = 0; i < count; i++) 1707 { 1708 struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i); 1709 1710 if (dst->type == IPA_JF_ANCESTOR) 1711 { 1712 struct ipa_jump_func *src; 1713 1714 /* Variable number of arguments can cause havoc if we try to access 1715 one that does not exist in the inlined edge. So make sure we 1716 don't. */ 1717 if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top)) 1718 { 1719 dst->type = IPA_JF_UNKNOWN; 1720 continue; 1721 } 1722 1723 src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id); 1724 if (src->type == IPA_JF_KNOWN_TYPE) 1725 combine_known_type_and_ancestor_jfs (src, dst); 1726 else if (src->type == IPA_JF_PASS_THROUGH 1727 && src->value.pass_through.operation == NOP_EXPR) 1728 dst->value.ancestor.formal_id = src->value.pass_through.formal_id; 1729 else if (src->type == IPA_JF_ANCESTOR) 1730 { 1731 dst->value.ancestor.formal_id = src->value.ancestor.formal_id; 1732 dst->value.ancestor.offset += src->value.ancestor.offset; 1733 } 1734 else 1735 dst->type = IPA_JF_UNKNOWN; 1736 } 1737 else if (dst->type == IPA_JF_PASS_THROUGH) 1738 { 1739 struct ipa_jump_func *src; 1740 /* We must check range due to calls with variable number of arguments 1741 and we cannot combine jump functions with operations. */ 1742 if (dst->value.pass_through.operation == NOP_EXPR 1743 && (dst->value.pass_through.formal_id 1744 < ipa_get_cs_argument_count (top))) 1745 { 1746 src = ipa_get_ith_jump_func (top, 1747 dst->value.pass_through.formal_id); 1748 *dst = *src; 1749 } 1750 else 1751 dst->type = IPA_JF_UNKNOWN; 1752 } 1753 } 1754 } 1755 1756 /* If TARGET is an addr_expr of a function declaration, make it the destination 1757 of an indirect edge IE and return the edge. Otherwise, return NULL. */ 1758 1759 struct cgraph_edge * 1760 ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target) 1761 { 1762 struct cgraph_node *callee; 1763 1764 if (TREE_CODE (target) == ADDR_EXPR) 1765 target = TREE_OPERAND (target, 0); 1766 if (TREE_CODE (target) != FUNCTION_DECL) 1767 return NULL; 1768 callee = cgraph_get_node (target); 1769 if (!callee) 1770 return NULL; 1771 ipa_check_create_node_params (); 1772 1773 /* We can not make edges to inline clones. It is bug that someone removed 1774 the cgraph node too early. */ 1775 gcc_assert (!callee->global.inlined_to); 1776 1777 cgraph_make_edge_direct (ie, callee); 1778 if (dump_file) 1779 { 1780 fprintf (dump_file, "ipa-prop: Discovered %s call to a known target " 1781 "(%s/%i -> %s/%i), for stmt ", 1782 ie->indirect_info->polymorphic ? "a virtual" : "an indirect", 1783 xstrdup (cgraph_node_name (ie->caller)), ie->caller->uid, 1784 xstrdup (cgraph_node_name (ie->callee)), ie->callee->uid); 1785 if (ie->call_stmt) 1786 print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM); 1787 else 1788 fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid); 1789 } 1790 callee = cgraph_function_or_thunk_node (callee, NULL); 1791 1792 return ie; 1793 } 1794 1795 /* Try to find a destination for indirect edge IE that corresponds to a simple 1796 call or a call of a member function pointer and where the destination is a 1797 pointer formal parameter described by jump function JFUNC. If it can be 1798 determined, return the newly direct edge, otherwise return NULL. */ 1799 1800 static struct cgraph_edge * 1801 try_make_edge_direct_simple_call (struct cgraph_edge *ie, 1802 struct ipa_jump_func *jfunc) 1803 { 1804 tree target; 1805 1806 if (jfunc->type == IPA_JF_CONST) 1807 target = jfunc->value.constant; 1808 else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR) 1809 target = jfunc->value.member_cst.pfn; 1810 else 1811 return NULL; 1812 1813 return ipa_make_edge_direct_to_target (ie, target); 1814 } 1815 1816 /* Try to find a destination for indirect edge IE that corresponds to a 1817 virtual call based on a formal parameter which is described by jump 1818 function JFUNC and if it can be determined, make it direct and return the 1819 direct edge. Otherwise, return NULL. */ 1820 1821 static struct cgraph_edge * 1822 try_make_edge_direct_virtual_call (struct cgraph_edge *ie, 1823 struct ipa_jump_func *jfunc) 1824 { 1825 tree binfo, target; 1826 1827 if (jfunc->type != IPA_JF_KNOWN_TYPE) 1828 return NULL; 1829 1830 binfo = TYPE_BINFO (jfunc->value.known_type.base_type); 1831 gcc_checking_assert (binfo); 1832 binfo = get_binfo_at_offset (binfo, jfunc->value.known_type.offset 1833 + ie->indirect_info->anc_offset, 1834 ie->indirect_info->otr_type); 1835 if (binfo) 1836 target = gimple_get_virt_method_for_binfo (ie->indirect_info->otr_token, 1837 binfo); 1838 else 1839 return NULL; 1840 1841 if (target) 1842 return ipa_make_edge_direct_to_target (ie, target); 1843 else 1844 return NULL; 1845 } 1846 1847 /* Update the param called notes associated with NODE when CS is being inlined, 1848 assuming NODE is (potentially indirectly) inlined into CS->callee. 1849 Moreover, if the callee is discovered to be constant, create a new cgraph 1850 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES, 1851 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */ 1852 1853 static bool 1854 update_indirect_edges_after_inlining (struct cgraph_edge *cs, 1855 struct cgraph_node *node, 1856 VEC (cgraph_edge_p, heap) **new_edges) 1857 { 1858 struct ipa_edge_args *top; 1859 struct cgraph_edge *ie, *next_ie, *new_direct_edge; 1860 bool res = false; 1861 1862 ipa_check_create_edge_args (); 1863 top = IPA_EDGE_REF (cs); 1864 1865 for (ie = node->indirect_calls; ie; ie = next_ie) 1866 { 1867 struct cgraph_indirect_call_info *ici = ie->indirect_info; 1868 struct ipa_jump_func *jfunc; 1869 1870 next_ie = ie->next_callee; 1871 1872 if (ici->param_index == -1) 1873 continue; 1874 1875 /* We must check range due to calls with variable number of arguments: */ 1876 if (ici->param_index >= ipa_get_cs_argument_count (top)) 1877 { 1878 ici->param_index = -1; 1879 continue; 1880 } 1881 1882 jfunc = ipa_get_ith_jump_func (top, ici->param_index); 1883 if (jfunc->type == IPA_JF_PASS_THROUGH 1884 && jfunc->value.pass_through.operation == NOP_EXPR) 1885 ici->param_index = jfunc->value.pass_through.formal_id; 1886 else if (jfunc->type == IPA_JF_ANCESTOR) 1887 { 1888 ici->param_index = jfunc->value.ancestor.formal_id; 1889 ici->anc_offset += jfunc->value.ancestor.offset; 1890 } 1891 else 1892 /* Either we can find a destination for this edge now or never. */ 1893 ici->param_index = -1; 1894 1895 if (!flag_indirect_inlining) 1896 continue; 1897 1898 if (ici->polymorphic) 1899 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc); 1900 else 1901 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc); 1902 1903 if (new_direct_edge) 1904 { 1905 new_direct_edge->indirect_inlining_edge = 1; 1906 if (new_direct_edge->call_stmt) 1907 new_direct_edge->call_stmt_cannot_inline_p 1908 = !gimple_check_call_matching_types (new_direct_edge->call_stmt, 1909 new_direct_edge->callee->decl); 1910 if (new_edges) 1911 { 1912 VEC_safe_push (cgraph_edge_p, heap, *new_edges, 1913 new_direct_edge); 1914 top = IPA_EDGE_REF (cs); 1915 res = true; 1916 } 1917 } 1918 } 1919 1920 return res; 1921 } 1922 1923 /* Recursively traverse subtree of NODE (including node) made of inlined 1924 cgraph_edges when CS has been inlined and invoke 1925 update_indirect_edges_after_inlining on all nodes and 1926 update_jump_functions_after_inlining on all non-inlined edges that lead out 1927 of this subtree. Newly discovered indirect edges will be added to 1928 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were 1929 created. */ 1930 1931 static bool 1932 propagate_info_to_inlined_callees (struct cgraph_edge *cs, 1933 struct cgraph_node *node, 1934 VEC (cgraph_edge_p, heap) **new_edges) 1935 { 1936 struct cgraph_edge *e; 1937 bool res; 1938 1939 res = update_indirect_edges_after_inlining (cs, node, new_edges); 1940 1941 for (e = node->callees; e; e = e->next_callee) 1942 if (!e->inline_failed) 1943 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges); 1944 else 1945 update_jump_functions_after_inlining (cs, e); 1946 for (e = node->indirect_calls; e; e = e->next_callee) 1947 update_jump_functions_after_inlining (cs, e); 1948 1949 return res; 1950 } 1951 1952 /* Update jump functions and call note functions on inlining the call site CS. 1953 CS is expected to lead to a node already cloned by 1954 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to 1955 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were + 1956 created. */ 1957 1958 bool 1959 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs, 1960 VEC (cgraph_edge_p, heap) **new_edges) 1961 { 1962 bool changed; 1963 /* Do nothing if the preparation phase has not been carried out yet 1964 (i.e. during early inlining). */ 1965 if (!ipa_node_params_vector) 1966 return false; 1967 gcc_assert (ipa_edge_args_vector); 1968 1969 changed = propagate_info_to_inlined_callees (cs, cs->callee, new_edges); 1970 1971 /* We do not keep jump functions of inlined edges up to date. Better to free 1972 them so we do not access them accidentally. */ 1973 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs)); 1974 return changed; 1975 } 1976 1977 /* Frees all dynamically allocated structures that the argument info points 1978 to. */ 1979 1980 void 1981 ipa_free_edge_args_substructures (struct ipa_edge_args *args) 1982 { 1983 if (args->jump_functions) 1984 ggc_free (args->jump_functions); 1985 1986 memset (args, 0, sizeof (*args)); 1987 } 1988 1989 /* Free all ipa_edge structures. */ 1990 1991 void 1992 ipa_free_all_edge_args (void) 1993 { 1994 int i; 1995 struct ipa_edge_args *args; 1996 1997 FOR_EACH_VEC_ELT (ipa_edge_args_t, ipa_edge_args_vector, i, args) 1998 ipa_free_edge_args_substructures (args); 1999 2000 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector); 2001 ipa_edge_args_vector = NULL; 2002 } 2003 2004 /* Frees all dynamically allocated structures that the param info points 2005 to. */ 2006 2007 void 2008 ipa_free_node_params_substructures (struct ipa_node_params *info) 2009 { 2010 VEC_free (ipa_param_descriptor_t, heap, info->descriptors); 2011 free (info->lattices); 2012 /* Lattice values and their sources are deallocated with their alocation 2013 pool. */ 2014 VEC_free (tree, heap, info->known_vals); 2015 memset (info, 0, sizeof (*info)); 2016 } 2017 2018 /* Free all ipa_node_params structures. */ 2019 2020 void 2021 ipa_free_all_node_params (void) 2022 { 2023 int i; 2024 struct ipa_node_params *info; 2025 2026 FOR_EACH_VEC_ELT (ipa_node_params_t, ipa_node_params_vector, i, info) 2027 ipa_free_node_params_substructures (info); 2028 2029 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector); 2030 ipa_node_params_vector = NULL; 2031 } 2032 2033 /* Hook that is called by cgraph.c when an edge is removed. */ 2034 2035 static void 2036 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED) 2037 { 2038 /* During IPA-CP updating we can be called on not-yet analyze clones. */ 2039 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector) 2040 <= (unsigned)cs->uid) 2041 return; 2042 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs)); 2043 } 2044 2045 /* Hook that is called by cgraph.c when a node is removed. */ 2046 2047 static void 2048 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED) 2049 { 2050 /* During IPA-CP updating we can be called on not-yet analyze clones. */ 2051 if (VEC_length (ipa_node_params_t, ipa_node_params_vector) 2052 <= (unsigned)node->uid) 2053 return; 2054 ipa_free_node_params_substructures (IPA_NODE_REF (node)); 2055 } 2056 2057 /* Hook that is called by cgraph.c when a node is duplicated. */ 2058 2059 static void 2060 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst, 2061 __attribute__((unused)) void *data) 2062 { 2063 struct ipa_edge_args *old_args, *new_args; 2064 2065 ipa_check_create_edge_args (); 2066 2067 old_args = IPA_EDGE_REF (src); 2068 new_args = IPA_EDGE_REF (dst); 2069 2070 new_args->jump_functions = VEC_copy (ipa_jump_func_t, gc, 2071 old_args->jump_functions); 2072 } 2073 2074 /* Hook that is called by cgraph.c when a node is duplicated. */ 2075 2076 static void 2077 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst, 2078 ATTRIBUTE_UNUSED void *data) 2079 { 2080 struct ipa_node_params *old_info, *new_info; 2081 2082 ipa_check_create_node_params (); 2083 old_info = IPA_NODE_REF (src); 2084 new_info = IPA_NODE_REF (dst); 2085 2086 new_info->descriptors = VEC_copy (ipa_param_descriptor_t, heap, 2087 old_info->descriptors); 2088 new_info->lattices = NULL; 2089 new_info->ipcp_orig_node = old_info->ipcp_orig_node; 2090 2091 new_info->uses_analysis_done = old_info->uses_analysis_done; 2092 new_info->node_enqueued = old_info->node_enqueued; 2093 } 2094 2095 2096 /* Analyze newly added function into callgraph. */ 2097 2098 static void 2099 ipa_add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED) 2100 { 2101 ipa_analyze_node (node); 2102 } 2103 2104 /* Register our cgraph hooks if they are not already there. */ 2105 2106 void 2107 ipa_register_cgraph_hooks (void) 2108 { 2109 if (!edge_removal_hook_holder) 2110 edge_removal_hook_holder = 2111 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL); 2112 if (!node_removal_hook_holder) 2113 node_removal_hook_holder = 2114 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL); 2115 if (!edge_duplication_hook_holder) 2116 edge_duplication_hook_holder = 2117 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL); 2118 if (!node_duplication_hook_holder) 2119 node_duplication_hook_holder = 2120 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL); 2121 function_insertion_hook_holder = 2122 cgraph_add_function_insertion_hook (&ipa_add_new_function, NULL); 2123 } 2124 2125 /* Unregister our cgraph hooks if they are not already there. */ 2126 2127 static void 2128 ipa_unregister_cgraph_hooks (void) 2129 { 2130 cgraph_remove_edge_removal_hook (edge_removal_hook_holder); 2131 edge_removal_hook_holder = NULL; 2132 cgraph_remove_node_removal_hook (node_removal_hook_holder); 2133 node_removal_hook_holder = NULL; 2134 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder); 2135 edge_duplication_hook_holder = NULL; 2136 cgraph_remove_node_duplication_hook (node_duplication_hook_holder); 2137 node_duplication_hook_holder = NULL; 2138 cgraph_remove_function_insertion_hook (function_insertion_hook_holder); 2139 function_insertion_hook_holder = NULL; 2140 } 2141 2142 /* Free all ipa_node_params and all ipa_edge_args structures if they are no 2143 longer needed after ipa-cp. */ 2144 2145 void 2146 ipa_free_all_structures_after_ipa_cp (void) 2147 { 2148 if (!optimize) 2149 { 2150 ipa_free_all_edge_args (); 2151 ipa_free_all_node_params (); 2152 free_alloc_pool (ipcp_sources_pool); 2153 free_alloc_pool (ipcp_values_pool); 2154 ipa_unregister_cgraph_hooks (); 2155 } 2156 } 2157 2158 /* Free all ipa_node_params and all ipa_edge_args structures if they are no 2159 longer needed after indirect inlining. */ 2160 2161 void 2162 ipa_free_all_structures_after_iinln (void) 2163 { 2164 ipa_free_all_edge_args (); 2165 ipa_free_all_node_params (); 2166 ipa_unregister_cgraph_hooks (); 2167 if (ipcp_sources_pool) 2168 free_alloc_pool (ipcp_sources_pool); 2169 if (ipcp_values_pool) 2170 free_alloc_pool (ipcp_values_pool); 2171 } 2172 2173 /* Print ipa_tree_map data structures of all functions in the 2174 callgraph to F. */ 2175 2176 void 2177 ipa_print_node_params (FILE * f, struct cgraph_node *node) 2178 { 2179 int i, count; 2180 tree temp; 2181 struct ipa_node_params *info; 2182 2183 if (!node->analyzed) 2184 return; 2185 info = IPA_NODE_REF (node); 2186 fprintf (f, " function %s parameter descriptors:\n", 2187 cgraph_node_name (node)); 2188 count = ipa_get_param_count (info); 2189 for (i = 0; i < count; i++) 2190 { 2191 temp = ipa_get_param (info, i); 2192 if (TREE_CODE (temp) == PARM_DECL) 2193 fprintf (f, " param %d : %s", i, 2194 (DECL_NAME (temp) 2195 ? (*lang_hooks.decl_printable_name) (temp, 2) 2196 : "(unnamed)")); 2197 if (ipa_is_param_used (info, i)) 2198 fprintf (f, " used"); 2199 fprintf (f, "\n"); 2200 } 2201 } 2202 2203 /* Print ipa_tree_map data structures of all functions in the 2204 callgraph to F. */ 2205 2206 void 2207 ipa_print_all_params (FILE * f) 2208 { 2209 struct cgraph_node *node; 2210 2211 fprintf (f, "\nFunction parameters:\n"); 2212 for (node = cgraph_nodes; node; node = node->next) 2213 ipa_print_node_params (f, node); 2214 } 2215 2216 /* Return a heap allocated vector containing formal parameters of FNDECL. */ 2217 2218 VEC(tree, heap) * 2219 ipa_get_vector_of_formal_parms (tree fndecl) 2220 { 2221 VEC(tree, heap) *args; 2222 int count; 2223 tree parm; 2224 2225 count = count_formal_params (fndecl); 2226 args = VEC_alloc (tree, heap, count); 2227 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm)) 2228 VEC_quick_push (tree, args, parm); 2229 2230 return args; 2231 } 2232 2233 /* Return a heap allocated vector containing types of formal parameters of 2234 function type FNTYPE. */ 2235 2236 static inline VEC(tree, heap) * 2237 get_vector_of_formal_parm_types (tree fntype) 2238 { 2239 VEC(tree, heap) *types; 2240 int count = 0; 2241 tree t; 2242 2243 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t)) 2244 count++; 2245 2246 types = VEC_alloc (tree, heap, count); 2247 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t)) 2248 VEC_quick_push (tree, types, TREE_VALUE (t)); 2249 2250 return types; 2251 } 2252 2253 /* Modify the function declaration FNDECL and its type according to the plan in 2254 ADJUSTMENTS. It also sets base fields of individual adjustments structures 2255 to reflect the actual parameters being modified which are determined by the 2256 base_index field. */ 2257 2258 void 2259 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments, 2260 const char *synth_parm_prefix) 2261 { 2262 VEC(tree, heap) *oparms, *otypes; 2263 tree orig_type, new_type = NULL; 2264 tree old_arg_types, t, new_arg_types = NULL; 2265 tree parm, *link = &DECL_ARGUMENTS (fndecl); 2266 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments); 2267 tree new_reversed = NULL; 2268 bool care_for_types, last_parm_void; 2269 2270 if (!synth_parm_prefix) 2271 synth_parm_prefix = "SYNTH"; 2272 2273 oparms = ipa_get_vector_of_formal_parms (fndecl); 2274 orig_type = TREE_TYPE (fndecl); 2275 old_arg_types = TYPE_ARG_TYPES (orig_type); 2276 2277 /* The following test is an ugly hack, some functions simply don't have any 2278 arguments in their type. This is probably a bug but well... */ 2279 care_for_types = (old_arg_types != NULL_TREE); 2280 if (care_for_types) 2281 { 2282 last_parm_void = (TREE_VALUE (tree_last (old_arg_types)) 2283 == void_type_node); 2284 otypes = get_vector_of_formal_parm_types (orig_type); 2285 if (last_parm_void) 2286 gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes)); 2287 else 2288 gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes)); 2289 } 2290 else 2291 { 2292 last_parm_void = false; 2293 otypes = NULL; 2294 } 2295 2296 for (i = 0; i < len; i++) 2297 { 2298 struct ipa_parm_adjustment *adj; 2299 gcc_assert (link); 2300 2301 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); 2302 parm = VEC_index (tree, oparms, adj->base_index); 2303 adj->base = parm; 2304 2305 if (adj->copy_param) 2306 { 2307 if (care_for_types) 2308 new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes, 2309 adj->base_index), 2310 new_arg_types); 2311 *link = parm; 2312 link = &DECL_CHAIN (parm); 2313 } 2314 else if (!adj->remove_param) 2315 { 2316 tree new_parm; 2317 tree ptype; 2318 2319 if (adj->by_ref) 2320 ptype = build_pointer_type (adj->type); 2321 else 2322 ptype = adj->type; 2323 2324 if (care_for_types) 2325 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types); 2326 2327 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE, 2328 ptype); 2329 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix); 2330 2331 DECL_ARTIFICIAL (new_parm) = 1; 2332 DECL_ARG_TYPE (new_parm) = ptype; 2333 DECL_CONTEXT (new_parm) = fndecl; 2334 TREE_USED (new_parm) = 1; 2335 DECL_IGNORED_P (new_parm) = 1; 2336 layout_decl (new_parm, 0); 2337 2338 add_referenced_var (new_parm); 2339 mark_sym_for_renaming (new_parm); 2340 adj->base = parm; 2341 adj->reduction = new_parm; 2342 2343 *link = new_parm; 2344 2345 link = &DECL_CHAIN (new_parm); 2346 } 2347 } 2348 2349 *link = NULL_TREE; 2350 2351 if (care_for_types) 2352 { 2353 new_reversed = nreverse (new_arg_types); 2354 if (last_parm_void) 2355 { 2356 if (new_reversed) 2357 TREE_CHAIN (new_arg_types) = void_list_node; 2358 else 2359 new_reversed = void_list_node; 2360 } 2361 } 2362 2363 /* Use copy_node to preserve as much as possible from original type 2364 (debug info, attribute lists etc.) 2365 Exception is METHOD_TYPEs must have THIS argument. 2366 When we are asked to remove it, we need to build new FUNCTION_TYPE 2367 instead. */ 2368 if (TREE_CODE (orig_type) != METHOD_TYPE 2369 || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param 2370 && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0)) 2371 { 2372 new_type = build_distinct_type_copy (orig_type); 2373 TYPE_ARG_TYPES (new_type) = new_reversed; 2374 } 2375 else 2376 { 2377 new_type 2378 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type), 2379 new_reversed)); 2380 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type); 2381 DECL_VINDEX (fndecl) = NULL_TREE; 2382 } 2383 2384 /* When signature changes, we need to clear builtin info. */ 2385 if (DECL_BUILT_IN (fndecl)) 2386 { 2387 DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN; 2388 DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0; 2389 } 2390 2391 /* This is a new type, not a copy of an old type. Need to reassociate 2392 variants. We can handle everything except the main variant lazily. */ 2393 t = TYPE_MAIN_VARIANT (orig_type); 2394 if (orig_type != t) 2395 { 2396 TYPE_MAIN_VARIANT (new_type) = t; 2397 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t); 2398 TYPE_NEXT_VARIANT (t) = new_type; 2399 } 2400 else 2401 { 2402 TYPE_MAIN_VARIANT (new_type) = new_type; 2403 TYPE_NEXT_VARIANT (new_type) = NULL; 2404 } 2405 2406 TREE_TYPE (fndecl) = new_type; 2407 DECL_VIRTUAL_P (fndecl) = 0; 2408 if (otypes) 2409 VEC_free (tree, heap, otypes); 2410 VEC_free (tree, heap, oparms); 2411 } 2412 2413 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS. 2414 If this is a directly recursive call, CS must be NULL. Otherwise it must 2415 contain the corresponding call graph edge. */ 2416 2417 void 2418 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt, 2419 ipa_parm_adjustment_vec adjustments) 2420 { 2421 VEC(tree, heap) *vargs; 2422 VEC(tree, gc) **debug_args = NULL; 2423 gimple new_stmt; 2424 gimple_stmt_iterator gsi; 2425 tree callee_decl; 2426 int i, len; 2427 2428 len = VEC_length (ipa_parm_adjustment_t, adjustments); 2429 vargs = VEC_alloc (tree, heap, len); 2430 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl; 2431 2432 gsi = gsi_for_stmt (stmt); 2433 for (i = 0; i < len; i++) 2434 { 2435 struct ipa_parm_adjustment *adj; 2436 2437 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); 2438 2439 if (adj->copy_param) 2440 { 2441 tree arg = gimple_call_arg (stmt, adj->base_index); 2442 2443 VEC_quick_push (tree, vargs, arg); 2444 } 2445 else if (!adj->remove_param) 2446 { 2447 tree expr, base, off; 2448 location_t loc; 2449 2450 /* We create a new parameter out of the value of the old one, we can 2451 do the following kind of transformations: 2452 2453 - A scalar passed by reference is converted to a scalar passed by 2454 value. (adj->by_ref is false and the type of the original 2455 actual argument is a pointer to a scalar). 2456 2457 - A part of an aggregate is passed instead of the whole aggregate. 2458 The part can be passed either by value or by reference, this is 2459 determined by value of adj->by_ref. Moreover, the code below 2460 handles both situations when the original aggregate is passed by 2461 value (its type is not a pointer) and when it is passed by 2462 reference (it is a pointer to an aggregate). 2463 2464 When the new argument is passed by reference (adj->by_ref is true) 2465 it must be a part of an aggregate and therefore we form it by 2466 simply taking the address of a reference inside the original 2467 aggregate. */ 2468 2469 gcc_checking_assert (adj->offset % BITS_PER_UNIT == 0); 2470 base = gimple_call_arg (stmt, adj->base_index); 2471 loc = EXPR_LOCATION (base); 2472 2473 if (TREE_CODE (base) != ADDR_EXPR 2474 && POINTER_TYPE_P (TREE_TYPE (base))) 2475 off = build_int_cst (adj->alias_ptr_type, 2476 adj->offset / BITS_PER_UNIT); 2477 else 2478 { 2479 HOST_WIDE_INT base_offset; 2480 tree prev_base; 2481 2482 if (TREE_CODE (base) == ADDR_EXPR) 2483 base = TREE_OPERAND (base, 0); 2484 prev_base = base; 2485 base = get_addr_base_and_unit_offset (base, &base_offset); 2486 /* Aggregate arguments can have non-invariant addresses. */ 2487 if (!base) 2488 { 2489 base = build_fold_addr_expr (prev_base); 2490 off = build_int_cst (adj->alias_ptr_type, 2491 adj->offset / BITS_PER_UNIT); 2492 } 2493 else if (TREE_CODE (base) == MEM_REF) 2494 { 2495 off = build_int_cst (adj->alias_ptr_type, 2496 base_offset 2497 + adj->offset / BITS_PER_UNIT); 2498 off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1), 2499 off); 2500 base = TREE_OPERAND (base, 0); 2501 } 2502 else 2503 { 2504 off = build_int_cst (adj->alias_ptr_type, 2505 base_offset 2506 + adj->offset / BITS_PER_UNIT); 2507 base = build_fold_addr_expr (base); 2508 } 2509 } 2510 2511 if (!adj->by_ref) 2512 { 2513 tree type = adj->type; 2514 unsigned int align; 2515 unsigned HOST_WIDE_INT misalign; 2516 align = get_pointer_alignment_1 (base, &misalign); 2517 misalign += (double_int_sext (tree_to_double_int (off), 2518 TYPE_PRECISION (TREE_TYPE (off))).low 2519 * BITS_PER_UNIT); 2520 misalign = misalign & (align - 1); 2521 if (misalign != 0) 2522 align = (misalign & -misalign); 2523 if (align < TYPE_ALIGN (type)) 2524 type = build_aligned_type (type, align); 2525 expr = fold_build2_loc (loc, MEM_REF, type, base, off); 2526 } 2527 else 2528 { 2529 expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off); 2530 expr = build_fold_addr_expr (expr); 2531 } 2532 2533 expr = force_gimple_operand_gsi (&gsi, expr, 2534 adj->by_ref 2535 || is_gimple_reg_type (adj->type), 2536 NULL, true, GSI_SAME_STMT); 2537 VEC_quick_push (tree, vargs, expr); 2538 } 2539 if (!adj->copy_param && MAY_HAVE_DEBUG_STMTS) 2540 { 2541 unsigned int ix; 2542 tree ddecl = NULL_TREE, origin = DECL_ORIGIN (adj->base), arg; 2543 gimple def_temp; 2544 2545 arg = gimple_call_arg (stmt, adj->base_index); 2546 if (!useless_type_conversion_p (TREE_TYPE (origin), TREE_TYPE (arg))) 2547 { 2548 if (!fold_convertible_p (TREE_TYPE (origin), arg)) 2549 continue; 2550 arg = fold_convert_loc (gimple_location (stmt), 2551 TREE_TYPE (origin), arg); 2552 } 2553 if (debug_args == NULL) 2554 debug_args = decl_debug_args_insert (callee_decl); 2555 for (ix = 0; VEC_iterate (tree, *debug_args, ix, ddecl); ix += 2) 2556 if (ddecl == origin) 2557 { 2558 ddecl = VEC_index (tree, *debug_args, ix + 1); 2559 break; 2560 } 2561 if (ddecl == NULL) 2562 { 2563 ddecl = make_node (DEBUG_EXPR_DECL); 2564 DECL_ARTIFICIAL (ddecl) = 1; 2565 TREE_TYPE (ddecl) = TREE_TYPE (origin); 2566 DECL_MODE (ddecl) = DECL_MODE (origin); 2567 2568 VEC_safe_push (tree, gc, *debug_args, origin); 2569 VEC_safe_push (tree, gc, *debug_args, ddecl); 2570 } 2571 def_temp = gimple_build_debug_bind (ddecl, unshare_expr (arg), 2572 stmt); 2573 gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT); 2574 } 2575 } 2576 2577 if (dump_file && (dump_flags & TDF_DETAILS)) 2578 { 2579 fprintf (dump_file, "replacing stmt:"); 2580 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0); 2581 } 2582 2583 new_stmt = gimple_build_call_vec (callee_decl, vargs); 2584 VEC_free (tree, heap, vargs); 2585 if (gimple_call_lhs (stmt)) 2586 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt)); 2587 2588 gimple_set_block (new_stmt, gimple_block (stmt)); 2589 if (gimple_has_location (stmt)) 2590 gimple_set_location (new_stmt, gimple_location (stmt)); 2591 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt)); 2592 gimple_call_copy_flags (new_stmt, stmt); 2593 2594 if (dump_file && (dump_flags & TDF_DETAILS)) 2595 { 2596 fprintf (dump_file, "with stmt:"); 2597 print_gimple_stmt (dump_file, new_stmt, 0, 0); 2598 fprintf (dump_file, "\n"); 2599 } 2600 gsi_replace (&gsi, new_stmt, true); 2601 if (cs) 2602 cgraph_set_call_stmt (cs, new_stmt); 2603 update_ssa (TODO_update_ssa); 2604 free_dominance_info (CDI_DOMINATORS); 2605 } 2606 2607 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */ 2608 2609 static bool 2610 index_in_adjustments_multiple_times_p (int base_index, 2611 ipa_parm_adjustment_vec adjustments) 2612 { 2613 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments); 2614 bool one = false; 2615 2616 for (i = 0; i < len; i++) 2617 { 2618 struct ipa_parm_adjustment *adj; 2619 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); 2620 2621 if (adj->base_index == base_index) 2622 { 2623 if (one) 2624 return true; 2625 else 2626 one = true; 2627 } 2628 } 2629 return false; 2630 } 2631 2632 2633 /* Return adjustments that should have the same effect on function parameters 2634 and call arguments as if they were first changed according to adjustments in 2635 INNER and then by adjustments in OUTER. */ 2636 2637 ipa_parm_adjustment_vec 2638 ipa_combine_adjustments (ipa_parm_adjustment_vec inner, 2639 ipa_parm_adjustment_vec outer) 2640 { 2641 int i, outlen = VEC_length (ipa_parm_adjustment_t, outer); 2642 int inlen = VEC_length (ipa_parm_adjustment_t, inner); 2643 int removals = 0; 2644 ipa_parm_adjustment_vec adjustments, tmp; 2645 2646 tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen); 2647 for (i = 0; i < inlen; i++) 2648 { 2649 struct ipa_parm_adjustment *n; 2650 n = VEC_index (ipa_parm_adjustment_t, inner, i); 2651 2652 if (n->remove_param) 2653 removals++; 2654 else 2655 VEC_quick_push (ipa_parm_adjustment_t, tmp, n); 2656 } 2657 2658 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals); 2659 for (i = 0; i < outlen; i++) 2660 { 2661 struct ipa_parm_adjustment *r; 2662 struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t, 2663 outer, i); 2664 struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp, 2665 out->base_index); 2666 2667 gcc_assert (!in->remove_param); 2668 if (out->remove_param) 2669 { 2670 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp)) 2671 { 2672 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL); 2673 memset (r, 0, sizeof (*r)); 2674 r->remove_param = true; 2675 } 2676 continue; 2677 } 2678 2679 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL); 2680 memset (r, 0, sizeof (*r)); 2681 r->base_index = in->base_index; 2682 r->type = out->type; 2683 2684 /* FIXME: Create nonlocal value too. */ 2685 2686 if (in->copy_param && out->copy_param) 2687 r->copy_param = true; 2688 else if (in->copy_param) 2689 r->offset = out->offset; 2690 else if (out->copy_param) 2691 r->offset = in->offset; 2692 else 2693 r->offset = in->offset + out->offset; 2694 } 2695 2696 for (i = 0; i < inlen; i++) 2697 { 2698 struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t, 2699 inner, i); 2700 2701 if (n->remove_param) 2702 VEC_quick_push (ipa_parm_adjustment_t, adjustments, n); 2703 } 2704 2705 VEC_free (ipa_parm_adjustment_t, heap, tmp); 2706 return adjustments; 2707 } 2708 2709 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human 2710 friendly way, assuming they are meant to be applied to FNDECL. */ 2711 2712 void 2713 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments, 2714 tree fndecl) 2715 { 2716 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments); 2717 bool first = true; 2718 VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl); 2719 2720 fprintf (file, "IPA param adjustments: "); 2721 for (i = 0; i < len; i++) 2722 { 2723 struct ipa_parm_adjustment *adj; 2724 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i); 2725 2726 if (!first) 2727 fprintf (file, " "); 2728 else 2729 first = false; 2730 2731 fprintf (file, "%i. base_index: %i - ", i, adj->base_index); 2732 print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0); 2733 if (adj->base) 2734 { 2735 fprintf (file, ", base: "); 2736 print_generic_expr (file, adj->base, 0); 2737 } 2738 if (adj->reduction) 2739 { 2740 fprintf (file, ", reduction: "); 2741 print_generic_expr (file, adj->reduction, 0); 2742 } 2743 if (adj->new_ssa_base) 2744 { 2745 fprintf (file, ", new_ssa_base: "); 2746 print_generic_expr (file, adj->new_ssa_base, 0); 2747 } 2748 2749 if (adj->copy_param) 2750 fprintf (file, ", copy_param"); 2751 else if (adj->remove_param) 2752 fprintf (file, ", remove_param"); 2753 else 2754 fprintf (file, ", offset %li", (long) adj->offset); 2755 if (adj->by_ref) 2756 fprintf (file, ", by_ref"); 2757 print_node_brief (file, ", type: ", adj->type, 0); 2758 fprintf (file, "\n"); 2759 } 2760 VEC_free (tree, heap, parms); 2761 } 2762 2763 /* Stream out jump function JUMP_FUNC to OB. */ 2764 2765 static void 2766 ipa_write_jump_function (struct output_block *ob, 2767 struct ipa_jump_func *jump_func) 2768 { 2769 streamer_write_uhwi (ob, jump_func->type); 2770 2771 switch (jump_func->type) 2772 { 2773 case IPA_JF_UNKNOWN: 2774 break; 2775 case IPA_JF_KNOWN_TYPE: 2776 streamer_write_uhwi (ob, jump_func->value.known_type.offset); 2777 stream_write_tree (ob, jump_func->value.known_type.base_type, true); 2778 stream_write_tree (ob, jump_func->value.known_type.component_type, true); 2779 break; 2780 case IPA_JF_CONST: 2781 stream_write_tree (ob, jump_func->value.constant, true); 2782 break; 2783 case IPA_JF_PASS_THROUGH: 2784 stream_write_tree (ob, jump_func->value.pass_through.operand, true); 2785 streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id); 2786 streamer_write_uhwi (ob, jump_func->value.pass_through.operation); 2787 break; 2788 case IPA_JF_ANCESTOR: 2789 streamer_write_uhwi (ob, jump_func->value.ancestor.offset); 2790 stream_write_tree (ob, jump_func->value.ancestor.type, true); 2791 streamer_write_uhwi (ob, jump_func->value.ancestor.formal_id); 2792 break; 2793 case IPA_JF_CONST_MEMBER_PTR: 2794 stream_write_tree (ob, jump_func->value.member_cst.pfn, true); 2795 stream_write_tree (ob, jump_func->value.member_cst.delta, false); 2796 break; 2797 } 2798 } 2799 2800 /* Read in jump function JUMP_FUNC from IB. */ 2801 2802 static void 2803 ipa_read_jump_function (struct lto_input_block *ib, 2804 struct ipa_jump_func *jump_func, 2805 struct data_in *data_in) 2806 { 2807 jump_func->type = (enum jump_func_type) streamer_read_uhwi (ib); 2808 2809 switch (jump_func->type) 2810 { 2811 case IPA_JF_UNKNOWN: 2812 break; 2813 case IPA_JF_KNOWN_TYPE: 2814 jump_func->value.known_type.offset = streamer_read_uhwi (ib); 2815 jump_func->value.known_type.base_type = stream_read_tree (ib, data_in); 2816 jump_func->value.known_type.component_type = stream_read_tree (ib, 2817 data_in); 2818 break; 2819 case IPA_JF_CONST: 2820 jump_func->value.constant = stream_read_tree (ib, data_in); 2821 break; 2822 case IPA_JF_PASS_THROUGH: 2823 jump_func->value.pass_through.operand = stream_read_tree (ib, data_in); 2824 jump_func->value.pass_through.formal_id = streamer_read_uhwi (ib); 2825 jump_func->value.pass_through.operation 2826 = (enum tree_code) streamer_read_uhwi (ib); 2827 break; 2828 case IPA_JF_ANCESTOR: 2829 jump_func->value.ancestor.offset = streamer_read_uhwi (ib); 2830 jump_func->value.ancestor.type = stream_read_tree (ib, data_in); 2831 jump_func->value.ancestor.formal_id = streamer_read_uhwi (ib); 2832 break; 2833 case IPA_JF_CONST_MEMBER_PTR: 2834 jump_func->value.member_cst.pfn = stream_read_tree (ib, data_in); 2835 jump_func->value.member_cst.delta = stream_read_tree (ib, data_in); 2836 break; 2837 } 2838 } 2839 2840 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are 2841 relevant to indirect inlining to OB. */ 2842 2843 static void 2844 ipa_write_indirect_edge_info (struct output_block *ob, 2845 struct cgraph_edge *cs) 2846 { 2847 struct cgraph_indirect_call_info *ii = cs->indirect_info; 2848 struct bitpack_d bp; 2849 2850 streamer_write_hwi (ob, ii->param_index); 2851 streamer_write_hwi (ob, ii->anc_offset); 2852 bp = bitpack_create (ob->main_stream); 2853 bp_pack_value (&bp, ii->polymorphic, 1); 2854 streamer_write_bitpack (&bp); 2855 2856 if (ii->polymorphic) 2857 { 2858 streamer_write_hwi (ob, ii->otr_token); 2859 stream_write_tree (ob, ii->otr_type, true); 2860 } 2861 } 2862 2863 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are 2864 relevant to indirect inlining from IB. */ 2865 2866 static void 2867 ipa_read_indirect_edge_info (struct lto_input_block *ib, 2868 struct data_in *data_in ATTRIBUTE_UNUSED, 2869 struct cgraph_edge *cs) 2870 { 2871 struct cgraph_indirect_call_info *ii = cs->indirect_info; 2872 struct bitpack_d bp; 2873 2874 ii->param_index = (int) streamer_read_hwi (ib); 2875 ii->anc_offset = (HOST_WIDE_INT) streamer_read_hwi (ib); 2876 bp = streamer_read_bitpack (ib); 2877 ii->polymorphic = bp_unpack_value (&bp, 1); 2878 if (ii->polymorphic) 2879 { 2880 ii->otr_token = (HOST_WIDE_INT) streamer_read_hwi (ib); 2881 ii->otr_type = stream_read_tree (ib, data_in); 2882 } 2883 } 2884 2885 /* Stream out NODE info to OB. */ 2886 2887 static void 2888 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node) 2889 { 2890 int node_ref; 2891 lto_cgraph_encoder_t encoder; 2892 struct ipa_node_params *info = IPA_NODE_REF (node); 2893 int j; 2894 struct cgraph_edge *e; 2895 struct bitpack_d bp; 2896 2897 encoder = ob->decl_state->cgraph_node_encoder; 2898 node_ref = lto_cgraph_encoder_encode (encoder, node); 2899 streamer_write_uhwi (ob, node_ref); 2900 2901 bp = bitpack_create (ob->main_stream); 2902 gcc_assert (info->uses_analysis_done 2903 || ipa_get_param_count (info) == 0); 2904 gcc_assert (!info->node_enqueued); 2905 gcc_assert (!info->ipcp_orig_node); 2906 for (j = 0; j < ipa_get_param_count (info); j++) 2907 bp_pack_value (&bp, ipa_is_param_used (info, j), 1); 2908 streamer_write_bitpack (&bp); 2909 for (e = node->callees; e; e = e->next_callee) 2910 { 2911 struct ipa_edge_args *args = IPA_EDGE_REF (e); 2912 2913 streamer_write_uhwi (ob, ipa_get_cs_argument_count (args)); 2914 for (j = 0; j < ipa_get_cs_argument_count (args); j++) 2915 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j)); 2916 } 2917 for (e = node->indirect_calls; e; e = e->next_callee) 2918 { 2919 struct ipa_edge_args *args = IPA_EDGE_REF (e); 2920 2921 streamer_write_uhwi (ob, ipa_get_cs_argument_count (args)); 2922 for (j = 0; j < ipa_get_cs_argument_count (args); j++) 2923 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j)); 2924 ipa_write_indirect_edge_info (ob, e); 2925 } 2926 } 2927 2928 /* Stream in NODE info from IB. */ 2929 2930 static void 2931 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node, 2932 struct data_in *data_in) 2933 { 2934 struct ipa_node_params *info = IPA_NODE_REF (node); 2935 int k; 2936 struct cgraph_edge *e; 2937 struct bitpack_d bp; 2938 2939 ipa_initialize_node_params (node); 2940 2941 bp = streamer_read_bitpack (ib); 2942 if (ipa_get_param_count (info) != 0) 2943 info->uses_analysis_done = true; 2944 info->node_enqueued = false; 2945 for (k = 0; k < ipa_get_param_count (info); k++) 2946 ipa_set_param_used (info, k, bp_unpack_value (&bp, 1)); 2947 for (e = node->callees; e; e = e->next_callee) 2948 { 2949 struct ipa_edge_args *args = IPA_EDGE_REF (e); 2950 int count = streamer_read_uhwi (ib); 2951 2952 if (!count) 2953 continue; 2954 VEC_safe_grow_cleared (ipa_jump_func_t, gc, args->jump_functions, count); 2955 2956 for (k = 0; k < ipa_get_cs_argument_count (args); k++) 2957 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in); 2958 } 2959 for (e = node->indirect_calls; e; e = e->next_callee) 2960 { 2961 struct ipa_edge_args *args = IPA_EDGE_REF (e); 2962 int count = streamer_read_uhwi (ib); 2963 2964 if (count) 2965 { 2966 VEC_safe_grow_cleared (ipa_jump_func_t, gc, args->jump_functions, 2967 count); 2968 for (k = 0; k < ipa_get_cs_argument_count (args); k++) 2969 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), 2970 data_in); 2971 } 2972 ipa_read_indirect_edge_info (ib, data_in, e); 2973 } 2974 } 2975 2976 /* Write jump functions for nodes in SET. */ 2977 2978 void 2979 ipa_prop_write_jump_functions (cgraph_node_set set) 2980 { 2981 struct cgraph_node *node; 2982 struct output_block *ob; 2983 unsigned int count = 0; 2984 cgraph_node_set_iterator csi; 2985 2986 if (!ipa_node_params_vector) 2987 return; 2988 2989 ob = create_output_block (LTO_section_jump_functions); 2990 ob->cgraph_node = NULL; 2991 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) 2992 { 2993 node = csi_node (csi); 2994 if (cgraph_function_with_gimple_body_p (node) 2995 && IPA_NODE_REF (node) != NULL) 2996 count++; 2997 } 2998 2999 streamer_write_uhwi (ob, count); 3000 3001 /* Process all of the functions. */ 3002 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) 3003 { 3004 node = csi_node (csi); 3005 if (cgraph_function_with_gimple_body_p (node) 3006 && IPA_NODE_REF (node) != NULL) 3007 ipa_write_node_info (ob, node); 3008 } 3009 streamer_write_char_stream (ob->main_stream, 0); 3010 produce_asm (ob, NULL); 3011 destroy_output_block (ob); 3012 } 3013 3014 /* Read section in file FILE_DATA of length LEN with data DATA. */ 3015 3016 static void 3017 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data, 3018 size_t len) 3019 { 3020 const struct lto_function_header *header = 3021 (const struct lto_function_header *) data; 3022 const int cfg_offset = sizeof (struct lto_function_header); 3023 const int main_offset = cfg_offset + header->cfg_size; 3024 const int string_offset = main_offset + header->main_size; 3025 struct data_in *data_in; 3026 struct lto_input_block ib_main; 3027 unsigned int i; 3028 unsigned int count; 3029 3030 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0, 3031 header->main_size); 3032 3033 data_in = 3034 lto_data_in_create (file_data, (const char *) data + string_offset, 3035 header->string_size, NULL); 3036 count = streamer_read_uhwi (&ib_main); 3037 3038 for (i = 0; i < count; i++) 3039 { 3040 unsigned int index; 3041 struct cgraph_node *node; 3042 lto_cgraph_encoder_t encoder; 3043 3044 index = streamer_read_uhwi (&ib_main); 3045 encoder = file_data->cgraph_node_encoder; 3046 node = lto_cgraph_encoder_deref (encoder, index); 3047 gcc_assert (node->analyzed); 3048 ipa_read_node_info (&ib_main, node, data_in); 3049 } 3050 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data, 3051 len); 3052 lto_data_in_delete (data_in); 3053 } 3054 3055 /* Read ipcp jump functions. */ 3056 3057 void 3058 ipa_prop_read_jump_functions (void) 3059 { 3060 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data (); 3061 struct lto_file_decl_data *file_data; 3062 unsigned int j = 0; 3063 3064 ipa_check_create_node_params (); 3065 ipa_check_create_edge_args (); 3066 ipa_register_cgraph_hooks (); 3067 3068 while ((file_data = file_data_vec[j++])) 3069 { 3070 size_t len; 3071 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len); 3072 3073 if (data) 3074 ipa_prop_read_section (file_data, data, len); 3075 } 3076 } 3077 3078 /* After merging units, we can get mismatch in argument counts. 3079 Also decl merging might've rendered parameter lists obsolete. 3080 Also compute called_with_variable_arg info. */ 3081 3082 void 3083 ipa_update_after_lto_read (void) 3084 { 3085 struct cgraph_node *node; 3086 3087 ipa_check_create_node_params (); 3088 ipa_check_create_edge_args (); 3089 3090 for (node = cgraph_nodes; node; node = node->next) 3091 if (node->analyzed) 3092 ipa_initialize_node_params (node); 3093 } 3094