1 /* Tree based points-to analysis 2 Copyright (C) 2005-2020 Free Software Foundation, Inc. 3 Contributed by Daniel Berlin <dberlin@dberlin.org> 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify 8 under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 GCC is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "backend.h" 25 #include "rtl.h" 26 #include "tree.h" 27 #include "gimple.h" 28 #include "alloc-pool.h" 29 #include "tree-pass.h" 30 #include "ssa.h" 31 #include "cgraph.h" 32 #include "tree-pretty-print.h" 33 #include "diagnostic-core.h" 34 #include "fold-const.h" 35 #include "stor-layout.h" 36 #include "stmt.h" 37 #include "gimple-iterator.h" 38 #include "tree-into-ssa.h" 39 #include "tree-dfa.h" 40 #include "gimple-walk.h" 41 #include "varasm.h" 42 #include "stringpool.h" 43 #include "attribs.h" 44 #include "tree-ssa.h" 45 #include "tree-cfg.h" 46 47 /* The idea behind this analyzer is to generate set constraints from the 48 program, then solve the resulting constraints in order to generate the 49 points-to sets. 50 51 Set constraints are a way of modeling program analysis problems that 52 involve sets. They consist of an inclusion constraint language, 53 describing the variables (each variable is a set) and operations that 54 are involved on the variables, and a set of rules that derive facts 55 from these operations. To solve a system of set constraints, you derive 56 all possible facts under the rules, which gives you the correct sets 57 as a consequence. 58 59 See "Efficient Field-sensitive pointer analysis for C" by "David 60 J. Pearce and Paul H. J. Kelly and Chris Hankin, at 61 http://citeseer.ist.psu.edu/pearce04efficient.html 62 63 Also see "Ultra-fast Aliasing Analysis using CLA: A Million Lines 64 of C Code in a Second" by ""Nevin Heintze and Olivier Tardieu" at 65 http://citeseer.ist.psu.edu/heintze01ultrafast.html 66 67 There are three types of real constraint expressions, DEREF, 68 ADDRESSOF, and SCALAR. Each constraint expression consists 69 of a constraint type, a variable, and an offset. 70 71 SCALAR is a constraint expression type used to represent x, whether 72 it appears on the LHS or the RHS of a statement. 73 DEREF is a constraint expression type used to represent *x, whether 74 it appears on the LHS or the RHS of a statement. 75 ADDRESSOF is a constraint expression used to represent &x, whether 76 it appears on the LHS or the RHS of a statement. 77 78 Each pointer variable in the program is assigned an integer id, and 79 each field of a structure variable is assigned an integer id as well. 80 81 Structure variables are linked to their list of fields through a "next 82 field" in each variable that points to the next field in offset 83 order. 84 Each variable for a structure field has 85 86 1. "size", that tells the size in bits of that field. 87 2. "fullsize, that tells the size in bits of the entire structure. 88 3. "offset", that tells the offset in bits from the beginning of the 89 structure to this field. 90 91 Thus, 92 struct f 93 { 94 int a; 95 int b; 96 } foo; 97 int *bar; 98 99 looks like 100 101 foo.a -> id 1, size 32, offset 0, fullsize 64, next foo.b 102 foo.b -> id 2, size 32, offset 32, fullsize 64, next NULL 103 bar -> id 3, size 32, offset 0, fullsize 32, next NULL 104 105 106 In order to solve the system of set constraints, the following is 107 done: 108 109 1. Each constraint variable x has a solution set associated with it, 110 Sol(x). 111 112 2. Constraints are separated into direct, copy, and complex. 113 Direct constraints are ADDRESSOF constraints that require no extra 114 processing, such as P = &Q 115 Copy constraints are those of the form P = Q. 116 Complex constraints are all the constraints involving dereferences 117 and offsets (including offsetted copies). 118 119 3. All direct constraints of the form P = &Q are processed, such 120 that Q is added to Sol(P) 121 122 4. All complex constraints for a given constraint variable are stored in a 123 linked list attached to that variable's node. 124 125 5. A directed graph is built out of the copy constraints. Each 126 constraint variable is a node in the graph, and an edge from 127 Q to P is added for each copy constraint of the form P = Q 128 129 6. The graph is then walked, and solution sets are 130 propagated along the copy edges, such that an edge from Q to P 131 causes Sol(P) <- Sol(P) union Sol(Q). 132 133 7. As we visit each node, all complex constraints associated with 134 that node are processed by adding appropriate copy edges to the graph, or the 135 appropriate variables to the solution set. 136 137 8. The process of walking the graph is iterated until no solution 138 sets change. 139 140 Prior to walking the graph in steps 6 and 7, We perform static 141 cycle elimination on the constraint graph, as well 142 as off-line variable substitution. 143 144 TODO: Adding offsets to pointer-to-structures can be handled (IE not punted 145 on and turned into anything), but isn't. You can just see what offset 146 inside the pointed-to struct it's going to access. 147 148 TODO: Constant bounded arrays can be handled as if they were structs of the 149 same number of elements. 150 151 TODO: Modeling heap and incoming pointers becomes much better if we 152 add fields to them as we discover them, which we could do. 153 154 TODO: We could handle unions, but to be honest, it's probably not 155 worth the pain or slowdown. */ 156 157 /* IPA-PTA optimizations possible. 158 159 When the indirect function called is ANYTHING we can add disambiguation 160 based on the function signatures (or simply the parameter count which 161 is the varinfo size). We also do not need to consider functions that 162 do not have their address taken. 163 164 The is_global_var bit which marks escape points is overly conservative 165 in IPA mode. Split it to is_escape_point and is_global_var - only 166 externally visible globals are escape points in IPA mode. 167 There is now is_ipa_escape_point but this is only used in a few 168 selected places. 169 170 The way we introduce DECL_PT_UID to avoid fixing up all points-to 171 sets in the translation unit when we copy a DECL during inlining 172 pessimizes precision. The advantage is that the DECL_PT_UID keeps 173 compile-time and memory usage overhead low - the points-to sets 174 do not grow or get unshared as they would during a fixup phase. 175 An alternative solution is to delay IPA PTA until after all 176 inlining transformations have been applied. 177 178 The way we propagate clobber/use information isn't optimized. 179 It should use a new complex constraint that properly filters 180 out local variables of the callee (though that would make 181 the sets invalid after inlining). OTOH we might as well 182 admit defeat to WHOPR and simply do all the clobber/use analysis 183 and propagation after PTA finished but before we threw away 184 points-to information for memory variables. WHOPR and PTA 185 do not play along well anyway - the whole constraint solving 186 would need to be done in WPA phase and it will be very interesting 187 to apply the results to local SSA names during LTRANS phase. 188 189 We probably should compute a per-function unit-ESCAPE solution 190 propagating it simply like the clobber / uses solutions. The 191 solution can go alongside the non-IPA espaced solution and be 192 used to query which vars escape the unit through a function. 193 This is also required to make the escaped-HEAP trick work in IPA mode. 194 195 We never put function decls in points-to sets so we do not 196 keep the set of called functions for indirect calls. 197 198 And probably more. */ 199 200 static bool use_field_sensitive = true; 201 static int in_ipa_mode = 0; 202 203 /* Used for predecessor bitmaps. */ 204 static bitmap_obstack predbitmap_obstack; 205 206 /* Used for points-to sets. */ 207 static bitmap_obstack pta_obstack; 208 209 /* Used for oldsolution members of variables. */ 210 static bitmap_obstack oldpta_obstack; 211 212 /* Used for per-solver-iteration bitmaps. */ 213 static bitmap_obstack iteration_obstack; 214 215 static unsigned int create_variable_info_for (tree, const char *, bool); 216 typedef struct constraint_graph *constraint_graph_t; 217 static void unify_nodes (constraint_graph_t, unsigned int, unsigned int, bool); 218 219 struct constraint; 220 typedef struct constraint *constraint_t; 221 222 223 #define EXECUTE_IF_IN_NONNULL_BITMAP(a, b, c, d) \ 224 if (a) \ 225 EXECUTE_IF_SET_IN_BITMAP (a, b, c, d) 226 227 static struct constraint_stats 228 { 229 unsigned int total_vars; 230 unsigned int nonpointer_vars; 231 unsigned int unified_vars_static; 232 unsigned int unified_vars_dynamic; 233 unsigned int iterations; 234 unsigned int num_edges; 235 unsigned int num_implicit_edges; 236 unsigned int points_to_sets_created; 237 } stats; 238 239 struct variable_info 240 { 241 /* ID of this variable */ 242 unsigned int id; 243 244 /* True if this is a variable created by the constraint analysis, such as 245 heap variables and constraints we had to break up. */ 246 unsigned int is_artificial_var : 1; 247 248 /* True if this is a special variable whose solution set should not be 249 changed. */ 250 unsigned int is_special_var : 1; 251 252 /* True for variables whose size is not known or variable. */ 253 unsigned int is_unknown_size_var : 1; 254 255 /* True for (sub-)fields that represent a whole variable. */ 256 unsigned int is_full_var : 1; 257 258 /* True if this is a heap variable. */ 259 unsigned int is_heap_var : 1; 260 261 /* True if this is a register variable. */ 262 unsigned int is_reg_var : 1; 263 264 /* True if this field may contain pointers. */ 265 unsigned int may_have_pointers : 1; 266 267 /* True if this field has only restrict qualified pointers. */ 268 unsigned int only_restrict_pointers : 1; 269 270 /* True if this represents a heap var created for a restrict qualified 271 pointer. */ 272 unsigned int is_restrict_var : 1; 273 274 /* True if this represents a global variable. */ 275 unsigned int is_global_var : 1; 276 277 /* True if this represents a module escape point for IPA analysis. */ 278 unsigned int is_ipa_escape_point : 1; 279 280 /* True if this represents a IPA function info. */ 281 unsigned int is_fn_info : 1; 282 283 /* ??? Store somewhere better. */ 284 unsigned short ruid; 285 286 /* The ID of the variable for the next field in this structure 287 or zero for the last field in this structure. */ 288 unsigned next; 289 290 /* The ID of the variable for the first field in this structure. */ 291 unsigned head; 292 293 /* Offset of this variable, in bits, from the base variable */ 294 unsigned HOST_WIDE_INT offset; 295 296 /* Size of the variable, in bits. */ 297 unsigned HOST_WIDE_INT size; 298 299 /* Full size of the base variable, in bits. */ 300 unsigned HOST_WIDE_INT fullsize; 301 302 /* In IPA mode the shadow UID in case the variable needs to be duplicated in 303 the final points-to solution because it reaches its containing 304 function recursively. Zero if none is needed. */ 305 unsigned int shadow_var_uid; 306 307 /* Name of this variable */ 308 const char *name; 309 310 /* Tree that this variable is associated with. */ 311 tree decl; 312 313 /* Points-to set for this variable. */ 314 bitmap solution; 315 316 /* Old points-to set for this variable. */ 317 bitmap oldsolution; 318 }; 319 typedef struct variable_info *varinfo_t; 320 321 static varinfo_t first_vi_for_offset (varinfo_t, unsigned HOST_WIDE_INT); 322 static varinfo_t first_or_preceding_vi_for_offset (varinfo_t, 323 unsigned HOST_WIDE_INT); 324 static varinfo_t lookup_vi_for_tree (tree); 325 static inline bool type_can_have_subvars (const_tree); 326 static void make_param_constraints (varinfo_t); 327 328 /* Pool of variable info structures. */ 329 static object_allocator<variable_info> variable_info_pool 330 ("Variable info pool"); 331 332 /* Map varinfo to final pt_solution. */ 333 static hash_map<varinfo_t, pt_solution *> *final_solutions; 334 struct obstack final_solutions_obstack; 335 336 /* Table of variable info structures for constraint variables. 337 Indexed directly by variable info id. */ 338 static vec<varinfo_t> varmap; 339 340 /* Return the varmap element N */ 341 342 static inline varinfo_t 343 get_varinfo (unsigned int n) 344 { 345 return varmap[n]; 346 } 347 348 /* Return the next variable in the list of sub-variables of VI 349 or NULL if VI is the last sub-variable. */ 350 351 static inline varinfo_t 352 vi_next (varinfo_t vi) 353 { 354 return get_varinfo (vi->next); 355 } 356 357 /* Static IDs for the special variables. Variable ID zero is unused 358 and used as terminator for the sub-variable chain. */ 359 enum { nothing_id = 1, anything_id = 2, string_id = 3, 360 escaped_id = 4, nonlocal_id = 5, 361 storedanything_id = 6, integer_id = 7 }; 362 363 /* Return a new variable info structure consisting for a variable 364 named NAME, and using constraint graph node NODE. Append it 365 to the vector of variable info structures. */ 366 367 static varinfo_t 368 new_var_info (tree t, const char *name, bool add_id) 369 { 370 unsigned index = varmap.length (); 371 varinfo_t ret = variable_info_pool.allocate (); 372 373 if (dump_file && add_id) 374 { 375 char *tempname = xasprintf ("%s(%d)", name, index); 376 name = ggc_strdup (tempname); 377 free (tempname); 378 } 379 380 ret->id = index; 381 ret->name = name; 382 ret->decl = t; 383 /* Vars without decl are artificial and do not have sub-variables. */ 384 ret->is_artificial_var = (t == NULL_TREE); 385 ret->is_special_var = false; 386 ret->is_unknown_size_var = false; 387 ret->is_full_var = (t == NULL_TREE); 388 ret->is_heap_var = false; 389 ret->may_have_pointers = true; 390 ret->only_restrict_pointers = false; 391 ret->is_restrict_var = false; 392 ret->ruid = 0; 393 ret->is_global_var = (t == NULL_TREE); 394 ret->is_ipa_escape_point = false; 395 ret->is_fn_info = false; 396 if (t && DECL_P (t)) 397 ret->is_global_var = (is_global_var (t) 398 /* We have to treat even local register variables 399 as escape points. */ 400 || (VAR_P (t) && DECL_HARD_REGISTER (t))); 401 ret->is_reg_var = (t && TREE_CODE (t) == SSA_NAME); 402 ret->solution = BITMAP_ALLOC (&pta_obstack); 403 ret->oldsolution = NULL; 404 ret->next = 0; 405 ret->shadow_var_uid = 0; 406 ret->head = ret->id; 407 408 stats.total_vars++; 409 410 varmap.safe_push (ret); 411 412 return ret; 413 } 414 415 /* A map mapping call statements to per-stmt variables for uses 416 and clobbers specific to the call. */ 417 static hash_map<gimple *, varinfo_t> *call_stmt_vars; 418 419 /* Lookup or create the variable for the call statement CALL. */ 420 421 static varinfo_t 422 get_call_vi (gcall *call) 423 { 424 varinfo_t vi, vi2; 425 426 bool existed; 427 varinfo_t *slot_p = &call_stmt_vars->get_or_insert (call, &existed); 428 if (existed) 429 return *slot_p; 430 431 vi = new_var_info (NULL_TREE, "CALLUSED", true); 432 vi->offset = 0; 433 vi->size = 1; 434 vi->fullsize = 2; 435 vi->is_full_var = true; 436 vi->is_reg_var = true; 437 438 vi2 = new_var_info (NULL_TREE, "CALLCLOBBERED", true); 439 vi2->offset = 1; 440 vi2->size = 1; 441 vi2->fullsize = 2; 442 vi2->is_full_var = true; 443 vi2->is_reg_var = true; 444 445 vi->next = vi2->id; 446 447 *slot_p = vi; 448 return vi; 449 } 450 451 /* Lookup the variable for the call statement CALL representing 452 the uses. Returns NULL if there is nothing special about this call. */ 453 454 static varinfo_t 455 lookup_call_use_vi (gcall *call) 456 { 457 varinfo_t *slot_p = call_stmt_vars->get (call); 458 if (slot_p) 459 return *slot_p; 460 461 return NULL; 462 } 463 464 /* Lookup the variable for the call statement CALL representing 465 the clobbers. Returns NULL if there is nothing special about this call. */ 466 467 static varinfo_t 468 lookup_call_clobber_vi (gcall *call) 469 { 470 varinfo_t uses = lookup_call_use_vi (call); 471 if (!uses) 472 return NULL; 473 474 return vi_next (uses); 475 } 476 477 /* Lookup or create the variable for the call statement CALL representing 478 the uses. */ 479 480 static varinfo_t 481 get_call_use_vi (gcall *call) 482 { 483 return get_call_vi (call); 484 } 485 486 /* Lookup or create the variable for the call statement CALL representing 487 the clobbers. */ 488 489 static varinfo_t ATTRIBUTE_UNUSED 490 get_call_clobber_vi (gcall *call) 491 { 492 return vi_next (get_call_vi (call)); 493 } 494 495 496 enum constraint_expr_type {SCALAR, DEREF, ADDRESSOF}; 497 498 /* An expression that appears in a constraint. */ 499 500 struct constraint_expr 501 { 502 /* Constraint type. */ 503 constraint_expr_type type; 504 505 /* Variable we are referring to in the constraint. */ 506 unsigned int var; 507 508 /* Offset, in bits, of this constraint from the beginning of 509 variables it ends up referring to. 510 511 IOW, in a deref constraint, we would deref, get the result set, 512 then add OFFSET to each member. */ 513 HOST_WIDE_INT offset; 514 }; 515 516 /* Use 0x8000... as special unknown offset. */ 517 #define UNKNOWN_OFFSET HOST_WIDE_INT_MIN 518 519 typedef struct constraint_expr ce_s; 520 static void get_constraint_for_1 (tree, vec<ce_s> *, bool, bool); 521 static void get_constraint_for (tree, vec<ce_s> *); 522 static void get_constraint_for_rhs (tree, vec<ce_s> *); 523 static void do_deref (vec<ce_s> *); 524 525 /* Our set constraints are made up of two constraint expressions, one 526 LHS, and one RHS. 527 528 As described in the introduction, our set constraints each represent an 529 operation between set valued variables. 530 */ 531 struct constraint 532 { 533 struct constraint_expr lhs; 534 struct constraint_expr rhs; 535 }; 536 537 /* List of constraints that we use to build the constraint graph from. */ 538 539 static vec<constraint_t> constraints; 540 static object_allocator<constraint> constraint_pool ("Constraint pool"); 541 542 /* The constraint graph is represented as an array of bitmaps 543 containing successor nodes. */ 544 545 struct constraint_graph 546 { 547 /* Size of this graph, which may be different than the number of 548 nodes in the variable map. */ 549 unsigned int size; 550 551 /* Explicit successors of each node. */ 552 bitmap *succs; 553 554 /* Implicit predecessors of each node (Used for variable 555 substitution). */ 556 bitmap *implicit_preds; 557 558 /* Explicit predecessors of each node (Used for variable substitution). */ 559 bitmap *preds; 560 561 /* Indirect cycle representatives, or -1 if the node has no indirect 562 cycles. */ 563 int *indirect_cycles; 564 565 /* Representative node for a node. rep[a] == a unless the node has 566 been unified. */ 567 unsigned int *rep; 568 569 /* Equivalence class representative for a label. This is used for 570 variable substitution. */ 571 int *eq_rep; 572 573 /* Pointer equivalence label for a node. All nodes with the same 574 pointer equivalence label can be unified together at some point 575 (either during constraint optimization or after the constraint 576 graph is built). */ 577 unsigned int *pe; 578 579 /* Pointer equivalence representative for a label. This is used to 580 handle nodes that are pointer equivalent but not location 581 equivalent. We can unite these once the addressof constraints 582 are transformed into initial points-to sets. */ 583 int *pe_rep; 584 585 /* Pointer equivalence label for each node, used during variable 586 substitution. */ 587 unsigned int *pointer_label; 588 589 /* Location equivalence label for each node, used during location 590 equivalence finding. */ 591 unsigned int *loc_label; 592 593 /* Pointed-by set for each node, used during location equivalence 594 finding. This is pointed-by rather than pointed-to, because it 595 is constructed using the predecessor graph. */ 596 bitmap *pointed_by; 597 598 /* Points to sets for pointer equivalence. This is *not* the actual 599 points-to sets for nodes. */ 600 bitmap *points_to; 601 602 /* Bitmap of nodes where the bit is set if the node is a direct 603 node. Used for variable substitution. */ 604 sbitmap direct_nodes; 605 606 /* Bitmap of nodes where the bit is set if the node is address 607 taken. Used for variable substitution. */ 608 bitmap address_taken; 609 610 /* Vector of complex constraints for each graph node. Complex 611 constraints are those involving dereferences or offsets that are 612 not 0. */ 613 vec<constraint_t> *complex; 614 }; 615 616 static constraint_graph_t graph; 617 618 /* During variable substitution and the offline version of indirect 619 cycle finding, we create nodes to represent dereferences and 620 address taken constraints. These represent where these start and 621 end. */ 622 #define FIRST_REF_NODE (varmap).length () 623 #define LAST_REF_NODE (FIRST_REF_NODE + (FIRST_REF_NODE - 1)) 624 625 /* Return the representative node for NODE, if NODE has been unioned 626 with another NODE. 627 This function performs path compression along the way to finding 628 the representative. */ 629 630 static unsigned int 631 find (unsigned int node) 632 { 633 gcc_checking_assert (node < graph->size); 634 if (graph->rep[node] != node) 635 return graph->rep[node] = find (graph->rep[node]); 636 return node; 637 } 638 639 /* Union the TO and FROM nodes to the TO nodes. 640 Note that at some point in the future, we may want to do 641 union-by-rank, in which case we are going to have to return the 642 node we unified to. */ 643 644 static bool 645 unite (unsigned int to, unsigned int from) 646 { 647 gcc_checking_assert (to < graph->size && from < graph->size); 648 if (to != from && graph->rep[from] != to) 649 { 650 graph->rep[from] = to; 651 return true; 652 } 653 return false; 654 } 655 656 /* Create a new constraint consisting of LHS and RHS expressions. */ 657 658 static constraint_t 659 new_constraint (const struct constraint_expr lhs, 660 const struct constraint_expr rhs) 661 { 662 constraint_t ret = constraint_pool.allocate (); 663 ret->lhs = lhs; 664 ret->rhs = rhs; 665 return ret; 666 } 667 668 /* Print out constraint C to FILE. */ 669 670 static void 671 dump_constraint (FILE *file, constraint_t c) 672 { 673 if (c->lhs.type == ADDRESSOF) 674 fprintf (file, "&"); 675 else if (c->lhs.type == DEREF) 676 fprintf (file, "*"); 677 fprintf (file, "%s", get_varinfo (c->lhs.var)->name); 678 if (c->lhs.offset == UNKNOWN_OFFSET) 679 fprintf (file, " + UNKNOWN"); 680 else if (c->lhs.offset != 0) 681 fprintf (file, " + " HOST_WIDE_INT_PRINT_DEC, c->lhs.offset); 682 fprintf (file, " = "); 683 if (c->rhs.type == ADDRESSOF) 684 fprintf (file, "&"); 685 else if (c->rhs.type == DEREF) 686 fprintf (file, "*"); 687 fprintf (file, "%s", get_varinfo (c->rhs.var)->name); 688 if (c->rhs.offset == UNKNOWN_OFFSET) 689 fprintf (file, " + UNKNOWN"); 690 else if (c->rhs.offset != 0) 691 fprintf (file, " + " HOST_WIDE_INT_PRINT_DEC, c->rhs.offset); 692 } 693 694 695 void debug_constraint (constraint_t); 696 void debug_constraints (void); 697 void debug_constraint_graph (void); 698 void debug_solution_for_var (unsigned int); 699 void debug_sa_points_to_info (void); 700 void debug_varinfo (varinfo_t); 701 void debug_varmap (void); 702 703 /* Print out constraint C to stderr. */ 704 705 DEBUG_FUNCTION void 706 debug_constraint (constraint_t c) 707 { 708 dump_constraint (stderr, c); 709 fprintf (stderr, "\n"); 710 } 711 712 /* Print out all constraints to FILE */ 713 714 static void 715 dump_constraints (FILE *file, int from) 716 { 717 int i; 718 constraint_t c; 719 for (i = from; constraints.iterate (i, &c); i++) 720 if (c) 721 { 722 dump_constraint (file, c); 723 fprintf (file, "\n"); 724 } 725 } 726 727 /* Print out all constraints to stderr. */ 728 729 DEBUG_FUNCTION void 730 debug_constraints (void) 731 { 732 dump_constraints (stderr, 0); 733 } 734 735 /* Print the constraint graph in dot format. */ 736 737 static void 738 dump_constraint_graph (FILE *file) 739 { 740 unsigned int i; 741 742 /* Only print the graph if it has already been initialized: */ 743 if (!graph) 744 return; 745 746 /* Prints the header of the dot file: */ 747 fprintf (file, "strict digraph {\n"); 748 fprintf (file, " node [\n shape = box\n ]\n"); 749 fprintf (file, " edge [\n fontsize = \"12\"\n ]\n"); 750 fprintf (file, "\n // List of nodes and complex constraints in " 751 "the constraint graph:\n"); 752 753 /* The next lines print the nodes in the graph together with the 754 complex constraints attached to them. */ 755 for (i = 1; i < graph->size; i++) 756 { 757 if (i == FIRST_REF_NODE) 758 continue; 759 if (find (i) != i) 760 continue; 761 if (i < FIRST_REF_NODE) 762 fprintf (file, "\"%s\"", get_varinfo (i)->name); 763 else 764 fprintf (file, "\"*%s\"", get_varinfo (i - FIRST_REF_NODE)->name); 765 if (graph->complex[i].exists ()) 766 { 767 unsigned j; 768 constraint_t c; 769 fprintf (file, " [label=\"\\N\\n"); 770 for (j = 0; graph->complex[i].iterate (j, &c); ++j) 771 { 772 dump_constraint (file, c); 773 fprintf (file, "\\l"); 774 } 775 fprintf (file, "\"]"); 776 } 777 fprintf (file, ";\n"); 778 } 779 780 /* Go over the edges. */ 781 fprintf (file, "\n // Edges in the constraint graph:\n"); 782 for (i = 1; i < graph->size; i++) 783 { 784 unsigned j; 785 bitmap_iterator bi; 786 if (find (i) != i) 787 continue; 788 EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[i], 0, j, bi) 789 { 790 unsigned to = find (j); 791 if (i == to) 792 continue; 793 if (i < FIRST_REF_NODE) 794 fprintf (file, "\"%s\"", get_varinfo (i)->name); 795 else 796 fprintf (file, "\"*%s\"", get_varinfo (i - FIRST_REF_NODE)->name); 797 fprintf (file, " -> "); 798 if (to < FIRST_REF_NODE) 799 fprintf (file, "\"%s\"", get_varinfo (to)->name); 800 else 801 fprintf (file, "\"*%s\"", get_varinfo (to - FIRST_REF_NODE)->name); 802 fprintf (file, ";\n"); 803 } 804 } 805 806 /* Prints the tail of the dot file. */ 807 fprintf (file, "}\n"); 808 } 809 810 /* Print out the constraint graph to stderr. */ 811 812 DEBUG_FUNCTION void 813 debug_constraint_graph (void) 814 { 815 dump_constraint_graph (stderr); 816 } 817 818 /* SOLVER FUNCTIONS 819 820 The solver is a simple worklist solver, that works on the following 821 algorithm: 822 823 sbitmap changed_nodes = all zeroes; 824 changed_count = 0; 825 For each node that is not already collapsed: 826 changed_count++; 827 set bit in changed nodes 828 829 while (changed_count > 0) 830 { 831 compute topological ordering for constraint graph 832 833 find and collapse cycles in the constraint graph (updating 834 changed if necessary) 835 836 for each node (n) in the graph in topological order: 837 changed_count--; 838 839 Process each complex constraint associated with the node, 840 updating changed if necessary. 841 842 For each outgoing edge from n, propagate the solution from n to 843 the destination of the edge, updating changed as necessary. 844 845 } */ 846 847 /* Return true if two constraint expressions A and B are equal. */ 848 849 static bool 850 constraint_expr_equal (struct constraint_expr a, struct constraint_expr b) 851 { 852 return a.type == b.type && a.var == b.var && a.offset == b.offset; 853 } 854 855 /* Return true if constraint expression A is less than constraint expression 856 B. This is just arbitrary, but consistent, in order to give them an 857 ordering. */ 858 859 static bool 860 constraint_expr_less (struct constraint_expr a, struct constraint_expr b) 861 { 862 if (a.type == b.type) 863 { 864 if (a.var == b.var) 865 return a.offset < b.offset; 866 else 867 return a.var < b.var; 868 } 869 else 870 return a.type < b.type; 871 } 872 873 /* Return true if constraint A is less than constraint B. This is just 874 arbitrary, but consistent, in order to give them an ordering. */ 875 876 static bool 877 constraint_less (const constraint_t &a, const constraint_t &b) 878 { 879 if (constraint_expr_less (a->lhs, b->lhs)) 880 return true; 881 else if (constraint_expr_less (b->lhs, a->lhs)) 882 return false; 883 else 884 return constraint_expr_less (a->rhs, b->rhs); 885 } 886 887 /* Return true if two constraints A and B are equal. */ 888 889 static bool 890 constraint_equal (struct constraint a, struct constraint b) 891 { 892 return constraint_expr_equal (a.lhs, b.lhs) 893 && constraint_expr_equal (a.rhs, b.rhs); 894 } 895 896 897 /* Find a constraint LOOKFOR in the sorted constraint vector VEC */ 898 899 static constraint_t 900 constraint_vec_find (vec<constraint_t> vec, 901 struct constraint lookfor) 902 { 903 unsigned int place; 904 constraint_t found; 905 906 if (!vec.exists ()) 907 return NULL; 908 909 place = vec.lower_bound (&lookfor, constraint_less); 910 if (place >= vec.length ()) 911 return NULL; 912 found = vec[place]; 913 if (!constraint_equal (*found, lookfor)) 914 return NULL; 915 return found; 916 } 917 918 /* Union two constraint vectors, TO and FROM. Put the result in TO. 919 Returns true of TO set is changed. */ 920 921 static bool 922 constraint_set_union (vec<constraint_t> *to, 923 vec<constraint_t> *from) 924 { 925 int i; 926 constraint_t c; 927 bool any_change = false; 928 929 FOR_EACH_VEC_ELT (*from, i, c) 930 { 931 if (constraint_vec_find (*to, *c) == NULL) 932 { 933 unsigned int place = to->lower_bound (c, constraint_less); 934 to->safe_insert (place, c); 935 any_change = true; 936 } 937 } 938 return any_change; 939 } 940 941 /* Expands the solution in SET to all sub-fields of variables included. */ 942 943 static bitmap 944 solution_set_expand (bitmap set, bitmap *expanded) 945 { 946 bitmap_iterator bi; 947 unsigned j; 948 949 if (*expanded) 950 return *expanded; 951 952 *expanded = BITMAP_ALLOC (&iteration_obstack); 953 954 /* In a first pass expand to the head of the variables we need to 955 add all sub-fields off. This avoids quadratic behavior. */ 956 EXECUTE_IF_SET_IN_BITMAP (set, 0, j, bi) 957 { 958 varinfo_t v = get_varinfo (j); 959 if (v->is_artificial_var 960 || v->is_full_var) 961 continue; 962 bitmap_set_bit (*expanded, v->head); 963 } 964 965 /* In the second pass now expand all head variables with subfields. */ 966 EXECUTE_IF_SET_IN_BITMAP (*expanded, 0, j, bi) 967 { 968 varinfo_t v = get_varinfo (j); 969 if (v->head != j) 970 continue; 971 for (v = vi_next (v); v != NULL; v = vi_next (v)) 972 bitmap_set_bit (*expanded, v->id); 973 } 974 975 /* And finally set the rest of the bits from SET. */ 976 bitmap_ior_into (*expanded, set); 977 978 return *expanded; 979 } 980 981 /* Union solution sets TO and DELTA, and add INC to each member of DELTA in the 982 process. */ 983 984 static bool 985 set_union_with_increment (bitmap to, bitmap delta, HOST_WIDE_INT inc, 986 bitmap *expanded_delta) 987 { 988 bool changed = false; 989 bitmap_iterator bi; 990 unsigned int i; 991 992 /* If the solution of DELTA contains anything it is good enough to transfer 993 this to TO. */ 994 if (bitmap_bit_p (delta, anything_id)) 995 return bitmap_set_bit (to, anything_id); 996 997 /* If the offset is unknown we have to expand the solution to 998 all subfields. */ 999 if (inc == UNKNOWN_OFFSET) 1000 { 1001 delta = solution_set_expand (delta, expanded_delta); 1002 changed |= bitmap_ior_into (to, delta); 1003 return changed; 1004 } 1005 1006 /* For non-zero offset union the offsetted solution into the destination. */ 1007 EXECUTE_IF_SET_IN_BITMAP (delta, 0, i, bi) 1008 { 1009 varinfo_t vi = get_varinfo (i); 1010 1011 /* If this is a variable with just one field just set its bit 1012 in the result. */ 1013 if (vi->is_artificial_var 1014 || vi->is_unknown_size_var 1015 || vi->is_full_var) 1016 changed |= bitmap_set_bit (to, i); 1017 else 1018 { 1019 HOST_WIDE_INT fieldoffset = vi->offset + inc; 1020 unsigned HOST_WIDE_INT size = vi->size; 1021 1022 /* If the offset makes the pointer point to before the 1023 variable use offset zero for the field lookup. */ 1024 if (fieldoffset < 0) 1025 vi = get_varinfo (vi->head); 1026 else 1027 vi = first_or_preceding_vi_for_offset (vi, fieldoffset); 1028 1029 do 1030 { 1031 changed |= bitmap_set_bit (to, vi->id); 1032 if (vi->is_full_var 1033 || vi->next == 0) 1034 break; 1035 1036 /* We have to include all fields that overlap the current field 1037 shifted by inc. */ 1038 vi = vi_next (vi); 1039 } 1040 while (vi->offset < fieldoffset + size); 1041 } 1042 } 1043 1044 return changed; 1045 } 1046 1047 /* Insert constraint C into the list of complex constraints for graph 1048 node VAR. */ 1049 1050 static void 1051 insert_into_complex (constraint_graph_t graph, 1052 unsigned int var, constraint_t c) 1053 { 1054 vec<constraint_t> complex = graph->complex[var]; 1055 unsigned int place = complex.lower_bound (c, constraint_less); 1056 1057 /* Only insert constraints that do not already exist. */ 1058 if (place >= complex.length () 1059 || !constraint_equal (*c, *complex[place])) 1060 graph->complex[var].safe_insert (place, c); 1061 } 1062 1063 1064 /* Condense two variable nodes into a single variable node, by moving 1065 all associated info from FROM to TO. Returns true if TO node's 1066 constraint set changes after the merge. */ 1067 1068 static bool 1069 merge_node_constraints (constraint_graph_t graph, unsigned int to, 1070 unsigned int from) 1071 { 1072 unsigned int i; 1073 constraint_t c; 1074 bool any_change = false; 1075 1076 gcc_checking_assert (find (from) == to); 1077 1078 /* Move all complex constraints from src node into to node */ 1079 FOR_EACH_VEC_ELT (graph->complex[from], i, c) 1080 { 1081 /* In complex constraints for node FROM, we may have either 1082 a = *FROM, and *FROM = a, or an offseted constraint which are 1083 always added to the rhs node's constraints. */ 1084 1085 if (c->rhs.type == DEREF) 1086 c->rhs.var = to; 1087 else if (c->lhs.type == DEREF) 1088 c->lhs.var = to; 1089 else 1090 c->rhs.var = to; 1091 1092 } 1093 any_change = constraint_set_union (&graph->complex[to], 1094 &graph->complex[from]); 1095 graph->complex[from].release (); 1096 return any_change; 1097 } 1098 1099 1100 /* Remove edges involving NODE from GRAPH. */ 1101 1102 static void 1103 clear_edges_for_node (constraint_graph_t graph, unsigned int node) 1104 { 1105 if (graph->succs[node]) 1106 BITMAP_FREE (graph->succs[node]); 1107 } 1108 1109 /* Merge GRAPH nodes FROM and TO into node TO. */ 1110 1111 static void 1112 merge_graph_nodes (constraint_graph_t graph, unsigned int to, 1113 unsigned int from) 1114 { 1115 if (graph->indirect_cycles[from] != -1) 1116 { 1117 /* If we have indirect cycles with the from node, and we have 1118 none on the to node, the to node has indirect cycles from the 1119 from node now that they are unified. 1120 If indirect cycles exist on both, unify the nodes that they 1121 are in a cycle with, since we know they are in a cycle with 1122 each other. */ 1123 if (graph->indirect_cycles[to] == -1) 1124 graph->indirect_cycles[to] = graph->indirect_cycles[from]; 1125 } 1126 1127 /* Merge all the successor edges. */ 1128 if (graph->succs[from]) 1129 { 1130 if (!graph->succs[to]) 1131 graph->succs[to] = BITMAP_ALLOC (&pta_obstack); 1132 bitmap_ior_into (graph->succs[to], 1133 graph->succs[from]); 1134 } 1135 1136 clear_edges_for_node (graph, from); 1137 } 1138 1139 1140 /* Add an indirect graph edge to GRAPH, going from TO to FROM if 1141 it doesn't exist in the graph already. */ 1142 1143 static void 1144 add_implicit_graph_edge (constraint_graph_t graph, unsigned int to, 1145 unsigned int from) 1146 { 1147 if (to == from) 1148 return; 1149 1150 if (!graph->implicit_preds[to]) 1151 graph->implicit_preds[to] = BITMAP_ALLOC (&predbitmap_obstack); 1152 1153 if (bitmap_set_bit (graph->implicit_preds[to], from)) 1154 stats.num_implicit_edges++; 1155 } 1156 1157 /* Add a predecessor graph edge to GRAPH, going from TO to FROM if 1158 it doesn't exist in the graph already. 1159 Return false if the edge already existed, true otherwise. */ 1160 1161 static void 1162 add_pred_graph_edge (constraint_graph_t graph, unsigned int to, 1163 unsigned int from) 1164 { 1165 if (!graph->preds[to]) 1166 graph->preds[to] = BITMAP_ALLOC (&predbitmap_obstack); 1167 bitmap_set_bit (graph->preds[to], from); 1168 } 1169 1170 /* Add a graph edge to GRAPH, going from FROM to TO if 1171 it doesn't exist in the graph already. 1172 Return false if the edge already existed, true otherwise. */ 1173 1174 static bool 1175 add_graph_edge (constraint_graph_t graph, unsigned int to, 1176 unsigned int from) 1177 { 1178 if (to == from) 1179 { 1180 return false; 1181 } 1182 else 1183 { 1184 bool r = false; 1185 1186 if (!graph->succs[from]) 1187 graph->succs[from] = BITMAP_ALLOC (&pta_obstack); 1188 if (bitmap_set_bit (graph->succs[from], to)) 1189 { 1190 r = true; 1191 if (to < FIRST_REF_NODE && from < FIRST_REF_NODE) 1192 stats.num_edges++; 1193 } 1194 return r; 1195 } 1196 } 1197 1198 1199 /* Initialize the constraint graph structure to contain SIZE nodes. */ 1200 1201 static void 1202 init_graph (unsigned int size) 1203 { 1204 unsigned int j; 1205 1206 graph = XCNEW (struct constraint_graph); 1207 graph->size = size; 1208 graph->succs = XCNEWVEC (bitmap, graph->size); 1209 graph->indirect_cycles = XNEWVEC (int, graph->size); 1210 graph->rep = XNEWVEC (unsigned int, graph->size); 1211 /* ??? Macros do not support template types with multiple arguments, 1212 so we use a typedef to work around it. */ 1213 typedef vec<constraint_t> vec_constraint_t_heap; 1214 graph->complex = XCNEWVEC (vec_constraint_t_heap, size); 1215 graph->pe = XCNEWVEC (unsigned int, graph->size); 1216 graph->pe_rep = XNEWVEC (int, graph->size); 1217 1218 for (j = 0; j < graph->size; j++) 1219 { 1220 graph->rep[j] = j; 1221 graph->pe_rep[j] = -1; 1222 graph->indirect_cycles[j] = -1; 1223 } 1224 } 1225 1226 /* Build the constraint graph, adding only predecessor edges right now. */ 1227 1228 static void 1229 build_pred_graph (void) 1230 { 1231 int i; 1232 constraint_t c; 1233 unsigned int j; 1234 1235 graph->implicit_preds = XCNEWVEC (bitmap, graph->size); 1236 graph->preds = XCNEWVEC (bitmap, graph->size); 1237 graph->pointer_label = XCNEWVEC (unsigned int, graph->size); 1238 graph->loc_label = XCNEWVEC (unsigned int, graph->size); 1239 graph->pointed_by = XCNEWVEC (bitmap, graph->size); 1240 graph->points_to = XCNEWVEC (bitmap, graph->size); 1241 graph->eq_rep = XNEWVEC (int, graph->size); 1242 graph->direct_nodes = sbitmap_alloc (graph->size); 1243 graph->address_taken = BITMAP_ALLOC (&predbitmap_obstack); 1244 bitmap_clear (graph->direct_nodes); 1245 1246 for (j = 1; j < FIRST_REF_NODE; j++) 1247 { 1248 if (!get_varinfo (j)->is_special_var) 1249 bitmap_set_bit (graph->direct_nodes, j); 1250 } 1251 1252 for (j = 0; j < graph->size; j++) 1253 graph->eq_rep[j] = -1; 1254 1255 for (j = 0; j < varmap.length (); j++) 1256 graph->indirect_cycles[j] = -1; 1257 1258 FOR_EACH_VEC_ELT (constraints, i, c) 1259 { 1260 struct constraint_expr lhs = c->lhs; 1261 struct constraint_expr rhs = c->rhs; 1262 unsigned int lhsvar = lhs.var; 1263 unsigned int rhsvar = rhs.var; 1264 1265 if (lhs.type == DEREF) 1266 { 1267 /* *x = y. */ 1268 if (rhs.offset == 0 && lhs.offset == 0 && rhs.type == SCALAR) 1269 add_pred_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar); 1270 } 1271 else if (rhs.type == DEREF) 1272 { 1273 /* x = *y */ 1274 if (rhs.offset == 0 && lhs.offset == 0 && lhs.type == SCALAR) 1275 add_pred_graph_edge (graph, lhsvar, FIRST_REF_NODE + rhsvar); 1276 else 1277 bitmap_clear_bit (graph->direct_nodes, lhsvar); 1278 } 1279 else if (rhs.type == ADDRESSOF) 1280 { 1281 varinfo_t v; 1282 1283 /* x = &y */ 1284 if (graph->points_to[lhsvar] == NULL) 1285 graph->points_to[lhsvar] = BITMAP_ALLOC (&predbitmap_obstack); 1286 bitmap_set_bit (graph->points_to[lhsvar], rhsvar); 1287 1288 if (graph->pointed_by[rhsvar] == NULL) 1289 graph->pointed_by[rhsvar] = BITMAP_ALLOC (&predbitmap_obstack); 1290 bitmap_set_bit (graph->pointed_by[rhsvar], lhsvar); 1291 1292 /* Implicitly, *x = y */ 1293 add_implicit_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar); 1294 1295 /* All related variables are no longer direct nodes. */ 1296 bitmap_clear_bit (graph->direct_nodes, rhsvar); 1297 v = get_varinfo (rhsvar); 1298 if (!v->is_full_var) 1299 { 1300 v = get_varinfo (v->head); 1301 do 1302 { 1303 bitmap_clear_bit (graph->direct_nodes, v->id); 1304 v = vi_next (v); 1305 } 1306 while (v != NULL); 1307 } 1308 bitmap_set_bit (graph->address_taken, rhsvar); 1309 } 1310 else if (lhsvar > anything_id 1311 && lhsvar != rhsvar && lhs.offset == 0 && rhs.offset == 0) 1312 { 1313 /* x = y */ 1314 add_pred_graph_edge (graph, lhsvar, rhsvar); 1315 /* Implicitly, *x = *y */ 1316 add_implicit_graph_edge (graph, FIRST_REF_NODE + lhsvar, 1317 FIRST_REF_NODE + rhsvar); 1318 } 1319 else if (lhs.offset != 0 || rhs.offset != 0) 1320 { 1321 if (rhs.offset != 0) 1322 bitmap_clear_bit (graph->direct_nodes, lhs.var); 1323 else if (lhs.offset != 0) 1324 bitmap_clear_bit (graph->direct_nodes, rhs.var); 1325 } 1326 } 1327 } 1328 1329 /* Build the constraint graph, adding successor edges. */ 1330 1331 static void 1332 build_succ_graph (void) 1333 { 1334 unsigned i, t; 1335 constraint_t c; 1336 1337 FOR_EACH_VEC_ELT (constraints, i, c) 1338 { 1339 struct constraint_expr lhs; 1340 struct constraint_expr rhs; 1341 unsigned int lhsvar; 1342 unsigned int rhsvar; 1343 1344 if (!c) 1345 continue; 1346 1347 lhs = c->lhs; 1348 rhs = c->rhs; 1349 lhsvar = find (lhs.var); 1350 rhsvar = find (rhs.var); 1351 1352 if (lhs.type == DEREF) 1353 { 1354 if (rhs.offset == 0 && lhs.offset == 0 && rhs.type == SCALAR) 1355 add_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar); 1356 } 1357 else if (rhs.type == DEREF) 1358 { 1359 if (rhs.offset == 0 && lhs.offset == 0 && lhs.type == SCALAR) 1360 add_graph_edge (graph, lhsvar, FIRST_REF_NODE + rhsvar); 1361 } 1362 else if (rhs.type == ADDRESSOF) 1363 { 1364 /* x = &y */ 1365 gcc_checking_assert (find (rhs.var) == rhs.var); 1366 bitmap_set_bit (get_varinfo (lhsvar)->solution, rhsvar); 1367 } 1368 else if (lhsvar > anything_id 1369 && lhsvar != rhsvar && lhs.offset == 0 && rhs.offset == 0) 1370 { 1371 add_graph_edge (graph, lhsvar, rhsvar); 1372 } 1373 } 1374 1375 /* Add edges from STOREDANYTHING to all non-direct nodes that can 1376 receive pointers. */ 1377 t = find (storedanything_id); 1378 for (i = integer_id + 1; i < FIRST_REF_NODE; ++i) 1379 { 1380 if (!bitmap_bit_p (graph->direct_nodes, i) 1381 && get_varinfo (i)->may_have_pointers) 1382 add_graph_edge (graph, find (i), t); 1383 } 1384 1385 /* Everything stored to ANYTHING also potentially escapes. */ 1386 add_graph_edge (graph, find (escaped_id), t); 1387 } 1388 1389 1390 /* Changed variables on the last iteration. */ 1391 static bitmap changed; 1392 1393 /* Strongly Connected Component visitation info. */ 1394 1395 class scc_info 1396 { 1397 public: 1398 scc_info (size_t size); 1399 ~scc_info (); 1400 1401 auto_sbitmap visited; 1402 auto_sbitmap deleted; 1403 unsigned int *dfs; 1404 unsigned int *node_mapping; 1405 int current_index; 1406 auto_vec<unsigned> scc_stack; 1407 }; 1408 1409 1410 /* Recursive routine to find strongly connected components in GRAPH. 1411 SI is the SCC info to store the information in, and N is the id of current 1412 graph node we are processing. 1413 1414 This is Tarjan's strongly connected component finding algorithm, as 1415 modified by Nuutila to keep only non-root nodes on the stack. 1416 The algorithm can be found in "On finding the strongly connected 1417 connected components in a directed graph" by Esko Nuutila and Eljas 1418 Soisalon-Soininen, in Information Processing Letters volume 49, 1419 number 1, pages 9-14. */ 1420 1421 static void 1422 scc_visit (constraint_graph_t graph, class scc_info *si, unsigned int n) 1423 { 1424 unsigned int i; 1425 bitmap_iterator bi; 1426 unsigned int my_dfs; 1427 1428 bitmap_set_bit (si->visited, n); 1429 si->dfs[n] = si->current_index ++; 1430 my_dfs = si->dfs[n]; 1431 1432 /* Visit all the successors. */ 1433 EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[n], 0, i, bi) 1434 { 1435 unsigned int w; 1436 1437 if (i > LAST_REF_NODE) 1438 break; 1439 1440 w = find (i); 1441 if (bitmap_bit_p (si->deleted, w)) 1442 continue; 1443 1444 if (!bitmap_bit_p (si->visited, w)) 1445 scc_visit (graph, si, w); 1446 1447 unsigned int t = find (w); 1448 gcc_checking_assert (find (n) == n); 1449 if (si->dfs[t] < si->dfs[n]) 1450 si->dfs[n] = si->dfs[t]; 1451 } 1452 1453 /* See if any components have been identified. */ 1454 if (si->dfs[n] == my_dfs) 1455 { 1456 if (si->scc_stack.length () > 0 1457 && si->dfs[si->scc_stack.last ()] >= my_dfs) 1458 { 1459 bitmap scc = BITMAP_ALLOC (NULL); 1460 unsigned int lowest_node; 1461 bitmap_iterator bi; 1462 1463 bitmap_set_bit (scc, n); 1464 1465 while (si->scc_stack.length () != 0 1466 && si->dfs[si->scc_stack.last ()] >= my_dfs) 1467 { 1468 unsigned int w = si->scc_stack.pop (); 1469 1470 bitmap_set_bit (scc, w); 1471 } 1472 1473 lowest_node = bitmap_first_set_bit (scc); 1474 gcc_assert (lowest_node < FIRST_REF_NODE); 1475 1476 /* Collapse the SCC nodes into a single node, and mark the 1477 indirect cycles. */ 1478 EXECUTE_IF_SET_IN_BITMAP (scc, 0, i, bi) 1479 { 1480 if (i < FIRST_REF_NODE) 1481 { 1482 if (unite (lowest_node, i)) 1483 unify_nodes (graph, lowest_node, i, false); 1484 } 1485 else 1486 { 1487 unite (lowest_node, i); 1488 graph->indirect_cycles[i - FIRST_REF_NODE] = lowest_node; 1489 } 1490 } 1491 } 1492 bitmap_set_bit (si->deleted, n); 1493 } 1494 else 1495 si->scc_stack.safe_push (n); 1496 } 1497 1498 /* Unify node FROM into node TO, updating the changed count if 1499 necessary when UPDATE_CHANGED is true. */ 1500 1501 static void 1502 unify_nodes (constraint_graph_t graph, unsigned int to, unsigned int from, 1503 bool update_changed) 1504 { 1505 gcc_checking_assert (to != from && find (to) == to); 1506 1507 if (dump_file && (dump_flags & TDF_DETAILS)) 1508 fprintf (dump_file, "Unifying %s to %s\n", 1509 get_varinfo (from)->name, 1510 get_varinfo (to)->name); 1511 1512 if (update_changed) 1513 stats.unified_vars_dynamic++; 1514 else 1515 stats.unified_vars_static++; 1516 1517 merge_graph_nodes (graph, to, from); 1518 if (merge_node_constraints (graph, to, from)) 1519 { 1520 if (update_changed) 1521 bitmap_set_bit (changed, to); 1522 } 1523 1524 /* Mark TO as changed if FROM was changed. If TO was already marked 1525 as changed, decrease the changed count. */ 1526 1527 if (update_changed 1528 && bitmap_clear_bit (changed, from)) 1529 bitmap_set_bit (changed, to); 1530 varinfo_t fromvi = get_varinfo (from); 1531 if (fromvi->solution) 1532 { 1533 /* If the solution changes because of the merging, we need to mark 1534 the variable as changed. */ 1535 varinfo_t tovi = get_varinfo (to); 1536 if (bitmap_ior_into (tovi->solution, fromvi->solution)) 1537 { 1538 if (update_changed) 1539 bitmap_set_bit (changed, to); 1540 } 1541 1542 BITMAP_FREE (fromvi->solution); 1543 if (fromvi->oldsolution) 1544 BITMAP_FREE (fromvi->oldsolution); 1545 1546 if (stats.iterations > 0 1547 && tovi->oldsolution) 1548 BITMAP_FREE (tovi->oldsolution); 1549 } 1550 if (graph->succs[to]) 1551 bitmap_clear_bit (graph->succs[to], to); 1552 } 1553 1554 /* Information needed to compute the topological ordering of a graph. */ 1555 1556 struct topo_info 1557 { 1558 /* sbitmap of visited nodes. */ 1559 sbitmap visited; 1560 /* Array that stores the topological order of the graph, *in 1561 reverse*. */ 1562 vec<unsigned> topo_order; 1563 }; 1564 1565 1566 /* Initialize and return a topological info structure. */ 1567 1568 static struct topo_info * 1569 init_topo_info (void) 1570 { 1571 size_t size = graph->size; 1572 struct topo_info *ti = XNEW (struct topo_info); 1573 ti->visited = sbitmap_alloc (size); 1574 bitmap_clear (ti->visited); 1575 ti->topo_order.create (1); 1576 return ti; 1577 } 1578 1579 1580 /* Free the topological sort info pointed to by TI. */ 1581 1582 static void 1583 free_topo_info (struct topo_info *ti) 1584 { 1585 sbitmap_free (ti->visited); 1586 ti->topo_order.release (); 1587 free (ti); 1588 } 1589 1590 /* Visit the graph in topological order, and store the order in the 1591 topo_info structure. */ 1592 1593 static void 1594 topo_visit (constraint_graph_t graph, struct topo_info *ti, 1595 unsigned int n) 1596 { 1597 bitmap_iterator bi; 1598 unsigned int j; 1599 1600 bitmap_set_bit (ti->visited, n); 1601 1602 if (graph->succs[n]) 1603 EXECUTE_IF_SET_IN_BITMAP (graph->succs[n], 0, j, bi) 1604 { 1605 if (!bitmap_bit_p (ti->visited, j)) 1606 topo_visit (graph, ti, j); 1607 } 1608 1609 ti->topo_order.safe_push (n); 1610 } 1611 1612 /* Process a constraint C that represents x = *(y + off), using DELTA as the 1613 starting solution for y. */ 1614 1615 static void 1616 do_sd_constraint (constraint_graph_t graph, constraint_t c, 1617 bitmap delta, bitmap *expanded_delta) 1618 { 1619 unsigned int lhs = c->lhs.var; 1620 bool flag = false; 1621 bitmap sol = get_varinfo (lhs)->solution; 1622 unsigned int j; 1623 bitmap_iterator bi; 1624 HOST_WIDE_INT roffset = c->rhs.offset; 1625 1626 /* Our IL does not allow this. */ 1627 gcc_checking_assert (c->lhs.offset == 0); 1628 1629 /* If the solution of Y contains anything it is good enough to transfer 1630 this to the LHS. */ 1631 if (bitmap_bit_p (delta, anything_id)) 1632 { 1633 flag |= bitmap_set_bit (sol, anything_id); 1634 goto done; 1635 } 1636 1637 /* If we do not know at with offset the rhs is dereferenced compute 1638 the reachability set of DELTA, conservatively assuming it is 1639 dereferenced at all valid offsets. */ 1640 if (roffset == UNKNOWN_OFFSET) 1641 { 1642 delta = solution_set_expand (delta, expanded_delta); 1643 /* No further offset processing is necessary. */ 1644 roffset = 0; 1645 } 1646 1647 /* For each variable j in delta (Sol(y)), add 1648 an edge in the graph from j to x, and union Sol(j) into Sol(x). */ 1649 EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi) 1650 { 1651 varinfo_t v = get_varinfo (j); 1652 HOST_WIDE_INT fieldoffset = v->offset + roffset; 1653 unsigned HOST_WIDE_INT size = v->size; 1654 unsigned int t; 1655 1656 if (v->is_full_var) 1657 ; 1658 else if (roffset != 0) 1659 { 1660 if (fieldoffset < 0) 1661 v = get_varinfo (v->head); 1662 else 1663 v = first_or_preceding_vi_for_offset (v, fieldoffset); 1664 } 1665 1666 /* We have to include all fields that overlap the current field 1667 shifted by roffset. */ 1668 do 1669 { 1670 t = find (v->id); 1671 1672 /* Adding edges from the special vars is pointless. 1673 They don't have sets that can change. */ 1674 if (get_varinfo (t)->is_special_var) 1675 flag |= bitmap_ior_into (sol, get_varinfo (t)->solution); 1676 /* Merging the solution from ESCAPED needlessly increases 1677 the set. Use ESCAPED as representative instead. */ 1678 else if (v->id == escaped_id) 1679 flag |= bitmap_set_bit (sol, escaped_id); 1680 else if (v->may_have_pointers 1681 && add_graph_edge (graph, lhs, t)) 1682 flag |= bitmap_ior_into (sol, get_varinfo (t)->solution); 1683 1684 if (v->is_full_var 1685 || v->next == 0) 1686 break; 1687 1688 v = vi_next (v); 1689 } 1690 while (v->offset < fieldoffset + size); 1691 } 1692 1693 done: 1694 /* If the LHS solution changed, mark the var as changed. */ 1695 if (flag) 1696 { 1697 get_varinfo (lhs)->solution = sol; 1698 bitmap_set_bit (changed, lhs); 1699 } 1700 } 1701 1702 /* Process a constraint C that represents *(x + off) = y using DELTA 1703 as the starting solution for x. */ 1704 1705 static void 1706 do_ds_constraint (constraint_t c, bitmap delta, bitmap *expanded_delta) 1707 { 1708 unsigned int rhs = c->rhs.var; 1709 bitmap sol = get_varinfo (rhs)->solution; 1710 unsigned int j; 1711 bitmap_iterator bi; 1712 HOST_WIDE_INT loff = c->lhs.offset; 1713 bool escaped_p = false; 1714 1715 /* Our IL does not allow this. */ 1716 gcc_checking_assert (c->rhs.offset == 0); 1717 1718 /* If the solution of y contains ANYTHING simply use the ANYTHING 1719 solution. This avoids needlessly increasing the points-to sets. */ 1720 if (bitmap_bit_p (sol, anything_id)) 1721 sol = get_varinfo (find (anything_id))->solution; 1722 1723 /* If the solution for x contains ANYTHING we have to merge the 1724 solution of y into all pointer variables which we do via 1725 STOREDANYTHING. */ 1726 if (bitmap_bit_p (delta, anything_id)) 1727 { 1728 unsigned t = find (storedanything_id); 1729 if (add_graph_edge (graph, t, rhs)) 1730 { 1731 if (bitmap_ior_into (get_varinfo (t)->solution, sol)) 1732 bitmap_set_bit (changed, t); 1733 } 1734 return; 1735 } 1736 1737 /* If we do not know at with offset the rhs is dereferenced compute 1738 the reachability set of DELTA, conservatively assuming it is 1739 dereferenced at all valid offsets. */ 1740 if (loff == UNKNOWN_OFFSET) 1741 { 1742 delta = solution_set_expand (delta, expanded_delta); 1743 loff = 0; 1744 } 1745 1746 /* For each member j of delta (Sol(x)), add an edge from y to j and 1747 union Sol(y) into Sol(j) */ 1748 EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi) 1749 { 1750 varinfo_t v = get_varinfo (j); 1751 unsigned int t; 1752 HOST_WIDE_INT fieldoffset = v->offset + loff; 1753 unsigned HOST_WIDE_INT size = v->size; 1754 1755 if (v->is_full_var) 1756 ; 1757 else if (loff != 0) 1758 { 1759 if (fieldoffset < 0) 1760 v = get_varinfo (v->head); 1761 else 1762 v = first_or_preceding_vi_for_offset (v, fieldoffset); 1763 } 1764 1765 /* We have to include all fields that overlap the current field 1766 shifted by loff. */ 1767 do 1768 { 1769 if (v->may_have_pointers) 1770 { 1771 /* If v is a global variable then this is an escape point. */ 1772 if (v->is_global_var 1773 && !escaped_p) 1774 { 1775 t = find (escaped_id); 1776 if (add_graph_edge (graph, t, rhs) 1777 && bitmap_ior_into (get_varinfo (t)->solution, sol)) 1778 bitmap_set_bit (changed, t); 1779 /* Enough to let rhs escape once. */ 1780 escaped_p = true; 1781 } 1782 1783 if (v->is_special_var) 1784 break; 1785 1786 t = find (v->id); 1787 if (add_graph_edge (graph, t, rhs) 1788 && bitmap_ior_into (get_varinfo (t)->solution, sol)) 1789 bitmap_set_bit (changed, t); 1790 } 1791 1792 if (v->is_full_var 1793 || v->next == 0) 1794 break; 1795 1796 v = vi_next (v); 1797 } 1798 while (v->offset < fieldoffset + size); 1799 } 1800 } 1801 1802 /* Handle a non-simple (simple meaning requires no iteration), 1803 constraint (IE *x = &y, x = *y, *x = y, and x = y with offsets involved). */ 1804 1805 static void 1806 do_complex_constraint (constraint_graph_t graph, constraint_t c, bitmap delta, 1807 bitmap *expanded_delta) 1808 { 1809 if (c->lhs.type == DEREF) 1810 { 1811 if (c->rhs.type == ADDRESSOF) 1812 { 1813 gcc_unreachable (); 1814 } 1815 else 1816 { 1817 /* *x = y */ 1818 do_ds_constraint (c, delta, expanded_delta); 1819 } 1820 } 1821 else if (c->rhs.type == DEREF) 1822 { 1823 /* x = *y */ 1824 if (!(get_varinfo (c->lhs.var)->is_special_var)) 1825 do_sd_constraint (graph, c, delta, expanded_delta); 1826 } 1827 else 1828 { 1829 bitmap tmp; 1830 bool flag = false; 1831 1832 gcc_checking_assert (c->rhs.type == SCALAR && c->lhs.type == SCALAR 1833 && c->rhs.offset != 0 && c->lhs.offset == 0); 1834 tmp = get_varinfo (c->lhs.var)->solution; 1835 1836 flag = set_union_with_increment (tmp, delta, c->rhs.offset, 1837 expanded_delta); 1838 1839 if (flag) 1840 bitmap_set_bit (changed, c->lhs.var); 1841 } 1842 } 1843 1844 /* Initialize and return a new SCC info structure. */ 1845 1846 scc_info::scc_info (size_t size) : 1847 visited (size), deleted (size), current_index (0), scc_stack (1) 1848 { 1849 bitmap_clear (visited); 1850 bitmap_clear (deleted); 1851 node_mapping = XNEWVEC (unsigned int, size); 1852 dfs = XCNEWVEC (unsigned int, size); 1853 1854 for (size_t i = 0; i < size; i++) 1855 node_mapping[i] = i; 1856 } 1857 1858 /* Free an SCC info structure pointed to by SI */ 1859 1860 scc_info::~scc_info () 1861 { 1862 free (node_mapping); 1863 free (dfs); 1864 } 1865 1866 1867 /* Find indirect cycles in GRAPH that occur, using strongly connected 1868 components, and note them in the indirect cycles map. 1869 1870 This technique comes from Ben Hardekopf and Calvin Lin, 1871 "It Pays to be Lazy: Fast and Accurate Pointer Analysis for Millions of 1872 Lines of Code", submitted to PLDI 2007. */ 1873 1874 static void 1875 find_indirect_cycles (constraint_graph_t graph) 1876 { 1877 unsigned int i; 1878 unsigned int size = graph->size; 1879 scc_info si (size); 1880 1881 for (i = 0; i < MIN (LAST_REF_NODE, size); i ++ ) 1882 if (!bitmap_bit_p (si.visited, i) && find (i) == i) 1883 scc_visit (graph, &si, i); 1884 } 1885 1886 /* Compute a topological ordering for GRAPH, and store the result in the 1887 topo_info structure TI. */ 1888 1889 static void 1890 compute_topo_order (constraint_graph_t graph, 1891 struct topo_info *ti) 1892 { 1893 unsigned int i; 1894 unsigned int size = graph->size; 1895 1896 for (i = 0; i != size; ++i) 1897 if (!bitmap_bit_p (ti->visited, i) && find (i) == i) 1898 topo_visit (graph, ti, i); 1899 } 1900 1901 /* Structure used to for hash value numbering of pointer equivalence 1902 classes. */ 1903 1904 typedef struct equiv_class_label 1905 { 1906 hashval_t hashcode; 1907 unsigned int equivalence_class; 1908 bitmap labels; 1909 } *equiv_class_label_t; 1910 typedef const struct equiv_class_label *const_equiv_class_label_t; 1911 1912 /* Equiv_class_label hashtable helpers. */ 1913 1914 struct equiv_class_hasher : nofree_ptr_hash <equiv_class_label> 1915 { 1916 static inline hashval_t hash (const equiv_class_label *); 1917 static inline bool equal (const equiv_class_label *, 1918 const equiv_class_label *); 1919 }; 1920 1921 /* Hash function for a equiv_class_label_t */ 1922 1923 inline hashval_t 1924 equiv_class_hasher::hash (const equiv_class_label *ecl) 1925 { 1926 return ecl->hashcode; 1927 } 1928 1929 /* Equality function for two equiv_class_label_t's. */ 1930 1931 inline bool 1932 equiv_class_hasher::equal (const equiv_class_label *eql1, 1933 const equiv_class_label *eql2) 1934 { 1935 return (eql1->hashcode == eql2->hashcode 1936 && bitmap_equal_p (eql1->labels, eql2->labels)); 1937 } 1938 1939 /* A hashtable for mapping a bitmap of labels->pointer equivalence 1940 classes. */ 1941 static hash_table<equiv_class_hasher> *pointer_equiv_class_table; 1942 1943 /* A hashtable for mapping a bitmap of labels->location equivalence 1944 classes. */ 1945 static hash_table<equiv_class_hasher> *location_equiv_class_table; 1946 1947 struct obstack equiv_class_obstack; 1948 1949 /* Lookup a equivalence class in TABLE by the bitmap of LABELS with 1950 hash HAS it contains. Sets *REF_LABELS to the bitmap LABELS 1951 is equivalent to. */ 1952 1953 static equiv_class_label * 1954 equiv_class_lookup_or_add (hash_table<equiv_class_hasher> *table, 1955 bitmap labels) 1956 { 1957 equiv_class_label **slot; 1958 equiv_class_label ecl; 1959 1960 ecl.labels = labels; 1961 ecl.hashcode = bitmap_hash (labels); 1962 slot = table->find_slot (&ecl, INSERT); 1963 if (!*slot) 1964 { 1965 *slot = XOBNEW (&equiv_class_obstack, struct equiv_class_label); 1966 (*slot)->labels = labels; 1967 (*slot)->hashcode = ecl.hashcode; 1968 (*slot)->equivalence_class = 0; 1969 } 1970 1971 return *slot; 1972 } 1973 1974 /* Perform offline variable substitution. 1975 1976 This is a worst case quadratic time way of identifying variables 1977 that must have equivalent points-to sets, including those caused by 1978 static cycles, and single entry subgraphs, in the constraint graph. 1979 1980 The technique is described in "Exploiting Pointer and Location 1981 Equivalence to Optimize Pointer Analysis. In the 14th International 1982 Static Analysis Symposium (SAS), August 2007." It is known as the 1983 "HU" algorithm, and is equivalent to value numbering the collapsed 1984 constraint graph including evaluating unions. 1985 1986 The general method of finding equivalence classes is as follows: 1987 Add fake nodes (REF nodes) and edges for *a = b and a = *b constraints. 1988 Initialize all non-REF nodes to be direct nodes. 1989 For each constraint a = a U {b}, we set pts(a) = pts(a) u {fresh 1990 variable} 1991 For each constraint containing the dereference, we also do the same 1992 thing. 1993 1994 We then compute SCC's in the graph and unify nodes in the same SCC, 1995 including pts sets. 1996 1997 For each non-collapsed node x: 1998 Visit all unvisited explicit incoming edges. 1999 Ignoring all non-pointers, set pts(x) = Union of pts(a) for y 2000 where y->x. 2001 Lookup the equivalence class for pts(x). 2002 If we found one, equivalence_class(x) = found class. 2003 Otherwise, equivalence_class(x) = new class, and new_class is 2004 added to the lookup table. 2005 2006 All direct nodes with the same equivalence class can be replaced 2007 with a single representative node. 2008 All unlabeled nodes (label == 0) are not pointers and all edges 2009 involving them can be eliminated. 2010 We perform these optimizations during rewrite_constraints 2011 2012 In addition to pointer equivalence class finding, we also perform 2013 location equivalence class finding. This is the set of variables 2014 that always appear together in points-to sets. We use this to 2015 compress the size of the points-to sets. */ 2016 2017 /* Current maximum pointer equivalence class id. */ 2018 static int pointer_equiv_class; 2019 2020 /* Current maximum location equivalence class id. */ 2021 static int location_equiv_class; 2022 2023 /* Recursive routine to find strongly connected components in GRAPH, 2024 and label it's nodes with DFS numbers. */ 2025 2026 static void 2027 condense_visit (constraint_graph_t graph, class scc_info *si, unsigned int n) 2028 { 2029 unsigned int i; 2030 bitmap_iterator bi; 2031 unsigned int my_dfs; 2032 2033 gcc_checking_assert (si->node_mapping[n] == n); 2034 bitmap_set_bit (si->visited, n); 2035 si->dfs[n] = si->current_index ++; 2036 my_dfs = si->dfs[n]; 2037 2038 /* Visit all the successors. */ 2039 EXECUTE_IF_IN_NONNULL_BITMAP (graph->preds[n], 0, i, bi) 2040 { 2041 unsigned int w = si->node_mapping[i]; 2042 2043 if (bitmap_bit_p (si->deleted, w)) 2044 continue; 2045 2046 if (!bitmap_bit_p (si->visited, w)) 2047 condense_visit (graph, si, w); 2048 2049 unsigned int t = si->node_mapping[w]; 2050 gcc_checking_assert (si->node_mapping[n] == n); 2051 if (si->dfs[t] < si->dfs[n]) 2052 si->dfs[n] = si->dfs[t]; 2053 } 2054 2055 /* Visit all the implicit predecessors. */ 2056 EXECUTE_IF_IN_NONNULL_BITMAP (graph->implicit_preds[n], 0, i, bi) 2057 { 2058 unsigned int w = si->node_mapping[i]; 2059 2060 if (bitmap_bit_p (si->deleted, w)) 2061 continue; 2062 2063 if (!bitmap_bit_p (si->visited, w)) 2064 condense_visit (graph, si, w); 2065 2066 unsigned int t = si->node_mapping[w]; 2067 gcc_assert (si->node_mapping[n] == n); 2068 if (si->dfs[t] < si->dfs[n]) 2069 si->dfs[n] = si->dfs[t]; 2070 } 2071 2072 /* See if any components have been identified. */ 2073 if (si->dfs[n] == my_dfs) 2074 { 2075 if (si->scc_stack.length () != 0 2076 && si->dfs[si->scc_stack.last ()] >= my_dfs) 2077 { 2078 /* Find the first node of the SCC and do non-bitmap work. */ 2079 bool direct_p = true; 2080 unsigned first = si->scc_stack.length (); 2081 do 2082 { 2083 --first; 2084 unsigned int w = si->scc_stack[first]; 2085 si->node_mapping[w] = n; 2086 if (!bitmap_bit_p (graph->direct_nodes, w)) 2087 direct_p = false; 2088 } 2089 while (first > 0 2090 && si->dfs[si->scc_stack[first - 1]] >= my_dfs); 2091 if (!direct_p) 2092 bitmap_clear_bit (graph->direct_nodes, n); 2093 2094 /* Want to reduce to node n, push that first. */ 2095 si->scc_stack.reserve (1); 2096 si->scc_stack.quick_push (si->scc_stack[first]); 2097 si->scc_stack[first] = n; 2098 2099 unsigned scc_size = si->scc_stack.length () - first; 2100 unsigned split = scc_size / 2; 2101 unsigned carry = scc_size - split * 2; 2102 while (split > 0) 2103 { 2104 for (unsigned i = 0; i < split; ++i) 2105 { 2106 unsigned a = si->scc_stack[first + i]; 2107 unsigned b = si->scc_stack[first + split + carry + i]; 2108 2109 /* Unify our nodes. */ 2110 if (graph->preds[b]) 2111 { 2112 if (!graph->preds[a]) 2113 std::swap (graph->preds[a], graph->preds[b]); 2114 else 2115 bitmap_ior_into_and_free (graph->preds[a], 2116 &graph->preds[b]); 2117 } 2118 if (graph->implicit_preds[b]) 2119 { 2120 if (!graph->implicit_preds[a]) 2121 std::swap (graph->implicit_preds[a], 2122 graph->implicit_preds[b]); 2123 else 2124 bitmap_ior_into_and_free (graph->implicit_preds[a], 2125 &graph->implicit_preds[b]); 2126 } 2127 if (graph->points_to[b]) 2128 { 2129 if (!graph->points_to[a]) 2130 std::swap (graph->points_to[a], graph->points_to[b]); 2131 else 2132 bitmap_ior_into_and_free (graph->points_to[a], 2133 &graph->points_to[b]); 2134 } 2135 } 2136 unsigned remain = split + carry; 2137 split = remain / 2; 2138 carry = remain - split * 2; 2139 } 2140 /* Actually pop the SCC. */ 2141 si->scc_stack.truncate (first); 2142 } 2143 bitmap_set_bit (si->deleted, n); 2144 } 2145 else 2146 si->scc_stack.safe_push (n); 2147 } 2148 2149 /* Label pointer equivalences. 2150 2151 This performs a value numbering of the constraint graph to 2152 discover which variables will always have the same points-to sets 2153 under the current set of constraints. 2154 2155 The way it value numbers is to store the set of points-to bits 2156 generated by the constraints and graph edges. This is just used as a 2157 hash and equality comparison. The *actual set of points-to bits* is 2158 completely irrelevant, in that we don't care about being able to 2159 extract them later. 2160 2161 The equality values (currently bitmaps) just have to satisfy a few 2162 constraints, the main ones being: 2163 1. The combining operation must be order independent. 2164 2. The end result of a given set of operations must be unique iff the 2165 combination of input values is unique 2166 3. Hashable. */ 2167 2168 static void 2169 label_visit (constraint_graph_t graph, class scc_info *si, unsigned int n) 2170 { 2171 unsigned int i, first_pred; 2172 bitmap_iterator bi; 2173 2174 bitmap_set_bit (si->visited, n); 2175 2176 /* Label and union our incoming edges's points to sets. */ 2177 first_pred = -1U; 2178 EXECUTE_IF_IN_NONNULL_BITMAP (graph->preds[n], 0, i, bi) 2179 { 2180 unsigned int w = si->node_mapping[i]; 2181 if (!bitmap_bit_p (si->visited, w)) 2182 label_visit (graph, si, w); 2183 2184 /* Skip unused edges */ 2185 if (w == n || graph->pointer_label[w] == 0) 2186 continue; 2187 2188 if (graph->points_to[w]) 2189 { 2190 if (!graph->points_to[n]) 2191 { 2192 if (first_pred == -1U) 2193 first_pred = w; 2194 else 2195 { 2196 graph->points_to[n] = BITMAP_ALLOC (&predbitmap_obstack); 2197 bitmap_ior (graph->points_to[n], 2198 graph->points_to[first_pred], 2199 graph->points_to[w]); 2200 } 2201 } 2202 else 2203 bitmap_ior_into (graph->points_to[n], graph->points_to[w]); 2204 } 2205 } 2206 2207 /* Indirect nodes get fresh variables and a new pointer equiv class. */ 2208 if (!bitmap_bit_p (graph->direct_nodes, n)) 2209 { 2210 if (!graph->points_to[n]) 2211 { 2212 graph->points_to[n] = BITMAP_ALLOC (&predbitmap_obstack); 2213 if (first_pred != -1U) 2214 bitmap_copy (graph->points_to[n], graph->points_to[first_pred]); 2215 } 2216 bitmap_set_bit (graph->points_to[n], FIRST_REF_NODE + n); 2217 graph->pointer_label[n] = pointer_equiv_class++; 2218 equiv_class_label_t ecl; 2219 ecl = equiv_class_lookup_or_add (pointer_equiv_class_table, 2220 graph->points_to[n]); 2221 ecl->equivalence_class = graph->pointer_label[n]; 2222 return; 2223 } 2224 2225 /* If there was only a single non-empty predecessor the pointer equiv 2226 class is the same. */ 2227 if (!graph->points_to[n]) 2228 { 2229 if (first_pred != -1U) 2230 { 2231 graph->pointer_label[n] = graph->pointer_label[first_pred]; 2232 graph->points_to[n] = graph->points_to[first_pred]; 2233 } 2234 return; 2235 } 2236 2237 if (!bitmap_empty_p (graph->points_to[n])) 2238 { 2239 equiv_class_label_t ecl; 2240 ecl = equiv_class_lookup_or_add (pointer_equiv_class_table, 2241 graph->points_to[n]); 2242 if (ecl->equivalence_class == 0) 2243 ecl->equivalence_class = pointer_equiv_class++; 2244 else 2245 { 2246 BITMAP_FREE (graph->points_to[n]); 2247 graph->points_to[n] = ecl->labels; 2248 } 2249 graph->pointer_label[n] = ecl->equivalence_class; 2250 } 2251 } 2252 2253 /* Print the pred graph in dot format. */ 2254 2255 static void 2256 dump_pred_graph (class scc_info *si, FILE *file) 2257 { 2258 unsigned int i; 2259 2260 /* Only print the graph if it has already been initialized: */ 2261 if (!graph) 2262 return; 2263 2264 /* Prints the header of the dot file: */ 2265 fprintf (file, "strict digraph {\n"); 2266 fprintf (file, " node [\n shape = box\n ]\n"); 2267 fprintf (file, " edge [\n fontsize = \"12\"\n ]\n"); 2268 fprintf (file, "\n // List of nodes and complex constraints in " 2269 "the constraint graph:\n"); 2270 2271 /* The next lines print the nodes in the graph together with the 2272 complex constraints attached to them. */ 2273 for (i = 1; i < graph->size; i++) 2274 { 2275 if (i == FIRST_REF_NODE) 2276 continue; 2277 if (si->node_mapping[i] != i) 2278 continue; 2279 if (i < FIRST_REF_NODE) 2280 fprintf (file, "\"%s\"", get_varinfo (i)->name); 2281 else 2282 fprintf (file, "\"*%s\"", get_varinfo (i - FIRST_REF_NODE)->name); 2283 if (graph->points_to[i] 2284 && !bitmap_empty_p (graph->points_to[i])) 2285 { 2286 if (i < FIRST_REF_NODE) 2287 fprintf (file, "[label=\"%s = {", get_varinfo (i)->name); 2288 else 2289 fprintf (file, "[label=\"*%s = {", 2290 get_varinfo (i - FIRST_REF_NODE)->name); 2291 unsigned j; 2292 bitmap_iterator bi; 2293 EXECUTE_IF_SET_IN_BITMAP (graph->points_to[i], 0, j, bi) 2294 fprintf (file, " %d", j); 2295 fprintf (file, " }\"]"); 2296 } 2297 fprintf (file, ";\n"); 2298 } 2299 2300 /* Go over the edges. */ 2301 fprintf (file, "\n // Edges in the constraint graph:\n"); 2302 for (i = 1; i < graph->size; i++) 2303 { 2304 unsigned j; 2305 bitmap_iterator bi; 2306 if (si->node_mapping[i] != i) 2307 continue; 2308 EXECUTE_IF_IN_NONNULL_BITMAP (graph->preds[i], 0, j, bi) 2309 { 2310 unsigned from = si->node_mapping[j]; 2311 if (from < FIRST_REF_NODE) 2312 fprintf (file, "\"%s\"", get_varinfo (from)->name); 2313 else 2314 fprintf (file, "\"*%s\"", get_varinfo (from - FIRST_REF_NODE)->name); 2315 fprintf (file, " -> "); 2316 if (i < FIRST_REF_NODE) 2317 fprintf (file, "\"%s\"", get_varinfo (i)->name); 2318 else 2319 fprintf (file, "\"*%s\"", get_varinfo (i - FIRST_REF_NODE)->name); 2320 fprintf (file, ";\n"); 2321 } 2322 } 2323 2324 /* Prints the tail of the dot file. */ 2325 fprintf (file, "}\n"); 2326 } 2327 2328 /* Perform offline variable substitution, discovering equivalence 2329 classes, and eliminating non-pointer variables. */ 2330 2331 static class scc_info * 2332 perform_var_substitution (constraint_graph_t graph) 2333 { 2334 unsigned int i; 2335 unsigned int size = graph->size; 2336 scc_info *si = new scc_info (size); 2337 2338 bitmap_obstack_initialize (&iteration_obstack); 2339 gcc_obstack_init (&equiv_class_obstack); 2340 pointer_equiv_class_table = new hash_table<equiv_class_hasher> (511); 2341 location_equiv_class_table 2342 = new hash_table<equiv_class_hasher> (511); 2343 pointer_equiv_class = 1; 2344 location_equiv_class = 1; 2345 2346 /* Condense the nodes, which means to find SCC's, count incoming 2347 predecessors, and unite nodes in SCC's. */ 2348 for (i = 1; i < FIRST_REF_NODE; i++) 2349 if (!bitmap_bit_p (si->visited, si->node_mapping[i])) 2350 condense_visit (graph, si, si->node_mapping[i]); 2351 2352 if (dump_file && (dump_flags & TDF_GRAPH)) 2353 { 2354 fprintf (dump_file, "\n\n// The constraint graph before var-substitution " 2355 "in dot format:\n"); 2356 dump_pred_graph (si, dump_file); 2357 fprintf (dump_file, "\n\n"); 2358 } 2359 2360 bitmap_clear (si->visited); 2361 /* Actually the label the nodes for pointer equivalences */ 2362 for (i = 1; i < FIRST_REF_NODE; i++) 2363 if (!bitmap_bit_p (si->visited, si->node_mapping[i])) 2364 label_visit (graph, si, si->node_mapping[i]); 2365 2366 /* Calculate location equivalence labels. */ 2367 for (i = 1; i < FIRST_REF_NODE; i++) 2368 { 2369 bitmap pointed_by; 2370 bitmap_iterator bi; 2371 unsigned int j; 2372 2373 if (!graph->pointed_by[i]) 2374 continue; 2375 pointed_by = BITMAP_ALLOC (&iteration_obstack); 2376 2377 /* Translate the pointed-by mapping for pointer equivalence 2378 labels. */ 2379 EXECUTE_IF_SET_IN_BITMAP (graph->pointed_by[i], 0, j, bi) 2380 { 2381 bitmap_set_bit (pointed_by, 2382 graph->pointer_label[si->node_mapping[j]]); 2383 } 2384 /* The original pointed_by is now dead. */ 2385 BITMAP_FREE (graph->pointed_by[i]); 2386 2387 /* Look up the location equivalence label if one exists, or make 2388 one otherwise. */ 2389 equiv_class_label_t ecl; 2390 ecl = equiv_class_lookup_or_add (location_equiv_class_table, pointed_by); 2391 if (ecl->equivalence_class == 0) 2392 ecl->equivalence_class = location_equiv_class++; 2393 else 2394 { 2395 if (dump_file && (dump_flags & TDF_DETAILS)) 2396 fprintf (dump_file, "Found location equivalence for node %s\n", 2397 get_varinfo (i)->name); 2398 BITMAP_FREE (pointed_by); 2399 } 2400 graph->loc_label[i] = ecl->equivalence_class; 2401 2402 } 2403 2404 if (dump_file && (dump_flags & TDF_DETAILS)) 2405 for (i = 1; i < FIRST_REF_NODE; i++) 2406 { 2407 unsigned j = si->node_mapping[i]; 2408 if (j != i) 2409 { 2410 fprintf (dump_file, "%s node id %d ", 2411 bitmap_bit_p (graph->direct_nodes, i) 2412 ? "Direct" : "Indirect", i); 2413 if (i < FIRST_REF_NODE) 2414 fprintf (dump_file, "\"%s\"", get_varinfo (i)->name); 2415 else 2416 fprintf (dump_file, "\"*%s\"", 2417 get_varinfo (i - FIRST_REF_NODE)->name); 2418 fprintf (dump_file, " mapped to SCC leader node id %d ", j); 2419 if (j < FIRST_REF_NODE) 2420 fprintf (dump_file, "\"%s\"\n", get_varinfo (j)->name); 2421 else 2422 fprintf (dump_file, "\"*%s\"\n", 2423 get_varinfo (j - FIRST_REF_NODE)->name); 2424 } 2425 else 2426 { 2427 fprintf (dump_file, 2428 "Equivalence classes for %s node id %d ", 2429 bitmap_bit_p (graph->direct_nodes, i) 2430 ? "direct" : "indirect", i); 2431 if (i < FIRST_REF_NODE) 2432 fprintf (dump_file, "\"%s\"", get_varinfo (i)->name); 2433 else 2434 fprintf (dump_file, "\"*%s\"", 2435 get_varinfo (i - FIRST_REF_NODE)->name); 2436 fprintf (dump_file, 2437 ": pointer %d, location %d\n", 2438 graph->pointer_label[i], graph->loc_label[i]); 2439 } 2440 } 2441 2442 /* Quickly eliminate our non-pointer variables. */ 2443 2444 for (i = 1; i < FIRST_REF_NODE; i++) 2445 { 2446 unsigned int node = si->node_mapping[i]; 2447 2448 if (graph->pointer_label[node] == 0) 2449 { 2450 if (dump_file && (dump_flags & TDF_DETAILS)) 2451 fprintf (dump_file, 2452 "%s is a non-pointer variable, eliminating edges.\n", 2453 get_varinfo (node)->name); 2454 stats.nonpointer_vars++; 2455 clear_edges_for_node (graph, node); 2456 } 2457 } 2458 2459 return si; 2460 } 2461 2462 /* Free information that was only necessary for variable 2463 substitution. */ 2464 2465 static void 2466 free_var_substitution_info (class scc_info *si) 2467 { 2468 delete si; 2469 free (graph->pointer_label); 2470 free (graph->loc_label); 2471 free (graph->pointed_by); 2472 free (graph->points_to); 2473 free (graph->eq_rep); 2474 sbitmap_free (graph->direct_nodes); 2475 delete pointer_equiv_class_table; 2476 pointer_equiv_class_table = NULL; 2477 delete location_equiv_class_table; 2478 location_equiv_class_table = NULL; 2479 obstack_free (&equiv_class_obstack, NULL); 2480 bitmap_obstack_release (&iteration_obstack); 2481 } 2482 2483 /* Return an existing node that is equivalent to NODE, which has 2484 equivalence class LABEL, if one exists. Return NODE otherwise. */ 2485 2486 static unsigned int 2487 find_equivalent_node (constraint_graph_t graph, 2488 unsigned int node, unsigned int label) 2489 { 2490 /* If the address version of this variable is unused, we can 2491 substitute it for anything else with the same label. 2492 Otherwise, we know the pointers are equivalent, but not the 2493 locations, and we can unite them later. */ 2494 2495 if (!bitmap_bit_p (graph->address_taken, node)) 2496 { 2497 gcc_checking_assert (label < graph->size); 2498 2499 if (graph->eq_rep[label] != -1) 2500 { 2501 /* Unify the two variables since we know they are equivalent. */ 2502 if (unite (graph->eq_rep[label], node)) 2503 unify_nodes (graph, graph->eq_rep[label], node, false); 2504 return graph->eq_rep[label]; 2505 } 2506 else 2507 { 2508 graph->eq_rep[label] = node; 2509 graph->pe_rep[label] = node; 2510 } 2511 } 2512 else 2513 { 2514 gcc_checking_assert (label < graph->size); 2515 graph->pe[node] = label; 2516 if (graph->pe_rep[label] == -1) 2517 graph->pe_rep[label] = node; 2518 } 2519 2520 return node; 2521 } 2522 2523 /* Unite pointer equivalent but not location equivalent nodes in 2524 GRAPH. This may only be performed once variable substitution is 2525 finished. */ 2526 2527 static void 2528 unite_pointer_equivalences (constraint_graph_t graph) 2529 { 2530 unsigned int i; 2531 2532 /* Go through the pointer equivalences and unite them to their 2533 representative, if they aren't already. */ 2534 for (i = 1; i < FIRST_REF_NODE; i++) 2535 { 2536 unsigned int label = graph->pe[i]; 2537 if (label) 2538 { 2539 int label_rep = graph->pe_rep[label]; 2540 2541 if (label_rep == -1) 2542 continue; 2543 2544 label_rep = find (label_rep); 2545 if (label_rep >= 0 && unite (label_rep, find (i))) 2546 unify_nodes (graph, label_rep, i, false); 2547 } 2548 } 2549 } 2550 2551 /* Move complex constraints to the GRAPH nodes they belong to. */ 2552 2553 static void 2554 move_complex_constraints (constraint_graph_t graph) 2555 { 2556 int i; 2557 constraint_t c; 2558 2559 FOR_EACH_VEC_ELT (constraints, i, c) 2560 { 2561 if (c) 2562 { 2563 struct constraint_expr lhs = c->lhs; 2564 struct constraint_expr rhs = c->rhs; 2565 2566 if (lhs.type == DEREF) 2567 { 2568 insert_into_complex (graph, lhs.var, c); 2569 } 2570 else if (rhs.type == DEREF) 2571 { 2572 if (!(get_varinfo (lhs.var)->is_special_var)) 2573 insert_into_complex (graph, rhs.var, c); 2574 } 2575 else if (rhs.type != ADDRESSOF && lhs.var > anything_id 2576 && (lhs.offset != 0 || rhs.offset != 0)) 2577 { 2578 insert_into_complex (graph, rhs.var, c); 2579 } 2580 } 2581 } 2582 } 2583 2584 2585 /* Optimize and rewrite complex constraints while performing 2586 collapsing of equivalent nodes. SI is the SCC_INFO that is the 2587 result of perform_variable_substitution. */ 2588 2589 static void 2590 rewrite_constraints (constraint_graph_t graph, 2591 class scc_info *si) 2592 { 2593 int i; 2594 constraint_t c; 2595 2596 if (flag_checking) 2597 { 2598 for (unsigned int j = 0; j < graph->size; j++) 2599 gcc_assert (find (j) == j); 2600 } 2601 2602 FOR_EACH_VEC_ELT (constraints, i, c) 2603 { 2604 struct constraint_expr lhs = c->lhs; 2605 struct constraint_expr rhs = c->rhs; 2606 unsigned int lhsvar = find (lhs.var); 2607 unsigned int rhsvar = find (rhs.var); 2608 unsigned int lhsnode, rhsnode; 2609 unsigned int lhslabel, rhslabel; 2610 2611 lhsnode = si->node_mapping[lhsvar]; 2612 rhsnode = si->node_mapping[rhsvar]; 2613 lhslabel = graph->pointer_label[lhsnode]; 2614 rhslabel = graph->pointer_label[rhsnode]; 2615 2616 /* See if it is really a non-pointer variable, and if so, ignore 2617 the constraint. */ 2618 if (lhslabel == 0) 2619 { 2620 if (dump_file && (dump_flags & TDF_DETAILS)) 2621 { 2622 2623 fprintf (dump_file, "%s is a non-pointer variable, " 2624 "ignoring constraint:", 2625 get_varinfo (lhs.var)->name); 2626 dump_constraint (dump_file, c); 2627 fprintf (dump_file, "\n"); 2628 } 2629 constraints[i] = NULL; 2630 continue; 2631 } 2632 2633 if (rhslabel == 0) 2634 { 2635 if (dump_file && (dump_flags & TDF_DETAILS)) 2636 { 2637 2638 fprintf (dump_file, "%s is a non-pointer variable, " 2639 "ignoring constraint:", 2640 get_varinfo (rhs.var)->name); 2641 dump_constraint (dump_file, c); 2642 fprintf (dump_file, "\n"); 2643 } 2644 constraints[i] = NULL; 2645 continue; 2646 } 2647 2648 lhsvar = find_equivalent_node (graph, lhsvar, lhslabel); 2649 rhsvar = find_equivalent_node (graph, rhsvar, rhslabel); 2650 c->lhs.var = lhsvar; 2651 c->rhs.var = rhsvar; 2652 } 2653 } 2654 2655 /* Eliminate indirect cycles involving NODE. Return true if NODE was 2656 part of an SCC, false otherwise. */ 2657 2658 static bool 2659 eliminate_indirect_cycles (unsigned int node) 2660 { 2661 if (graph->indirect_cycles[node] != -1 2662 && !bitmap_empty_p (get_varinfo (node)->solution)) 2663 { 2664 unsigned int i; 2665 auto_vec<unsigned> queue; 2666 int queuepos; 2667 unsigned int to = find (graph->indirect_cycles[node]); 2668 bitmap_iterator bi; 2669 2670 /* We can't touch the solution set and call unify_nodes 2671 at the same time, because unify_nodes is going to do 2672 bitmap unions into it. */ 2673 2674 EXECUTE_IF_SET_IN_BITMAP (get_varinfo (node)->solution, 0, i, bi) 2675 { 2676 if (find (i) == i && i != to) 2677 { 2678 if (unite (to, i)) 2679 queue.safe_push (i); 2680 } 2681 } 2682 2683 for (queuepos = 0; 2684 queue.iterate (queuepos, &i); 2685 queuepos++) 2686 { 2687 unify_nodes (graph, to, i, true); 2688 } 2689 return true; 2690 } 2691 return false; 2692 } 2693 2694 /* Solve the constraint graph GRAPH using our worklist solver. 2695 This is based on the PW* family of solvers from the "Efficient Field 2696 Sensitive Pointer Analysis for C" paper. 2697 It works by iterating over all the graph nodes, processing the complex 2698 constraints and propagating the copy constraints, until everything stops 2699 changed. This corresponds to steps 6-8 in the solving list given above. */ 2700 2701 static void 2702 solve_graph (constraint_graph_t graph) 2703 { 2704 unsigned int size = graph->size; 2705 unsigned int i; 2706 bitmap pts; 2707 2708 changed = BITMAP_ALLOC (NULL); 2709 2710 /* Mark all initial non-collapsed nodes as changed. */ 2711 for (i = 1; i < size; i++) 2712 { 2713 varinfo_t ivi = get_varinfo (i); 2714 if (find (i) == i && !bitmap_empty_p (ivi->solution) 2715 && ((graph->succs[i] && !bitmap_empty_p (graph->succs[i])) 2716 || graph->complex[i].length () > 0)) 2717 bitmap_set_bit (changed, i); 2718 } 2719 2720 /* Allocate a bitmap to be used to store the changed bits. */ 2721 pts = BITMAP_ALLOC (&pta_obstack); 2722 2723 while (!bitmap_empty_p (changed)) 2724 { 2725 unsigned int i; 2726 struct topo_info *ti = init_topo_info (); 2727 stats.iterations++; 2728 2729 bitmap_obstack_initialize (&iteration_obstack); 2730 2731 compute_topo_order (graph, ti); 2732 2733 while (ti->topo_order.length () != 0) 2734 { 2735 2736 i = ti->topo_order.pop (); 2737 2738 /* If this variable is not a representative, skip it. */ 2739 if (find (i) != i) 2740 continue; 2741 2742 /* In certain indirect cycle cases, we may merge this 2743 variable to another. */ 2744 if (eliminate_indirect_cycles (i) && find (i) != i) 2745 continue; 2746 2747 /* If the node has changed, we need to process the 2748 complex constraints and outgoing edges again. */ 2749 if (bitmap_clear_bit (changed, i)) 2750 { 2751 unsigned int j; 2752 constraint_t c; 2753 bitmap solution; 2754 vec<constraint_t> complex = graph->complex[i]; 2755 varinfo_t vi = get_varinfo (i); 2756 bool solution_empty; 2757 2758 /* Compute the changed set of solution bits. If anything 2759 is in the solution just propagate that. */ 2760 if (bitmap_bit_p (vi->solution, anything_id)) 2761 { 2762 /* If anything is also in the old solution there is 2763 nothing to do. 2764 ??? But we shouldn't ended up with "changed" set ... */ 2765 if (vi->oldsolution 2766 && bitmap_bit_p (vi->oldsolution, anything_id)) 2767 continue; 2768 bitmap_copy (pts, get_varinfo (find (anything_id))->solution); 2769 } 2770 else if (vi->oldsolution) 2771 bitmap_and_compl (pts, vi->solution, vi->oldsolution); 2772 else 2773 bitmap_copy (pts, vi->solution); 2774 2775 if (bitmap_empty_p (pts)) 2776 continue; 2777 2778 if (vi->oldsolution) 2779 bitmap_ior_into (vi->oldsolution, pts); 2780 else 2781 { 2782 vi->oldsolution = BITMAP_ALLOC (&oldpta_obstack); 2783 bitmap_copy (vi->oldsolution, pts); 2784 } 2785 2786 solution = vi->solution; 2787 solution_empty = bitmap_empty_p (solution); 2788 2789 /* Process the complex constraints */ 2790 bitmap expanded_pts = NULL; 2791 FOR_EACH_VEC_ELT (complex, j, c) 2792 { 2793 /* XXX: This is going to unsort the constraints in 2794 some cases, which will occasionally add duplicate 2795 constraints during unification. This does not 2796 affect correctness. */ 2797 c->lhs.var = find (c->lhs.var); 2798 c->rhs.var = find (c->rhs.var); 2799 2800 /* The only complex constraint that can change our 2801 solution to non-empty, given an empty solution, 2802 is a constraint where the lhs side is receiving 2803 some set from elsewhere. */ 2804 if (!solution_empty || c->lhs.type != DEREF) 2805 do_complex_constraint (graph, c, pts, &expanded_pts); 2806 } 2807 BITMAP_FREE (expanded_pts); 2808 2809 solution_empty = bitmap_empty_p (solution); 2810 2811 if (!solution_empty) 2812 { 2813 bitmap_iterator bi; 2814 unsigned eff_escaped_id = find (escaped_id); 2815 2816 /* Propagate solution to all successors. */ 2817 unsigned to_remove = ~0U; 2818 EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[i], 2819 0, j, bi) 2820 { 2821 if (to_remove != ~0U) 2822 { 2823 bitmap_clear_bit (graph->succs[i], to_remove); 2824 to_remove = ~0U; 2825 } 2826 unsigned int to = find (j); 2827 if (to != j) 2828 { 2829 /* Update the succ graph, avoiding duplicate 2830 work. */ 2831 to_remove = j; 2832 if (! bitmap_set_bit (graph->succs[i], to)) 2833 continue; 2834 /* We eventually end up processing 'to' twice 2835 as it is undefined whether bitmap iteration 2836 iterates over bits set during iteration. 2837 Play safe instead of doing tricks. */ 2838 } 2839 /* Don't try to propagate to ourselves. */ 2840 if (to == i) 2841 continue; 2842 2843 bitmap tmp = get_varinfo (to)->solution; 2844 bool flag = false; 2845 2846 /* If we propagate from ESCAPED use ESCAPED as 2847 placeholder. */ 2848 if (i == eff_escaped_id) 2849 flag = bitmap_set_bit (tmp, escaped_id); 2850 else 2851 flag = bitmap_ior_into (tmp, pts); 2852 2853 if (flag) 2854 bitmap_set_bit (changed, to); 2855 } 2856 if (to_remove != ~0U) 2857 bitmap_clear_bit (graph->succs[i], to_remove); 2858 } 2859 } 2860 } 2861 free_topo_info (ti); 2862 bitmap_obstack_release (&iteration_obstack); 2863 } 2864 2865 BITMAP_FREE (pts); 2866 BITMAP_FREE (changed); 2867 bitmap_obstack_release (&oldpta_obstack); 2868 } 2869 2870 /* Map from trees to variable infos. */ 2871 static hash_map<tree, varinfo_t> *vi_for_tree; 2872 2873 2874 /* Insert ID as the variable id for tree T in the vi_for_tree map. */ 2875 2876 static void 2877 insert_vi_for_tree (tree t, varinfo_t vi) 2878 { 2879 gcc_assert (vi); 2880 gcc_assert (!vi_for_tree->put (t, vi)); 2881 } 2882 2883 /* Find the variable info for tree T in VI_FOR_TREE. If T does not 2884 exist in the map, return NULL, otherwise, return the varinfo we found. */ 2885 2886 static varinfo_t 2887 lookup_vi_for_tree (tree t) 2888 { 2889 varinfo_t *slot = vi_for_tree->get (t); 2890 if (slot == NULL) 2891 return NULL; 2892 2893 return *slot; 2894 } 2895 2896 /* Return a printable name for DECL */ 2897 2898 static const char * 2899 alias_get_name (tree decl) 2900 { 2901 const char *res = "NULL"; 2902 if (dump_file) 2903 { 2904 char *temp = NULL; 2905 if (TREE_CODE (decl) == SSA_NAME) 2906 { 2907 res = get_name (decl); 2908 temp = xasprintf ("%s_%u", res ? res : "", SSA_NAME_VERSION (decl)); 2909 } 2910 else if (HAS_DECL_ASSEMBLER_NAME_P (decl) 2911 && DECL_ASSEMBLER_NAME_SET_P (decl)) 2912 res = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME_RAW (decl)); 2913 else if (DECL_P (decl)) 2914 { 2915 res = get_name (decl); 2916 if (!res) 2917 temp = xasprintf ("D.%u", DECL_UID (decl)); 2918 } 2919 2920 if (temp) 2921 { 2922 res = ggc_strdup (temp); 2923 free (temp); 2924 } 2925 } 2926 2927 return res; 2928 } 2929 2930 /* Find the variable id for tree T in the map. 2931 If T doesn't exist in the map, create an entry for it and return it. */ 2932 2933 static varinfo_t 2934 get_vi_for_tree (tree t) 2935 { 2936 varinfo_t *slot = vi_for_tree->get (t); 2937 if (slot == NULL) 2938 { 2939 unsigned int id = create_variable_info_for (t, alias_get_name (t), false); 2940 return get_varinfo (id); 2941 } 2942 2943 return *slot; 2944 } 2945 2946 /* Get a scalar constraint expression for a new temporary variable. */ 2947 2948 static struct constraint_expr 2949 new_scalar_tmp_constraint_exp (const char *name, bool add_id) 2950 { 2951 struct constraint_expr tmp; 2952 varinfo_t vi; 2953 2954 vi = new_var_info (NULL_TREE, name, add_id); 2955 vi->offset = 0; 2956 vi->size = -1; 2957 vi->fullsize = -1; 2958 vi->is_full_var = 1; 2959 vi->is_reg_var = 1; 2960 2961 tmp.var = vi->id; 2962 tmp.type = SCALAR; 2963 tmp.offset = 0; 2964 2965 return tmp; 2966 } 2967 2968 /* Get a constraint expression vector from an SSA_VAR_P node. 2969 If address_p is true, the result will be taken its address of. */ 2970 2971 static void 2972 get_constraint_for_ssa_var (tree t, vec<ce_s> *results, bool address_p) 2973 { 2974 struct constraint_expr cexpr; 2975 varinfo_t vi; 2976 2977 /* We allow FUNCTION_DECLs here even though it doesn't make much sense. */ 2978 gcc_assert (TREE_CODE (t) == SSA_NAME || DECL_P (t)); 2979 2980 if (TREE_CODE (t) == SSA_NAME 2981 && SSA_NAME_IS_DEFAULT_DEF (t)) 2982 { 2983 /* For parameters, get at the points-to set for the actual parm 2984 decl. */ 2985 if (TREE_CODE (SSA_NAME_VAR (t)) == PARM_DECL 2986 || TREE_CODE (SSA_NAME_VAR (t)) == RESULT_DECL) 2987 { 2988 get_constraint_for_ssa_var (SSA_NAME_VAR (t), results, address_p); 2989 return; 2990 } 2991 /* For undefined SSA names return nothing. */ 2992 else if (!ssa_defined_default_def_p (t)) 2993 { 2994 cexpr.var = nothing_id; 2995 cexpr.type = SCALAR; 2996 cexpr.offset = 0; 2997 results->safe_push (cexpr); 2998 return; 2999 } 3000 } 3001 3002 /* For global variables resort to the alias target. */ 3003 if (VAR_P (t) && (TREE_STATIC (t) || DECL_EXTERNAL (t))) 3004 { 3005 varpool_node *node = varpool_node::get (t); 3006 if (node && node->alias && node->analyzed) 3007 { 3008 node = node->ultimate_alias_target (); 3009 /* Canonicalize the PT uid of all aliases to the ultimate target. 3010 ??? Hopefully the set of aliases can't change in a way that 3011 changes the ultimate alias target. */ 3012 gcc_assert ((! DECL_PT_UID_SET_P (node->decl) 3013 || DECL_PT_UID (node->decl) == DECL_UID (node->decl)) 3014 && (! DECL_PT_UID_SET_P (t) 3015 || DECL_PT_UID (t) == DECL_UID (node->decl))); 3016 DECL_PT_UID (t) = DECL_UID (node->decl); 3017 t = node->decl; 3018 } 3019 3020 /* If this is decl may bind to NULL note that. */ 3021 if (address_p 3022 && (! node || ! node->nonzero_address ())) 3023 { 3024 cexpr.var = nothing_id; 3025 cexpr.type = SCALAR; 3026 cexpr.offset = 0; 3027 results->safe_push (cexpr); 3028 } 3029 } 3030 3031 vi = get_vi_for_tree (t); 3032 cexpr.var = vi->id; 3033 cexpr.type = SCALAR; 3034 cexpr.offset = 0; 3035 3036 /* If we are not taking the address of the constraint expr, add all 3037 sub-fiels of the variable as well. */ 3038 if (!address_p 3039 && !vi->is_full_var) 3040 { 3041 for (; vi; vi = vi_next (vi)) 3042 { 3043 cexpr.var = vi->id; 3044 results->safe_push (cexpr); 3045 } 3046 return; 3047 } 3048 3049 results->safe_push (cexpr); 3050 } 3051 3052 /* Process constraint T, performing various simplifications and then 3053 adding it to our list of overall constraints. */ 3054 3055 static void 3056 process_constraint (constraint_t t) 3057 { 3058 struct constraint_expr rhs = t->rhs; 3059 struct constraint_expr lhs = t->lhs; 3060 3061 gcc_assert (rhs.var < varmap.length ()); 3062 gcc_assert (lhs.var < varmap.length ()); 3063 3064 /* If we didn't get any useful constraint from the lhs we get 3065 &ANYTHING as fallback from get_constraint_for. Deal with 3066 it here by turning it into *ANYTHING. */ 3067 if (lhs.type == ADDRESSOF 3068 && lhs.var == anything_id) 3069 lhs.type = DEREF; 3070 3071 /* ADDRESSOF on the lhs is invalid. */ 3072 gcc_assert (lhs.type != ADDRESSOF); 3073 3074 /* We shouldn't add constraints from things that cannot have pointers. 3075 It's not completely trivial to avoid in the callers, so do it here. */ 3076 if (rhs.type != ADDRESSOF 3077 && !get_varinfo (rhs.var)->may_have_pointers) 3078 return; 3079 3080 /* Likewise adding to the solution of a non-pointer var isn't useful. */ 3081 if (!get_varinfo (lhs.var)->may_have_pointers) 3082 return; 3083 3084 /* This can happen in our IR with things like n->a = *p */ 3085 if (rhs.type == DEREF && lhs.type == DEREF && rhs.var != anything_id) 3086 { 3087 /* Split into tmp = *rhs, *lhs = tmp */ 3088 struct constraint_expr tmplhs; 3089 tmplhs = new_scalar_tmp_constraint_exp ("doubledereftmp", true); 3090 process_constraint (new_constraint (tmplhs, rhs)); 3091 process_constraint (new_constraint (lhs, tmplhs)); 3092 } 3093 else if ((rhs.type != SCALAR || rhs.offset != 0) && lhs.type == DEREF) 3094 { 3095 /* Split into tmp = &rhs, *lhs = tmp */ 3096 struct constraint_expr tmplhs; 3097 tmplhs = new_scalar_tmp_constraint_exp ("derefaddrtmp", true); 3098 process_constraint (new_constraint (tmplhs, rhs)); 3099 process_constraint (new_constraint (lhs, tmplhs)); 3100 } 3101 else 3102 { 3103 gcc_assert (rhs.type != ADDRESSOF || rhs.offset == 0); 3104 constraints.safe_push (t); 3105 } 3106 } 3107 3108 3109 /* Return the position, in bits, of FIELD_DECL from the beginning of its 3110 structure. */ 3111 3112 static HOST_WIDE_INT 3113 bitpos_of_field (const tree fdecl) 3114 { 3115 if (!tree_fits_shwi_p (DECL_FIELD_OFFSET (fdecl)) 3116 || !tree_fits_shwi_p (DECL_FIELD_BIT_OFFSET (fdecl))) 3117 return -1; 3118 3119 return (tree_to_shwi (DECL_FIELD_OFFSET (fdecl)) * BITS_PER_UNIT 3120 + tree_to_shwi (DECL_FIELD_BIT_OFFSET (fdecl))); 3121 } 3122 3123 3124 /* Get constraint expressions for offsetting PTR by OFFSET. Stores the 3125 resulting constraint expressions in *RESULTS. */ 3126 3127 static void 3128 get_constraint_for_ptr_offset (tree ptr, tree offset, 3129 vec<ce_s> *results) 3130 { 3131 struct constraint_expr c; 3132 unsigned int j, n; 3133 HOST_WIDE_INT rhsoffset; 3134 3135 /* If we do not do field-sensitive PTA adding offsets to pointers 3136 does not change the points-to solution. */ 3137 if (!use_field_sensitive) 3138 { 3139 get_constraint_for_rhs (ptr, results); 3140 return; 3141 } 3142 3143 /* If the offset is not a non-negative integer constant that fits 3144 in a HOST_WIDE_INT, we have to fall back to a conservative 3145 solution which includes all sub-fields of all pointed-to 3146 variables of ptr. */ 3147 if (offset == NULL_TREE 3148 || TREE_CODE (offset) != INTEGER_CST) 3149 rhsoffset = UNKNOWN_OFFSET; 3150 else 3151 { 3152 /* Sign-extend the offset. */ 3153 offset_int soffset = offset_int::from (wi::to_wide (offset), SIGNED); 3154 if (!wi::fits_shwi_p (soffset)) 3155 rhsoffset = UNKNOWN_OFFSET; 3156 else 3157 { 3158 /* Make sure the bit-offset also fits. */ 3159 HOST_WIDE_INT rhsunitoffset = soffset.to_shwi (); 3160 rhsoffset = rhsunitoffset * (unsigned HOST_WIDE_INT) BITS_PER_UNIT; 3161 if (rhsunitoffset != rhsoffset / BITS_PER_UNIT) 3162 rhsoffset = UNKNOWN_OFFSET; 3163 } 3164 } 3165 3166 get_constraint_for_rhs (ptr, results); 3167 if (rhsoffset == 0) 3168 return; 3169 3170 /* As we are eventually appending to the solution do not use 3171 vec::iterate here. */ 3172 n = results->length (); 3173 for (j = 0; j < n; j++) 3174 { 3175 varinfo_t curr; 3176 c = (*results)[j]; 3177 curr = get_varinfo (c.var); 3178 3179 if (c.type == ADDRESSOF 3180 /* If this varinfo represents a full variable just use it. */ 3181 && curr->is_full_var) 3182 ; 3183 else if (c.type == ADDRESSOF 3184 /* If we do not know the offset add all subfields. */ 3185 && rhsoffset == UNKNOWN_OFFSET) 3186 { 3187 varinfo_t temp = get_varinfo (curr->head); 3188 do 3189 { 3190 struct constraint_expr c2; 3191 c2.var = temp->id; 3192 c2.type = ADDRESSOF; 3193 c2.offset = 0; 3194 if (c2.var != c.var) 3195 results->safe_push (c2); 3196 temp = vi_next (temp); 3197 } 3198 while (temp); 3199 } 3200 else if (c.type == ADDRESSOF) 3201 { 3202 varinfo_t temp; 3203 unsigned HOST_WIDE_INT offset = curr->offset + rhsoffset; 3204 3205 /* If curr->offset + rhsoffset is less than zero adjust it. */ 3206 if (rhsoffset < 0 3207 && curr->offset < offset) 3208 offset = 0; 3209 3210 /* We have to include all fields that overlap the current 3211 field shifted by rhsoffset. And we include at least 3212 the last or the first field of the variable to represent 3213 reachability of off-bound addresses, in particular &object + 1, 3214 conservatively correct. */ 3215 temp = first_or_preceding_vi_for_offset (curr, offset); 3216 c.var = temp->id; 3217 c.offset = 0; 3218 temp = vi_next (temp); 3219 while (temp 3220 && temp->offset < offset + curr->size) 3221 { 3222 struct constraint_expr c2; 3223 c2.var = temp->id; 3224 c2.type = ADDRESSOF; 3225 c2.offset = 0; 3226 results->safe_push (c2); 3227 temp = vi_next (temp); 3228 } 3229 } 3230 else if (c.type == SCALAR) 3231 { 3232 gcc_assert (c.offset == 0); 3233 c.offset = rhsoffset; 3234 } 3235 else 3236 /* We shouldn't get any DEREFs here. */ 3237 gcc_unreachable (); 3238 3239 (*results)[j] = c; 3240 } 3241 } 3242 3243 3244 /* Given a COMPONENT_REF T, return the constraint_expr vector for it. 3245 If address_p is true the result will be taken its address of. 3246 If lhs_p is true then the constraint expression is assumed to be used 3247 as the lhs. */ 3248 3249 static void 3250 get_constraint_for_component_ref (tree t, vec<ce_s> *results, 3251 bool address_p, bool lhs_p) 3252 { 3253 tree orig_t = t; 3254 poly_int64 bitsize = -1; 3255 poly_int64 bitmaxsize = -1; 3256 poly_int64 bitpos; 3257 bool reverse; 3258 tree forzero; 3259 3260 /* Some people like to do cute things like take the address of 3261 &0->a.b */ 3262 forzero = t; 3263 while (handled_component_p (forzero) 3264 || INDIRECT_REF_P (forzero) 3265 || TREE_CODE (forzero) == MEM_REF) 3266 forzero = TREE_OPERAND (forzero, 0); 3267 3268 if (CONSTANT_CLASS_P (forzero) && integer_zerop (forzero)) 3269 { 3270 struct constraint_expr temp; 3271 3272 temp.offset = 0; 3273 temp.var = integer_id; 3274 temp.type = SCALAR; 3275 results->safe_push (temp); 3276 return; 3277 } 3278 3279 t = get_ref_base_and_extent (t, &bitpos, &bitsize, &bitmaxsize, &reverse); 3280 3281 /* We can end up here for component references on a 3282 VIEW_CONVERT_EXPR <>(&foobar) or things like a 3283 BIT_FIELD_REF <&MEM[(void *)&b + 4B], ...>. So for 3284 symbolic constants simply give up. */ 3285 if (TREE_CODE (t) == ADDR_EXPR) 3286 { 3287 constraint_expr result; 3288 result.type = SCALAR; 3289 result.var = anything_id; 3290 result.offset = 0; 3291 results->safe_push (result); 3292 return; 3293 } 3294 3295 /* Avoid creating pointer-offset constraints, so handle MEM_REF 3296 offsets directly. Pretend to take the address of the base, 3297 we'll take care of adding the required subset of sub-fields below. */ 3298 if (TREE_CODE (t) == MEM_REF 3299 && !integer_zerop (TREE_OPERAND (t, 0))) 3300 { 3301 poly_offset_int off = mem_ref_offset (t); 3302 off <<= LOG2_BITS_PER_UNIT; 3303 off += bitpos; 3304 poly_int64 off_hwi; 3305 if (off.to_shwi (&off_hwi)) 3306 bitpos = off_hwi; 3307 else 3308 { 3309 bitpos = 0; 3310 bitmaxsize = -1; 3311 } 3312 get_constraint_for_1 (TREE_OPERAND (t, 0), results, false, lhs_p); 3313 do_deref (results); 3314 } 3315 else 3316 get_constraint_for_1 (t, results, true, lhs_p); 3317 3318 /* Strip off nothing_id. */ 3319 if (results->length () == 2) 3320 { 3321 gcc_assert ((*results)[0].var == nothing_id); 3322 results->unordered_remove (0); 3323 } 3324 gcc_assert (results->length () == 1); 3325 struct constraint_expr &result = results->last (); 3326 3327 if (result.type == SCALAR 3328 && get_varinfo (result.var)->is_full_var) 3329 /* For single-field vars do not bother about the offset. */ 3330 result.offset = 0; 3331 else if (result.type == SCALAR) 3332 { 3333 /* In languages like C, you can access one past the end of an 3334 array. You aren't allowed to dereference it, so we can 3335 ignore this constraint. When we handle pointer subtraction, 3336 we may have to do something cute here. */ 3337 3338 if (maybe_lt (poly_uint64 (bitpos), get_varinfo (result.var)->fullsize) 3339 && maybe_ne (bitmaxsize, 0)) 3340 { 3341 /* It's also not true that the constraint will actually start at the 3342 right offset, it may start in some padding. We only care about 3343 setting the constraint to the first actual field it touches, so 3344 walk to find it. */ 3345 struct constraint_expr cexpr = result; 3346 varinfo_t curr; 3347 results->pop (); 3348 cexpr.offset = 0; 3349 for (curr = get_varinfo (cexpr.var); curr; curr = vi_next (curr)) 3350 { 3351 if (ranges_maybe_overlap_p (poly_int64 (curr->offset), 3352 curr->size, bitpos, bitmaxsize)) 3353 { 3354 cexpr.var = curr->id; 3355 results->safe_push (cexpr); 3356 if (address_p) 3357 break; 3358 } 3359 } 3360 /* If we are going to take the address of this field then 3361 to be able to compute reachability correctly add at least 3362 the last field of the variable. */ 3363 if (address_p && results->length () == 0) 3364 { 3365 curr = get_varinfo (cexpr.var); 3366 while (curr->next != 0) 3367 curr = vi_next (curr); 3368 cexpr.var = curr->id; 3369 results->safe_push (cexpr); 3370 } 3371 else if (results->length () == 0) 3372 /* Assert that we found *some* field there. The user couldn't be 3373 accessing *only* padding. */ 3374 /* Still the user could access one past the end of an array 3375 embedded in a struct resulting in accessing *only* padding. */ 3376 /* Or accessing only padding via type-punning to a type 3377 that has a filed just in padding space. */ 3378 { 3379 cexpr.type = SCALAR; 3380 cexpr.var = anything_id; 3381 cexpr.offset = 0; 3382 results->safe_push (cexpr); 3383 } 3384 } 3385 else if (known_eq (bitmaxsize, 0)) 3386 { 3387 if (dump_file && (dump_flags & TDF_DETAILS)) 3388 fprintf (dump_file, "Access to zero-sized part of variable, " 3389 "ignoring\n"); 3390 } 3391 else 3392 if (dump_file && (dump_flags & TDF_DETAILS)) 3393 fprintf (dump_file, "Access to past the end of variable, ignoring\n"); 3394 } 3395 else if (result.type == DEREF) 3396 { 3397 /* If we do not know exactly where the access goes say so. Note 3398 that only for non-structure accesses we know that we access 3399 at most one subfiled of any variable. */ 3400 HOST_WIDE_INT const_bitpos; 3401 if (!bitpos.is_constant (&const_bitpos) 3402 || const_bitpos == -1 3403 || maybe_ne (bitsize, bitmaxsize) 3404 || AGGREGATE_TYPE_P (TREE_TYPE (orig_t)) 3405 || result.offset == UNKNOWN_OFFSET) 3406 result.offset = UNKNOWN_OFFSET; 3407 else 3408 result.offset += const_bitpos; 3409 } 3410 else if (result.type == ADDRESSOF) 3411 { 3412 /* We can end up here for component references on constants like 3413 VIEW_CONVERT_EXPR <>({ 0, 1, 2, 3 })[i]. */ 3414 result.type = SCALAR; 3415 result.var = anything_id; 3416 result.offset = 0; 3417 } 3418 else 3419 gcc_unreachable (); 3420 } 3421 3422 3423 /* Dereference the constraint expression CONS, and return the result. 3424 DEREF (ADDRESSOF) = SCALAR 3425 DEREF (SCALAR) = DEREF 3426 DEREF (DEREF) = (temp = DEREF1; result = DEREF(temp)) 3427 This is needed so that we can handle dereferencing DEREF constraints. */ 3428 3429 static void 3430 do_deref (vec<ce_s> *constraints) 3431 { 3432 struct constraint_expr *c; 3433 unsigned int i = 0; 3434 3435 FOR_EACH_VEC_ELT (*constraints, i, c) 3436 { 3437 if (c->type == SCALAR) 3438 c->type = DEREF; 3439 else if (c->type == ADDRESSOF) 3440 c->type = SCALAR; 3441 else if (c->type == DEREF) 3442 { 3443 struct constraint_expr tmplhs; 3444 tmplhs = new_scalar_tmp_constraint_exp ("dereftmp", true); 3445 process_constraint (new_constraint (tmplhs, *c)); 3446 c->var = tmplhs.var; 3447 } 3448 else 3449 gcc_unreachable (); 3450 } 3451 } 3452 3453 /* Given a tree T, return the constraint expression for taking the 3454 address of it. */ 3455 3456 static void 3457 get_constraint_for_address_of (tree t, vec<ce_s> *results) 3458 { 3459 struct constraint_expr *c; 3460 unsigned int i; 3461 3462 get_constraint_for_1 (t, results, true, true); 3463 3464 FOR_EACH_VEC_ELT (*results, i, c) 3465 { 3466 if (c->type == DEREF) 3467 c->type = SCALAR; 3468 else 3469 c->type = ADDRESSOF; 3470 } 3471 } 3472 3473 /* Given a tree T, return the constraint expression for it. */ 3474 3475 static void 3476 get_constraint_for_1 (tree t, vec<ce_s> *results, bool address_p, 3477 bool lhs_p) 3478 { 3479 struct constraint_expr temp; 3480 3481 /* x = integer is all glommed to a single variable, which doesn't 3482 point to anything by itself. That is, of course, unless it is an 3483 integer constant being treated as a pointer, in which case, we 3484 will return that this is really the addressof anything. This 3485 happens below, since it will fall into the default case. The only 3486 case we know something about an integer treated like a pointer is 3487 when it is the NULL pointer, and then we just say it points to 3488 NULL. 3489 3490 Do not do that if -fno-delete-null-pointer-checks though, because 3491 in that case *NULL does not fail, so it _should_ alias *anything. 3492 It is not worth adding a new option or renaming the existing one, 3493 since this case is relatively obscure. */ 3494 if ((TREE_CODE (t) == INTEGER_CST 3495 && integer_zerop (t)) 3496 /* The only valid CONSTRUCTORs in gimple with pointer typed 3497 elements are zero-initializer. But in IPA mode we also 3498 process global initializers, so verify at least. */ 3499 || (TREE_CODE (t) == CONSTRUCTOR 3500 && CONSTRUCTOR_NELTS (t) == 0)) 3501 { 3502 if (flag_delete_null_pointer_checks) 3503 temp.var = nothing_id; 3504 else 3505 temp.var = nonlocal_id; 3506 temp.type = ADDRESSOF; 3507 temp.offset = 0; 3508 results->safe_push (temp); 3509 return; 3510 } 3511 3512 /* String constants are read-only, ideally we'd have a CONST_DECL 3513 for those. */ 3514 if (TREE_CODE (t) == STRING_CST) 3515 { 3516 temp.var = string_id; 3517 temp.type = SCALAR; 3518 temp.offset = 0; 3519 results->safe_push (temp); 3520 return; 3521 } 3522 3523 switch (TREE_CODE_CLASS (TREE_CODE (t))) 3524 { 3525 case tcc_expression: 3526 { 3527 switch (TREE_CODE (t)) 3528 { 3529 case ADDR_EXPR: 3530 get_constraint_for_address_of (TREE_OPERAND (t, 0), results); 3531 return; 3532 default:; 3533 } 3534 break; 3535 } 3536 case tcc_reference: 3537 { 3538 switch (TREE_CODE (t)) 3539 { 3540 case MEM_REF: 3541 { 3542 struct constraint_expr cs; 3543 varinfo_t vi, curr; 3544 get_constraint_for_ptr_offset (TREE_OPERAND (t, 0), 3545 TREE_OPERAND (t, 1), results); 3546 do_deref (results); 3547 3548 /* If we are not taking the address then make sure to process 3549 all subvariables we might access. */ 3550 if (address_p) 3551 return; 3552 3553 cs = results->last (); 3554 if (cs.type == DEREF 3555 && type_can_have_subvars (TREE_TYPE (t))) 3556 { 3557 /* For dereferences this means we have to defer it 3558 to solving time. */ 3559 results->last ().offset = UNKNOWN_OFFSET; 3560 return; 3561 } 3562 if (cs.type != SCALAR) 3563 return; 3564 3565 vi = get_varinfo (cs.var); 3566 curr = vi_next (vi); 3567 if (!vi->is_full_var 3568 && curr) 3569 { 3570 unsigned HOST_WIDE_INT size; 3571 if (tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (t)))) 3572 size = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (t))); 3573 else 3574 size = -1; 3575 for (; curr; curr = vi_next (curr)) 3576 { 3577 if (curr->offset - vi->offset < size) 3578 { 3579 cs.var = curr->id; 3580 results->safe_push (cs); 3581 } 3582 else 3583 break; 3584 } 3585 } 3586 return; 3587 } 3588 case ARRAY_REF: 3589 case ARRAY_RANGE_REF: 3590 case COMPONENT_REF: 3591 case IMAGPART_EXPR: 3592 case REALPART_EXPR: 3593 case BIT_FIELD_REF: 3594 get_constraint_for_component_ref (t, results, address_p, lhs_p); 3595 return; 3596 case VIEW_CONVERT_EXPR: 3597 get_constraint_for_1 (TREE_OPERAND (t, 0), results, address_p, 3598 lhs_p); 3599 return; 3600 /* We are missing handling for TARGET_MEM_REF here. */ 3601 default:; 3602 } 3603 break; 3604 } 3605 case tcc_exceptional: 3606 { 3607 switch (TREE_CODE (t)) 3608 { 3609 case SSA_NAME: 3610 { 3611 get_constraint_for_ssa_var (t, results, address_p); 3612 return; 3613 } 3614 case CONSTRUCTOR: 3615 { 3616 unsigned int i; 3617 tree val; 3618 auto_vec<ce_s> tmp; 3619 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), i, val) 3620 { 3621 struct constraint_expr *rhsp; 3622 unsigned j; 3623 get_constraint_for_1 (val, &tmp, address_p, lhs_p); 3624 FOR_EACH_VEC_ELT (tmp, j, rhsp) 3625 results->safe_push (*rhsp); 3626 tmp.truncate (0); 3627 } 3628 /* We do not know whether the constructor was complete, 3629 so technically we have to add &NOTHING or &ANYTHING 3630 like we do for an empty constructor as well. */ 3631 return; 3632 } 3633 default:; 3634 } 3635 break; 3636 } 3637 case tcc_declaration: 3638 { 3639 get_constraint_for_ssa_var (t, results, address_p); 3640 return; 3641 } 3642 case tcc_constant: 3643 { 3644 /* We cannot refer to automatic variables through constants. */ 3645 temp.type = ADDRESSOF; 3646 temp.var = nonlocal_id; 3647 temp.offset = 0; 3648 results->safe_push (temp); 3649 return; 3650 } 3651 default:; 3652 } 3653 3654 /* The default fallback is a constraint from anything. */ 3655 temp.type = ADDRESSOF; 3656 temp.var = anything_id; 3657 temp.offset = 0; 3658 results->safe_push (temp); 3659 } 3660 3661 /* Given a gimple tree T, return the constraint expression vector for it. */ 3662 3663 static void 3664 get_constraint_for (tree t, vec<ce_s> *results) 3665 { 3666 gcc_assert (results->length () == 0); 3667 3668 get_constraint_for_1 (t, results, false, true); 3669 } 3670 3671 /* Given a gimple tree T, return the constraint expression vector for it 3672 to be used as the rhs of a constraint. */ 3673 3674 static void 3675 get_constraint_for_rhs (tree t, vec<ce_s> *results) 3676 { 3677 gcc_assert (results->length () == 0); 3678 3679 get_constraint_for_1 (t, results, false, false); 3680 } 3681 3682 3683 /* Efficiently generates constraints from all entries in *RHSC to all 3684 entries in *LHSC. */ 3685 3686 static void 3687 process_all_all_constraints (vec<ce_s> lhsc, 3688 vec<ce_s> rhsc) 3689 { 3690 struct constraint_expr *lhsp, *rhsp; 3691 unsigned i, j; 3692 3693 if (lhsc.length () <= 1 || rhsc.length () <= 1) 3694 { 3695 FOR_EACH_VEC_ELT (lhsc, i, lhsp) 3696 FOR_EACH_VEC_ELT (rhsc, j, rhsp) 3697 process_constraint (new_constraint (*lhsp, *rhsp)); 3698 } 3699 else 3700 { 3701 struct constraint_expr tmp; 3702 tmp = new_scalar_tmp_constraint_exp ("allalltmp", true); 3703 FOR_EACH_VEC_ELT (rhsc, i, rhsp) 3704 process_constraint (new_constraint (tmp, *rhsp)); 3705 FOR_EACH_VEC_ELT (lhsc, i, lhsp) 3706 process_constraint (new_constraint (*lhsp, tmp)); 3707 } 3708 } 3709 3710 /* Handle aggregate copies by expanding into copies of the respective 3711 fields of the structures. */ 3712 3713 static void 3714 do_structure_copy (tree lhsop, tree rhsop) 3715 { 3716 struct constraint_expr *lhsp, *rhsp; 3717 auto_vec<ce_s> lhsc; 3718 auto_vec<ce_s> rhsc; 3719 unsigned j; 3720 3721 get_constraint_for (lhsop, &lhsc); 3722 get_constraint_for_rhs (rhsop, &rhsc); 3723 lhsp = &lhsc[0]; 3724 rhsp = &rhsc[0]; 3725 if (lhsp->type == DEREF 3726 || (lhsp->type == ADDRESSOF && lhsp->var == anything_id) 3727 || rhsp->type == DEREF) 3728 { 3729 if (lhsp->type == DEREF) 3730 { 3731 gcc_assert (lhsc.length () == 1); 3732 lhsp->offset = UNKNOWN_OFFSET; 3733 } 3734 if (rhsp->type == DEREF) 3735 { 3736 gcc_assert (rhsc.length () == 1); 3737 rhsp->offset = UNKNOWN_OFFSET; 3738 } 3739 process_all_all_constraints (lhsc, rhsc); 3740 } 3741 else if (lhsp->type == SCALAR 3742 && (rhsp->type == SCALAR 3743 || rhsp->type == ADDRESSOF)) 3744 { 3745 HOST_WIDE_INT lhssize, lhsoffset; 3746 HOST_WIDE_INT rhssize, rhsoffset; 3747 bool reverse; 3748 unsigned k = 0; 3749 if (!get_ref_base_and_extent_hwi (lhsop, &lhsoffset, &lhssize, &reverse) 3750 || !get_ref_base_and_extent_hwi (rhsop, &rhsoffset, &rhssize, 3751 &reverse)) 3752 { 3753 process_all_all_constraints (lhsc, rhsc); 3754 return; 3755 } 3756 for (j = 0; lhsc.iterate (j, &lhsp);) 3757 { 3758 varinfo_t lhsv, rhsv; 3759 rhsp = &rhsc[k]; 3760 lhsv = get_varinfo (lhsp->var); 3761 rhsv = get_varinfo (rhsp->var); 3762 if (lhsv->may_have_pointers 3763 && (lhsv->is_full_var 3764 || rhsv->is_full_var 3765 || ranges_overlap_p (lhsv->offset + rhsoffset, lhsv->size, 3766 rhsv->offset + lhsoffset, rhsv->size))) 3767 process_constraint (new_constraint (*lhsp, *rhsp)); 3768 if (!rhsv->is_full_var 3769 && (lhsv->is_full_var 3770 || (lhsv->offset + rhsoffset + lhsv->size 3771 > rhsv->offset + lhsoffset + rhsv->size))) 3772 { 3773 ++k; 3774 if (k >= rhsc.length ()) 3775 break; 3776 } 3777 else 3778 ++j; 3779 } 3780 } 3781 else 3782 gcc_unreachable (); 3783 } 3784 3785 /* Create constraints ID = { rhsc }. */ 3786 3787 static void 3788 make_constraints_to (unsigned id, vec<ce_s> rhsc) 3789 { 3790 struct constraint_expr *c; 3791 struct constraint_expr includes; 3792 unsigned int j; 3793 3794 includes.var = id; 3795 includes.offset = 0; 3796 includes.type = SCALAR; 3797 3798 FOR_EACH_VEC_ELT (rhsc, j, c) 3799 process_constraint (new_constraint (includes, *c)); 3800 } 3801 3802 /* Create a constraint ID = OP. */ 3803 3804 static void 3805 make_constraint_to (unsigned id, tree op) 3806 { 3807 auto_vec<ce_s> rhsc; 3808 get_constraint_for_rhs (op, &rhsc); 3809 make_constraints_to (id, rhsc); 3810 } 3811 3812 /* Create a constraint ID = &FROM. */ 3813 3814 static void 3815 make_constraint_from (varinfo_t vi, int from) 3816 { 3817 struct constraint_expr lhs, rhs; 3818 3819 lhs.var = vi->id; 3820 lhs.offset = 0; 3821 lhs.type = SCALAR; 3822 3823 rhs.var = from; 3824 rhs.offset = 0; 3825 rhs.type = ADDRESSOF; 3826 process_constraint (new_constraint (lhs, rhs)); 3827 } 3828 3829 /* Create a constraint ID = FROM. */ 3830 3831 static void 3832 make_copy_constraint (varinfo_t vi, int from) 3833 { 3834 struct constraint_expr lhs, rhs; 3835 3836 lhs.var = vi->id; 3837 lhs.offset = 0; 3838 lhs.type = SCALAR; 3839 3840 rhs.var = from; 3841 rhs.offset = 0; 3842 rhs.type = SCALAR; 3843 process_constraint (new_constraint (lhs, rhs)); 3844 } 3845 3846 /* Make constraints necessary to make OP escape. */ 3847 3848 static void 3849 make_escape_constraint (tree op) 3850 { 3851 make_constraint_to (escaped_id, op); 3852 } 3853 3854 /* Add constraints to that the solution of VI is transitively closed. */ 3855 3856 static void 3857 make_transitive_closure_constraints (varinfo_t vi) 3858 { 3859 struct constraint_expr lhs, rhs; 3860 3861 /* VAR = *(VAR + UNKNOWN); */ 3862 lhs.type = SCALAR; 3863 lhs.var = vi->id; 3864 lhs.offset = 0; 3865 rhs.type = DEREF; 3866 rhs.var = vi->id; 3867 rhs.offset = UNKNOWN_OFFSET; 3868 process_constraint (new_constraint (lhs, rhs)); 3869 } 3870 3871 /* Add constraints to that the solution of VI has all subvariables added. */ 3872 3873 static void 3874 make_any_offset_constraints (varinfo_t vi) 3875 { 3876 struct constraint_expr lhs, rhs; 3877 3878 /* VAR = VAR + UNKNOWN; */ 3879 lhs.type = SCALAR; 3880 lhs.var = vi->id; 3881 lhs.offset = 0; 3882 rhs.type = SCALAR; 3883 rhs.var = vi->id; 3884 rhs.offset = UNKNOWN_OFFSET; 3885 process_constraint (new_constraint (lhs, rhs)); 3886 } 3887 3888 /* Temporary storage for fake var decls. */ 3889 struct obstack fake_var_decl_obstack; 3890 3891 /* Build a fake VAR_DECL acting as referrer to a DECL_UID. */ 3892 3893 static tree 3894 build_fake_var_decl (tree type) 3895 { 3896 tree decl = (tree) XOBNEW (&fake_var_decl_obstack, struct tree_var_decl); 3897 memset (decl, 0, sizeof (struct tree_var_decl)); 3898 TREE_SET_CODE (decl, VAR_DECL); 3899 TREE_TYPE (decl) = type; 3900 DECL_UID (decl) = allocate_decl_uid (); 3901 SET_DECL_PT_UID (decl, -1); 3902 layout_decl (decl, 0); 3903 return decl; 3904 } 3905 3906 /* Create a new artificial heap variable with NAME. 3907 Return the created variable. */ 3908 3909 static varinfo_t 3910 make_heapvar (const char *name, bool add_id) 3911 { 3912 varinfo_t vi; 3913 tree heapvar; 3914 3915 heapvar = build_fake_var_decl (ptr_type_node); 3916 DECL_EXTERNAL (heapvar) = 1; 3917 3918 vi = new_var_info (heapvar, name, add_id); 3919 vi->is_heap_var = true; 3920 vi->is_unknown_size_var = true; 3921 vi->offset = 0; 3922 vi->fullsize = ~0; 3923 vi->size = ~0; 3924 vi->is_full_var = true; 3925 insert_vi_for_tree (heapvar, vi); 3926 3927 return vi; 3928 } 3929 3930 /* Create a new artificial heap variable with NAME and make a 3931 constraint from it to LHS. Set flags according to a tag used 3932 for tracking restrict pointers. */ 3933 3934 static varinfo_t 3935 make_constraint_from_restrict (varinfo_t lhs, const char *name, bool add_id) 3936 { 3937 varinfo_t vi = make_heapvar (name, add_id); 3938 vi->is_restrict_var = 1; 3939 vi->is_global_var = 1; 3940 vi->may_have_pointers = 1; 3941 make_constraint_from (lhs, vi->id); 3942 return vi; 3943 } 3944 3945 /* Create a new artificial heap variable with NAME and make a 3946 constraint from it to LHS. Set flags according to a tag used 3947 for tracking restrict pointers and make the artificial heap 3948 point to global memory. */ 3949 3950 static varinfo_t 3951 make_constraint_from_global_restrict (varinfo_t lhs, const char *name, 3952 bool add_id) 3953 { 3954 varinfo_t vi = make_constraint_from_restrict (lhs, name, add_id); 3955 make_copy_constraint (vi, nonlocal_id); 3956 return vi; 3957 } 3958 3959 /* In IPA mode there are varinfos for different aspects of reach 3960 function designator. One for the points-to set of the return 3961 value, one for the variables that are clobbered by the function, 3962 one for its uses and one for each parameter (including a single 3963 glob for remaining variadic arguments). */ 3964 3965 enum { fi_clobbers = 1, fi_uses = 2, 3966 fi_static_chain = 3, fi_result = 4, fi_parm_base = 5 }; 3967 3968 /* Get a constraint for the requested part of a function designator FI 3969 when operating in IPA mode. */ 3970 3971 static struct constraint_expr 3972 get_function_part_constraint (varinfo_t fi, unsigned part) 3973 { 3974 struct constraint_expr c; 3975 3976 gcc_assert (in_ipa_mode); 3977 3978 if (fi->id == anything_id) 3979 { 3980 /* ??? We probably should have a ANYFN special variable. */ 3981 c.var = anything_id; 3982 c.offset = 0; 3983 c.type = SCALAR; 3984 } 3985 else if (fi->decl && TREE_CODE (fi->decl) == FUNCTION_DECL) 3986 { 3987 varinfo_t ai = first_vi_for_offset (fi, part); 3988 if (ai) 3989 c.var = ai->id; 3990 else 3991 c.var = anything_id; 3992 c.offset = 0; 3993 c.type = SCALAR; 3994 } 3995 else 3996 { 3997 c.var = fi->id; 3998 c.offset = part; 3999 c.type = DEREF; 4000 } 4001 4002 return c; 4003 } 4004 4005 /* For non-IPA mode, generate constraints necessary for a call on the 4006 RHS. */ 4007 4008 static void 4009 handle_rhs_call (gcall *stmt, vec<ce_s> *results) 4010 { 4011 struct constraint_expr rhsc; 4012 unsigned i; 4013 bool returns_uses = false; 4014 4015 for (i = 0; i < gimple_call_num_args (stmt); ++i) 4016 { 4017 tree arg = gimple_call_arg (stmt, i); 4018 int flags = gimple_call_arg_flags (stmt, i); 4019 4020 /* If the argument is not used we can ignore it. */ 4021 if (flags & EAF_UNUSED) 4022 continue; 4023 4024 /* As we compute ESCAPED context-insensitive we do not gain 4025 any precision with just EAF_NOCLOBBER but not EAF_NOESCAPE 4026 set. The argument would still get clobbered through the 4027 escape solution. */ 4028 if ((flags & EAF_NOCLOBBER) 4029 && (flags & EAF_NOESCAPE)) 4030 { 4031 varinfo_t uses = get_call_use_vi (stmt); 4032 varinfo_t tem = new_var_info (NULL_TREE, "callarg", true); 4033 tem->is_reg_var = true; 4034 make_constraint_to (tem->id, arg); 4035 make_any_offset_constraints (tem); 4036 if (!(flags & EAF_DIRECT)) 4037 make_transitive_closure_constraints (tem); 4038 make_copy_constraint (uses, tem->id); 4039 returns_uses = true; 4040 } 4041 else if (flags & EAF_NOESCAPE) 4042 { 4043 struct constraint_expr lhs, rhs; 4044 varinfo_t uses = get_call_use_vi (stmt); 4045 varinfo_t clobbers = get_call_clobber_vi (stmt); 4046 varinfo_t tem = new_var_info (NULL_TREE, "callarg", true); 4047 tem->is_reg_var = true; 4048 make_constraint_to (tem->id, arg); 4049 make_any_offset_constraints (tem); 4050 if (!(flags & EAF_DIRECT)) 4051 make_transitive_closure_constraints (tem); 4052 make_copy_constraint (uses, tem->id); 4053 make_copy_constraint (clobbers, tem->id); 4054 /* Add *tem = nonlocal, do not add *tem = callused as 4055 EAF_NOESCAPE parameters do not escape to other parameters 4056 and all other uses appear in NONLOCAL as well. */ 4057 lhs.type = DEREF; 4058 lhs.var = tem->id; 4059 lhs.offset = 0; 4060 rhs.type = SCALAR; 4061 rhs.var = nonlocal_id; 4062 rhs.offset = 0; 4063 process_constraint (new_constraint (lhs, rhs)); 4064 returns_uses = true; 4065 } 4066 else 4067 make_escape_constraint (arg); 4068 } 4069 4070 /* If we added to the calls uses solution make sure we account for 4071 pointers to it to be returned. */ 4072 if (returns_uses) 4073 { 4074 rhsc.var = get_call_use_vi (stmt)->id; 4075 rhsc.offset = UNKNOWN_OFFSET; 4076 rhsc.type = SCALAR; 4077 results->safe_push (rhsc); 4078 } 4079 4080 /* The static chain escapes as well. */ 4081 if (gimple_call_chain (stmt)) 4082 make_escape_constraint (gimple_call_chain (stmt)); 4083 4084 /* And if we applied NRV the address of the return slot escapes as well. */ 4085 if (gimple_call_return_slot_opt_p (stmt) 4086 && gimple_call_lhs (stmt) != NULL_TREE 4087 && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt)))) 4088 { 4089 auto_vec<ce_s> tmpc; 4090 struct constraint_expr lhsc, *c; 4091 get_constraint_for_address_of (gimple_call_lhs (stmt), &tmpc); 4092 lhsc.var = escaped_id; 4093 lhsc.offset = 0; 4094 lhsc.type = SCALAR; 4095 FOR_EACH_VEC_ELT (tmpc, i, c) 4096 process_constraint (new_constraint (lhsc, *c)); 4097 } 4098 4099 /* Regular functions return nonlocal memory. */ 4100 rhsc.var = nonlocal_id; 4101 rhsc.offset = 0; 4102 rhsc.type = SCALAR; 4103 results->safe_push (rhsc); 4104 } 4105 4106 /* For non-IPA mode, generate constraints necessary for a call 4107 that returns a pointer and assigns it to LHS. This simply makes 4108 the LHS point to global and escaped variables. */ 4109 4110 static void 4111 handle_lhs_call (gcall *stmt, tree lhs, int flags, vec<ce_s> rhsc, 4112 tree fndecl) 4113 { 4114 auto_vec<ce_s> lhsc; 4115 4116 get_constraint_for (lhs, &lhsc); 4117 /* If the store is to a global decl make sure to 4118 add proper escape constraints. */ 4119 lhs = get_base_address (lhs); 4120 if (lhs 4121 && DECL_P (lhs) 4122 && is_global_var (lhs)) 4123 { 4124 struct constraint_expr tmpc; 4125 tmpc.var = escaped_id; 4126 tmpc.offset = 0; 4127 tmpc.type = SCALAR; 4128 lhsc.safe_push (tmpc); 4129 } 4130 4131 /* If the call returns an argument unmodified override the rhs 4132 constraints. */ 4133 if (flags & ERF_RETURNS_ARG 4134 && (flags & ERF_RETURN_ARG_MASK) < gimple_call_num_args (stmt)) 4135 { 4136 tree arg; 4137 rhsc.create (0); 4138 arg = gimple_call_arg (stmt, flags & ERF_RETURN_ARG_MASK); 4139 get_constraint_for (arg, &rhsc); 4140 process_all_all_constraints (lhsc, rhsc); 4141 rhsc.release (); 4142 } 4143 else if (flags & ERF_NOALIAS) 4144 { 4145 varinfo_t vi; 4146 struct constraint_expr tmpc; 4147 rhsc.create (0); 4148 vi = make_heapvar ("HEAP", true); 4149 /* We are marking allocated storage local, we deal with it becoming 4150 global by escaping and setting of vars_contains_escaped_heap. */ 4151 DECL_EXTERNAL (vi->decl) = 0; 4152 vi->is_global_var = 0; 4153 /* If this is not a real malloc call assume the memory was 4154 initialized and thus may point to global memory. All 4155 builtin functions with the malloc attribute behave in a sane way. */ 4156 if (!fndecl 4157 || !fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)) 4158 make_constraint_from (vi, nonlocal_id); 4159 tmpc.var = vi->id; 4160 tmpc.offset = 0; 4161 tmpc.type = ADDRESSOF; 4162 rhsc.safe_push (tmpc); 4163 process_all_all_constraints (lhsc, rhsc); 4164 rhsc.release (); 4165 } 4166 else 4167 process_all_all_constraints (lhsc, rhsc); 4168 } 4169 4170 /* For non-IPA mode, generate constraints necessary for a call of a 4171 const function that returns a pointer in the statement STMT. */ 4172 4173 static void 4174 handle_const_call (gcall *stmt, vec<ce_s> *results) 4175 { 4176 struct constraint_expr rhsc; 4177 unsigned int k; 4178 bool need_uses = false; 4179 4180 /* Treat nested const functions the same as pure functions as far 4181 as the static chain is concerned. */ 4182 if (gimple_call_chain (stmt)) 4183 { 4184 varinfo_t uses = get_call_use_vi (stmt); 4185 make_constraint_to (uses->id, gimple_call_chain (stmt)); 4186 need_uses = true; 4187 } 4188 4189 /* And if we applied NRV the address of the return slot escapes as well. */ 4190 if (gimple_call_return_slot_opt_p (stmt) 4191 && gimple_call_lhs (stmt) != NULL_TREE 4192 && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt)))) 4193 { 4194 varinfo_t uses = get_call_use_vi (stmt); 4195 auto_vec<ce_s> tmpc; 4196 get_constraint_for_address_of (gimple_call_lhs (stmt), &tmpc); 4197 make_constraints_to (uses->id, tmpc); 4198 need_uses = true; 4199 } 4200 4201 if (need_uses) 4202 { 4203 varinfo_t uses = get_call_use_vi (stmt); 4204 make_any_offset_constraints (uses); 4205 make_transitive_closure_constraints (uses); 4206 rhsc.var = uses->id; 4207 rhsc.offset = 0; 4208 rhsc.type = SCALAR; 4209 results->safe_push (rhsc); 4210 } 4211 4212 /* May return offsetted arguments. */ 4213 varinfo_t tem = NULL; 4214 if (gimple_call_num_args (stmt) != 0) 4215 { 4216 tem = new_var_info (NULL_TREE, "callarg", true); 4217 tem->is_reg_var = true; 4218 } 4219 for (k = 0; k < gimple_call_num_args (stmt); ++k) 4220 { 4221 tree arg = gimple_call_arg (stmt, k); 4222 auto_vec<ce_s> argc; 4223 get_constraint_for_rhs (arg, &argc); 4224 make_constraints_to (tem->id, argc); 4225 } 4226 if (tem) 4227 { 4228 ce_s ce; 4229 ce.type = SCALAR; 4230 ce.var = tem->id; 4231 ce.offset = UNKNOWN_OFFSET; 4232 results->safe_push (ce); 4233 } 4234 4235 /* May return addresses of globals. */ 4236 rhsc.var = nonlocal_id; 4237 rhsc.offset = 0; 4238 rhsc.type = ADDRESSOF; 4239 results->safe_push (rhsc); 4240 } 4241 4242 /* For non-IPA mode, generate constraints necessary for a call to a 4243 pure function in statement STMT. */ 4244 4245 static void 4246 handle_pure_call (gcall *stmt, vec<ce_s> *results) 4247 { 4248 struct constraint_expr rhsc; 4249 unsigned i; 4250 varinfo_t uses = NULL; 4251 4252 /* Memory reached from pointer arguments is call-used. */ 4253 for (i = 0; i < gimple_call_num_args (stmt); ++i) 4254 { 4255 tree arg = gimple_call_arg (stmt, i); 4256 if (!uses) 4257 { 4258 uses = get_call_use_vi (stmt); 4259 make_any_offset_constraints (uses); 4260 make_transitive_closure_constraints (uses); 4261 } 4262 make_constraint_to (uses->id, arg); 4263 } 4264 4265 /* The static chain is used as well. */ 4266 if (gimple_call_chain (stmt)) 4267 { 4268 if (!uses) 4269 { 4270 uses = get_call_use_vi (stmt); 4271 make_any_offset_constraints (uses); 4272 make_transitive_closure_constraints (uses); 4273 } 4274 make_constraint_to (uses->id, gimple_call_chain (stmt)); 4275 } 4276 4277 /* And if we applied NRV the address of the return slot. */ 4278 if (gimple_call_return_slot_opt_p (stmt) 4279 && gimple_call_lhs (stmt) != NULL_TREE 4280 && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt)))) 4281 { 4282 if (!uses) 4283 { 4284 uses = get_call_use_vi (stmt); 4285 make_any_offset_constraints (uses); 4286 make_transitive_closure_constraints (uses); 4287 } 4288 auto_vec<ce_s> tmpc; 4289 get_constraint_for_address_of (gimple_call_lhs (stmt), &tmpc); 4290 make_constraints_to (uses->id, tmpc); 4291 } 4292 4293 /* Pure functions may return call-used and nonlocal memory. */ 4294 if (uses) 4295 { 4296 rhsc.var = uses->id; 4297 rhsc.offset = 0; 4298 rhsc.type = SCALAR; 4299 results->safe_push (rhsc); 4300 } 4301 rhsc.var = nonlocal_id; 4302 rhsc.offset = 0; 4303 rhsc.type = SCALAR; 4304 results->safe_push (rhsc); 4305 } 4306 4307 4308 /* Return the varinfo for the callee of CALL. */ 4309 4310 static varinfo_t 4311 get_fi_for_callee (gcall *call) 4312 { 4313 tree decl, fn = gimple_call_fn (call); 4314 4315 if (fn && TREE_CODE (fn) == OBJ_TYPE_REF) 4316 fn = OBJ_TYPE_REF_EXPR (fn); 4317 4318 /* If we can directly resolve the function being called, do so. 4319 Otherwise, it must be some sort of indirect expression that 4320 we should still be able to handle. */ 4321 decl = gimple_call_addr_fndecl (fn); 4322 if (decl) 4323 return get_vi_for_tree (decl); 4324 4325 /* If the function is anything other than a SSA name pointer we have no 4326 clue and should be getting ANYFN (well, ANYTHING for now). */ 4327 if (!fn || TREE_CODE (fn) != SSA_NAME) 4328 return get_varinfo (anything_id); 4329 4330 if (SSA_NAME_IS_DEFAULT_DEF (fn) 4331 && (TREE_CODE (SSA_NAME_VAR (fn)) == PARM_DECL 4332 || TREE_CODE (SSA_NAME_VAR (fn)) == RESULT_DECL)) 4333 fn = SSA_NAME_VAR (fn); 4334 4335 return get_vi_for_tree (fn); 4336 } 4337 4338 /* Create constraints for assigning call argument ARG to the incoming parameter 4339 INDEX of function FI. */ 4340 4341 static void 4342 find_func_aliases_for_call_arg (varinfo_t fi, unsigned index, tree arg) 4343 { 4344 struct constraint_expr lhs; 4345 lhs = get_function_part_constraint (fi, fi_parm_base + index); 4346 4347 auto_vec<ce_s, 2> rhsc; 4348 get_constraint_for_rhs (arg, &rhsc); 4349 4350 unsigned j; 4351 struct constraint_expr *rhsp; 4352 FOR_EACH_VEC_ELT (rhsc, j, rhsp) 4353 process_constraint (new_constraint (lhs, *rhsp)); 4354 } 4355 4356 /* Return true if FNDECL may be part of another lto partition. */ 4357 4358 static bool 4359 fndecl_maybe_in_other_partition (tree fndecl) 4360 { 4361 cgraph_node *fn_node = cgraph_node::get (fndecl); 4362 if (fn_node == NULL) 4363 return true; 4364 4365 return fn_node->in_other_partition; 4366 } 4367 4368 /* Create constraints for the builtin call T. Return true if the call 4369 was handled, otherwise false. */ 4370 4371 static bool 4372 find_func_aliases_for_builtin_call (struct function *fn, gcall *t) 4373 { 4374 tree fndecl = gimple_call_fndecl (t); 4375 auto_vec<ce_s, 2> lhsc; 4376 auto_vec<ce_s, 4> rhsc; 4377 varinfo_t fi; 4378 4379 if (gimple_call_builtin_p (t, BUILT_IN_NORMAL)) 4380 /* ??? All builtins that are handled here need to be handled 4381 in the alias-oracle query functions explicitly! */ 4382 switch (DECL_FUNCTION_CODE (fndecl)) 4383 { 4384 /* All the following functions return a pointer to the same object 4385 as their first argument points to. The functions do not add 4386 to the ESCAPED solution. The functions make the first argument 4387 pointed to memory point to what the second argument pointed to 4388 memory points to. */ 4389 case BUILT_IN_STRCPY: 4390 case BUILT_IN_STRNCPY: 4391 case BUILT_IN_BCOPY: 4392 case BUILT_IN_MEMCPY: 4393 case BUILT_IN_MEMMOVE: 4394 case BUILT_IN_MEMPCPY: 4395 case BUILT_IN_STPCPY: 4396 case BUILT_IN_STPNCPY: 4397 case BUILT_IN_STRCAT: 4398 case BUILT_IN_STRNCAT: 4399 case BUILT_IN_STRCPY_CHK: 4400 case BUILT_IN_STRNCPY_CHK: 4401 case BUILT_IN_MEMCPY_CHK: 4402 case BUILT_IN_MEMMOVE_CHK: 4403 case BUILT_IN_MEMPCPY_CHK: 4404 case BUILT_IN_STPCPY_CHK: 4405 case BUILT_IN_STPNCPY_CHK: 4406 case BUILT_IN_STRCAT_CHK: 4407 case BUILT_IN_STRNCAT_CHK: 4408 case BUILT_IN_TM_MEMCPY: 4409 case BUILT_IN_TM_MEMMOVE: 4410 { 4411 tree res = gimple_call_lhs (t); 4412 tree dest = gimple_call_arg (t, (DECL_FUNCTION_CODE (fndecl) 4413 == BUILT_IN_BCOPY ? 1 : 0)); 4414 tree src = gimple_call_arg (t, (DECL_FUNCTION_CODE (fndecl) 4415 == BUILT_IN_BCOPY ? 0 : 1)); 4416 if (res != NULL_TREE) 4417 { 4418 get_constraint_for (res, &lhsc); 4419 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMPCPY 4420 || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STPCPY 4421 || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STPNCPY 4422 || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMPCPY_CHK 4423 || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STPCPY_CHK 4424 || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STPNCPY_CHK) 4425 get_constraint_for_ptr_offset (dest, NULL_TREE, &rhsc); 4426 else 4427 get_constraint_for (dest, &rhsc); 4428 process_all_all_constraints (lhsc, rhsc); 4429 lhsc.truncate (0); 4430 rhsc.truncate (0); 4431 } 4432 get_constraint_for_ptr_offset (dest, NULL_TREE, &lhsc); 4433 get_constraint_for_ptr_offset (src, NULL_TREE, &rhsc); 4434 do_deref (&lhsc); 4435 do_deref (&rhsc); 4436 process_all_all_constraints (lhsc, rhsc); 4437 return true; 4438 } 4439 case BUILT_IN_MEMSET: 4440 case BUILT_IN_MEMSET_CHK: 4441 case BUILT_IN_TM_MEMSET: 4442 { 4443 tree res = gimple_call_lhs (t); 4444 tree dest = gimple_call_arg (t, 0); 4445 unsigned i; 4446 ce_s *lhsp; 4447 struct constraint_expr ac; 4448 if (res != NULL_TREE) 4449 { 4450 get_constraint_for (res, &lhsc); 4451 get_constraint_for (dest, &rhsc); 4452 process_all_all_constraints (lhsc, rhsc); 4453 lhsc.truncate (0); 4454 } 4455 get_constraint_for_ptr_offset (dest, NULL_TREE, &lhsc); 4456 do_deref (&lhsc); 4457 if (flag_delete_null_pointer_checks 4458 && integer_zerop (gimple_call_arg (t, 1))) 4459 { 4460 ac.type = ADDRESSOF; 4461 ac.var = nothing_id; 4462 } 4463 else 4464 { 4465 ac.type = SCALAR; 4466 ac.var = integer_id; 4467 } 4468 ac.offset = 0; 4469 FOR_EACH_VEC_ELT (lhsc, i, lhsp) 4470 process_constraint (new_constraint (*lhsp, ac)); 4471 return true; 4472 } 4473 case BUILT_IN_STACK_SAVE: 4474 case BUILT_IN_STACK_RESTORE: 4475 /* Nothing interesting happens. */ 4476 return true; 4477 case BUILT_IN_ALLOCA: 4478 case BUILT_IN_ALLOCA_WITH_ALIGN: 4479 case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX: 4480 { 4481 tree ptr = gimple_call_lhs (t); 4482 if (ptr == NULL_TREE) 4483 return true; 4484 get_constraint_for (ptr, &lhsc); 4485 varinfo_t vi = make_heapvar ("HEAP", true); 4486 /* Alloca storage is never global. To exempt it from escaped 4487 handling make it a non-heap var. */ 4488 DECL_EXTERNAL (vi->decl) = 0; 4489 vi->is_global_var = 0; 4490 vi->is_heap_var = 0; 4491 struct constraint_expr tmpc; 4492 tmpc.var = vi->id; 4493 tmpc.offset = 0; 4494 tmpc.type = ADDRESSOF; 4495 rhsc.safe_push (tmpc); 4496 process_all_all_constraints (lhsc, rhsc); 4497 return true; 4498 } 4499 case BUILT_IN_POSIX_MEMALIGN: 4500 { 4501 tree ptrptr = gimple_call_arg (t, 0); 4502 get_constraint_for (ptrptr, &lhsc); 4503 do_deref (&lhsc); 4504 varinfo_t vi = make_heapvar ("HEAP", true); 4505 /* We are marking allocated storage local, we deal with it becoming 4506 global by escaping and setting of vars_contains_escaped_heap. */ 4507 DECL_EXTERNAL (vi->decl) = 0; 4508 vi->is_global_var = 0; 4509 struct constraint_expr tmpc; 4510 tmpc.var = vi->id; 4511 tmpc.offset = 0; 4512 tmpc.type = ADDRESSOF; 4513 rhsc.safe_push (tmpc); 4514 process_all_all_constraints (lhsc, rhsc); 4515 return true; 4516 } 4517 case BUILT_IN_ASSUME_ALIGNED: 4518 { 4519 tree res = gimple_call_lhs (t); 4520 tree dest = gimple_call_arg (t, 0); 4521 if (res != NULL_TREE) 4522 { 4523 get_constraint_for (res, &lhsc); 4524 get_constraint_for (dest, &rhsc); 4525 process_all_all_constraints (lhsc, rhsc); 4526 } 4527 return true; 4528 } 4529 /* All the following functions do not return pointers, do not 4530 modify the points-to sets of memory reachable from their 4531 arguments and do not add to the ESCAPED solution. */ 4532 case BUILT_IN_SINCOS: 4533 case BUILT_IN_SINCOSF: 4534 case BUILT_IN_SINCOSL: 4535 case BUILT_IN_FREXP: 4536 case BUILT_IN_FREXPF: 4537 case BUILT_IN_FREXPL: 4538 case BUILT_IN_GAMMA_R: 4539 case BUILT_IN_GAMMAF_R: 4540 case BUILT_IN_GAMMAL_R: 4541 case BUILT_IN_LGAMMA_R: 4542 case BUILT_IN_LGAMMAF_R: 4543 case BUILT_IN_LGAMMAL_R: 4544 case BUILT_IN_MODF: 4545 case BUILT_IN_MODFF: 4546 case BUILT_IN_MODFL: 4547 case BUILT_IN_REMQUO: 4548 case BUILT_IN_REMQUOF: 4549 case BUILT_IN_REMQUOL: 4550 case BUILT_IN_FREE: 4551 return true; 4552 case BUILT_IN_STRDUP: 4553 case BUILT_IN_STRNDUP: 4554 case BUILT_IN_REALLOC: 4555 if (gimple_call_lhs (t)) 4556 { 4557 handle_lhs_call (t, gimple_call_lhs (t), 4558 gimple_call_return_flags (t) | ERF_NOALIAS, 4559 vNULL, fndecl); 4560 get_constraint_for_ptr_offset (gimple_call_lhs (t), 4561 NULL_TREE, &lhsc); 4562 get_constraint_for_ptr_offset (gimple_call_arg (t, 0), 4563 NULL_TREE, &rhsc); 4564 do_deref (&lhsc); 4565 do_deref (&rhsc); 4566 process_all_all_constraints (lhsc, rhsc); 4567 lhsc.truncate (0); 4568 rhsc.truncate (0); 4569 /* For realloc the resulting pointer can be equal to the 4570 argument as well. But only doing this wouldn't be 4571 correct because with ptr == 0 realloc behaves like malloc. */ 4572 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_REALLOC) 4573 { 4574 get_constraint_for (gimple_call_lhs (t), &lhsc); 4575 get_constraint_for (gimple_call_arg (t, 0), &rhsc); 4576 process_all_all_constraints (lhsc, rhsc); 4577 } 4578 return true; 4579 } 4580 break; 4581 /* String / character search functions return a pointer into the 4582 source string or NULL. */ 4583 case BUILT_IN_INDEX: 4584 case BUILT_IN_STRCHR: 4585 case BUILT_IN_STRRCHR: 4586 case BUILT_IN_MEMCHR: 4587 case BUILT_IN_STRSTR: 4588 case BUILT_IN_STRPBRK: 4589 if (gimple_call_lhs (t)) 4590 { 4591 tree src = gimple_call_arg (t, 0); 4592 get_constraint_for_ptr_offset (src, NULL_TREE, &rhsc); 4593 constraint_expr nul; 4594 nul.var = nothing_id; 4595 nul.offset = 0; 4596 nul.type = ADDRESSOF; 4597 rhsc.safe_push (nul); 4598 get_constraint_for (gimple_call_lhs (t), &lhsc); 4599 process_all_all_constraints (lhsc, rhsc); 4600 } 4601 return true; 4602 /* Pure functions that return something not based on any object and 4603 that use the memory pointed to by their arguments (but not 4604 transitively). */ 4605 case BUILT_IN_STRCMP: 4606 case BUILT_IN_STRCMP_EQ: 4607 case BUILT_IN_STRNCMP: 4608 case BUILT_IN_STRNCMP_EQ: 4609 case BUILT_IN_STRCASECMP: 4610 case BUILT_IN_STRNCASECMP: 4611 case BUILT_IN_MEMCMP: 4612 case BUILT_IN_BCMP: 4613 case BUILT_IN_STRSPN: 4614 case BUILT_IN_STRCSPN: 4615 { 4616 varinfo_t uses = get_call_use_vi (t); 4617 make_any_offset_constraints (uses); 4618 make_constraint_to (uses->id, gimple_call_arg (t, 0)); 4619 make_constraint_to (uses->id, gimple_call_arg (t, 1)); 4620 /* No constraints are necessary for the return value. */ 4621 return true; 4622 } 4623 case BUILT_IN_STRLEN: 4624 { 4625 varinfo_t uses = get_call_use_vi (t); 4626 make_any_offset_constraints (uses); 4627 make_constraint_to (uses->id, gimple_call_arg (t, 0)); 4628 /* No constraints are necessary for the return value. */ 4629 return true; 4630 } 4631 case BUILT_IN_OBJECT_SIZE: 4632 case BUILT_IN_CONSTANT_P: 4633 { 4634 /* No constraints are necessary for the return value or the 4635 arguments. */ 4636 return true; 4637 } 4638 /* Trampolines are special - they set up passing the static 4639 frame. */ 4640 case BUILT_IN_INIT_TRAMPOLINE: 4641 { 4642 tree tramp = gimple_call_arg (t, 0); 4643 tree nfunc = gimple_call_arg (t, 1); 4644 tree frame = gimple_call_arg (t, 2); 4645 unsigned i; 4646 struct constraint_expr lhs, *rhsp; 4647 if (in_ipa_mode) 4648 { 4649 varinfo_t nfi = NULL; 4650 gcc_assert (TREE_CODE (nfunc) == ADDR_EXPR); 4651 nfi = lookup_vi_for_tree (TREE_OPERAND (nfunc, 0)); 4652 if (nfi) 4653 { 4654 lhs = get_function_part_constraint (nfi, fi_static_chain); 4655 get_constraint_for (frame, &rhsc); 4656 FOR_EACH_VEC_ELT (rhsc, i, rhsp) 4657 process_constraint (new_constraint (lhs, *rhsp)); 4658 rhsc.truncate (0); 4659 4660 /* Make the frame point to the function for 4661 the trampoline adjustment call. */ 4662 get_constraint_for (tramp, &lhsc); 4663 do_deref (&lhsc); 4664 get_constraint_for (nfunc, &rhsc); 4665 process_all_all_constraints (lhsc, rhsc); 4666 4667 return true; 4668 } 4669 } 4670 /* Else fallthru to generic handling which will let 4671 the frame escape. */ 4672 break; 4673 } 4674 case BUILT_IN_ADJUST_TRAMPOLINE: 4675 { 4676 tree tramp = gimple_call_arg (t, 0); 4677 tree res = gimple_call_lhs (t); 4678 if (in_ipa_mode && res) 4679 { 4680 get_constraint_for (res, &lhsc); 4681 get_constraint_for (tramp, &rhsc); 4682 do_deref (&rhsc); 4683 process_all_all_constraints (lhsc, rhsc); 4684 } 4685 return true; 4686 } 4687 CASE_BUILT_IN_TM_STORE (1): 4688 CASE_BUILT_IN_TM_STORE (2): 4689 CASE_BUILT_IN_TM_STORE (4): 4690 CASE_BUILT_IN_TM_STORE (8): 4691 CASE_BUILT_IN_TM_STORE (FLOAT): 4692 CASE_BUILT_IN_TM_STORE (DOUBLE): 4693 CASE_BUILT_IN_TM_STORE (LDOUBLE): 4694 CASE_BUILT_IN_TM_STORE (M64): 4695 CASE_BUILT_IN_TM_STORE (M128): 4696 CASE_BUILT_IN_TM_STORE (M256): 4697 { 4698 tree addr = gimple_call_arg (t, 0); 4699 tree src = gimple_call_arg (t, 1); 4700 4701 get_constraint_for (addr, &lhsc); 4702 do_deref (&lhsc); 4703 get_constraint_for (src, &rhsc); 4704 process_all_all_constraints (lhsc, rhsc); 4705 return true; 4706 } 4707 CASE_BUILT_IN_TM_LOAD (1): 4708 CASE_BUILT_IN_TM_LOAD (2): 4709 CASE_BUILT_IN_TM_LOAD (4): 4710 CASE_BUILT_IN_TM_LOAD (8): 4711 CASE_BUILT_IN_TM_LOAD (FLOAT): 4712 CASE_BUILT_IN_TM_LOAD (DOUBLE): 4713 CASE_BUILT_IN_TM_LOAD (LDOUBLE): 4714 CASE_BUILT_IN_TM_LOAD (M64): 4715 CASE_BUILT_IN_TM_LOAD (M128): 4716 CASE_BUILT_IN_TM_LOAD (M256): 4717 { 4718 tree dest = gimple_call_lhs (t); 4719 tree addr = gimple_call_arg (t, 0); 4720 4721 get_constraint_for (dest, &lhsc); 4722 get_constraint_for (addr, &rhsc); 4723 do_deref (&rhsc); 4724 process_all_all_constraints (lhsc, rhsc); 4725 return true; 4726 } 4727 /* Variadic argument handling needs to be handled in IPA 4728 mode as well. */ 4729 case BUILT_IN_VA_START: 4730 { 4731 tree valist = gimple_call_arg (t, 0); 4732 struct constraint_expr rhs, *lhsp; 4733 unsigned i; 4734 get_constraint_for_ptr_offset (valist, NULL_TREE, &lhsc); 4735 do_deref (&lhsc); 4736 /* The va_list gets access to pointers in variadic 4737 arguments. Which we know in the case of IPA analysis 4738 and otherwise are just all nonlocal variables. */ 4739 if (in_ipa_mode) 4740 { 4741 fi = lookup_vi_for_tree (fn->decl); 4742 rhs = get_function_part_constraint (fi, ~0); 4743 rhs.type = ADDRESSOF; 4744 } 4745 else 4746 { 4747 rhs.var = nonlocal_id; 4748 rhs.type = ADDRESSOF; 4749 rhs.offset = 0; 4750 } 4751 FOR_EACH_VEC_ELT (lhsc, i, lhsp) 4752 process_constraint (new_constraint (*lhsp, rhs)); 4753 /* va_list is clobbered. */ 4754 make_constraint_to (get_call_clobber_vi (t)->id, valist); 4755 return true; 4756 } 4757 /* va_end doesn't have any effect that matters. */ 4758 case BUILT_IN_VA_END: 4759 return true; 4760 /* Alternate return. Simply give up for now. */ 4761 case BUILT_IN_RETURN: 4762 { 4763 fi = NULL; 4764 if (!in_ipa_mode 4765 || !(fi = get_vi_for_tree (fn->decl))) 4766 make_constraint_from (get_varinfo (escaped_id), anything_id); 4767 else if (in_ipa_mode 4768 && fi != NULL) 4769 { 4770 struct constraint_expr lhs, rhs; 4771 lhs = get_function_part_constraint (fi, fi_result); 4772 rhs.var = anything_id; 4773 rhs.offset = 0; 4774 rhs.type = SCALAR; 4775 process_constraint (new_constraint (lhs, rhs)); 4776 } 4777 return true; 4778 } 4779 case BUILT_IN_GOMP_PARALLEL: 4780 case BUILT_IN_GOACC_PARALLEL: 4781 { 4782 if (in_ipa_mode) 4783 { 4784 unsigned int fnpos, argpos; 4785 switch (DECL_FUNCTION_CODE (fndecl)) 4786 { 4787 case BUILT_IN_GOMP_PARALLEL: 4788 /* __builtin_GOMP_parallel (fn, data, num_threads, flags). */ 4789 fnpos = 0; 4790 argpos = 1; 4791 break; 4792 case BUILT_IN_GOACC_PARALLEL: 4793 /* __builtin_GOACC_parallel (flags_m, fn, mapnum, hostaddrs, 4794 sizes, kinds, ...). */ 4795 fnpos = 1; 4796 argpos = 3; 4797 break; 4798 default: 4799 gcc_unreachable (); 4800 } 4801 4802 tree fnarg = gimple_call_arg (t, fnpos); 4803 gcc_assert (TREE_CODE (fnarg) == ADDR_EXPR); 4804 tree fndecl = TREE_OPERAND (fnarg, 0); 4805 if (fndecl_maybe_in_other_partition (fndecl)) 4806 /* Fallthru to general call handling. */ 4807 break; 4808 4809 tree arg = gimple_call_arg (t, argpos); 4810 4811 varinfo_t fi = get_vi_for_tree (fndecl); 4812 find_func_aliases_for_call_arg (fi, 0, arg); 4813 return true; 4814 } 4815 /* Else fallthru to generic call handling. */ 4816 break; 4817 } 4818 /* printf-style functions may have hooks to set pointers to 4819 point to somewhere into the generated string. Leave them 4820 for a later exercise... */ 4821 default: 4822 /* Fallthru to general call handling. */; 4823 } 4824 4825 return false; 4826 } 4827 4828 /* Create constraints for the call T. */ 4829 4830 static void 4831 find_func_aliases_for_call (struct function *fn, gcall *t) 4832 { 4833 tree fndecl = gimple_call_fndecl (t); 4834 varinfo_t fi; 4835 4836 if (fndecl != NULL_TREE 4837 && fndecl_built_in_p (fndecl) 4838 && find_func_aliases_for_builtin_call (fn, t)) 4839 return; 4840 4841 fi = get_fi_for_callee (t); 4842 if (!in_ipa_mode 4843 || (fi->decl && fndecl && !fi->is_fn_info)) 4844 { 4845 auto_vec<ce_s, 16> rhsc; 4846 int flags = gimple_call_flags (t); 4847 4848 /* Const functions can return their arguments and addresses 4849 of global memory but not of escaped memory. */ 4850 if (flags & (ECF_CONST|ECF_NOVOPS)) 4851 { 4852 if (gimple_call_lhs (t)) 4853 handle_const_call (t, &rhsc); 4854 } 4855 /* Pure functions can return addresses in and of memory 4856 reachable from their arguments, but they are not an escape 4857 point for reachable memory of their arguments. */ 4858 else if (flags & (ECF_PURE|ECF_LOOPING_CONST_OR_PURE)) 4859 handle_pure_call (t, &rhsc); 4860 else 4861 handle_rhs_call (t, &rhsc); 4862 if (gimple_call_lhs (t)) 4863 handle_lhs_call (t, gimple_call_lhs (t), 4864 gimple_call_return_flags (t), rhsc, fndecl); 4865 } 4866 else 4867 { 4868 auto_vec<ce_s, 2> rhsc; 4869 tree lhsop; 4870 unsigned j; 4871 4872 /* Assign all the passed arguments to the appropriate incoming 4873 parameters of the function. */ 4874 for (j = 0; j < gimple_call_num_args (t); j++) 4875 { 4876 tree arg = gimple_call_arg (t, j); 4877 find_func_aliases_for_call_arg (fi, j, arg); 4878 } 4879 4880 /* If we are returning a value, assign it to the result. */ 4881 lhsop = gimple_call_lhs (t); 4882 if (lhsop) 4883 { 4884 auto_vec<ce_s, 2> lhsc; 4885 struct constraint_expr rhs; 4886 struct constraint_expr *lhsp; 4887 bool aggr_p = aggregate_value_p (lhsop, gimple_call_fntype (t)); 4888 4889 get_constraint_for (lhsop, &lhsc); 4890 rhs = get_function_part_constraint (fi, fi_result); 4891 if (aggr_p) 4892 { 4893 auto_vec<ce_s, 2> tem; 4894 tem.quick_push (rhs); 4895 do_deref (&tem); 4896 gcc_checking_assert (tem.length () == 1); 4897 rhs = tem[0]; 4898 } 4899 FOR_EACH_VEC_ELT (lhsc, j, lhsp) 4900 process_constraint (new_constraint (*lhsp, rhs)); 4901 4902 /* If we pass the result decl by reference, honor that. */ 4903 if (aggr_p) 4904 { 4905 struct constraint_expr lhs; 4906 struct constraint_expr *rhsp; 4907 4908 get_constraint_for_address_of (lhsop, &rhsc); 4909 lhs = get_function_part_constraint (fi, fi_result); 4910 FOR_EACH_VEC_ELT (rhsc, j, rhsp) 4911 process_constraint (new_constraint (lhs, *rhsp)); 4912 rhsc.truncate (0); 4913 } 4914 } 4915 4916 /* If we use a static chain, pass it along. */ 4917 if (gimple_call_chain (t)) 4918 { 4919 struct constraint_expr lhs; 4920 struct constraint_expr *rhsp; 4921 4922 get_constraint_for (gimple_call_chain (t), &rhsc); 4923 lhs = get_function_part_constraint (fi, fi_static_chain); 4924 FOR_EACH_VEC_ELT (rhsc, j, rhsp) 4925 process_constraint (new_constraint (lhs, *rhsp)); 4926 } 4927 } 4928 } 4929 4930 /* Walk statement T setting up aliasing constraints according to the 4931 references found in T. This function is the main part of the 4932 constraint builder. AI points to auxiliary alias information used 4933 when building alias sets and computing alias grouping heuristics. */ 4934 4935 static void 4936 find_func_aliases (struct function *fn, gimple *origt) 4937 { 4938 gimple *t = origt; 4939 auto_vec<ce_s, 16> lhsc; 4940 auto_vec<ce_s, 16> rhsc; 4941 varinfo_t fi; 4942 4943 /* Now build constraints expressions. */ 4944 if (gimple_code (t) == GIMPLE_PHI) 4945 { 4946 /* For a phi node, assign all the arguments to 4947 the result. */ 4948 get_constraint_for (gimple_phi_result (t), &lhsc); 4949 for (unsigned i = 0; i < gimple_phi_num_args (t); i++) 4950 { 4951 get_constraint_for_rhs (gimple_phi_arg_def (t, i), &rhsc); 4952 process_all_all_constraints (lhsc, rhsc); 4953 rhsc.truncate (0); 4954 } 4955 } 4956 /* In IPA mode, we need to generate constraints to pass call 4957 arguments through their calls. There are two cases, 4958 either a GIMPLE_CALL returning a value, or just a plain 4959 GIMPLE_CALL when we are not. 4960 4961 In non-ipa mode, we need to generate constraints for each 4962 pointer passed by address. */ 4963 else if (is_gimple_call (t)) 4964 find_func_aliases_for_call (fn, as_a <gcall *> (t)); 4965 4966 /* Otherwise, just a regular assignment statement. Only care about 4967 operations with pointer result, others are dealt with as escape 4968 points if they have pointer operands. */ 4969 else if (is_gimple_assign (t)) 4970 { 4971 /* Otherwise, just a regular assignment statement. */ 4972 tree lhsop = gimple_assign_lhs (t); 4973 tree rhsop = (gimple_num_ops (t) == 2) ? gimple_assign_rhs1 (t) : NULL; 4974 4975 if (rhsop && TREE_CLOBBER_P (rhsop)) 4976 /* Ignore clobbers, they don't actually store anything into 4977 the LHS. */ 4978 ; 4979 else if (rhsop && AGGREGATE_TYPE_P (TREE_TYPE (lhsop))) 4980 do_structure_copy (lhsop, rhsop); 4981 else 4982 { 4983 enum tree_code code = gimple_assign_rhs_code (t); 4984 4985 get_constraint_for (lhsop, &lhsc); 4986 4987 if (code == POINTER_PLUS_EXPR) 4988 get_constraint_for_ptr_offset (gimple_assign_rhs1 (t), 4989 gimple_assign_rhs2 (t), &rhsc); 4990 else if (code == POINTER_DIFF_EXPR) 4991 /* The result is not a pointer (part). */ 4992 ; 4993 else if (code == BIT_AND_EXPR 4994 && TREE_CODE (gimple_assign_rhs2 (t)) == INTEGER_CST) 4995 { 4996 /* Aligning a pointer via a BIT_AND_EXPR is offsetting 4997 the pointer. Handle it by offsetting it by UNKNOWN. */ 4998 get_constraint_for_ptr_offset (gimple_assign_rhs1 (t), 4999 NULL_TREE, &rhsc); 5000 } 5001 else if (code == TRUNC_DIV_EXPR 5002 || code == CEIL_DIV_EXPR 5003 || code == FLOOR_DIV_EXPR 5004 || code == ROUND_DIV_EXPR 5005 || code == EXACT_DIV_EXPR 5006 || code == TRUNC_MOD_EXPR 5007 || code == CEIL_MOD_EXPR 5008 || code == FLOOR_MOD_EXPR 5009 || code == ROUND_MOD_EXPR) 5010 /* Division and modulo transfer the pointer from the LHS. */ 5011 get_constraint_for_ptr_offset (gimple_assign_rhs1 (t), 5012 NULL_TREE, &rhsc); 5013 else if (CONVERT_EXPR_CODE_P (code) 5014 || gimple_assign_single_p (t)) 5015 /* See through conversions, single RHS are handled by 5016 get_constraint_for_rhs. */ 5017 get_constraint_for_rhs (rhsop, &rhsc); 5018 else if (code == COND_EXPR) 5019 { 5020 /* The result is a merge of both COND_EXPR arms. */ 5021 auto_vec<ce_s, 2> tmp; 5022 struct constraint_expr *rhsp; 5023 unsigned i; 5024 get_constraint_for_rhs (gimple_assign_rhs2 (t), &rhsc); 5025 get_constraint_for_rhs (gimple_assign_rhs3 (t), &tmp); 5026 FOR_EACH_VEC_ELT (tmp, i, rhsp) 5027 rhsc.safe_push (*rhsp); 5028 } 5029 else if (truth_value_p (code)) 5030 /* Truth value results are not pointer (parts). Or at least 5031 very unreasonable obfuscation of a part. */ 5032 ; 5033 else 5034 { 5035 /* All other operations are possibly offsetting merges. */ 5036 auto_vec<ce_s, 4> tmp; 5037 struct constraint_expr *rhsp; 5038 unsigned i, j; 5039 get_constraint_for_ptr_offset (gimple_assign_rhs1 (t), 5040 NULL_TREE, &rhsc); 5041 for (i = 2; i < gimple_num_ops (t); ++i) 5042 { 5043 get_constraint_for_ptr_offset (gimple_op (t, i), 5044 NULL_TREE, &tmp); 5045 FOR_EACH_VEC_ELT (tmp, j, rhsp) 5046 rhsc.safe_push (*rhsp); 5047 tmp.truncate (0); 5048 } 5049 } 5050 process_all_all_constraints (lhsc, rhsc); 5051 } 5052 /* If there is a store to a global variable the rhs escapes. */ 5053 if ((lhsop = get_base_address (lhsop)) != NULL_TREE 5054 && DECL_P (lhsop)) 5055 { 5056 varinfo_t vi = get_vi_for_tree (lhsop); 5057 if ((! in_ipa_mode && vi->is_global_var) 5058 || vi->is_ipa_escape_point) 5059 make_escape_constraint (rhsop); 5060 } 5061 } 5062 /* Handle escapes through return. */ 5063 else if (gimple_code (t) == GIMPLE_RETURN 5064 && gimple_return_retval (as_a <greturn *> (t)) != NULL_TREE) 5065 { 5066 greturn *return_stmt = as_a <greturn *> (t); 5067 fi = NULL; 5068 if (!in_ipa_mode 5069 && SSA_VAR_P (gimple_return_retval (return_stmt))) 5070 { 5071 /* We handle simple returns by post-processing the solutions. */ 5072 ; 5073 } 5074 if (!(fi = get_vi_for_tree (fn->decl))) 5075 make_escape_constraint (gimple_return_retval (return_stmt)); 5076 else if (in_ipa_mode) 5077 { 5078 struct constraint_expr lhs ; 5079 struct constraint_expr *rhsp; 5080 unsigned i; 5081 5082 lhs = get_function_part_constraint (fi, fi_result); 5083 get_constraint_for_rhs (gimple_return_retval (return_stmt), &rhsc); 5084 FOR_EACH_VEC_ELT (rhsc, i, rhsp) 5085 process_constraint (new_constraint (lhs, *rhsp)); 5086 } 5087 } 5088 /* Handle asms conservatively by adding escape constraints to everything. */ 5089 else if (gasm *asm_stmt = dyn_cast <gasm *> (t)) 5090 { 5091 unsigned i, noutputs; 5092 const char **oconstraints; 5093 const char *constraint; 5094 bool allows_mem, allows_reg, is_inout; 5095 5096 noutputs = gimple_asm_noutputs (asm_stmt); 5097 oconstraints = XALLOCAVEC (const char *, noutputs); 5098 5099 for (i = 0; i < noutputs; ++i) 5100 { 5101 tree link = gimple_asm_output_op (asm_stmt, i); 5102 tree op = TREE_VALUE (link); 5103 5104 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); 5105 oconstraints[i] = constraint; 5106 parse_output_constraint (&constraint, i, 0, 0, &allows_mem, 5107 &allows_reg, &is_inout); 5108 5109 /* A memory constraint makes the address of the operand escape. */ 5110 if (!allows_reg && allows_mem) 5111 make_escape_constraint (build_fold_addr_expr (op)); 5112 5113 /* The asm may read global memory, so outputs may point to 5114 any global memory. */ 5115 if (op) 5116 { 5117 auto_vec<ce_s, 2> lhsc; 5118 struct constraint_expr rhsc, *lhsp; 5119 unsigned j; 5120 get_constraint_for (op, &lhsc); 5121 rhsc.var = nonlocal_id; 5122 rhsc.offset = 0; 5123 rhsc.type = SCALAR; 5124 FOR_EACH_VEC_ELT (lhsc, j, lhsp) 5125 process_constraint (new_constraint (*lhsp, rhsc)); 5126 } 5127 } 5128 for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i) 5129 { 5130 tree link = gimple_asm_input_op (asm_stmt, i); 5131 tree op = TREE_VALUE (link); 5132 5133 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); 5134 5135 parse_input_constraint (&constraint, 0, 0, noutputs, 0, oconstraints, 5136 &allows_mem, &allows_reg); 5137 5138 /* A memory constraint makes the address of the operand escape. */ 5139 if (!allows_reg && allows_mem) 5140 make_escape_constraint (build_fold_addr_expr (op)); 5141 /* Strictly we'd only need the constraint to ESCAPED if 5142 the asm clobbers memory, otherwise using something 5143 along the lines of per-call clobbers/uses would be enough. */ 5144 else if (op) 5145 make_escape_constraint (op); 5146 } 5147 } 5148 } 5149 5150 5151 /* Create a constraint adding to the clobber set of FI the memory 5152 pointed to by PTR. */ 5153 5154 static void 5155 process_ipa_clobber (varinfo_t fi, tree ptr) 5156 { 5157 vec<ce_s> ptrc = vNULL; 5158 struct constraint_expr *c, lhs; 5159 unsigned i; 5160 get_constraint_for_rhs (ptr, &ptrc); 5161 lhs = get_function_part_constraint (fi, fi_clobbers); 5162 FOR_EACH_VEC_ELT (ptrc, i, c) 5163 process_constraint (new_constraint (lhs, *c)); 5164 ptrc.release (); 5165 } 5166 5167 /* Walk statement T setting up clobber and use constraints according to the 5168 references found in T. This function is a main part of the 5169 IPA constraint builder. */ 5170 5171 static void 5172 find_func_clobbers (struct function *fn, gimple *origt) 5173 { 5174 gimple *t = origt; 5175 auto_vec<ce_s, 16> lhsc; 5176 auto_vec<ce_s, 16> rhsc; 5177 varinfo_t fi; 5178 5179 /* Add constraints for clobbered/used in IPA mode. 5180 We are not interested in what automatic variables are clobbered 5181 or used as we only use the information in the caller to which 5182 they do not escape. */ 5183 gcc_assert (in_ipa_mode); 5184 5185 /* If the stmt refers to memory in any way it better had a VUSE. */ 5186 if (gimple_vuse (t) == NULL_TREE) 5187 return; 5188 5189 /* We'd better have function information for the current function. */ 5190 fi = lookup_vi_for_tree (fn->decl); 5191 gcc_assert (fi != NULL); 5192 5193 /* Account for stores in assignments and calls. */ 5194 if (gimple_vdef (t) != NULL_TREE 5195 && gimple_has_lhs (t)) 5196 { 5197 tree lhs = gimple_get_lhs (t); 5198 tree tem = lhs; 5199 while (handled_component_p (tem)) 5200 tem = TREE_OPERAND (tem, 0); 5201 if ((DECL_P (tem) 5202 && !auto_var_in_fn_p (tem, fn->decl)) 5203 || INDIRECT_REF_P (tem) 5204 || (TREE_CODE (tem) == MEM_REF 5205 && !(TREE_CODE (TREE_OPERAND (tem, 0)) == ADDR_EXPR 5206 && auto_var_in_fn_p 5207 (TREE_OPERAND (TREE_OPERAND (tem, 0), 0), fn->decl)))) 5208 { 5209 struct constraint_expr lhsc, *rhsp; 5210 unsigned i; 5211 lhsc = get_function_part_constraint (fi, fi_clobbers); 5212 get_constraint_for_address_of (lhs, &rhsc); 5213 FOR_EACH_VEC_ELT (rhsc, i, rhsp) 5214 process_constraint (new_constraint (lhsc, *rhsp)); 5215 rhsc.truncate (0); 5216 } 5217 } 5218 5219 /* Account for uses in assigments and returns. */ 5220 if (gimple_assign_single_p (t) 5221 || (gimple_code (t) == GIMPLE_RETURN 5222 && gimple_return_retval (as_a <greturn *> (t)) != NULL_TREE)) 5223 { 5224 tree rhs = (gimple_assign_single_p (t) 5225 ? gimple_assign_rhs1 (t) 5226 : gimple_return_retval (as_a <greturn *> (t))); 5227 tree tem = rhs; 5228 while (handled_component_p (tem)) 5229 tem = TREE_OPERAND (tem, 0); 5230 if ((DECL_P (tem) 5231 && !auto_var_in_fn_p (tem, fn->decl)) 5232 || INDIRECT_REF_P (tem) 5233 || (TREE_CODE (tem) == MEM_REF 5234 && !(TREE_CODE (TREE_OPERAND (tem, 0)) == ADDR_EXPR 5235 && auto_var_in_fn_p 5236 (TREE_OPERAND (TREE_OPERAND (tem, 0), 0), fn->decl)))) 5237 { 5238 struct constraint_expr lhs, *rhsp; 5239 unsigned i; 5240 lhs = get_function_part_constraint (fi, fi_uses); 5241 get_constraint_for_address_of (rhs, &rhsc); 5242 FOR_EACH_VEC_ELT (rhsc, i, rhsp) 5243 process_constraint (new_constraint (lhs, *rhsp)); 5244 rhsc.truncate (0); 5245 } 5246 } 5247 5248 if (gcall *call_stmt = dyn_cast <gcall *> (t)) 5249 { 5250 varinfo_t cfi = NULL; 5251 tree decl = gimple_call_fndecl (t); 5252 struct constraint_expr lhs, rhs; 5253 unsigned i, j; 5254 5255 /* For builtins we do not have separate function info. For those 5256 we do not generate escapes for we have to generate clobbers/uses. */ 5257 if (gimple_call_builtin_p (t, BUILT_IN_NORMAL)) 5258 switch (DECL_FUNCTION_CODE (decl)) 5259 { 5260 /* The following functions use and clobber memory pointed to 5261 by their arguments. */ 5262 case BUILT_IN_STRCPY: 5263 case BUILT_IN_STRNCPY: 5264 case BUILT_IN_BCOPY: 5265 case BUILT_IN_MEMCPY: 5266 case BUILT_IN_MEMMOVE: 5267 case BUILT_IN_MEMPCPY: 5268 case BUILT_IN_STPCPY: 5269 case BUILT_IN_STPNCPY: 5270 case BUILT_IN_STRCAT: 5271 case BUILT_IN_STRNCAT: 5272 case BUILT_IN_STRCPY_CHK: 5273 case BUILT_IN_STRNCPY_CHK: 5274 case BUILT_IN_MEMCPY_CHK: 5275 case BUILT_IN_MEMMOVE_CHK: 5276 case BUILT_IN_MEMPCPY_CHK: 5277 case BUILT_IN_STPCPY_CHK: 5278 case BUILT_IN_STPNCPY_CHK: 5279 case BUILT_IN_STRCAT_CHK: 5280 case BUILT_IN_STRNCAT_CHK: 5281 { 5282 tree dest = gimple_call_arg (t, (DECL_FUNCTION_CODE (decl) 5283 == BUILT_IN_BCOPY ? 1 : 0)); 5284 tree src = gimple_call_arg (t, (DECL_FUNCTION_CODE (decl) 5285 == BUILT_IN_BCOPY ? 0 : 1)); 5286 unsigned i; 5287 struct constraint_expr *rhsp, *lhsp; 5288 get_constraint_for_ptr_offset (dest, NULL_TREE, &lhsc); 5289 lhs = get_function_part_constraint (fi, fi_clobbers); 5290 FOR_EACH_VEC_ELT (lhsc, i, lhsp) 5291 process_constraint (new_constraint (lhs, *lhsp)); 5292 get_constraint_for_ptr_offset (src, NULL_TREE, &rhsc); 5293 lhs = get_function_part_constraint (fi, fi_uses); 5294 FOR_EACH_VEC_ELT (rhsc, i, rhsp) 5295 process_constraint (new_constraint (lhs, *rhsp)); 5296 return; 5297 } 5298 /* The following function clobbers memory pointed to by 5299 its argument. */ 5300 case BUILT_IN_MEMSET: 5301 case BUILT_IN_MEMSET_CHK: 5302 case BUILT_IN_POSIX_MEMALIGN: 5303 { 5304 tree dest = gimple_call_arg (t, 0); 5305 unsigned i; 5306 ce_s *lhsp; 5307 get_constraint_for_ptr_offset (dest, NULL_TREE, &lhsc); 5308 lhs = get_function_part_constraint (fi, fi_clobbers); 5309 FOR_EACH_VEC_ELT (lhsc, i, lhsp) 5310 process_constraint (new_constraint (lhs, *lhsp)); 5311 return; 5312 } 5313 /* The following functions clobber their second and third 5314 arguments. */ 5315 case BUILT_IN_SINCOS: 5316 case BUILT_IN_SINCOSF: 5317 case BUILT_IN_SINCOSL: 5318 { 5319 process_ipa_clobber (fi, gimple_call_arg (t, 1)); 5320 process_ipa_clobber (fi, gimple_call_arg (t, 2)); 5321 return; 5322 } 5323 /* The following functions clobber their second argument. */ 5324 case BUILT_IN_FREXP: 5325 case BUILT_IN_FREXPF: 5326 case BUILT_IN_FREXPL: 5327 case BUILT_IN_LGAMMA_R: 5328 case BUILT_IN_LGAMMAF_R: 5329 case BUILT_IN_LGAMMAL_R: 5330 case BUILT_IN_GAMMA_R: 5331 case BUILT_IN_GAMMAF_R: 5332 case BUILT_IN_GAMMAL_R: 5333 case BUILT_IN_MODF: 5334 case BUILT_IN_MODFF: 5335 case BUILT_IN_MODFL: 5336 { 5337 process_ipa_clobber (fi, gimple_call_arg (t, 1)); 5338 return; 5339 } 5340 /* The following functions clobber their third argument. */ 5341 case BUILT_IN_REMQUO: 5342 case BUILT_IN_REMQUOF: 5343 case BUILT_IN_REMQUOL: 5344 { 5345 process_ipa_clobber (fi, gimple_call_arg (t, 2)); 5346 return; 5347 } 5348 /* The following functions neither read nor clobber memory. */ 5349 case BUILT_IN_ASSUME_ALIGNED: 5350 case BUILT_IN_FREE: 5351 return; 5352 /* Trampolines are of no interest to us. */ 5353 case BUILT_IN_INIT_TRAMPOLINE: 5354 case BUILT_IN_ADJUST_TRAMPOLINE: 5355 return; 5356 case BUILT_IN_VA_START: 5357 case BUILT_IN_VA_END: 5358 return; 5359 case BUILT_IN_GOMP_PARALLEL: 5360 case BUILT_IN_GOACC_PARALLEL: 5361 { 5362 unsigned int fnpos, argpos; 5363 unsigned int implicit_use_args[2]; 5364 unsigned int num_implicit_use_args = 0; 5365 switch (DECL_FUNCTION_CODE (decl)) 5366 { 5367 case BUILT_IN_GOMP_PARALLEL: 5368 /* __builtin_GOMP_parallel (fn, data, num_threads, flags). */ 5369 fnpos = 0; 5370 argpos = 1; 5371 break; 5372 case BUILT_IN_GOACC_PARALLEL: 5373 /* __builtin_GOACC_parallel (flags_m, fn, mapnum, hostaddrs, 5374 sizes, kinds, ...). */ 5375 fnpos = 1; 5376 argpos = 3; 5377 implicit_use_args[num_implicit_use_args++] = 4; 5378 implicit_use_args[num_implicit_use_args++] = 5; 5379 break; 5380 default: 5381 gcc_unreachable (); 5382 } 5383 5384 tree fnarg = gimple_call_arg (t, fnpos); 5385 gcc_assert (TREE_CODE (fnarg) == ADDR_EXPR); 5386 tree fndecl = TREE_OPERAND (fnarg, 0); 5387 if (fndecl_maybe_in_other_partition (fndecl)) 5388 /* Fallthru to general call handling. */ 5389 break; 5390 5391 varinfo_t cfi = get_vi_for_tree (fndecl); 5392 5393 tree arg = gimple_call_arg (t, argpos); 5394 5395 /* Parameter passed by value is used. */ 5396 lhs = get_function_part_constraint (fi, fi_uses); 5397 struct constraint_expr *rhsp; 5398 get_constraint_for (arg, &rhsc); 5399 FOR_EACH_VEC_ELT (rhsc, j, rhsp) 5400 process_constraint (new_constraint (lhs, *rhsp)); 5401 rhsc.truncate (0); 5402 5403 /* Handle parameters used by the call, but not used in cfi, as 5404 implicitly used by cfi. */ 5405 lhs = get_function_part_constraint (cfi, fi_uses); 5406 for (unsigned i = 0; i < num_implicit_use_args; ++i) 5407 { 5408 tree arg = gimple_call_arg (t, implicit_use_args[i]); 5409 get_constraint_for (arg, &rhsc); 5410 FOR_EACH_VEC_ELT (rhsc, j, rhsp) 5411 process_constraint (new_constraint (lhs, *rhsp)); 5412 rhsc.truncate (0); 5413 } 5414 5415 /* The caller clobbers what the callee does. */ 5416 lhs = get_function_part_constraint (fi, fi_clobbers); 5417 rhs = get_function_part_constraint (cfi, fi_clobbers); 5418 process_constraint (new_constraint (lhs, rhs)); 5419 5420 /* The caller uses what the callee does. */ 5421 lhs = get_function_part_constraint (fi, fi_uses); 5422 rhs = get_function_part_constraint (cfi, fi_uses); 5423 process_constraint (new_constraint (lhs, rhs)); 5424 5425 return; 5426 } 5427 /* printf-style functions may have hooks to set pointers to 5428 point to somewhere into the generated string. Leave them 5429 for a later exercise... */ 5430 default: 5431 /* Fallthru to general call handling. */; 5432 } 5433 5434 /* Parameters passed by value are used. */ 5435 lhs = get_function_part_constraint (fi, fi_uses); 5436 for (i = 0; i < gimple_call_num_args (t); i++) 5437 { 5438 struct constraint_expr *rhsp; 5439 tree arg = gimple_call_arg (t, i); 5440 5441 if (TREE_CODE (arg) == SSA_NAME 5442 || is_gimple_min_invariant (arg)) 5443 continue; 5444 5445 get_constraint_for_address_of (arg, &rhsc); 5446 FOR_EACH_VEC_ELT (rhsc, j, rhsp) 5447 process_constraint (new_constraint (lhs, *rhsp)); 5448 rhsc.truncate (0); 5449 } 5450 5451 /* Build constraints for propagating clobbers/uses along the 5452 callgraph edges. */ 5453 cfi = get_fi_for_callee (call_stmt); 5454 if (cfi->id == anything_id) 5455 { 5456 if (gimple_vdef (t)) 5457 make_constraint_from (first_vi_for_offset (fi, fi_clobbers), 5458 anything_id); 5459 make_constraint_from (first_vi_for_offset (fi, fi_uses), 5460 anything_id); 5461 return; 5462 } 5463 5464 /* For callees without function info (that's external functions), 5465 ESCAPED is clobbered and used. */ 5466 if (cfi->decl 5467 && TREE_CODE (cfi->decl) == FUNCTION_DECL 5468 && !cfi->is_fn_info) 5469 { 5470 varinfo_t vi; 5471 5472 if (gimple_vdef (t)) 5473 make_copy_constraint (first_vi_for_offset (fi, fi_clobbers), 5474 escaped_id); 5475 make_copy_constraint (first_vi_for_offset (fi, fi_uses), escaped_id); 5476 5477 /* Also honor the call statement use/clobber info. */ 5478 if ((vi = lookup_call_clobber_vi (call_stmt)) != NULL) 5479 make_copy_constraint (first_vi_for_offset (fi, fi_clobbers), 5480 vi->id); 5481 if ((vi = lookup_call_use_vi (call_stmt)) != NULL) 5482 make_copy_constraint (first_vi_for_offset (fi, fi_uses), 5483 vi->id); 5484 return; 5485 } 5486 5487 /* Otherwise the caller clobbers and uses what the callee does. 5488 ??? This should use a new complex constraint that filters 5489 local variables of the callee. */ 5490 if (gimple_vdef (t)) 5491 { 5492 lhs = get_function_part_constraint (fi, fi_clobbers); 5493 rhs = get_function_part_constraint (cfi, fi_clobbers); 5494 process_constraint (new_constraint (lhs, rhs)); 5495 } 5496 lhs = get_function_part_constraint (fi, fi_uses); 5497 rhs = get_function_part_constraint (cfi, fi_uses); 5498 process_constraint (new_constraint (lhs, rhs)); 5499 } 5500 else if (gimple_code (t) == GIMPLE_ASM) 5501 { 5502 /* ??? Ick. We can do better. */ 5503 if (gimple_vdef (t)) 5504 make_constraint_from (first_vi_for_offset (fi, fi_clobbers), 5505 anything_id); 5506 make_constraint_from (first_vi_for_offset (fi, fi_uses), 5507 anything_id); 5508 } 5509 } 5510 5511 5512 /* Find the first varinfo in the same variable as START that overlaps with 5513 OFFSET. Return NULL if we can't find one. */ 5514 5515 static varinfo_t 5516 first_vi_for_offset (varinfo_t start, unsigned HOST_WIDE_INT offset) 5517 { 5518 /* If the offset is outside of the variable, bail out. */ 5519 if (offset >= start->fullsize) 5520 return NULL; 5521 5522 /* If we cannot reach offset from start, lookup the first field 5523 and start from there. */ 5524 if (start->offset > offset) 5525 start = get_varinfo (start->head); 5526 5527 while (start) 5528 { 5529 /* We may not find a variable in the field list with the actual 5530 offset when we have glommed a structure to a variable. 5531 In that case, however, offset should still be within the size 5532 of the variable. */ 5533 if (offset >= start->offset 5534 && (offset - start->offset) < start->size) 5535 return start; 5536 5537 start = vi_next (start); 5538 } 5539 5540 return NULL; 5541 } 5542 5543 /* Find the first varinfo in the same variable as START that overlaps with 5544 OFFSET. If there is no such varinfo the varinfo directly preceding 5545 OFFSET is returned. */ 5546 5547 static varinfo_t 5548 first_or_preceding_vi_for_offset (varinfo_t start, 5549 unsigned HOST_WIDE_INT offset) 5550 { 5551 /* If we cannot reach offset from start, lookup the first field 5552 and start from there. */ 5553 if (start->offset > offset) 5554 start = get_varinfo (start->head); 5555 5556 /* We may not find a variable in the field list with the actual 5557 offset when we have glommed a structure to a variable. 5558 In that case, however, offset should still be within the size 5559 of the variable. 5560 If we got beyond the offset we look for return the field 5561 directly preceding offset which may be the last field. */ 5562 while (start->next 5563 && offset >= start->offset 5564 && !((offset - start->offset) < start->size)) 5565 start = vi_next (start); 5566 5567 return start; 5568 } 5569 5570 5571 /* This structure is used during pushing fields onto the fieldstack 5572 to track the offset of the field, since bitpos_of_field gives it 5573 relative to its immediate containing type, and we want it relative 5574 to the ultimate containing object. */ 5575 5576 struct fieldoff 5577 { 5578 /* Offset from the base of the base containing object to this field. */ 5579 HOST_WIDE_INT offset; 5580 5581 /* Size, in bits, of the field. */ 5582 unsigned HOST_WIDE_INT size; 5583 5584 unsigned has_unknown_size : 1; 5585 5586 unsigned must_have_pointers : 1; 5587 5588 unsigned may_have_pointers : 1; 5589 5590 unsigned only_restrict_pointers : 1; 5591 5592 tree restrict_pointed_type; 5593 }; 5594 typedef struct fieldoff fieldoff_s; 5595 5596 5597 /* qsort comparison function for two fieldoff's PA and PB */ 5598 5599 static int 5600 fieldoff_compare (const void *pa, const void *pb) 5601 { 5602 const fieldoff_s *foa = (const fieldoff_s *)pa; 5603 const fieldoff_s *fob = (const fieldoff_s *)pb; 5604 unsigned HOST_WIDE_INT foasize, fobsize; 5605 5606 if (foa->offset < fob->offset) 5607 return -1; 5608 else if (foa->offset > fob->offset) 5609 return 1; 5610 5611 foasize = foa->size; 5612 fobsize = fob->size; 5613 if (foasize < fobsize) 5614 return -1; 5615 else if (foasize > fobsize) 5616 return 1; 5617 return 0; 5618 } 5619 5620 /* Sort a fieldstack according to the field offset and sizes. */ 5621 static void 5622 sort_fieldstack (vec<fieldoff_s> fieldstack) 5623 { 5624 fieldstack.qsort (fieldoff_compare); 5625 } 5626 5627 /* Return true if T is a type that can have subvars. */ 5628 5629 static inline bool 5630 type_can_have_subvars (const_tree t) 5631 { 5632 /* Aggregates without overlapping fields can have subvars. */ 5633 return TREE_CODE (t) == RECORD_TYPE; 5634 } 5635 5636 /* Return true if V is a tree that we can have subvars for. 5637 Normally, this is any aggregate type. Also complex 5638 types which are not gimple registers can have subvars. */ 5639 5640 static inline bool 5641 var_can_have_subvars (const_tree v) 5642 { 5643 /* Volatile variables should never have subvars. */ 5644 if (TREE_THIS_VOLATILE (v)) 5645 return false; 5646 5647 /* Non decls or memory tags can never have subvars. */ 5648 if (!DECL_P (v)) 5649 return false; 5650 5651 return type_can_have_subvars (TREE_TYPE (v)); 5652 } 5653 5654 /* Return true if T is a type that does contain pointers. */ 5655 5656 static bool 5657 type_must_have_pointers (tree type) 5658 { 5659 if (POINTER_TYPE_P (type)) 5660 return true; 5661 5662 if (TREE_CODE (type) == ARRAY_TYPE) 5663 return type_must_have_pointers (TREE_TYPE (type)); 5664 5665 /* A function or method can have pointers as arguments, so track 5666 those separately. */ 5667 if (TREE_CODE (type) == FUNCTION_TYPE 5668 || TREE_CODE (type) == METHOD_TYPE) 5669 return true; 5670 5671 return false; 5672 } 5673 5674 static bool 5675 field_must_have_pointers (tree t) 5676 { 5677 return type_must_have_pointers (TREE_TYPE (t)); 5678 } 5679 5680 /* Given a TYPE, and a vector of field offsets FIELDSTACK, push all 5681 the fields of TYPE onto fieldstack, recording their offsets along 5682 the way. 5683 5684 OFFSET is used to keep track of the offset in this entire 5685 structure, rather than just the immediately containing structure. 5686 Returns false if the caller is supposed to handle the field we 5687 recursed for. */ 5688 5689 static bool 5690 push_fields_onto_fieldstack (tree type, vec<fieldoff_s> *fieldstack, 5691 HOST_WIDE_INT offset) 5692 { 5693 tree field; 5694 bool empty_p = true; 5695 5696 if (TREE_CODE (type) != RECORD_TYPE) 5697 return false; 5698 5699 /* If the vector of fields is growing too big, bail out early. 5700 Callers check for vec::length <= param_max_fields_for_field_sensitive, make 5701 sure this fails. */ 5702 if (fieldstack->length () > (unsigned)param_max_fields_for_field_sensitive) 5703 return false; 5704 5705 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 5706 if (TREE_CODE (field) == FIELD_DECL) 5707 { 5708 bool push = false; 5709 HOST_WIDE_INT foff = bitpos_of_field (field); 5710 tree field_type = TREE_TYPE (field); 5711 5712 if (!var_can_have_subvars (field) 5713 || TREE_CODE (field_type) == QUAL_UNION_TYPE 5714 || TREE_CODE (field_type) == UNION_TYPE) 5715 push = true; 5716 else if (!push_fields_onto_fieldstack 5717 (field_type, fieldstack, offset + foff) 5718 && (DECL_SIZE (field) 5719 && !integer_zerop (DECL_SIZE (field)))) 5720 /* Empty structures may have actual size, like in C++. So 5721 see if we didn't push any subfields and the size is 5722 nonzero, push the field onto the stack. */ 5723 push = true; 5724 5725 if (push) 5726 { 5727 fieldoff_s *pair = NULL; 5728 bool has_unknown_size = false; 5729 bool must_have_pointers_p; 5730 5731 if (!fieldstack->is_empty ()) 5732 pair = &fieldstack->last (); 5733 5734 /* If there isn't anything at offset zero, create sth. */ 5735 if (!pair 5736 && offset + foff != 0) 5737 { 5738 fieldoff_s e 5739 = {0, offset + foff, false, false, true, false, NULL_TREE}; 5740 pair = fieldstack->safe_push (e); 5741 } 5742 5743 if (!DECL_SIZE (field) 5744 || !tree_fits_uhwi_p (DECL_SIZE (field))) 5745 has_unknown_size = true; 5746 5747 /* If adjacent fields do not contain pointers merge them. */ 5748 must_have_pointers_p = field_must_have_pointers (field); 5749 if (pair 5750 && !has_unknown_size 5751 && !must_have_pointers_p 5752 && !pair->must_have_pointers 5753 && !pair->has_unknown_size 5754 && pair->offset + (HOST_WIDE_INT)pair->size == offset + foff) 5755 { 5756 pair->size += tree_to_uhwi (DECL_SIZE (field)); 5757 } 5758 else 5759 { 5760 fieldoff_s e; 5761 e.offset = offset + foff; 5762 e.has_unknown_size = has_unknown_size; 5763 if (!has_unknown_size) 5764 e.size = tree_to_uhwi (DECL_SIZE (field)); 5765 else 5766 e.size = -1; 5767 e.must_have_pointers = must_have_pointers_p; 5768 e.may_have_pointers = true; 5769 e.only_restrict_pointers 5770 = (!has_unknown_size 5771 && POINTER_TYPE_P (field_type) 5772 && TYPE_RESTRICT (field_type)); 5773 if (e.only_restrict_pointers) 5774 e.restrict_pointed_type = TREE_TYPE (field_type); 5775 fieldstack->safe_push (e); 5776 } 5777 } 5778 5779 empty_p = false; 5780 } 5781 5782 return !empty_p; 5783 } 5784 5785 /* Count the number of arguments DECL has, and set IS_VARARGS to true 5786 if it is a varargs function. */ 5787 5788 static unsigned int 5789 count_num_arguments (tree decl, bool *is_varargs) 5790 { 5791 unsigned int num = 0; 5792 tree t; 5793 5794 /* Capture named arguments for K&R functions. They do not 5795 have a prototype and thus no TYPE_ARG_TYPES. */ 5796 for (t = DECL_ARGUMENTS (decl); t; t = DECL_CHAIN (t)) 5797 ++num; 5798 5799 /* Check if the function has variadic arguments. */ 5800 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t)) 5801 if (TREE_VALUE (t) == void_type_node) 5802 break; 5803 if (!t) 5804 *is_varargs = true; 5805 5806 return num; 5807 } 5808 5809 /* Creation function node for DECL, using NAME, and return the index 5810 of the variable we've created for the function. If NONLOCAL_p, create 5811 initial constraints. */ 5812 5813 static varinfo_t 5814 create_function_info_for (tree decl, const char *name, bool add_id, 5815 bool nonlocal_p) 5816 { 5817 struct function *fn = DECL_STRUCT_FUNCTION (decl); 5818 varinfo_t vi, prev_vi; 5819 tree arg; 5820 unsigned int i; 5821 bool is_varargs = false; 5822 unsigned int num_args = count_num_arguments (decl, &is_varargs); 5823 5824 /* Create the variable info. */ 5825 5826 vi = new_var_info (decl, name, add_id); 5827 vi->offset = 0; 5828 vi->size = 1; 5829 vi->fullsize = fi_parm_base + num_args; 5830 vi->is_fn_info = 1; 5831 vi->may_have_pointers = false; 5832 if (is_varargs) 5833 vi->fullsize = ~0; 5834 insert_vi_for_tree (vi->decl, vi); 5835 5836 prev_vi = vi; 5837 5838 /* Create a variable for things the function clobbers and one for 5839 things the function uses. */ 5840 { 5841 varinfo_t clobbervi, usevi; 5842 const char *newname; 5843 char *tempname; 5844 5845 tempname = xasprintf ("%s.clobber", name); 5846 newname = ggc_strdup (tempname); 5847 free (tempname); 5848 5849 clobbervi = new_var_info (NULL, newname, false); 5850 clobbervi->offset = fi_clobbers; 5851 clobbervi->size = 1; 5852 clobbervi->fullsize = vi->fullsize; 5853 clobbervi->is_full_var = true; 5854 clobbervi->is_global_var = false; 5855 clobbervi->is_reg_var = true; 5856 5857 gcc_assert (prev_vi->offset < clobbervi->offset); 5858 prev_vi->next = clobbervi->id; 5859 prev_vi = clobbervi; 5860 5861 tempname = xasprintf ("%s.use", name); 5862 newname = ggc_strdup (tempname); 5863 free (tempname); 5864 5865 usevi = new_var_info (NULL, newname, false); 5866 usevi->offset = fi_uses; 5867 usevi->size = 1; 5868 usevi->fullsize = vi->fullsize; 5869 usevi->is_full_var = true; 5870 usevi->is_global_var = false; 5871 usevi->is_reg_var = true; 5872 5873 gcc_assert (prev_vi->offset < usevi->offset); 5874 prev_vi->next = usevi->id; 5875 prev_vi = usevi; 5876 } 5877 5878 /* And one for the static chain. */ 5879 if (fn->static_chain_decl != NULL_TREE) 5880 { 5881 varinfo_t chainvi; 5882 const char *newname; 5883 char *tempname; 5884 5885 tempname = xasprintf ("%s.chain", name); 5886 newname = ggc_strdup (tempname); 5887 free (tempname); 5888 5889 chainvi = new_var_info (fn->static_chain_decl, newname, false); 5890 chainvi->offset = fi_static_chain; 5891 chainvi->size = 1; 5892 chainvi->fullsize = vi->fullsize; 5893 chainvi->is_full_var = true; 5894 chainvi->is_global_var = false; 5895 5896 insert_vi_for_tree (fn->static_chain_decl, chainvi); 5897 5898 if (nonlocal_p 5899 && chainvi->may_have_pointers) 5900 make_constraint_from (chainvi, nonlocal_id); 5901 5902 gcc_assert (prev_vi->offset < chainvi->offset); 5903 prev_vi->next = chainvi->id; 5904 prev_vi = chainvi; 5905 } 5906 5907 /* Create a variable for the return var. */ 5908 if (DECL_RESULT (decl) != NULL 5909 || !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl)))) 5910 { 5911 varinfo_t resultvi; 5912 const char *newname; 5913 char *tempname; 5914 tree resultdecl = decl; 5915 5916 if (DECL_RESULT (decl)) 5917 resultdecl = DECL_RESULT (decl); 5918 5919 tempname = xasprintf ("%s.result", name); 5920 newname = ggc_strdup (tempname); 5921 free (tempname); 5922 5923 resultvi = new_var_info (resultdecl, newname, false); 5924 resultvi->offset = fi_result; 5925 resultvi->size = 1; 5926 resultvi->fullsize = vi->fullsize; 5927 resultvi->is_full_var = true; 5928 if (DECL_RESULT (decl)) 5929 resultvi->may_have_pointers = true; 5930 5931 if (DECL_RESULT (decl)) 5932 insert_vi_for_tree (DECL_RESULT (decl), resultvi); 5933 5934 if (nonlocal_p 5935 && DECL_RESULT (decl) 5936 && DECL_BY_REFERENCE (DECL_RESULT (decl))) 5937 make_constraint_from (resultvi, nonlocal_id); 5938 5939 gcc_assert (prev_vi->offset < resultvi->offset); 5940 prev_vi->next = resultvi->id; 5941 prev_vi = resultvi; 5942 } 5943 5944 /* We also need to make function return values escape. Nothing 5945 escapes by returning from main though. */ 5946 if (nonlocal_p 5947 && !MAIN_NAME_P (DECL_NAME (decl))) 5948 { 5949 varinfo_t fi, rvi; 5950 fi = lookup_vi_for_tree (decl); 5951 rvi = first_vi_for_offset (fi, fi_result); 5952 if (rvi && rvi->offset == fi_result) 5953 make_copy_constraint (get_varinfo (escaped_id), rvi->id); 5954 } 5955 5956 /* Set up variables for each argument. */ 5957 arg = DECL_ARGUMENTS (decl); 5958 for (i = 0; i < num_args; i++) 5959 { 5960 varinfo_t argvi; 5961 const char *newname; 5962 char *tempname; 5963 tree argdecl = decl; 5964 5965 if (arg) 5966 argdecl = arg; 5967 5968 tempname = xasprintf ("%s.arg%d", name, i); 5969 newname = ggc_strdup (tempname); 5970 free (tempname); 5971 5972 argvi = new_var_info (argdecl, newname, false); 5973 argvi->offset = fi_parm_base + i; 5974 argvi->size = 1; 5975 argvi->is_full_var = true; 5976 argvi->fullsize = vi->fullsize; 5977 if (arg) 5978 argvi->may_have_pointers = true; 5979 5980 if (arg) 5981 insert_vi_for_tree (arg, argvi); 5982 5983 if (nonlocal_p 5984 && argvi->may_have_pointers) 5985 make_constraint_from (argvi, nonlocal_id); 5986 5987 gcc_assert (prev_vi->offset < argvi->offset); 5988 prev_vi->next = argvi->id; 5989 prev_vi = argvi; 5990 if (arg) 5991 arg = DECL_CHAIN (arg); 5992 } 5993 5994 /* Add one representative for all further args. */ 5995 if (is_varargs) 5996 { 5997 varinfo_t argvi; 5998 const char *newname; 5999 char *tempname; 6000 tree decl; 6001 6002 tempname = xasprintf ("%s.varargs", name); 6003 newname = ggc_strdup (tempname); 6004 free (tempname); 6005 6006 /* We need sth that can be pointed to for va_start. */ 6007 decl = build_fake_var_decl (ptr_type_node); 6008 6009 argvi = new_var_info (decl, newname, false); 6010 argvi->offset = fi_parm_base + num_args; 6011 argvi->size = ~0; 6012 argvi->is_full_var = true; 6013 argvi->is_heap_var = true; 6014 argvi->fullsize = vi->fullsize; 6015 6016 if (nonlocal_p 6017 && argvi->may_have_pointers) 6018 make_constraint_from (argvi, nonlocal_id); 6019 6020 gcc_assert (prev_vi->offset < argvi->offset); 6021 prev_vi->next = argvi->id; 6022 } 6023 6024 return vi; 6025 } 6026 6027 6028 /* Return true if FIELDSTACK contains fields that overlap. 6029 FIELDSTACK is assumed to be sorted by offset. */ 6030 6031 static bool 6032 check_for_overlaps (vec<fieldoff_s> fieldstack) 6033 { 6034 fieldoff_s *fo = NULL; 6035 unsigned int i; 6036 HOST_WIDE_INT lastoffset = -1; 6037 6038 FOR_EACH_VEC_ELT (fieldstack, i, fo) 6039 { 6040 if (fo->offset == lastoffset) 6041 return true; 6042 lastoffset = fo->offset; 6043 } 6044 return false; 6045 } 6046 6047 /* Create a varinfo structure for NAME and DECL, and add it to VARMAP. 6048 This will also create any varinfo structures necessary for fields 6049 of DECL. DECL is a function parameter if HANDLE_PARAM is set. 6050 HANDLED_STRUCT_TYPE is used to register struct types reached by following 6051 restrict pointers. This is needed to prevent infinite recursion. 6052 If ADD_RESTRICT, pretend that the pointer NAME is restrict even if DECL 6053 does not advertise it. */ 6054 6055 static varinfo_t 6056 create_variable_info_for_1 (tree decl, const char *name, bool add_id, 6057 bool handle_param, bitmap handled_struct_type, 6058 bool add_restrict = false) 6059 { 6060 varinfo_t vi, newvi; 6061 tree decl_type = TREE_TYPE (decl); 6062 tree declsize = DECL_P (decl) ? DECL_SIZE (decl) : TYPE_SIZE (decl_type); 6063 auto_vec<fieldoff_s> fieldstack; 6064 fieldoff_s *fo; 6065 unsigned int i; 6066 6067 if (!declsize 6068 || !tree_fits_uhwi_p (declsize)) 6069 { 6070 vi = new_var_info (decl, name, add_id); 6071 vi->offset = 0; 6072 vi->size = ~0; 6073 vi->fullsize = ~0; 6074 vi->is_unknown_size_var = true; 6075 vi->is_full_var = true; 6076 vi->may_have_pointers = true; 6077 return vi; 6078 } 6079 6080 /* Collect field information. */ 6081 if (use_field_sensitive 6082 && var_can_have_subvars (decl) 6083 /* ??? Force us to not use subfields for globals in IPA mode. 6084 Else we'd have to parse arbitrary initializers. */ 6085 && !(in_ipa_mode 6086 && is_global_var (decl))) 6087 { 6088 fieldoff_s *fo = NULL; 6089 bool notokay = false; 6090 unsigned int i; 6091 6092 push_fields_onto_fieldstack (decl_type, &fieldstack, 0); 6093 6094 for (i = 0; !notokay && fieldstack.iterate (i, &fo); i++) 6095 if (fo->has_unknown_size 6096 || fo->offset < 0) 6097 { 6098 notokay = true; 6099 break; 6100 } 6101 6102 /* We can't sort them if we have a field with a variable sized type, 6103 which will make notokay = true. In that case, we are going to return 6104 without creating varinfos for the fields anyway, so sorting them is a 6105 waste to boot. */ 6106 if (!notokay) 6107 { 6108 sort_fieldstack (fieldstack); 6109 /* Due to some C++ FE issues, like PR 22488, we might end up 6110 what appear to be overlapping fields even though they, 6111 in reality, do not overlap. Until the C++ FE is fixed, 6112 we will simply disable field-sensitivity for these cases. */ 6113 notokay = check_for_overlaps (fieldstack); 6114 } 6115 6116 if (notokay) 6117 fieldstack.release (); 6118 } 6119 6120 /* If we didn't end up collecting sub-variables create a full 6121 variable for the decl. */ 6122 if (fieldstack.length () == 0 6123 || fieldstack.length () > (unsigned)param_max_fields_for_field_sensitive) 6124 { 6125 vi = new_var_info (decl, name, add_id); 6126 vi->offset = 0; 6127 vi->may_have_pointers = true; 6128 vi->fullsize = tree_to_uhwi (declsize); 6129 vi->size = vi->fullsize; 6130 vi->is_full_var = true; 6131 if (POINTER_TYPE_P (decl_type) 6132 && (TYPE_RESTRICT (decl_type) || add_restrict)) 6133 vi->only_restrict_pointers = 1; 6134 if (vi->only_restrict_pointers 6135 && !type_contains_placeholder_p (TREE_TYPE (decl_type)) 6136 && handle_param 6137 && !bitmap_bit_p (handled_struct_type, 6138 TYPE_UID (TREE_TYPE (decl_type)))) 6139 { 6140 varinfo_t rvi; 6141 tree heapvar = build_fake_var_decl (TREE_TYPE (decl_type)); 6142 DECL_EXTERNAL (heapvar) = 1; 6143 if (var_can_have_subvars (heapvar)) 6144 bitmap_set_bit (handled_struct_type, 6145 TYPE_UID (TREE_TYPE (decl_type))); 6146 rvi = create_variable_info_for_1 (heapvar, "PARM_NOALIAS", true, 6147 true, handled_struct_type); 6148 if (var_can_have_subvars (heapvar)) 6149 bitmap_clear_bit (handled_struct_type, 6150 TYPE_UID (TREE_TYPE (decl_type))); 6151 rvi->is_restrict_var = 1; 6152 insert_vi_for_tree (heapvar, rvi); 6153 make_constraint_from (vi, rvi->id); 6154 make_param_constraints (rvi); 6155 } 6156 fieldstack.release (); 6157 return vi; 6158 } 6159 6160 vi = new_var_info (decl, name, add_id); 6161 vi->fullsize = tree_to_uhwi (declsize); 6162 if (fieldstack.length () == 1) 6163 vi->is_full_var = true; 6164 for (i = 0, newvi = vi; 6165 fieldstack.iterate (i, &fo); 6166 ++i, newvi = vi_next (newvi)) 6167 { 6168 const char *newname = NULL; 6169 char *tempname; 6170 6171 if (dump_file) 6172 { 6173 if (fieldstack.length () != 1) 6174 { 6175 tempname 6176 = xasprintf ("%s." HOST_WIDE_INT_PRINT_DEC 6177 "+" HOST_WIDE_INT_PRINT_DEC, name, 6178 fo->offset, fo->size); 6179 newname = ggc_strdup (tempname); 6180 free (tempname); 6181 } 6182 } 6183 else 6184 newname = "NULL"; 6185 6186 if (newname) 6187 newvi->name = newname; 6188 newvi->offset = fo->offset; 6189 newvi->size = fo->size; 6190 newvi->fullsize = vi->fullsize; 6191 newvi->may_have_pointers = fo->may_have_pointers; 6192 newvi->only_restrict_pointers = fo->only_restrict_pointers; 6193 if (handle_param 6194 && newvi->only_restrict_pointers 6195 && !type_contains_placeholder_p (fo->restrict_pointed_type) 6196 && !bitmap_bit_p (handled_struct_type, 6197 TYPE_UID (fo->restrict_pointed_type))) 6198 { 6199 varinfo_t rvi; 6200 tree heapvar = build_fake_var_decl (fo->restrict_pointed_type); 6201 DECL_EXTERNAL (heapvar) = 1; 6202 if (var_can_have_subvars (heapvar)) 6203 bitmap_set_bit (handled_struct_type, 6204 TYPE_UID (fo->restrict_pointed_type)); 6205 rvi = create_variable_info_for_1 (heapvar, "PARM_NOALIAS", true, 6206 true, handled_struct_type); 6207 if (var_can_have_subvars (heapvar)) 6208 bitmap_clear_bit (handled_struct_type, 6209 TYPE_UID (fo->restrict_pointed_type)); 6210 rvi->is_restrict_var = 1; 6211 insert_vi_for_tree (heapvar, rvi); 6212 make_constraint_from (newvi, rvi->id); 6213 make_param_constraints (rvi); 6214 } 6215 if (i + 1 < fieldstack.length ()) 6216 { 6217 varinfo_t tem = new_var_info (decl, name, false); 6218 newvi->next = tem->id; 6219 tem->head = vi->id; 6220 } 6221 } 6222 6223 return vi; 6224 } 6225 6226 static unsigned int 6227 create_variable_info_for (tree decl, const char *name, bool add_id) 6228 { 6229 /* First see if we are dealing with an ifunc resolver call and 6230 assiociate that with a call to the resolver function result. */ 6231 cgraph_node *node; 6232 if (in_ipa_mode 6233 && TREE_CODE (decl) == FUNCTION_DECL 6234 && (node = cgraph_node::get (decl)) 6235 && node->ifunc_resolver) 6236 { 6237 varinfo_t fi = get_vi_for_tree (node->get_alias_target ()->decl); 6238 constraint_expr rhs 6239 = get_function_part_constraint (fi, fi_result); 6240 fi = new_var_info (NULL_TREE, "ifuncres", true); 6241 fi->is_reg_var = true; 6242 constraint_expr lhs; 6243 lhs.type = SCALAR; 6244 lhs.var = fi->id; 6245 lhs.offset = 0; 6246 process_constraint (new_constraint (lhs, rhs)); 6247 insert_vi_for_tree (decl, fi); 6248 return fi->id; 6249 } 6250 6251 varinfo_t vi = create_variable_info_for_1 (decl, name, add_id, false, NULL); 6252 unsigned int id = vi->id; 6253 6254 insert_vi_for_tree (decl, vi); 6255 6256 if (!VAR_P (decl)) 6257 return id; 6258 6259 /* Create initial constraints for globals. */ 6260 for (; vi; vi = vi_next (vi)) 6261 { 6262 if (!vi->may_have_pointers 6263 || !vi->is_global_var) 6264 continue; 6265 6266 /* Mark global restrict qualified pointers. */ 6267 if ((POINTER_TYPE_P (TREE_TYPE (decl)) 6268 && TYPE_RESTRICT (TREE_TYPE (decl))) 6269 || vi->only_restrict_pointers) 6270 { 6271 varinfo_t rvi 6272 = make_constraint_from_global_restrict (vi, "GLOBAL_RESTRICT", 6273 true); 6274 /* ??? For now exclude reads from globals as restrict sources 6275 if those are not (indirectly) from incoming parameters. */ 6276 rvi->is_restrict_var = false; 6277 continue; 6278 } 6279 6280 /* In non-IPA mode the initializer from nonlocal is all we need. */ 6281 if (!in_ipa_mode 6282 || DECL_HARD_REGISTER (decl)) 6283 make_copy_constraint (vi, nonlocal_id); 6284 6285 /* In IPA mode parse the initializer and generate proper constraints 6286 for it. */ 6287 else 6288 { 6289 varpool_node *vnode = varpool_node::get (decl); 6290 6291 /* For escaped variables initialize them from nonlocal. */ 6292 if (!vnode->all_refs_explicit_p ()) 6293 make_copy_constraint (vi, nonlocal_id); 6294 6295 /* If this is a global variable with an initializer and we are in 6296 IPA mode generate constraints for it. */ 6297 ipa_ref *ref; 6298 for (unsigned idx = 0; vnode->iterate_reference (idx, ref); ++idx) 6299 { 6300 auto_vec<ce_s> rhsc; 6301 struct constraint_expr lhs, *rhsp; 6302 unsigned i; 6303 get_constraint_for_address_of (ref->referred->decl, &rhsc); 6304 lhs.var = vi->id; 6305 lhs.offset = 0; 6306 lhs.type = SCALAR; 6307 FOR_EACH_VEC_ELT (rhsc, i, rhsp) 6308 process_constraint (new_constraint (lhs, *rhsp)); 6309 /* If this is a variable that escapes from the unit 6310 the initializer escapes as well. */ 6311 if (!vnode->all_refs_explicit_p ()) 6312 { 6313 lhs.var = escaped_id; 6314 lhs.offset = 0; 6315 lhs.type = SCALAR; 6316 FOR_EACH_VEC_ELT (rhsc, i, rhsp) 6317 process_constraint (new_constraint (lhs, *rhsp)); 6318 } 6319 } 6320 } 6321 } 6322 6323 return id; 6324 } 6325 6326 /* Print out the points-to solution for VAR to FILE. */ 6327 6328 static void 6329 dump_solution_for_var (FILE *file, unsigned int var) 6330 { 6331 varinfo_t vi = get_varinfo (var); 6332 unsigned int i; 6333 bitmap_iterator bi; 6334 6335 /* Dump the solution for unified vars anyway, this avoids difficulties 6336 in scanning dumps in the testsuite. */ 6337 fprintf (file, "%s = { ", vi->name); 6338 vi = get_varinfo (find (var)); 6339 EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, i, bi) 6340 fprintf (file, "%s ", get_varinfo (i)->name); 6341 fprintf (file, "}"); 6342 6343 /* But note when the variable was unified. */ 6344 if (vi->id != var) 6345 fprintf (file, " same as %s", vi->name); 6346 6347 fprintf (file, "\n"); 6348 } 6349 6350 /* Print the points-to solution for VAR to stderr. */ 6351 6352 DEBUG_FUNCTION void 6353 debug_solution_for_var (unsigned int var) 6354 { 6355 dump_solution_for_var (stderr, var); 6356 } 6357 6358 /* Register the constraints for function parameter related VI. */ 6359 6360 static void 6361 make_param_constraints (varinfo_t vi) 6362 { 6363 for (; vi; vi = vi_next (vi)) 6364 { 6365 if (vi->only_restrict_pointers) 6366 ; 6367 else if (vi->may_have_pointers) 6368 make_constraint_from (vi, nonlocal_id); 6369 6370 if (vi->is_full_var) 6371 break; 6372 } 6373 } 6374 6375 /* Create varinfo structures for all of the variables in the 6376 function for intraprocedural mode. */ 6377 6378 static void 6379 intra_create_variable_infos (struct function *fn) 6380 { 6381 tree t; 6382 bitmap handled_struct_type = NULL; 6383 bool this_parm_in_ctor = DECL_CXX_CONSTRUCTOR_P (fn->decl); 6384 6385 /* For each incoming pointer argument arg, create the constraint ARG 6386 = NONLOCAL or a dummy variable if it is a restrict qualified 6387 passed-by-reference argument. */ 6388 for (t = DECL_ARGUMENTS (fn->decl); t; t = DECL_CHAIN (t)) 6389 { 6390 if (handled_struct_type == NULL) 6391 handled_struct_type = BITMAP_ALLOC (NULL); 6392 6393 varinfo_t p 6394 = create_variable_info_for_1 (t, alias_get_name (t), false, true, 6395 handled_struct_type, this_parm_in_ctor); 6396 insert_vi_for_tree (t, p); 6397 6398 make_param_constraints (p); 6399 6400 this_parm_in_ctor = false; 6401 } 6402 6403 if (handled_struct_type != NULL) 6404 BITMAP_FREE (handled_struct_type); 6405 6406 /* Add a constraint for a result decl that is passed by reference. */ 6407 if (DECL_RESULT (fn->decl) 6408 && DECL_BY_REFERENCE (DECL_RESULT (fn->decl))) 6409 { 6410 varinfo_t p, result_vi = get_vi_for_tree (DECL_RESULT (fn->decl)); 6411 6412 for (p = result_vi; p; p = vi_next (p)) 6413 make_constraint_from (p, nonlocal_id); 6414 } 6415 6416 /* Add a constraint for the incoming static chain parameter. */ 6417 if (fn->static_chain_decl != NULL_TREE) 6418 { 6419 varinfo_t p, chain_vi = get_vi_for_tree (fn->static_chain_decl); 6420 6421 for (p = chain_vi; p; p = vi_next (p)) 6422 make_constraint_from (p, nonlocal_id); 6423 } 6424 } 6425 6426 /* Structure used to put solution bitmaps in a hashtable so they can 6427 be shared among variables with the same points-to set. */ 6428 6429 typedef struct shared_bitmap_info 6430 { 6431 bitmap pt_vars; 6432 hashval_t hashcode; 6433 } *shared_bitmap_info_t; 6434 typedef const struct shared_bitmap_info *const_shared_bitmap_info_t; 6435 6436 /* Shared_bitmap hashtable helpers. */ 6437 6438 struct shared_bitmap_hasher : free_ptr_hash <shared_bitmap_info> 6439 { 6440 static inline hashval_t hash (const shared_bitmap_info *); 6441 static inline bool equal (const shared_bitmap_info *, 6442 const shared_bitmap_info *); 6443 }; 6444 6445 /* Hash function for a shared_bitmap_info_t */ 6446 6447 inline hashval_t 6448 shared_bitmap_hasher::hash (const shared_bitmap_info *bi) 6449 { 6450 return bi->hashcode; 6451 } 6452 6453 /* Equality function for two shared_bitmap_info_t's. */ 6454 6455 inline bool 6456 shared_bitmap_hasher::equal (const shared_bitmap_info *sbi1, 6457 const shared_bitmap_info *sbi2) 6458 { 6459 return bitmap_equal_p (sbi1->pt_vars, sbi2->pt_vars); 6460 } 6461 6462 /* Shared_bitmap hashtable. */ 6463 6464 static hash_table<shared_bitmap_hasher> *shared_bitmap_table; 6465 6466 /* Lookup a bitmap in the shared bitmap hashtable, and return an already 6467 existing instance if there is one, NULL otherwise. */ 6468 6469 static bitmap 6470 shared_bitmap_lookup (bitmap pt_vars) 6471 { 6472 shared_bitmap_info **slot; 6473 struct shared_bitmap_info sbi; 6474 6475 sbi.pt_vars = pt_vars; 6476 sbi.hashcode = bitmap_hash (pt_vars); 6477 6478 slot = shared_bitmap_table->find_slot (&sbi, NO_INSERT); 6479 if (!slot) 6480 return NULL; 6481 else 6482 return (*slot)->pt_vars; 6483 } 6484 6485 6486 /* Add a bitmap to the shared bitmap hashtable. */ 6487 6488 static void 6489 shared_bitmap_add (bitmap pt_vars) 6490 { 6491 shared_bitmap_info **slot; 6492 shared_bitmap_info_t sbi = XNEW (struct shared_bitmap_info); 6493 6494 sbi->pt_vars = pt_vars; 6495 sbi->hashcode = bitmap_hash (pt_vars); 6496 6497 slot = shared_bitmap_table->find_slot (sbi, INSERT); 6498 gcc_assert (!*slot); 6499 *slot = sbi; 6500 } 6501 6502 6503 /* Set bits in INTO corresponding to the variable uids in solution set FROM. */ 6504 6505 static void 6506 set_uids_in_ptset (bitmap into, bitmap from, struct pt_solution *pt, 6507 tree fndecl) 6508 { 6509 unsigned int i; 6510 bitmap_iterator bi; 6511 varinfo_t escaped_vi = get_varinfo (find (escaped_id)); 6512 bool everything_escaped 6513 = escaped_vi->solution && bitmap_bit_p (escaped_vi->solution, anything_id); 6514 6515 EXECUTE_IF_SET_IN_BITMAP (from, 0, i, bi) 6516 { 6517 varinfo_t vi = get_varinfo (i); 6518 6519 if (vi->is_artificial_var) 6520 continue; 6521 6522 if (everything_escaped 6523 || (escaped_vi->solution 6524 && bitmap_bit_p (escaped_vi->solution, i))) 6525 { 6526 pt->vars_contains_escaped = true; 6527 pt->vars_contains_escaped_heap |= vi->is_heap_var; 6528 } 6529 6530 if (vi->is_restrict_var) 6531 pt->vars_contains_restrict = true; 6532 6533 if (VAR_P (vi->decl) 6534 || TREE_CODE (vi->decl) == PARM_DECL 6535 || TREE_CODE (vi->decl) == RESULT_DECL) 6536 { 6537 /* If we are in IPA mode we will not recompute points-to 6538 sets after inlining so make sure they stay valid. */ 6539 if (in_ipa_mode 6540 && !DECL_PT_UID_SET_P (vi->decl)) 6541 SET_DECL_PT_UID (vi->decl, DECL_UID (vi->decl)); 6542 6543 /* Add the decl to the points-to set. Note that the points-to 6544 set contains global variables. */ 6545 bitmap_set_bit (into, DECL_PT_UID (vi->decl)); 6546 if (vi->is_global_var 6547 /* In IPA mode the escaped_heap trick doesn't work as 6548 ESCAPED is escaped from the unit but 6549 pt_solution_includes_global needs to answer true for 6550 all variables not automatic within a function. 6551 For the same reason is_global_var is not the 6552 correct flag to track - local variables from other 6553 functions also need to be considered global. 6554 Conveniently all HEAP vars are not put in function 6555 scope. */ 6556 || (in_ipa_mode 6557 && fndecl 6558 && ! auto_var_in_fn_p (vi->decl, fndecl))) 6559 pt->vars_contains_nonlocal = true; 6560 6561 /* If we have a variable that is interposable record that fact 6562 for pointer comparison simplification. */ 6563 if (VAR_P (vi->decl) 6564 && (TREE_STATIC (vi->decl) || DECL_EXTERNAL (vi->decl)) 6565 && ! decl_binds_to_current_def_p (vi->decl)) 6566 pt->vars_contains_interposable = true; 6567 6568 /* If this is a local variable we can have overlapping lifetime 6569 of different function invocations through recursion duplicate 6570 it with its shadow variable. */ 6571 if (in_ipa_mode 6572 && vi->shadow_var_uid != 0) 6573 { 6574 bitmap_set_bit (into, vi->shadow_var_uid); 6575 pt->vars_contains_nonlocal = true; 6576 } 6577 } 6578 6579 else if (TREE_CODE (vi->decl) == FUNCTION_DECL 6580 || TREE_CODE (vi->decl) == LABEL_DECL) 6581 { 6582 /* Nothing should read/write from/to code so we can 6583 save bits by not including them in the points-to bitmaps. 6584 Still mark the points-to set as containing global memory 6585 to make code-patching possible - see PR70128. */ 6586 pt->vars_contains_nonlocal = true; 6587 } 6588 } 6589 } 6590 6591 6592 /* Compute the points-to solution *PT for the variable VI. */ 6593 6594 static struct pt_solution 6595 find_what_var_points_to (tree fndecl, varinfo_t orig_vi) 6596 { 6597 unsigned int i; 6598 bitmap_iterator bi; 6599 bitmap finished_solution; 6600 bitmap result; 6601 varinfo_t vi; 6602 struct pt_solution *pt; 6603 6604 /* This variable may have been collapsed, let's get the real 6605 variable. */ 6606 vi = get_varinfo (find (orig_vi->id)); 6607 6608 /* See if we have already computed the solution and return it. */ 6609 pt_solution **slot = &final_solutions->get_or_insert (vi); 6610 if (*slot != NULL) 6611 return **slot; 6612 6613 *slot = pt = XOBNEW (&final_solutions_obstack, struct pt_solution); 6614 memset (pt, 0, sizeof (struct pt_solution)); 6615 6616 /* Translate artificial variables into SSA_NAME_PTR_INFO 6617 attributes. */ 6618 EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, i, bi) 6619 { 6620 varinfo_t vi = get_varinfo (i); 6621 6622 if (vi->is_artificial_var) 6623 { 6624 if (vi->id == nothing_id) 6625 pt->null = 1; 6626 else if (vi->id == escaped_id) 6627 { 6628 if (in_ipa_mode) 6629 pt->ipa_escaped = 1; 6630 else 6631 pt->escaped = 1; 6632 /* Expand some special vars of ESCAPED in-place here. */ 6633 varinfo_t evi = get_varinfo (find (escaped_id)); 6634 if (bitmap_bit_p (evi->solution, nonlocal_id)) 6635 pt->nonlocal = 1; 6636 } 6637 else if (vi->id == nonlocal_id) 6638 pt->nonlocal = 1; 6639 else if (vi->id == string_id) 6640 /* Nobody cares - STRING_CSTs are read-only entities. */ 6641 ; 6642 else if (vi->id == anything_id 6643 || vi->id == integer_id) 6644 pt->anything = 1; 6645 } 6646 } 6647 6648 /* Instead of doing extra work, simply do not create 6649 elaborate points-to information for pt_anything pointers. */ 6650 if (pt->anything) 6651 return *pt; 6652 6653 /* Share the final set of variables when possible. */ 6654 finished_solution = BITMAP_GGC_ALLOC (); 6655 stats.points_to_sets_created++; 6656 6657 set_uids_in_ptset (finished_solution, vi->solution, pt, fndecl); 6658 result = shared_bitmap_lookup (finished_solution); 6659 if (!result) 6660 { 6661 shared_bitmap_add (finished_solution); 6662 pt->vars = finished_solution; 6663 } 6664 else 6665 { 6666 pt->vars = result; 6667 bitmap_clear (finished_solution); 6668 } 6669 6670 return *pt; 6671 } 6672 6673 /* Given a pointer variable P, fill in its points-to set. */ 6674 6675 static void 6676 find_what_p_points_to (tree fndecl, tree p) 6677 { 6678 struct ptr_info_def *pi; 6679 tree lookup_p = p; 6680 varinfo_t vi; 6681 bool nonnull = get_ptr_nonnull (p); 6682 6683 /* For parameters, get at the points-to set for the actual parm 6684 decl. */ 6685 if (TREE_CODE (p) == SSA_NAME 6686 && SSA_NAME_IS_DEFAULT_DEF (p) 6687 && (TREE_CODE (SSA_NAME_VAR (p)) == PARM_DECL 6688 || TREE_CODE (SSA_NAME_VAR (p)) == RESULT_DECL)) 6689 lookup_p = SSA_NAME_VAR (p); 6690 6691 vi = lookup_vi_for_tree (lookup_p); 6692 if (!vi) 6693 return; 6694 6695 pi = get_ptr_info (p); 6696 pi->pt = find_what_var_points_to (fndecl, vi); 6697 /* Conservatively set to NULL from PTA (to true). */ 6698 pi->pt.null = 1; 6699 /* Preserve pointer nonnull computed by VRP. See get_ptr_nonnull 6700 in gcc/tree-ssaname.c for more information. */ 6701 if (nonnull) 6702 set_ptr_nonnull (p); 6703 } 6704 6705 6706 /* Query statistics for points-to solutions. */ 6707 6708 static struct { 6709 unsigned HOST_WIDE_INT pt_solution_includes_may_alias; 6710 unsigned HOST_WIDE_INT pt_solution_includes_no_alias; 6711 unsigned HOST_WIDE_INT pt_solutions_intersect_may_alias; 6712 unsigned HOST_WIDE_INT pt_solutions_intersect_no_alias; 6713 } pta_stats; 6714 6715 void 6716 dump_pta_stats (FILE *s) 6717 { 6718 fprintf (s, "\nPTA query stats:\n"); 6719 fprintf (s, " pt_solution_includes: " 6720 HOST_WIDE_INT_PRINT_DEC" disambiguations, " 6721 HOST_WIDE_INT_PRINT_DEC" queries\n", 6722 pta_stats.pt_solution_includes_no_alias, 6723 pta_stats.pt_solution_includes_no_alias 6724 + pta_stats.pt_solution_includes_may_alias); 6725 fprintf (s, " pt_solutions_intersect: " 6726 HOST_WIDE_INT_PRINT_DEC" disambiguations, " 6727 HOST_WIDE_INT_PRINT_DEC" queries\n", 6728 pta_stats.pt_solutions_intersect_no_alias, 6729 pta_stats.pt_solutions_intersect_no_alias 6730 + pta_stats.pt_solutions_intersect_may_alias); 6731 } 6732 6733 6734 /* Reset the points-to solution *PT to a conservative default 6735 (point to anything). */ 6736 6737 void 6738 pt_solution_reset (struct pt_solution *pt) 6739 { 6740 memset (pt, 0, sizeof (struct pt_solution)); 6741 pt->anything = true; 6742 pt->null = true; 6743 } 6744 6745 /* Set the points-to solution *PT to point only to the variables 6746 in VARS. VARS_CONTAINS_GLOBAL specifies whether that contains 6747 global variables and VARS_CONTAINS_RESTRICT specifies whether 6748 it contains restrict tag variables. */ 6749 6750 void 6751 pt_solution_set (struct pt_solution *pt, bitmap vars, 6752 bool vars_contains_nonlocal) 6753 { 6754 memset (pt, 0, sizeof (struct pt_solution)); 6755 pt->vars = vars; 6756 pt->vars_contains_nonlocal = vars_contains_nonlocal; 6757 pt->vars_contains_escaped 6758 = (cfun->gimple_df->escaped.anything 6759 || bitmap_intersect_p (cfun->gimple_df->escaped.vars, vars)); 6760 } 6761 6762 /* Set the points-to solution *PT to point only to the variable VAR. */ 6763 6764 void 6765 pt_solution_set_var (struct pt_solution *pt, tree var) 6766 { 6767 memset (pt, 0, sizeof (struct pt_solution)); 6768 pt->vars = BITMAP_GGC_ALLOC (); 6769 bitmap_set_bit (pt->vars, DECL_PT_UID (var)); 6770 pt->vars_contains_nonlocal = is_global_var (var); 6771 pt->vars_contains_escaped 6772 = (cfun->gimple_df->escaped.anything 6773 || bitmap_bit_p (cfun->gimple_df->escaped.vars, DECL_PT_UID (var))); 6774 } 6775 6776 /* Computes the union of the points-to solutions *DEST and *SRC and 6777 stores the result in *DEST. This changes the points-to bitmap 6778 of *DEST and thus may not be used if that might be shared. 6779 The points-to bitmap of *SRC and *DEST will not be shared after 6780 this function if they were not before. */ 6781 6782 static void 6783 pt_solution_ior_into (struct pt_solution *dest, struct pt_solution *src) 6784 { 6785 dest->anything |= src->anything; 6786 if (dest->anything) 6787 { 6788 pt_solution_reset (dest); 6789 return; 6790 } 6791 6792 dest->nonlocal |= src->nonlocal; 6793 dest->escaped |= src->escaped; 6794 dest->ipa_escaped |= src->ipa_escaped; 6795 dest->null |= src->null; 6796 dest->vars_contains_nonlocal |= src->vars_contains_nonlocal; 6797 dest->vars_contains_escaped |= src->vars_contains_escaped; 6798 dest->vars_contains_escaped_heap |= src->vars_contains_escaped_heap; 6799 if (!src->vars) 6800 return; 6801 6802 if (!dest->vars) 6803 dest->vars = BITMAP_GGC_ALLOC (); 6804 bitmap_ior_into (dest->vars, src->vars); 6805 } 6806 6807 /* Return true if the points-to solution *PT is empty. */ 6808 6809 bool 6810 pt_solution_empty_p (const pt_solution *pt) 6811 { 6812 if (pt->anything 6813 || pt->nonlocal) 6814 return false; 6815 6816 if (pt->vars 6817 && !bitmap_empty_p (pt->vars)) 6818 return false; 6819 6820 /* If the solution includes ESCAPED, check if that is empty. */ 6821 if (pt->escaped 6822 && !pt_solution_empty_p (&cfun->gimple_df->escaped)) 6823 return false; 6824 6825 /* If the solution includes ESCAPED, check if that is empty. */ 6826 if (pt->ipa_escaped 6827 && !pt_solution_empty_p (&ipa_escaped_pt)) 6828 return false; 6829 6830 return true; 6831 } 6832 6833 /* Return true if the points-to solution *PT only point to a single var, and 6834 return the var uid in *UID. */ 6835 6836 bool 6837 pt_solution_singleton_or_null_p (struct pt_solution *pt, unsigned *uid) 6838 { 6839 if (pt->anything || pt->nonlocal || pt->escaped || pt->ipa_escaped 6840 || pt->vars == NULL 6841 || !bitmap_single_bit_set_p (pt->vars)) 6842 return false; 6843 6844 *uid = bitmap_first_set_bit (pt->vars); 6845 return true; 6846 } 6847 6848 /* Return true if the points-to solution *PT includes global memory. */ 6849 6850 bool 6851 pt_solution_includes_global (struct pt_solution *pt) 6852 { 6853 if (pt->anything 6854 || pt->nonlocal 6855 || pt->vars_contains_nonlocal 6856 /* The following is a hack to make the malloc escape hack work. 6857 In reality we'd need different sets for escaped-through-return 6858 and escaped-to-callees and passes would need to be updated. */ 6859 || pt->vars_contains_escaped_heap) 6860 return true; 6861 6862 /* 'escaped' is also a placeholder so we have to look into it. */ 6863 if (pt->escaped) 6864 return pt_solution_includes_global (&cfun->gimple_df->escaped); 6865 6866 if (pt->ipa_escaped) 6867 return pt_solution_includes_global (&ipa_escaped_pt); 6868 6869 return false; 6870 } 6871 6872 /* Return true if the points-to solution *PT includes the variable 6873 declaration DECL. */ 6874 6875 static bool 6876 pt_solution_includes_1 (struct pt_solution *pt, const_tree decl) 6877 { 6878 if (pt->anything) 6879 return true; 6880 6881 if (pt->nonlocal 6882 && is_global_var (decl)) 6883 return true; 6884 6885 if (pt->vars 6886 && bitmap_bit_p (pt->vars, DECL_PT_UID (decl))) 6887 return true; 6888 6889 /* If the solution includes ESCAPED, check it. */ 6890 if (pt->escaped 6891 && pt_solution_includes_1 (&cfun->gimple_df->escaped, decl)) 6892 return true; 6893 6894 /* If the solution includes ESCAPED, check it. */ 6895 if (pt->ipa_escaped 6896 && pt_solution_includes_1 (&ipa_escaped_pt, decl)) 6897 return true; 6898 6899 return false; 6900 } 6901 6902 bool 6903 pt_solution_includes (struct pt_solution *pt, const_tree decl) 6904 { 6905 bool res = pt_solution_includes_1 (pt, decl); 6906 if (res) 6907 ++pta_stats.pt_solution_includes_may_alias; 6908 else 6909 ++pta_stats.pt_solution_includes_no_alias; 6910 return res; 6911 } 6912 6913 /* Return true if both points-to solutions PT1 and PT2 have a non-empty 6914 intersection. */ 6915 6916 static bool 6917 pt_solutions_intersect_1 (struct pt_solution *pt1, struct pt_solution *pt2) 6918 { 6919 if (pt1->anything || pt2->anything) 6920 return true; 6921 6922 /* If either points to unknown global memory and the other points to 6923 any global memory they alias. */ 6924 if ((pt1->nonlocal 6925 && (pt2->nonlocal 6926 || pt2->vars_contains_nonlocal)) 6927 || (pt2->nonlocal 6928 && pt1->vars_contains_nonlocal)) 6929 return true; 6930 6931 /* If either points to all escaped memory and the other points to 6932 any escaped memory they alias. */ 6933 if ((pt1->escaped 6934 && (pt2->escaped 6935 || pt2->vars_contains_escaped)) 6936 || (pt2->escaped 6937 && pt1->vars_contains_escaped)) 6938 return true; 6939 6940 /* Check the escaped solution if required. 6941 ??? Do we need to check the local against the IPA escaped sets? */ 6942 if ((pt1->ipa_escaped || pt2->ipa_escaped) 6943 && !pt_solution_empty_p (&ipa_escaped_pt)) 6944 { 6945 /* If both point to escaped memory and that solution 6946 is not empty they alias. */ 6947 if (pt1->ipa_escaped && pt2->ipa_escaped) 6948 return true; 6949 6950 /* If either points to escaped memory see if the escaped solution 6951 intersects with the other. */ 6952 if ((pt1->ipa_escaped 6953 && pt_solutions_intersect_1 (&ipa_escaped_pt, pt2)) 6954 || (pt2->ipa_escaped 6955 && pt_solutions_intersect_1 (&ipa_escaped_pt, pt1))) 6956 return true; 6957 } 6958 6959 /* Now both pointers alias if their points-to solution intersects. */ 6960 return (pt1->vars 6961 && pt2->vars 6962 && bitmap_intersect_p (pt1->vars, pt2->vars)); 6963 } 6964 6965 bool 6966 pt_solutions_intersect (struct pt_solution *pt1, struct pt_solution *pt2) 6967 { 6968 bool res = pt_solutions_intersect_1 (pt1, pt2); 6969 if (res) 6970 ++pta_stats.pt_solutions_intersect_may_alias; 6971 else 6972 ++pta_stats.pt_solutions_intersect_no_alias; 6973 return res; 6974 } 6975 6976 6977 /* Dump points-to information to OUTFILE. */ 6978 6979 static void 6980 dump_sa_points_to_info (FILE *outfile) 6981 { 6982 unsigned int i; 6983 6984 fprintf (outfile, "\nPoints-to sets\n\n"); 6985 6986 if (dump_flags & TDF_STATS) 6987 { 6988 fprintf (outfile, "Stats:\n"); 6989 fprintf (outfile, "Total vars: %d\n", stats.total_vars); 6990 fprintf (outfile, "Non-pointer vars: %d\n", 6991 stats.nonpointer_vars); 6992 fprintf (outfile, "Statically unified vars: %d\n", 6993 stats.unified_vars_static); 6994 fprintf (outfile, "Dynamically unified vars: %d\n", 6995 stats.unified_vars_dynamic); 6996 fprintf (outfile, "Iterations: %d\n", stats.iterations); 6997 fprintf (outfile, "Number of edges: %d\n", stats.num_edges); 6998 fprintf (outfile, "Number of implicit edges: %d\n", 6999 stats.num_implicit_edges); 7000 } 7001 7002 for (i = 1; i < varmap.length (); i++) 7003 { 7004 varinfo_t vi = get_varinfo (i); 7005 if (!vi->may_have_pointers) 7006 continue; 7007 dump_solution_for_var (outfile, i); 7008 } 7009 } 7010 7011 7012 /* Debug points-to information to stderr. */ 7013 7014 DEBUG_FUNCTION void 7015 debug_sa_points_to_info (void) 7016 { 7017 dump_sa_points_to_info (stderr); 7018 } 7019 7020 7021 /* Initialize the always-existing constraint variables for NULL 7022 ANYTHING, READONLY, and INTEGER */ 7023 7024 static void 7025 init_base_vars (void) 7026 { 7027 struct constraint_expr lhs, rhs; 7028 varinfo_t var_anything; 7029 varinfo_t var_nothing; 7030 varinfo_t var_string; 7031 varinfo_t var_escaped; 7032 varinfo_t var_nonlocal; 7033 varinfo_t var_storedanything; 7034 varinfo_t var_integer; 7035 7036 /* Variable ID zero is reserved and should be NULL. */ 7037 varmap.safe_push (NULL); 7038 7039 /* Create the NULL variable, used to represent that a variable points 7040 to NULL. */ 7041 var_nothing = new_var_info (NULL_TREE, "NULL", false); 7042 gcc_assert (var_nothing->id == nothing_id); 7043 var_nothing->is_artificial_var = 1; 7044 var_nothing->offset = 0; 7045 var_nothing->size = ~0; 7046 var_nothing->fullsize = ~0; 7047 var_nothing->is_special_var = 1; 7048 var_nothing->may_have_pointers = 0; 7049 var_nothing->is_global_var = 0; 7050 7051 /* Create the ANYTHING variable, used to represent that a variable 7052 points to some unknown piece of memory. */ 7053 var_anything = new_var_info (NULL_TREE, "ANYTHING", false); 7054 gcc_assert (var_anything->id == anything_id); 7055 var_anything->is_artificial_var = 1; 7056 var_anything->size = ~0; 7057 var_anything->offset = 0; 7058 var_anything->fullsize = ~0; 7059 var_anything->is_special_var = 1; 7060 7061 /* Anything points to anything. This makes deref constraints just 7062 work in the presence of linked list and other p = *p type loops, 7063 by saying that *ANYTHING = ANYTHING. */ 7064 lhs.type = SCALAR; 7065 lhs.var = anything_id; 7066 lhs.offset = 0; 7067 rhs.type = ADDRESSOF; 7068 rhs.var = anything_id; 7069 rhs.offset = 0; 7070 7071 /* This specifically does not use process_constraint because 7072 process_constraint ignores all anything = anything constraints, since all 7073 but this one are redundant. */ 7074 constraints.safe_push (new_constraint (lhs, rhs)); 7075 7076 /* Create the STRING variable, used to represent that a variable 7077 points to a string literal. String literals don't contain 7078 pointers so STRING doesn't point to anything. */ 7079 var_string = new_var_info (NULL_TREE, "STRING", false); 7080 gcc_assert (var_string->id == string_id); 7081 var_string->is_artificial_var = 1; 7082 var_string->offset = 0; 7083 var_string->size = ~0; 7084 var_string->fullsize = ~0; 7085 var_string->is_special_var = 1; 7086 var_string->may_have_pointers = 0; 7087 7088 /* Create the ESCAPED variable, used to represent the set of escaped 7089 memory. */ 7090 var_escaped = new_var_info (NULL_TREE, "ESCAPED", false); 7091 gcc_assert (var_escaped->id == escaped_id); 7092 var_escaped->is_artificial_var = 1; 7093 var_escaped->offset = 0; 7094 var_escaped->size = ~0; 7095 var_escaped->fullsize = ~0; 7096 var_escaped->is_special_var = 0; 7097 7098 /* Create the NONLOCAL variable, used to represent the set of nonlocal 7099 memory. */ 7100 var_nonlocal = new_var_info (NULL_TREE, "NONLOCAL", false); 7101 gcc_assert (var_nonlocal->id == nonlocal_id); 7102 var_nonlocal->is_artificial_var = 1; 7103 var_nonlocal->offset = 0; 7104 var_nonlocal->size = ~0; 7105 var_nonlocal->fullsize = ~0; 7106 var_nonlocal->is_special_var = 1; 7107 7108 /* ESCAPED = *ESCAPED, because escaped is may-deref'd at calls, etc. */ 7109 lhs.type = SCALAR; 7110 lhs.var = escaped_id; 7111 lhs.offset = 0; 7112 rhs.type = DEREF; 7113 rhs.var = escaped_id; 7114 rhs.offset = 0; 7115 process_constraint (new_constraint (lhs, rhs)); 7116 7117 /* ESCAPED = ESCAPED + UNKNOWN_OFFSET, because if a sub-field escapes the 7118 whole variable escapes. */ 7119 lhs.type = SCALAR; 7120 lhs.var = escaped_id; 7121 lhs.offset = 0; 7122 rhs.type = SCALAR; 7123 rhs.var = escaped_id; 7124 rhs.offset = UNKNOWN_OFFSET; 7125 process_constraint (new_constraint (lhs, rhs)); 7126 7127 /* *ESCAPED = NONLOCAL. This is true because we have to assume 7128 everything pointed to by escaped points to what global memory can 7129 point to. */ 7130 lhs.type = DEREF; 7131 lhs.var = escaped_id; 7132 lhs.offset = 0; 7133 rhs.type = SCALAR; 7134 rhs.var = nonlocal_id; 7135 rhs.offset = 0; 7136 process_constraint (new_constraint (lhs, rhs)); 7137 7138 /* NONLOCAL = &NONLOCAL, NONLOCAL = &ESCAPED. This is true because 7139 global memory may point to global memory and escaped memory. */ 7140 lhs.type = SCALAR; 7141 lhs.var = nonlocal_id; 7142 lhs.offset = 0; 7143 rhs.type = ADDRESSOF; 7144 rhs.var = nonlocal_id; 7145 rhs.offset = 0; 7146 process_constraint (new_constraint (lhs, rhs)); 7147 rhs.type = ADDRESSOF; 7148 rhs.var = escaped_id; 7149 rhs.offset = 0; 7150 process_constraint (new_constraint (lhs, rhs)); 7151 7152 /* Create the STOREDANYTHING variable, used to represent the set of 7153 variables stored to *ANYTHING. */ 7154 var_storedanything = new_var_info (NULL_TREE, "STOREDANYTHING", false); 7155 gcc_assert (var_storedanything->id == storedanything_id); 7156 var_storedanything->is_artificial_var = 1; 7157 var_storedanything->offset = 0; 7158 var_storedanything->size = ~0; 7159 var_storedanything->fullsize = ~0; 7160 var_storedanything->is_special_var = 0; 7161 7162 /* Create the INTEGER variable, used to represent that a variable points 7163 to what an INTEGER "points to". */ 7164 var_integer = new_var_info (NULL_TREE, "INTEGER", false); 7165 gcc_assert (var_integer->id == integer_id); 7166 var_integer->is_artificial_var = 1; 7167 var_integer->size = ~0; 7168 var_integer->fullsize = ~0; 7169 var_integer->offset = 0; 7170 var_integer->is_special_var = 1; 7171 7172 /* INTEGER = ANYTHING, because we don't know where a dereference of 7173 a random integer will point to. */ 7174 lhs.type = SCALAR; 7175 lhs.var = integer_id; 7176 lhs.offset = 0; 7177 rhs.type = ADDRESSOF; 7178 rhs.var = anything_id; 7179 rhs.offset = 0; 7180 process_constraint (new_constraint (lhs, rhs)); 7181 } 7182 7183 /* Initialize things necessary to perform PTA */ 7184 7185 static void 7186 init_alias_vars (void) 7187 { 7188 use_field_sensitive = (param_max_fields_for_field_sensitive > 1); 7189 7190 bitmap_obstack_initialize (&pta_obstack); 7191 bitmap_obstack_initialize (&oldpta_obstack); 7192 bitmap_obstack_initialize (&predbitmap_obstack); 7193 7194 constraints.create (8); 7195 varmap.create (8); 7196 vi_for_tree = new hash_map<tree, varinfo_t>; 7197 call_stmt_vars = new hash_map<gimple *, varinfo_t>; 7198 7199 memset (&stats, 0, sizeof (stats)); 7200 shared_bitmap_table = new hash_table<shared_bitmap_hasher> (511); 7201 init_base_vars (); 7202 7203 gcc_obstack_init (&fake_var_decl_obstack); 7204 7205 final_solutions = new hash_map<varinfo_t, pt_solution *>; 7206 gcc_obstack_init (&final_solutions_obstack); 7207 } 7208 7209 /* Remove the REF and ADDRESS edges from GRAPH, as well as all the 7210 predecessor edges. */ 7211 7212 static void 7213 remove_preds_and_fake_succs (constraint_graph_t graph) 7214 { 7215 unsigned int i; 7216 7217 /* Clear the implicit ref and address nodes from the successor 7218 lists. */ 7219 for (i = 1; i < FIRST_REF_NODE; i++) 7220 { 7221 if (graph->succs[i]) 7222 bitmap_clear_range (graph->succs[i], FIRST_REF_NODE, 7223 FIRST_REF_NODE * 2); 7224 } 7225 7226 /* Free the successor list for the non-ref nodes. */ 7227 for (i = FIRST_REF_NODE + 1; i < graph->size; i++) 7228 { 7229 if (graph->succs[i]) 7230 BITMAP_FREE (graph->succs[i]); 7231 } 7232 7233 /* Now reallocate the size of the successor list as, and blow away 7234 the predecessor bitmaps. */ 7235 graph->size = varmap.length (); 7236 graph->succs = XRESIZEVEC (bitmap, graph->succs, graph->size); 7237 7238 free (graph->implicit_preds); 7239 graph->implicit_preds = NULL; 7240 free (graph->preds); 7241 graph->preds = NULL; 7242 bitmap_obstack_release (&predbitmap_obstack); 7243 } 7244 7245 /* Solve the constraint set. */ 7246 7247 static void 7248 solve_constraints (void) 7249 { 7250 class scc_info *si; 7251 7252 /* Sort varinfos so that ones that cannot be pointed to are last. 7253 This makes bitmaps more efficient. */ 7254 unsigned int *map = XNEWVEC (unsigned int, varmap.length ()); 7255 for (unsigned i = 0; i < integer_id + 1; ++i) 7256 map[i] = i; 7257 /* Start with non-register vars (as possibly address-taken), followed 7258 by register vars as conservative set of vars never appearing in 7259 the points-to solution bitmaps. */ 7260 unsigned j = integer_id + 1; 7261 for (unsigned i = integer_id + 1; i < varmap.length (); ++i) 7262 if (! varmap[i]->is_reg_var) 7263 map[i] = j++; 7264 for (unsigned i = integer_id + 1; i < varmap.length (); ++i) 7265 if (varmap[i]->is_reg_var) 7266 map[i] = j++; 7267 /* Shuffle varmap according to map. */ 7268 for (unsigned i = integer_id + 1; i < varmap.length (); ++i) 7269 { 7270 while (map[varmap[i]->id] != i) 7271 std::swap (varmap[i], varmap[map[varmap[i]->id]]); 7272 gcc_assert (bitmap_empty_p (varmap[i]->solution)); 7273 varmap[i]->id = i; 7274 varmap[i]->next = map[varmap[i]->next]; 7275 varmap[i]->head = map[varmap[i]->head]; 7276 } 7277 /* Finally rewrite constraints. */ 7278 for (unsigned i = 0; i < constraints.length (); ++i) 7279 { 7280 constraints[i]->lhs.var = map[constraints[i]->lhs.var]; 7281 constraints[i]->rhs.var = map[constraints[i]->rhs.var]; 7282 } 7283 free (map); 7284 7285 if (dump_file) 7286 fprintf (dump_file, 7287 "\nCollapsing static cycles and doing variable " 7288 "substitution\n"); 7289 7290 init_graph (varmap.length () * 2); 7291 7292 if (dump_file) 7293 fprintf (dump_file, "Building predecessor graph\n"); 7294 build_pred_graph (); 7295 7296 if (dump_file) 7297 fprintf (dump_file, "Detecting pointer and location " 7298 "equivalences\n"); 7299 si = perform_var_substitution (graph); 7300 7301 if (dump_file) 7302 fprintf (dump_file, "Rewriting constraints and unifying " 7303 "variables\n"); 7304 rewrite_constraints (graph, si); 7305 7306 build_succ_graph (); 7307 7308 free_var_substitution_info (si); 7309 7310 /* Attach complex constraints to graph nodes. */ 7311 move_complex_constraints (graph); 7312 7313 if (dump_file) 7314 fprintf (dump_file, "Uniting pointer but not location equivalent " 7315 "variables\n"); 7316 unite_pointer_equivalences (graph); 7317 7318 if (dump_file) 7319 fprintf (dump_file, "Finding indirect cycles\n"); 7320 find_indirect_cycles (graph); 7321 7322 /* Implicit nodes and predecessors are no longer necessary at this 7323 point. */ 7324 remove_preds_and_fake_succs (graph); 7325 7326 if (dump_file && (dump_flags & TDF_GRAPH)) 7327 { 7328 fprintf (dump_file, "\n\n// The constraint graph before solve-graph " 7329 "in dot format:\n"); 7330 dump_constraint_graph (dump_file); 7331 fprintf (dump_file, "\n\n"); 7332 } 7333 7334 if (dump_file) 7335 fprintf (dump_file, "Solving graph\n"); 7336 7337 solve_graph (graph); 7338 7339 if (dump_file && (dump_flags & TDF_GRAPH)) 7340 { 7341 fprintf (dump_file, "\n\n// The constraint graph after solve-graph " 7342 "in dot format:\n"); 7343 dump_constraint_graph (dump_file); 7344 fprintf (dump_file, "\n\n"); 7345 } 7346 } 7347 7348 /* Create points-to sets for the current function. See the comments 7349 at the start of the file for an algorithmic overview. */ 7350 7351 static void 7352 compute_points_to_sets (void) 7353 { 7354 basic_block bb; 7355 varinfo_t vi; 7356 7357 timevar_push (TV_TREE_PTA); 7358 7359 init_alias_vars (); 7360 7361 intra_create_variable_infos (cfun); 7362 7363 /* Now walk all statements and build the constraint set. */ 7364 FOR_EACH_BB_FN (bb, cfun) 7365 { 7366 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); 7367 gsi_next (&gsi)) 7368 { 7369 gphi *phi = gsi.phi (); 7370 7371 if (! virtual_operand_p (gimple_phi_result (phi))) 7372 find_func_aliases (cfun, phi); 7373 } 7374 7375 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi); 7376 gsi_next (&gsi)) 7377 { 7378 gimple *stmt = gsi_stmt (gsi); 7379 7380 find_func_aliases (cfun, stmt); 7381 } 7382 } 7383 7384 if (dump_file) 7385 { 7386 fprintf (dump_file, "Points-to analysis\n\nConstraints:\n\n"); 7387 dump_constraints (dump_file, 0); 7388 } 7389 7390 /* From the constraints compute the points-to sets. */ 7391 solve_constraints (); 7392 7393 /* Post-process solutions for escapes through returns. */ 7394 edge_iterator ei; 7395 edge e; 7396 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) 7397 if (greturn *ret = safe_dyn_cast <greturn *> (last_stmt (e->src))) 7398 { 7399 tree val = gimple_return_retval (ret); 7400 /* ??? Easy to handle simple indirections with some work. 7401 Arbitrary references like foo.bar.baz are more difficult 7402 (but conservatively easy enough with just looking at the base). 7403 Mind to fixup find_func_aliases as well. */ 7404 if (!val || !SSA_VAR_P (val)) 7405 continue; 7406 /* returns happen last in non-IPA so they only influence 7407 the ESCAPED solution and we can filter local variables. */ 7408 varinfo_t escaped_vi = get_varinfo (find (escaped_id)); 7409 varinfo_t vi = lookup_vi_for_tree (val); 7410 bitmap delta = BITMAP_ALLOC (&pta_obstack); 7411 bitmap_iterator bi; 7412 unsigned i; 7413 for (; vi; vi = vi_next (vi)) 7414 { 7415 varinfo_t part_vi = get_varinfo (find (vi->id)); 7416 EXECUTE_IF_AND_COMPL_IN_BITMAP (part_vi->solution, 7417 escaped_vi->solution, 0, i, bi) 7418 { 7419 varinfo_t pointed_to_vi = get_varinfo (i); 7420 if (pointed_to_vi->is_global_var 7421 /* We delay marking of heap memory as global. */ 7422 || pointed_to_vi->is_heap_var) 7423 bitmap_set_bit (delta, i); 7424 } 7425 } 7426 7427 /* Now compute the transitive closure. */ 7428 bitmap_ior_into (escaped_vi->solution, delta); 7429 bitmap new_delta = BITMAP_ALLOC (&pta_obstack); 7430 while (!bitmap_empty_p (delta)) 7431 { 7432 EXECUTE_IF_SET_IN_BITMAP (delta, 0, i, bi) 7433 { 7434 varinfo_t pointed_to_vi = get_varinfo (i); 7435 pointed_to_vi = get_varinfo (find (pointed_to_vi->id)); 7436 unsigned j; 7437 bitmap_iterator bi2; 7438 EXECUTE_IF_AND_COMPL_IN_BITMAP (pointed_to_vi->solution, 7439 escaped_vi->solution, 7440 0, j, bi2) 7441 { 7442 varinfo_t pointed_to_vi2 = get_varinfo (j); 7443 if (pointed_to_vi2->is_global_var 7444 /* We delay marking of heap memory as global. */ 7445 || pointed_to_vi2->is_heap_var) 7446 bitmap_set_bit (new_delta, j); 7447 } 7448 } 7449 bitmap_ior_into (escaped_vi->solution, new_delta); 7450 bitmap_clear (delta); 7451 std::swap (delta, new_delta); 7452 } 7453 BITMAP_FREE (delta); 7454 BITMAP_FREE (new_delta); 7455 } 7456 7457 if (dump_file) 7458 dump_sa_points_to_info (dump_file); 7459 7460 /* Compute the points-to set for ESCAPED used for call-clobber analysis. */ 7461 cfun->gimple_df->escaped = find_what_var_points_to (cfun->decl, 7462 get_varinfo (escaped_id)); 7463 7464 /* Make sure the ESCAPED solution (which is used as placeholder in 7465 other solutions) does not reference itself. This simplifies 7466 points-to solution queries. */ 7467 cfun->gimple_df->escaped.escaped = 0; 7468 7469 /* Compute the points-to sets for pointer SSA_NAMEs. */ 7470 unsigned i; 7471 tree ptr; 7472 7473 FOR_EACH_SSA_NAME (i, ptr, cfun) 7474 { 7475 if (POINTER_TYPE_P (TREE_TYPE (ptr))) 7476 find_what_p_points_to (cfun->decl, ptr); 7477 } 7478 7479 /* Compute the call-used/clobbered sets. */ 7480 FOR_EACH_BB_FN (bb, cfun) 7481 { 7482 gimple_stmt_iterator gsi; 7483 7484 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 7485 { 7486 gcall *stmt; 7487 struct pt_solution *pt; 7488 7489 stmt = dyn_cast <gcall *> (gsi_stmt (gsi)); 7490 if (!stmt) 7491 continue; 7492 7493 pt = gimple_call_use_set (stmt); 7494 if (gimple_call_flags (stmt) & ECF_CONST) 7495 memset (pt, 0, sizeof (struct pt_solution)); 7496 else if ((vi = lookup_call_use_vi (stmt)) != NULL) 7497 { 7498 *pt = find_what_var_points_to (cfun->decl, vi); 7499 /* Escaped (and thus nonlocal) variables are always 7500 implicitly used by calls. */ 7501 /* ??? ESCAPED can be empty even though NONLOCAL 7502 always escaped. */ 7503 pt->nonlocal = 1; 7504 pt->escaped = 1; 7505 } 7506 else 7507 { 7508 /* If there is nothing special about this call then 7509 we have made everything that is used also escape. */ 7510 *pt = cfun->gimple_df->escaped; 7511 pt->nonlocal = 1; 7512 } 7513 7514 pt = gimple_call_clobber_set (stmt); 7515 if (gimple_call_flags (stmt) & (ECF_CONST|ECF_PURE|ECF_NOVOPS)) 7516 memset (pt, 0, sizeof (struct pt_solution)); 7517 else if ((vi = lookup_call_clobber_vi (stmt)) != NULL) 7518 { 7519 *pt = find_what_var_points_to (cfun->decl, vi); 7520 /* Escaped (and thus nonlocal) variables are always 7521 implicitly clobbered by calls. */ 7522 /* ??? ESCAPED can be empty even though NONLOCAL 7523 always escaped. */ 7524 pt->nonlocal = 1; 7525 pt->escaped = 1; 7526 } 7527 else 7528 { 7529 /* If there is nothing special about this call then 7530 we have made everything that is used also escape. */ 7531 *pt = cfun->gimple_df->escaped; 7532 pt->nonlocal = 1; 7533 } 7534 } 7535 } 7536 7537 timevar_pop (TV_TREE_PTA); 7538 } 7539 7540 7541 /* Delete created points-to sets. */ 7542 7543 static void 7544 delete_points_to_sets (void) 7545 { 7546 unsigned int i; 7547 7548 delete shared_bitmap_table; 7549 shared_bitmap_table = NULL; 7550 if (dump_file && (dump_flags & TDF_STATS)) 7551 fprintf (dump_file, "Points to sets created:%d\n", 7552 stats.points_to_sets_created); 7553 7554 delete vi_for_tree; 7555 delete call_stmt_vars; 7556 bitmap_obstack_release (&pta_obstack); 7557 constraints.release (); 7558 7559 for (i = 0; i < graph->size; i++) 7560 graph->complex[i].release (); 7561 free (graph->complex); 7562 7563 free (graph->rep); 7564 free (graph->succs); 7565 free (graph->pe); 7566 free (graph->pe_rep); 7567 free (graph->indirect_cycles); 7568 free (graph); 7569 7570 varmap.release (); 7571 variable_info_pool.release (); 7572 constraint_pool.release (); 7573 7574 obstack_free (&fake_var_decl_obstack, NULL); 7575 7576 delete final_solutions; 7577 obstack_free (&final_solutions_obstack, NULL); 7578 } 7579 7580 struct vls_data 7581 { 7582 unsigned short clique; 7583 bool escaped_p; 7584 bitmap rvars; 7585 }; 7586 7587 /* Mark "other" loads and stores as belonging to CLIQUE and with 7588 base zero. */ 7589 7590 static bool 7591 visit_loadstore (gimple *, tree base, tree ref, void *data) 7592 { 7593 unsigned short clique = ((vls_data *) data)->clique; 7594 bitmap rvars = ((vls_data *) data)->rvars; 7595 bool escaped_p = ((vls_data *) data)->escaped_p; 7596 if (TREE_CODE (base) == MEM_REF 7597 || TREE_CODE (base) == TARGET_MEM_REF) 7598 { 7599 tree ptr = TREE_OPERAND (base, 0); 7600 if (TREE_CODE (ptr) == SSA_NAME) 7601 { 7602 /* For parameters, get at the points-to set for the actual parm 7603 decl. */ 7604 if (SSA_NAME_IS_DEFAULT_DEF (ptr) 7605 && (TREE_CODE (SSA_NAME_VAR (ptr)) == PARM_DECL 7606 || TREE_CODE (SSA_NAME_VAR (ptr)) == RESULT_DECL)) 7607 ptr = SSA_NAME_VAR (ptr); 7608 7609 /* We need to make sure 'ptr' doesn't include any of 7610 the restrict tags we added bases for in its points-to set. */ 7611 varinfo_t vi = lookup_vi_for_tree (ptr); 7612 if (! vi) 7613 return false; 7614 7615 vi = get_varinfo (find (vi->id)); 7616 if (bitmap_intersect_p (rvars, vi->solution) 7617 || (escaped_p && bitmap_bit_p (vi->solution, escaped_id))) 7618 return false; 7619 } 7620 7621 /* Do not overwrite existing cliques (that includes clique, base 7622 pairs we just set). */ 7623 if (MR_DEPENDENCE_CLIQUE (base) == 0) 7624 { 7625 MR_DEPENDENCE_CLIQUE (base) = clique; 7626 MR_DEPENDENCE_BASE (base) = 0; 7627 } 7628 } 7629 7630 /* For plain decl accesses see whether they are accesses to globals 7631 and rewrite them to MEM_REFs with { clique, 0 }. */ 7632 if (VAR_P (base) 7633 && is_global_var (base) 7634 /* ??? We can't rewrite a plain decl with the walk_stmt_load_store 7635 ops callback. */ 7636 && base != ref) 7637 { 7638 tree *basep = &ref; 7639 while (handled_component_p (*basep)) 7640 basep = &TREE_OPERAND (*basep, 0); 7641 gcc_assert (VAR_P (*basep)); 7642 tree ptr = build_fold_addr_expr (*basep); 7643 tree zero = build_int_cst (TREE_TYPE (ptr), 0); 7644 *basep = build2 (MEM_REF, TREE_TYPE (*basep), ptr, zero); 7645 MR_DEPENDENCE_CLIQUE (*basep) = clique; 7646 MR_DEPENDENCE_BASE (*basep) = 0; 7647 } 7648 7649 return false; 7650 } 7651 7652 struct msdi_data { 7653 tree ptr; 7654 unsigned short *clique; 7655 unsigned short *last_ruid; 7656 varinfo_t restrict_var; 7657 }; 7658 7659 /* If BASE is a MEM_REF then assign a clique, base pair to it, updating 7660 CLIQUE, *RESTRICT_VAR and LAST_RUID as passed via DATA. 7661 Return whether dependence info was assigned to BASE. */ 7662 7663 static bool 7664 maybe_set_dependence_info (gimple *, tree base, tree, void *data) 7665 { 7666 tree ptr = ((msdi_data *)data)->ptr; 7667 unsigned short &clique = *((msdi_data *)data)->clique; 7668 unsigned short &last_ruid = *((msdi_data *)data)->last_ruid; 7669 varinfo_t restrict_var = ((msdi_data *)data)->restrict_var; 7670 if ((TREE_CODE (base) == MEM_REF 7671 || TREE_CODE (base) == TARGET_MEM_REF) 7672 && TREE_OPERAND (base, 0) == ptr) 7673 { 7674 /* Do not overwrite existing cliques. This avoids overwriting dependence 7675 info inlined from a function with restrict parameters inlined 7676 into a function with restrict parameters. This usually means we 7677 prefer to be precise in innermost loops. */ 7678 if (MR_DEPENDENCE_CLIQUE (base) == 0) 7679 { 7680 if (clique == 0) 7681 { 7682 if (cfun->last_clique == 0) 7683 cfun->last_clique = 1; 7684 clique = 1; 7685 } 7686 if (restrict_var->ruid == 0) 7687 restrict_var->ruid = ++last_ruid; 7688 MR_DEPENDENCE_CLIQUE (base) = clique; 7689 MR_DEPENDENCE_BASE (base) = restrict_var->ruid; 7690 return true; 7691 } 7692 } 7693 return false; 7694 } 7695 7696 /* Clear dependence info for the clique DATA. */ 7697 7698 static bool 7699 clear_dependence_clique (gimple *, tree base, tree, void *data) 7700 { 7701 unsigned short clique = (uintptr_t)data; 7702 if ((TREE_CODE (base) == MEM_REF 7703 || TREE_CODE (base) == TARGET_MEM_REF) 7704 && MR_DEPENDENCE_CLIQUE (base) == clique) 7705 { 7706 MR_DEPENDENCE_CLIQUE (base) = 0; 7707 MR_DEPENDENCE_BASE (base) = 0; 7708 } 7709 7710 return false; 7711 } 7712 7713 /* Compute the set of independend memory references based on restrict 7714 tags and their conservative propagation to the points-to sets. */ 7715 7716 static void 7717 compute_dependence_clique (void) 7718 { 7719 /* First clear the special "local" clique. */ 7720 basic_block bb; 7721 if (cfun->last_clique != 0) 7722 FOR_EACH_BB_FN (bb, cfun) 7723 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); 7724 !gsi_end_p (gsi); gsi_next (&gsi)) 7725 { 7726 gimple *stmt = gsi_stmt (gsi); 7727 walk_stmt_load_store_ops (stmt, (void *)(uintptr_t) 1, 7728 clear_dependence_clique, 7729 clear_dependence_clique); 7730 } 7731 7732 unsigned short clique = 0; 7733 unsigned short last_ruid = 0; 7734 bitmap rvars = BITMAP_ALLOC (NULL); 7735 bool escaped_p = false; 7736 for (unsigned i = 0; i < num_ssa_names; ++i) 7737 { 7738 tree ptr = ssa_name (i); 7739 if (!ptr || !POINTER_TYPE_P (TREE_TYPE (ptr))) 7740 continue; 7741 7742 /* Avoid all this when ptr is not dereferenced? */ 7743 tree p = ptr; 7744 if (SSA_NAME_IS_DEFAULT_DEF (ptr) 7745 && (TREE_CODE (SSA_NAME_VAR (ptr)) == PARM_DECL 7746 || TREE_CODE (SSA_NAME_VAR (ptr)) == RESULT_DECL)) 7747 p = SSA_NAME_VAR (ptr); 7748 varinfo_t vi = lookup_vi_for_tree (p); 7749 if (!vi) 7750 continue; 7751 vi = get_varinfo (find (vi->id)); 7752 bitmap_iterator bi; 7753 unsigned j; 7754 varinfo_t restrict_var = NULL; 7755 EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, j, bi) 7756 { 7757 varinfo_t oi = get_varinfo (j); 7758 if (oi->head != j) 7759 oi = get_varinfo (oi->head); 7760 if (oi->is_restrict_var) 7761 { 7762 if (restrict_var 7763 && restrict_var != oi) 7764 { 7765 if (dump_file && (dump_flags & TDF_DETAILS)) 7766 { 7767 fprintf (dump_file, "found restrict pointed-to " 7768 "for "); 7769 print_generic_expr (dump_file, ptr); 7770 fprintf (dump_file, " but not exclusively\n"); 7771 } 7772 restrict_var = NULL; 7773 break; 7774 } 7775 restrict_var = oi; 7776 } 7777 /* NULL is the only other valid points-to entry. */ 7778 else if (oi->id != nothing_id) 7779 { 7780 restrict_var = NULL; 7781 break; 7782 } 7783 } 7784 /* Ok, found that ptr must(!) point to a single(!) restrict 7785 variable. */ 7786 /* ??? PTA isn't really a proper propagation engine to compute 7787 this property. 7788 ??? We could handle merging of two restricts by unifying them. */ 7789 if (restrict_var) 7790 { 7791 /* Now look at possible dereferences of ptr. */ 7792 imm_use_iterator ui; 7793 gimple *use_stmt; 7794 bool used = false; 7795 msdi_data data = { ptr, &clique, &last_ruid, restrict_var }; 7796 FOR_EACH_IMM_USE_STMT (use_stmt, ui, ptr) 7797 used |= walk_stmt_load_store_ops (use_stmt, &data, 7798 maybe_set_dependence_info, 7799 maybe_set_dependence_info); 7800 if (used) 7801 { 7802 /* Add all subvars to the set of restrict pointed-to set. */ 7803 for (unsigned sv = restrict_var->head; sv != 0; 7804 sv = get_varinfo (sv)->next) 7805 bitmap_set_bit (rvars, sv); 7806 varinfo_t escaped = get_varinfo (find (escaped_id)); 7807 if (bitmap_bit_p (escaped->solution, restrict_var->id)) 7808 escaped_p = true; 7809 } 7810 } 7811 } 7812 7813 if (clique != 0) 7814 { 7815 /* Assign the BASE id zero to all accesses not based on a restrict 7816 pointer. That way they get disambiguated against restrict 7817 accesses but not against each other. */ 7818 /* ??? For restricts derived from globals (thus not incoming 7819 parameters) we can't restrict scoping properly thus the following 7820 is too aggressive there. For now we have excluded those globals from 7821 getting into the MR_DEPENDENCE machinery. */ 7822 vls_data data = { clique, escaped_p, rvars }; 7823 basic_block bb; 7824 FOR_EACH_BB_FN (bb, cfun) 7825 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); 7826 !gsi_end_p (gsi); gsi_next (&gsi)) 7827 { 7828 gimple *stmt = gsi_stmt (gsi); 7829 walk_stmt_load_store_ops (stmt, &data, 7830 visit_loadstore, visit_loadstore); 7831 } 7832 } 7833 7834 BITMAP_FREE (rvars); 7835 } 7836 7837 /* Compute points-to information for every SSA_NAME pointer in the 7838 current function and compute the transitive closure of escaped 7839 variables to re-initialize the call-clobber states of local variables. */ 7840 7841 unsigned int 7842 compute_may_aliases (void) 7843 { 7844 if (cfun->gimple_df->ipa_pta) 7845 { 7846 if (dump_file) 7847 { 7848 fprintf (dump_file, "\nNot re-computing points-to information " 7849 "because IPA points-to information is available.\n\n"); 7850 7851 /* But still dump what we have remaining it. */ 7852 dump_alias_info (dump_file); 7853 } 7854 7855 return 0; 7856 } 7857 7858 /* For each pointer P_i, determine the sets of variables that P_i may 7859 point-to. Compute the reachability set of escaped and call-used 7860 variables. */ 7861 compute_points_to_sets (); 7862 7863 /* Debugging dumps. */ 7864 if (dump_file) 7865 dump_alias_info (dump_file); 7866 7867 /* Compute restrict-based memory disambiguations. */ 7868 compute_dependence_clique (); 7869 7870 /* Deallocate memory used by aliasing data structures and the internal 7871 points-to solution. */ 7872 delete_points_to_sets (); 7873 7874 gcc_assert (!need_ssa_update_p (cfun)); 7875 7876 return 0; 7877 } 7878 7879 /* A dummy pass to cause points-to information to be computed via 7880 TODO_rebuild_alias. */ 7881 7882 namespace { 7883 7884 const pass_data pass_data_build_alias = 7885 { 7886 GIMPLE_PASS, /* type */ 7887 "alias", /* name */ 7888 OPTGROUP_NONE, /* optinfo_flags */ 7889 TV_NONE, /* tv_id */ 7890 ( PROP_cfg | PROP_ssa ), /* properties_required */ 7891 0, /* properties_provided */ 7892 0, /* properties_destroyed */ 7893 0, /* todo_flags_start */ 7894 TODO_rebuild_alias, /* todo_flags_finish */ 7895 }; 7896 7897 class pass_build_alias : public gimple_opt_pass 7898 { 7899 public: 7900 pass_build_alias (gcc::context *ctxt) 7901 : gimple_opt_pass (pass_data_build_alias, ctxt) 7902 {} 7903 7904 /* opt_pass methods: */ 7905 virtual bool gate (function *) { return flag_tree_pta; } 7906 7907 }; // class pass_build_alias 7908 7909 } // anon namespace 7910 7911 gimple_opt_pass * 7912 make_pass_build_alias (gcc::context *ctxt) 7913 { 7914 return new pass_build_alias (ctxt); 7915 } 7916 7917 /* A dummy pass to cause points-to information to be computed via 7918 TODO_rebuild_alias. */ 7919 7920 namespace { 7921 7922 const pass_data pass_data_build_ealias = 7923 { 7924 GIMPLE_PASS, /* type */ 7925 "ealias", /* name */ 7926 OPTGROUP_NONE, /* optinfo_flags */ 7927 TV_NONE, /* tv_id */ 7928 ( PROP_cfg | PROP_ssa ), /* properties_required */ 7929 0, /* properties_provided */ 7930 0, /* properties_destroyed */ 7931 0, /* todo_flags_start */ 7932 TODO_rebuild_alias, /* todo_flags_finish */ 7933 }; 7934 7935 class pass_build_ealias : public gimple_opt_pass 7936 { 7937 public: 7938 pass_build_ealias (gcc::context *ctxt) 7939 : gimple_opt_pass (pass_data_build_ealias, ctxt) 7940 {} 7941 7942 /* opt_pass methods: */ 7943 virtual bool gate (function *) { return flag_tree_pta; } 7944 7945 }; // class pass_build_ealias 7946 7947 } // anon namespace 7948 7949 gimple_opt_pass * 7950 make_pass_build_ealias (gcc::context *ctxt) 7951 { 7952 return new pass_build_ealias (ctxt); 7953 } 7954 7955 7956 /* IPA PTA solutions for ESCAPED. */ 7957 struct pt_solution ipa_escaped_pt 7958 = { true, false, false, false, false, 7959 false, false, false, false, false, NULL }; 7960 7961 /* Associate node with varinfo DATA. Worker for 7962 cgraph_for_symbol_thunks_and_aliases. */ 7963 static bool 7964 associate_varinfo_to_alias (struct cgraph_node *node, void *data) 7965 { 7966 if ((node->alias 7967 || (node->thunk.thunk_p 7968 && ! node->inlined_to)) 7969 && node->analyzed 7970 && !node->ifunc_resolver) 7971 insert_vi_for_tree (node->decl, (varinfo_t)data); 7972 return false; 7973 } 7974 7975 /* Dump varinfo VI to FILE. */ 7976 7977 static void 7978 dump_varinfo (FILE *file, varinfo_t vi) 7979 { 7980 if (vi == NULL) 7981 return; 7982 7983 fprintf (file, "%u: %s\n", vi->id, vi->name); 7984 7985 const char *sep = " "; 7986 if (vi->is_artificial_var) 7987 fprintf (file, "%sartificial", sep); 7988 if (vi->is_special_var) 7989 fprintf (file, "%sspecial", sep); 7990 if (vi->is_unknown_size_var) 7991 fprintf (file, "%sunknown-size", sep); 7992 if (vi->is_full_var) 7993 fprintf (file, "%sfull", sep); 7994 if (vi->is_heap_var) 7995 fprintf (file, "%sheap", sep); 7996 if (vi->may_have_pointers) 7997 fprintf (file, "%smay-have-pointers", sep); 7998 if (vi->only_restrict_pointers) 7999 fprintf (file, "%sonly-restrict-pointers", sep); 8000 if (vi->is_restrict_var) 8001 fprintf (file, "%sis-restrict-var", sep); 8002 if (vi->is_global_var) 8003 fprintf (file, "%sglobal", sep); 8004 if (vi->is_ipa_escape_point) 8005 fprintf (file, "%sipa-escape-point", sep); 8006 if (vi->is_fn_info) 8007 fprintf (file, "%sfn-info", sep); 8008 if (vi->ruid) 8009 fprintf (file, "%srestrict-uid:%u", sep, vi->ruid); 8010 if (vi->next) 8011 fprintf (file, "%snext:%u", sep, vi->next); 8012 if (vi->head != vi->id) 8013 fprintf (file, "%shead:%u", sep, vi->head); 8014 if (vi->offset) 8015 fprintf (file, "%soffset:" HOST_WIDE_INT_PRINT_DEC, sep, vi->offset); 8016 if (vi->size != ~(unsigned HOST_WIDE_INT)0) 8017 fprintf (file, "%ssize:" HOST_WIDE_INT_PRINT_DEC, sep, vi->size); 8018 if (vi->fullsize != ~(unsigned HOST_WIDE_INT)0 8019 && vi->fullsize != vi->size) 8020 fprintf (file, "%sfullsize:" HOST_WIDE_INT_PRINT_DEC, sep, 8021 vi->fullsize); 8022 fprintf (file, "\n"); 8023 8024 if (vi->solution && !bitmap_empty_p (vi->solution)) 8025 { 8026 bitmap_iterator bi; 8027 unsigned i; 8028 fprintf (file, " solution: {"); 8029 EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, i, bi) 8030 fprintf (file, " %u", i); 8031 fprintf (file, " }\n"); 8032 } 8033 8034 if (vi->oldsolution && !bitmap_empty_p (vi->oldsolution) 8035 && !bitmap_equal_p (vi->solution, vi->oldsolution)) 8036 { 8037 bitmap_iterator bi; 8038 unsigned i; 8039 fprintf (file, " oldsolution: {"); 8040 EXECUTE_IF_SET_IN_BITMAP (vi->oldsolution, 0, i, bi) 8041 fprintf (file, " %u", i); 8042 fprintf (file, " }\n"); 8043 } 8044 } 8045 8046 /* Dump varinfo VI to stderr. */ 8047 8048 DEBUG_FUNCTION void 8049 debug_varinfo (varinfo_t vi) 8050 { 8051 dump_varinfo (stderr, vi); 8052 } 8053 8054 /* Dump varmap to FILE. */ 8055 8056 static void 8057 dump_varmap (FILE *file) 8058 { 8059 if (varmap.length () == 0) 8060 return; 8061 8062 fprintf (file, "variables:\n"); 8063 8064 for (unsigned int i = 0; i < varmap.length (); ++i) 8065 { 8066 varinfo_t vi = get_varinfo (i); 8067 dump_varinfo (file, vi); 8068 } 8069 8070 fprintf (file, "\n"); 8071 } 8072 8073 /* Dump varmap to stderr. */ 8074 8075 DEBUG_FUNCTION void 8076 debug_varmap (void) 8077 { 8078 dump_varmap (stderr); 8079 } 8080 8081 /* Compute whether node is refered to non-locally. Worker for 8082 cgraph_for_symbol_thunks_and_aliases. */ 8083 static bool 8084 refered_from_nonlocal_fn (struct cgraph_node *node, void *data) 8085 { 8086 bool *nonlocal_p = (bool *)data; 8087 *nonlocal_p |= (node->used_from_other_partition 8088 || DECL_EXTERNAL (node->decl) 8089 || TREE_PUBLIC (node->decl) 8090 || node->force_output 8091 || lookup_attribute ("noipa", DECL_ATTRIBUTES (node->decl))); 8092 return false; 8093 } 8094 8095 /* Same for varpool nodes. */ 8096 static bool 8097 refered_from_nonlocal_var (struct varpool_node *node, void *data) 8098 { 8099 bool *nonlocal_p = (bool *)data; 8100 *nonlocal_p |= (node->used_from_other_partition 8101 || DECL_EXTERNAL (node->decl) 8102 || TREE_PUBLIC (node->decl) 8103 || node->force_output); 8104 return false; 8105 } 8106 8107 /* Execute the driver for IPA PTA. */ 8108 static unsigned int 8109 ipa_pta_execute (void) 8110 { 8111 struct cgraph_node *node; 8112 varpool_node *var; 8113 unsigned int from = 0; 8114 8115 in_ipa_mode = 1; 8116 8117 init_alias_vars (); 8118 8119 if (dump_file && (dump_flags & TDF_DETAILS)) 8120 { 8121 symtab->dump (dump_file); 8122 fprintf (dump_file, "\n"); 8123 } 8124 8125 if (dump_file) 8126 { 8127 fprintf (dump_file, "Generating generic constraints\n\n"); 8128 dump_constraints (dump_file, from); 8129 fprintf (dump_file, "\n"); 8130 from = constraints.length (); 8131 } 8132 8133 /* Build the constraints. */ 8134 FOR_EACH_DEFINED_FUNCTION (node) 8135 { 8136 varinfo_t vi; 8137 /* Nodes without a body in this partition are not interesting. 8138 Especially do not visit clones at this point for now - we 8139 get duplicate decls there for inline clones at least. */ 8140 if (!node->has_gimple_body_p () 8141 || node->in_other_partition 8142 || node->inlined_to) 8143 continue; 8144 node->get_body (); 8145 8146 gcc_assert (!node->clone_of); 8147 8148 /* For externally visible or attribute used annotated functions use 8149 local constraints for their arguments. 8150 For local functions we see all callers and thus do not need initial 8151 constraints for parameters. */ 8152 bool nonlocal_p = (node->used_from_other_partition 8153 || DECL_EXTERNAL (node->decl) 8154 || TREE_PUBLIC (node->decl) 8155 || node->force_output 8156 || lookup_attribute ("noipa", 8157 DECL_ATTRIBUTES (node->decl))); 8158 node->call_for_symbol_thunks_and_aliases (refered_from_nonlocal_fn, 8159 &nonlocal_p, true); 8160 8161 vi = create_function_info_for (node->decl, 8162 alias_get_name (node->decl), false, 8163 nonlocal_p); 8164 if (dump_file 8165 && from != constraints.length ()) 8166 { 8167 fprintf (dump_file, 8168 "Generating initial constraints for %s", 8169 node->dump_name ()); 8170 if (DECL_ASSEMBLER_NAME_SET_P (node->decl)) 8171 fprintf (dump_file, " (%s)", 8172 IDENTIFIER_POINTER 8173 (DECL_ASSEMBLER_NAME (node->decl))); 8174 fprintf (dump_file, "\n\n"); 8175 dump_constraints (dump_file, from); 8176 fprintf (dump_file, "\n"); 8177 8178 from = constraints.length (); 8179 } 8180 8181 node->call_for_symbol_thunks_and_aliases 8182 (associate_varinfo_to_alias, vi, true); 8183 } 8184 8185 /* Create constraints for global variables and their initializers. */ 8186 FOR_EACH_VARIABLE (var) 8187 { 8188 if (var->alias && var->analyzed) 8189 continue; 8190 8191 varinfo_t vi = get_vi_for_tree (var->decl); 8192 8193 /* For the purpose of IPA PTA unit-local globals are not 8194 escape points. */ 8195 bool nonlocal_p = (DECL_EXTERNAL (var->decl) 8196 || TREE_PUBLIC (var->decl) 8197 || var->used_from_other_partition 8198 || var->force_output); 8199 var->call_for_symbol_and_aliases (refered_from_nonlocal_var, 8200 &nonlocal_p, true); 8201 if (nonlocal_p) 8202 vi->is_ipa_escape_point = true; 8203 } 8204 8205 if (dump_file 8206 && from != constraints.length ()) 8207 { 8208 fprintf (dump_file, 8209 "Generating constraints for global initializers\n\n"); 8210 dump_constraints (dump_file, from); 8211 fprintf (dump_file, "\n"); 8212 from = constraints.length (); 8213 } 8214 8215 FOR_EACH_DEFINED_FUNCTION (node) 8216 { 8217 struct function *func; 8218 basic_block bb; 8219 8220 /* Nodes without a body in this partition are not interesting. */ 8221 if (!node->has_gimple_body_p () 8222 || node->in_other_partition 8223 || node->clone_of) 8224 continue; 8225 8226 if (dump_file) 8227 { 8228 fprintf (dump_file, 8229 "Generating constraints for %s", node->dump_name ()); 8230 if (DECL_ASSEMBLER_NAME_SET_P (node->decl)) 8231 fprintf (dump_file, " (%s)", 8232 IDENTIFIER_POINTER 8233 (DECL_ASSEMBLER_NAME (node->decl))); 8234 fprintf (dump_file, "\n"); 8235 } 8236 8237 func = DECL_STRUCT_FUNCTION (node->decl); 8238 gcc_assert (cfun == NULL); 8239 8240 /* Build constriants for the function body. */ 8241 FOR_EACH_BB_FN (bb, func) 8242 { 8243 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); 8244 gsi_next (&gsi)) 8245 { 8246 gphi *phi = gsi.phi (); 8247 8248 if (! virtual_operand_p (gimple_phi_result (phi))) 8249 find_func_aliases (func, phi); 8250 } 8251 8252 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi); 8253 gsi_next (&gsi)) 8254 { 8255 gimple *stmt = gsi_stmt (gsi); 8256 8257 find_func_aliases (func, stmt); 8258 find_func_clobbers (func, stmt); 8259 } 8260 } 8261 8262 if (dump_file) 8263 { 8264 fprintf (dump_file, "\n"); 8265 dump_constraints (dump_file, from); 8266 fprintf (dump_file, "\n"); 8267 from = constraints.length (); 8268 } 8269 } 8270 8271 /* From the constraints compute the points-to sets. */ 8272 solve_constraints (); 8273 8274 if (dump_file) 8275 dump_sa_points_to_info (dump_file); 8276 8277 /* Now post-process solutions to handle locals from different 8278 runtime instantiations coming in through recursive invocations. */ 8279 unsigned shadow_var_cnt = 0; 8280 for (unsigned i = 1; i < varmap.length (); ++i) 8281 { 8282 varinfo_t fi = get_varinfo (i); 8283 if (fi->is_fn_info 8284 && fi->decl) 8285 /* Automatic variables pointed to by their containing functions 8286 parameters need this treatment. */ 8287 for (varinfo_t ai = first_vi_for_offset (fi, fi_parm_base); 8288 ai; ai = vi_next (ai)) 8289 { 8290 varinfo_t vi = get_varinfo (find (ai->id)); 8291 bitmap_iterator bi; 8292 unsigned j; 8293 EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, j, bi) 8294 { 8295 varinfo_t pt = get_varinfo (j); 8296 if (pt->shadow_var_uid == 0 8297 && pt->decl 8298 && auto_var_in_fn_p (pt->decl, fi->decl)) 8299 { 8300 pt->shadow_var_uid = allocate_decl_uid (); 8301 shadow_var_cnt++; 8302 } 8303 } 8304 } 8305 /* As well as global variables which are another way of passing 8306 arguments to recursive invocations. */ 8307 else if (fi->is_global_var) 8308 { 8309 for (varinfo_t ai = fi; ai; ai = vi_next (ai)) 8310 { 8311 varinfo_t vi = get_varinfo (find (ai->id)); 8312 bitmap_iterator bi; 8313 unsigned j; 8314 EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, j, bi) 8315 { 8316 varinfo_t pt = get_varinfo (j); 8317 if (pt->shadow_var_uid == 0 8318 && pt->decl 8319 && auto_var_p (pt->decl)) 8320 { 8321 pt->shadow_var_uid = allocate_decl_uid (); 8322 shadow_var_cnt++; 8323 } 8324 } 8325 } 8326 } 8327 } 8328 if (shadow_var_cnt && dump_file && (dump_flags & TDF_DETAILS)) 8329 fprintf (dump_file, "Allocated %u shadow variables for locals " 8330 "maybe leaking into recursive invocations of their containing " 8331 "functions\n", shadow_var_cnt); 8332 8333 /* Compute the global points-to sets for ESCAPED. 8334 ??? Note that the computed escape set is not correct 8335 for the whole unit as we fail to consider graph edges to 8336 externally visible functions. */ 8337 ipa_escaped_pt = find_what_var_points_to (NULL, get_varinfo (escaped_id)); 8338 8339 /* Make sure the ESCAPED solution (which is used as placeholder in 8340 other solutions) does not reference itself. This simplifies 8341 points-to solution queries. */ 8342 ipa_escaped_pt.ipa_escaped = 0; 8343 8344 /* Assign the points-to sets to the SSA names in the unit. */ 8345 FOR_EACH_DEFINED_FUNCTION (node) 8346 { 8347 tree ptr; 8348 struct function *fn; 8349 unsigned i; 8350 basic_block bb; 8351 8352 /* Nodes without a body in this partition are not interesting. */ 8353 if (!node->has_gimple_body_p () 8354 || node->in_other_partition 8355 || node->clone_of) 8356 continue; 8357 8358 fn = DECL_STRUCT_FUNCTION (node->decl); 8359 8360 /* Compute the points-to sets for pointer SSA_NAMEs. */ 8361 FOR_EACH_VEC_ELT (*fn->gimple_df->ssa_names, i, ptr) 8362 { 8363 if (ptr 8364 && POINTER_TYPE_P (TREE_TYPE (ptr))) 8365 find_what_p_points_to (node->decl, ptr); 8366 } 8367 8368 /* Compute the call-use and call-clobber sets for indirect calls 8369 and calls to external functions. */ 8370 FOR_EACH_BB_FN (bb, fn) 8371 { 8372 gimple_stmt_iterator gsi; 8373 8374 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 8375 { 8376 gcall *stmt; 8377 struct pt_solution *pt; 8378 varinfo_t vi, fi; 8379 tree decl; 8380 8381 stmt = dyn_cast <gcall *> (gsi_stmt (gsi)); 8382 if (!stmt) 8383 continue; 8384 8385 /* Handle direct calls to functions with body. */ 8386 decl = gimple_call_fndecl (stmt); 8387 8388 { 8389 tree called_decl = NULL_TREE; 8390 if (gimple_call_builtin_p (stmt, BUILT_IN_GOMP_PARALLEL)) 8391 called_decl = TREE_OPERAND (gimple_call_arg (stmt, 0), 0); 8392 else if (gimple_call_builtin_p (stmt, BUILT_IN_GOACC_PARALLEL)) 8393 called_decl = TREE_OPERAND (gimple_call_arg (stmt, 1), 0); 8394 8395 if (called_decl != NULL_TREE 8396 && !fndecl_maybe_in_other_partition (called_decl)) 8397 decl = called_decl; 8398 } 8399 8400 if (decl 8401 && (fi = lookup_vi_for_tree (decl)) 8402 && fi->is_fn_info) 8403 { 8404 *gimple_call_clobber_set (stmt) 8405 = find_what_var_points_to 8406 (node->decl, first_vi_for_offset (fi, fi_clobbers)); 8407 *gimple_call_use_set (stmt) 8408 = find_what_var_points_to 8409 (node->decl, first_vi_for_offset (fi, fi_uses)); 8410 } 8411 /* Handle direct calls to external functions. */ 8412 else if (decl && (!fi || fi->decl)) 8413 { 8414 pt = gimple_call_use_set (stmt); 8415 if (gimple_call_flags (stmt) & ECF_CONST) 8416 memset (pt, 0, sizeof (struct pt_solution)); 8417 else if ((vi = lookup_call_use_vi (stmt)) != NULL) 8418 { 8419 *pt = find_what_var_points_to (node->decl, vi); 8420 /* Escaped (and thus nonlocal) variables are always 8421 implicitly used by calls. */ 8422 /* ??? ESCAPED can be empty even though NONLOCAL 8423 always escaped. */ 8424 pt->nonlocal = 1; 8425 pt->ipa_escaped = 1; 8426 } 8427 else 8428 { 8429 /* If there is nothing special about this call then 8430 we have made everything that is used also escape. */ 8431 *pt = ipa_escaped_pt; 8432 pt->nonlocal = 1; 8433 } 8434 8435 pt = gimple_call_clobber_set (stmt); 8436 if (gimple_call_flags (stmt) & (ECF_CONST|ECF_PURE|ECF_NOVOPS)) 8437 memset (pt, 0, sizeof (struct pt_solution)); 8438 else if ((vi = lookup_call_clobber_vi (stmt)) != NULL) 8439 { 8440 *pt = find_what_var_points_to (node->decl, vi); 8441 /* Escaped (and thus nonlocal) variables are always 8442 implicitly clobbered by calls. */ 8443 /* ??? ESCAPED can be empty even though NONLOCAL 8444 always escaped. */ 8445 pt->nonlocal = 1; 8446 pt->ipa_escaped = 1; 8447 } 8448 else 8449 { 8450 /* If there is nothing special about this call then 8451 we have made everything that is used also escape. */ 8452 *pt = ipa_escaped_pt; 8453 pt->nonlocal = 1; 8454 } 8455 } 8456 /* Handle indirect calls. */ 8457 else if ((fi = get_fi_for_callee (stmt))) 8458 { 8459 /* We need to accumulate all clobbers/uses of all possible 8460 callees. */ 8461 fi = get_varinfo (find (fi->id)); 8462 /* If we cannot constrain the set of functions we'll end up 8463 calling we end up using/clobbering everything. */ 8464 if (bitmap_bit_p (fi->solution, anything_id) 8465 || bitmap_bit_p (fi->solution, nonlocal_id) 8466 || bitmap_bit_p (fi->solution, escaped_id)) 8467 { 8468 pt_solution_reset (gimple_call_clobber_set (stmt)); 8469 pt_solution_reset (gimple_call_use_set (stmt)); 8470 } 8471 else 8472 { 8473 bitmap_iterator bi; 8474 unsigned i; 8475 struct pt_solution *uses, *clobbers; 8476 8477 uses = gimple_call_use_set (stmt); 8478 clobbers = gimple_call_clobber_set (stmt); 8479 memset (uses, 0, sizeof (struct pt_solution)); 8480 memset (clobbers, 0, sizeof (struct pt_solution)); 8481 EXECUTE_IF_SET_IN_BITMAP (fi->solution, 0, i, bi) 8482 { 8483 struct pt_solution sol; 8484 8485 vi = get_varinfo (i); 8486 if (!vi->is_fn_info) 8487 { 8488 /* ??? We could be more precise here? */ 8489 uses->nonlocal = 1; 8490 uses->ipa_escaped = 1; 8491 clobbers->nonlocal = 1; 8492 clobbers->ipa_escaped = 1; 8493 continue; 8494 } 8495 8496 if (!uses->anything) 8497 { 8498 sol = find_what_var_points_to 8499 (node->decl, 8500 first_vi_for_offset (vi, fi_uses)); 8501 pt_solution_ior_into (uses, &sol); 8502 } 8503 if (!clobbers->anything) 8504 { 8505 sol = find_what_var_points_to 8506 (node->decl, 8507 first_vi_for_offset (vi, fi_clobbers)); 8508 pt_solution_ior_into (clobbers, &sol); 8509 } 8510 } 8511 } 8512 } 8513 else 8514 gcc_unreachable (); 8515 } 8516 } 8517 8518 fn->gimple_df->ipa_pta = true; 8519 8520 /* We have to re-set the final-solution cache after each function 8521 because what is a "global" is dependent on function context. */ 8522 final_solutions->empty (); 8523 obstack_free (&final_solutions_obstack, NULL); 8524 gcc_obstack_init (&final_solutions_obstack); 8525 } 8526 8527 delete_points_to_sets (); 8528 8529 in_ipa_mode = 0; 8530 8531 return 0; 8532 } 8533 8534 namespace { 8535 8536 const pass_data pass_data_ipa_pta = 8537 { 8538 SIMPLE_IPA_PASS, /* type */ 8539 "pta", /* name */ 8540 OPTGROUP_NONE, /* optinfo_flags */ 8541 TV_IPA_PTA, /* tv_id */ 8542 0, /* properties_required */ 8543 0, /* properties_provided */ 8544 0, /* properties_destroyed */ 8545 0, /* todo_flags_start */ 8546 0, /* todo_flags_finish */ 8547 }; 8548 8549 class pass_ipa_pta : public simple_ipa_opt_pass 8550 { 8551 public: 8552 pass_ipa_pta (gcc::context *ctxt) 8553 : simple_ipa_opt_pass (pass_data_ipa_pta, ctxt) 8554 {} 8555 8556 /* opt_pass methods: */ 8557 virtual bool gate (function *) 8558 { 8559 return (optimize 8560 && flag_ipa_pta 8561 /* Don't bother doing anything if the program has errors. */ 8562 && !seen_error ()); 8563 } 8564 8565 opt_pass * clone () { return new pass_ipa_pta (m_ctxt); } 8566 8567 virtual unsigned int execute (function *) { return ipa_pta_execute (); } 8568 8569 }; // class pass_ipa_pta 8570 8571 } // anon namespace 8572 8573 simple_ipa_opt_pass * 8574 make_pass_ipa_pta (gcc::context *ctxt) 8575 { 8576 return new pass_ipa_pta (ctxt); 8577 } 8578