/* Tree based points-to analysis | |

Copyright (C) 2005-2013 Free Software Foundation, Inc. | |

Contributed by Daniel Berlin <dberlin@dberlin.org> | |

This file is part of GCC. | |

GCC is free software; you can redistribute it and/or modify | |

under the terms of the GNU General Public License as published by | |

the Free Software Foundation; either version 3 of the License, or | |

(at your option) any later version. | |

GCC is distributed in the hope that it will be useful, | |

but WITHOUT ANY WARRANTY; without even the implied warranty of | |

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |

GNU General Public License for more details. | |

You should have received a copy of the GNU General Public License | |

along with GCC; see the file COPYING3. If not see | |

<http://www.gnu.org/licenses/>. */ | |

#include "config.h" | |

#include "system.h" | |

#include "coretypes.h" | |

#include "tm.h" | |

#include "ggc.h" | |

#include "obstack.h" | |

#include "bitmap.h" | |

#include "flags.h" | |

#include "basic-block.h" | |

#include "tree.h" | |

#include "tree-flow.h" | |

#include "tree-inline.h" | |

#include "diagnostic-core.h" | |

#include "gimple.h" | |

#include "hashtab.h" | |

#include "function.h" | |

#include "cgraph.h" | |

#include "tree-pass.h" | |

#include "alloc-pool.h" | |

#include "splay-tree.h" | |

#include "params.h" | |

#include "cgraph.h" | |

#include "alias.h" | |

#include "pointer-set.h" | |

/* The idea behind this analyzer is to generate set constraints from the | |

program, then solve the resulting constraints in order to generate the | |

points-to sets. | |

Set constraints are a way of modeling program analysis problems that | |

involve sets. They consist of an inclusion constraint language, | |

describing the variables (each variable is a set) and operations that | |

are involved on the variables, and a set of rules that derive facts | |

from these operations. To solve a system of set constraints, you derive | |

all possible facts under the rules, which gives you the correct sets | |

as a consequence. | |

See "Efficient Field-sensitive pointer analysis for C" by "David | |

J. Pearce and Paul H. J. Kelly and Chris Hankin, at | |

http://citeseer.ist.psu.edu/pearce04efficient.html | |

Also see "Ultra-fast Aliasing Analysis using CLA: A Million Lines | |

of C Code in a Second" by ""Nevin Heintze and Olivier Tardieu" at | |

http://citeseer.ist.psu.edu/heintze01ultrafast.html | |

There are three types of real constraint expressions, DEREF, | |

ADDRESSOF, and SCALAR. Each constraint expression consists | |

of a constraint type, a variable, and an offset. | |

SCALAR is a constraint expression type used to represent x, whether | |

it appears on the LHS or the RHS of a statement. | |

DEREF is a constraint expression type used to represent *x, whether | |

it appears on the LHS or the RHS of a statement. | |

ADDRESSOF is a constraint expression used to represent &x, whether | |

it appears on the LHS or the RHS of a statement. | |

Each pointer variable in the program is assigned an integer id, and | |

each field of a structure variable is assigned an integer id as well. | |

Structure variables are linked to their list of fields through a "next | |

field" in each variable that points to the next field in offset | |

order. | |

Each variable for a structure field has | |

1. "size", that tells the size in bits of that field. | |

2. "fullsize, that tells the size in bits of the entire structure. | |

3. "offset", that tells the offset in bits from the beginning of the | |

structure to this field. | |

Thus, | |

struct f | |

{ | |

int a; | |

int b; | |

} foo; | |

int *bar; | |

looks like | |

foo.a -> id 1, size 32, offset 0, fullsize 64, next foo.b | |

foo.b -> id 2, size 32, offset 32, fullsize 64, next NULL | |

bar -> id 3, size 32, offset 0, fullsize 32, next NULL | |

In order to solve the system of set constraints, the following is | |

done: | |

1. Each constraint variable x has a solution set associated with it, | |

Sol(x). | |

2. Constraints are separated into direct, copy, and complex. | |

Direct constraints are ADDRESSOF constraints that require no extra | |

processing, such as P = &Q | |

Copy constraints are those of the form P = Q. | |

Complex constraints are all the constraints involving dereferences | |

and offsets (including offsetted copies). | |

3. All direct constraints of the form P = &Q are processed, such | |

that Q is added to Sol(P) | |

4. All complex constraints for a given constraint variable are stored in a | |

linked list attached to that variable's node. | |

5. A directed graph is built out of the copy constraints. Each | |

constraint variable is a node in the graph, and an edge from | |

Q to P is added for each copy constraint of the form P = Q | |

6. The graph is then walked, and solution sets are | |

propagated along the copy edges, such that an edge from Q to P | |

causes Sol(P) <- Sol(P) union Sol(Q). | |

7. As we visit each node, all complex constraints associated with | |

that node are processed by adding appropriate copy edges to the graph, or the | |

appropriate variables to the solution set. | |

8. The process of walking the graph is iterated until no solution | |

sets change. | |

Prior to walking the graph in steps 6 and 7, We perform static | |

cycle elimination on the constraint graph, as well | |

as off-line variable substitution. | |

TODO: Adding offsets to pointer-to-structures can be handled (IE not punted | |

on and turned into anything), but isn't. You can just see what offset | |

inside the pointed-to struct it's going to access. | |

TODO: Constant bounded arrays can be handled as if they were structs of the | |

same number of elements. | |

TODO: Modeling heap and incoming pointers becomes much better if we | |

add fields to them as we discover them, which we could do. | |

TODO: We could handle unions, but to be honest, it's probably not | |

worth the pain or slowdown. */ | |

/* IPA-PTA optimizations possible. | |

When the indirect function called is ANYTHING we can add disambiguation | |

based on the function signatures (or simply the parameter count which | |

is the varinfo size). We also do not need to consider functions that | |

do not have their address taken. | |

The is_global_var bit which marks escape points is overly conservative | |

in IPA mode. Split it to is_escape_point and is_global_var - only | |

externally visible globals are escape points in IPA mode. This is | |

also needed to fix the pt_solution_includes_global predicate | |

(and thus ptr_deref_may_alias_global_p). | |

The way we introduce DECL_PT_UID to avoid fixing up all points-to | |

sets in the translation unit when we copy a DECL during inlining | |

pessimizes precision. The advantage is that the DECL_PT_UID keeps | |

compile-time and memory usage overhead low - the points-to sets | |

do not grow or get unshared as they would during a fixup phase. | |

An alternative solution is to delay IPA PTA until after all | |

inlining transformations have been applied. | |

The way we propagate clobber/use information isn't optimized. | |

It should use a new complex constraint that properly filters | |

out local variables of the callee (though that would make | |

the sets invalid after inlining). OTOH we might as well | |

admit defeat to WHOPR and simply do all the clobber/use analysis | |

and propagation after PTA finished but before we threw away | |

points-to information for memory variables. WHOPR and PTA | |

do not play along well anyway - the whole constraint solving | |

would need to be done in WPA phase and it will be very interesting | |

to apply the results to local SSA names during LTRANS phase. | |

We probably should compute a per-function unit-ESCAPE solution | |

propagating it simply like the clobber / uses solutions. The | |

solution can go alongside the non-IPA espaced solution and be | |

used to query which vars escape the unit through a function. | |

We never put function decls in points-to sets so we do not | |

keep the set of called functions for indirect calls. | |

And probably more. */ | |

static bool use_field_sensitive = true; | |

static int in_ipa_mode = 0; | |

/* Used for predecessor bitmaps. */ | |

static bitmap_obstack predbitmap_obstack; | |

/* Used for points-to sets. */ | |

static bitmap_obstack pta_obstack; | |

/* Used for oldsolution members of variables. */ | |

static bitmap_obstack oldpta_obstack; | |

/* Used for per-solver-iteration bitmaps. */ | |

static bitmap_obstack iteration_obstack; | |

static unsigned int create_variable_info_for (tree, const char *); | |

typedef struct constraint_graph *constraint_graph_t; | |

static void unify_nodes (constraint_graph_t, unsigned int, unsigned int, bool); | |

struct constraint; | |

typedef struct constraint *constraint_t; | |

#define EXECUTE_IF_IN_NONNULL_BITMAP(a, b, c, d) \ | |

if (a) \ | |

EXECUTE_IF_SET_IN_BITMAP (a, b, c, d) | |

static struct constraint_stats | |

{ | |

unsigned int total_vars; | |

unsigned int nonpointer_vars; | |

unsigned int unified_vars_static; | |

unsigned int unified_vars_dynamic; | |

unsigned int iterations; | |

unsigned int num_edges; | |

unsigned int num_implicit_edges; | |

unsigned int points_to_sets_created; | |

} stats; | |

struct variable_info | |

{ | |

/* ID of this variable */ | |

unsigned int id; | |

/* True if this is a variable created by the constraint analysis, such as | |

heap variables and constraints we had to break up. */ | |

unsigned int is_artificial_var : 1; | |

/* True if this is a special variable whose solution set should not be | |

changed. */ | |

unsigned int is_special_var : 1; | |

/* True for variables whose size is not known or variable. */ | |

unsigned int is_unknown_size_var : 1; | |

/* True for (sub-)fields that represent a whole variable. */ | |

unsigned int is_full_var : 1; | |

/* True if this is a heap variable. */ | |

unsigned int is_heap_var : 1; | |

/* True if this field may contain pointers. */ | |

unsigned int may_have_pointers : 1; | |

/* True if this field has only restrict qualified pointers. */ | |

unsigned int only_restrict_pointers : 1; | |

/* True if this represents a global variable. */ | |

unsigned int is_global_var : 1; | |

/* True if this represents a IPA function info. */ | |

unsigned int is_fn_info : 1; | |

/* A link to the variable for the next field in this structure. */ | |

struct variable_info *next; | |

/* Offset of this variable, in bits, from the base variable */ | |

unsigned HOST_WIDE_INT offset; | |

/* Size of the variable, in bits. */ | |

unsigned HOST_WIDE_INT size; | |

/* Full size of the base variable, in bits. */ | |

unsigned HOST_WIDE_INT fullsize; | |

/* Name of this variable */ | |

const char *name; | |

/* Tree that this variable is associated with. */ | |

tree decl; | |

/* Points-to set for this variable. */ | |

bitmap solution; | |

/* Old points-to set for this variable. */ | |

bitmap oldsolution; | |

}; | |

typedef struct variable_info *varinfo_t; | |

static varinfo_t first_vi_for_offset (varinfo_t, unsigned HOST_WIDE_INT); | |

static varinfo_t first_or_preceding_vi_for_offset (varinfo_t, | |

unsigned HOST_WIDE_INT); | |

static varinfo_t lookup_vi_for_tree (tree); | |

static inline bool type_can_have_subvars (const_tree); | |

/* Pool of variable info structures. */ | |

static alloc_pool variable_info_pool; | |

/* Map varinfo to final pt_solution. */ | |

static pointer_map_t *final_solutions; | |

struct obstack final_solutions_obstack; | |

/* Table of variable info structures for constraint variables. | |

Indexed directly by variable info id. */ | |

static vec<varinfo_t> varmap; | |

/* Return the varmap element N */ | |

static inline varinfo_t | |

get_varinfo (unsigned int n) | |

{ | |

return varmap[n]; | |

} | |

/* Static IDs for the special variables. */ | |

enum { nothing_id = 0, anything_id = 1, readonly_id = 2, | |

escaped_id = 3, nonlocal_id = 4, | |

storedanything_id = 5, integer_id = 6 }; | |

/* Return a new variable info structure consisting for a variable | |

named NAME, and using constraint graph node NODE. Append it | |

to the vector of variable info structures. */ | |

static varinfo_t | |

new_var_info (tree t, const char *name) | |

{ | |

unsigned index = varmap.length (); | |

varinfo_t ret = (varinfo_t) pool_alloc (variable_info_pool); | |

ret->id = index; | |

ret->name = name; | |

ret->decl = t; | |

/* Vars without decl are artificial and do not have sub-variables. */ | |

ret->is_artificial_var = (t == NULL_TREE); | |

ret->is_special_var = false; | |

ret->is_unknown_size_var = false; | |

ret->is_full_var = (t == NULL_TREE); | |

ret->is_heap_var = false; | |

ret->may_have_pointers = true; | |

ret->only_restrict_pointers = false; | |

ret->is_global_var = (t == NULL_TREE); | |

ret->is_fn_info = false; | |

if (t && DECL_P (t)) | |

ret->is_global_var = (is_global_var (t) | |

/* We have to treat even local register variables | |

as escape points. */ | |

|| (TREE_CODE (t) == VAR_DECL | |

&& DECL_HARD_REGISTER (t))); | |

ret->solution = BITMAP_ALLOC (&pta_obstack); | |

ret->oldsolution = NULL; | |

ret->next = NULL; | |

stats.total_vars++; | |

varmap.safe_push (ret); | |

return ret; | |

} | |

/* A map mapping call statements to per-stmt variables for uses | |

and clobbers specific to the call. */ | |

struct pointer_map_t *call_stmt_vars; | |

/* Lookup or create the variable for the call statement CALL. */ | |

static varinfo_t | |

get_call_vi (gimple call) | |

{ | |

void **slot_p; | |

varinfo_t vi, vi2; | |

slot_p = pointer_map_insert (call_stmt_vars, call); | |

if (*slot_p) | |

return (varinfo_t) *slot_p; | |

vi = new_var_info (NULL_TREE, "CALLUSED"); | |

vi->offset = 0; | |

vi->size = 1; | |

vi->fullsize = 2; | |

vi->is_full_var = true; | |

vi->next = vi2 = new_var_info (NULL_TREE, "CALLCLOBBERED"); | |

vi2->offset = 1; | |

vi2->size = 1; | |

vi2->fullsize = 2; | |

vi2->is_full_var = true; | |

*slot_p = (void *) vi; | |

return vi; | |

} | |

/* Lookup the variable for the call statement CALL representing | |

the uses. Returns NULL if there is nothing special about this call. */ | |

static varinfo_t | |

lookup_call_use_vi (gimple call) | |

{ | |

void **slot_p; | |

slot_p = pointer_map_contains (call_stmt_vars, call); | |

if (slot_p) | |

return (varinfo_t) *slot_p; | |

return NULL; | |

} | |

/* Lookup the variable for the call statement CALL representing | |

the clobbers. Returns NULL if there is nothing special about this call. */ | |

static varinfo_t | |

lookup_call_clobber_vi (gimple call) | |

{ | |

varinfo_t uses = lookup_call_use_vi (call); | |

if (!uses) | |

return NULL; | |

return uses->next; | |

} | |

/* Lookup or create the variable for the call statement CALL representing | |

the uses. */ | |

static varinfo_t | |

get_call_use_vi (gimple call) | |

{ | |

return get_call_vi (call); | |

} | |

/* Lookup or create the variable for the call statement CALL representing | |

the clobbers. */ | |

static varinfo_t ATTRIBUTE_UNUSED | |

get_call_clobber_vi (gimple call) | |

{ | |

return get_call_vi (call)->next; | |

} | |

typedef enum {SCALAR, DEREF, ADDRESSOF} constraint_expr_type; | |

/* An expression that appears in a constraint. */ | |

struct constraint_expr | |

{ | |

/* Constraint type. */ | |

constraint_expr_type type; | |

/* Variable we are referring to in the constraint. */ | |

unsigned int var; | |

/* Offset, in bits, of this constraint from the beginning of | |

variables it ends up referring to. | |

IOW, in a deref constraint, we would deref, get the result set, | |

then add OFFSET to each member. */ | |

HOST_WIDE_INT offset; | |

}; | |

/* Use 0x8000... as special unknown offset. */ | |

#define UNKNOWN_OFFSET ((HOST_WIDE_INT)-1 << (HOST_BITS_PER_WIDE_INT-1)) | |

typedef struct constraint_expr ce_s; | |

static void get_constraint_for_1 (tree, vec<ce_s> *, bool, bool); | |

static void get_constraint_for (tree, vec<ce_s> *); | |

static void get_constraint_for_rhs (tree, vec<ce_s> *); | |

static void do_deref (vec<ce_s> *); | |

/* Our set constraints are made up of two constraint expressions, one | |

LHS, and one RHS. | |

As described in the introduction, our set constraints each represent an | |

operation between set valued variables. | |

*/ | |

struct constraint | |

{ | |

struct constraint_expr lhs; | |

struct constraint_expr rhs; | |

}; | |

/* List of constraints that we use to build the constraint graph from. */ | |

static vec<constraint_t> constraints; | |

static alloc_pool constraint_pool; | |

/* The constraint graph is represented as an array of bitmaps | |

containing successor nodes. */ | |

struct constraint_graph | |

{ | |

/* Size of this graph, which may be different than the number of | |

nodes in the variable map. */ | |

unsigned int size; | |

/* Explicit successors of each node. */ | |

bitmap *succs; | |

/* Implicit predecessors of each node (Used for variable | |

substitution). */ | |

bitmap *implicit_preds; | |

/* Explicit predecessors of each node (Used for variable substitution). */ | |

bitmap *preds; | |

/* Indirect cycle representatives, or -1 if the node has no indirect | |

cycles. */ | |

int *indirect_cycles; | |

/* Representative node for a node. rep[a] == a unless the node has | |

been unified. */ | |

unsigned int *rep; | |

/* Equivalence class representative for a label. This is used for | |

variable substitution. */ | |

int *eq_rep; | |

/* Pointer equivalence label for a node. All nodes with the same | |

pointer equivalence label can be unified together at some point | |

(either during constraint optimization or after the constraint | |

graph is built). */ | |

unsigned int *pe; | |

/* Pointer equivalence representative for a label. This is used to | |

handle nodes that are pointer equivalent but not location | |

equivalent. We can unite these once the addressof constraints | |

are transformed into initial points-to sets. */ | |

int *pe_rep; | |

/* Pointer equivalence label for each node, used during variable | |

substitution. */ | |

unsigned int *pointer_label; | |

/* Location equivalence label for each node, used during location | |

equivalence finding. */ | |

unsigned int *loc_label; | |

/* Pointed-by set for each node, used during location equivalence | |

finding. This is pointed-by rather than pointed-to, because it | |

is constructed using the predecessor graph. */ | |

bitmap *pointed_by; | |

/* Points to sets for pointer equivalence. This is *not* the actual | |

points-to sets for nodes. */ | |

bitmap *points_to; | |

/* Bitmap of nodes where the bit is set if the node is a direct | |

node. Used for variable substitution. */ | |

sbitmap direct_nodes; | |

/* Bitmap of nodes where the bit is set if the node is address | |

taken. Used for variable substitution. */ | |

bitmap address_taken; | |

/* Vector of complex constraints for each graph node. Complex | |

constraints are those involving dereferences or offsets that are | |

not 0. */ | |

vec<constraint_t> *complex; | |

}; | |

static constraint_graph_t graph; | |

/* During variable substitution and the offline version of indirect | |

cycle finding, we create nodes to represent dereferences and | |

address taken constraints. These represent where these start and | |

end. */ | |

#define FIRST_REF_NODE (varmap).length () | |

#define LAST_REF_NODE (FIRST_REF_NODE + (FIRST_REF_NODE - 1)) | |

/* Return the representative node for NODE, if NODE has been unioned | |

with another NODE. | |

This function performs path compression along the way to finding | |

the representative. */ | |

static unsigned int | |

find (unsigned int node) | |

{ | |

gcc_assert (node < graph->size); | |

if (graph->rep[node] != node) | |

return graph->rep[node] = find (graph->rep[node]); | |

return node; | |

} | |

/* Union the TO and FROM nodes to the TO nodes. | |

Note that at some point in the future, we may want to do | |

union-by-rank, in which case we are going to have to return the | |

node we unified to. */ | |

static bool | |

unite (unsigned int to, unsigned int from) | |

{ | |

gcc_assert (to < graph->size && from < graph->size); | |

if (to != from && graph->rep[from] != to) | |

{ | |

graph->rep[from] = to; | |

return true; | |

} | |

return false; | |

} | |

/* Create a new constraint consisting of LHS and RHS expressions. */ | |

static constraint_t | |

new_constraint (const struct constraint_expr lhs, | |

const struct constraint_expr rhs) | |

{ | |

constraint_t ret = (constraint_t) pool_alloc (constraint_pool); | |

ret->lhs = lhs; | |

ret->rhs = rhs; | |

return ret; | |

} | |

/* Print out constraint C to FILE. */ | |

static void | |

dump_constraint (FILE *file, constraint_t c) | |

{ | |

if (c->lhs.type == ADDRESSOF) | |

fprintf (file, "&"); | |

else if (c->lhs.type == DEREF) | |

fprintf (file, "*"); | |

fprintf (file, "%s", get_varinfo (c->lhs.var)->name); | |

if (c->lhs.offset == UNKNOWN_OFFSET) | |

fprintf (file, " + UNKNOWN"); | |

else if (c->lhs.offset != 0) | |

fprintf (file, " + " HOST_WIDE_INT_PRINT_DEC, c->lhs.offset); | |

fprintf (file, " = "); | |

if (c->rhs.type == ADDRESSOF) | |

fprintf (file, "&"); | |

else if (c->rhs.type == DEREF) | |

fprintf (file, "*"); | |

fprintf (file, "%s", get_varinfo (c->rhs.var)->name); | |

if (c->rhs.offset == UNKNOWN_OFFSET) | |

fprintf (file, " + UNKNOWN"); | |

else if (c->rhs.offset != 0) | |

fprintf (file, " + " HOST_WIDE_INT_PRINT_DEC, c->rhs.offset); | |

} | |

void debug_constraint (constraint_t); | |

void debug_constraints (void); | |

void debug_constraint_graph (void); | |

void debug_solution_for_var (unsigned int); | |

void debug_sa_points_to_info (void); | |

/* Print out constraint C to stderr. */ | |

DEBUG_FUNCTION void | |

debug_constraint (constraint_t c) | |

{ | |

dump_constraint (stderr, c); | |

fprintf (stderr, "\n"); | |

} | |

/* Print out all constraints to FILE */ | |

static void | |

dump_constraints (FILE *file, int from) | |

{ | |

int i; | |

constraint_t c; | |

for (i = from; constraints.iterate (i, &c); i++) | |

if (c) | |

{ | |

dump_constraint (file, c); | |

fprintf (file, "\n"); | |

} | |

} | |

/* Print out all constraints to stderr. */ | |

DEBUG_FUNCTION void | |

debug_constraints (void) | |

{ | |

dump_constraints (stderr, 0); | |

} | |

/* Print the constraint graph in dot format. */ | |

static void | |

dump_constraint_graph (FILE *file) | |

{ | |

unsigned int i; | |

/* Only print the graph if it has already been initialized: */ | |

if (!graph) | |

return; | |

/* Prints the header of the dot file: */ | |

fprintf (file, "strict digraph {\n"); | |

fprintf (file, " node [\n shape = box\n ]\n"); | |

fprintf (file, " edge [\n fontsize = \"12\"\n ]\n"); | |

fprintf (file, "\n // List of nodes and complex constraints in " | |

"the constraint graph:\n"); | |

/* The next lines print the nodes in the graph together with the | |

complex constraints attached to them. */ | |

for (i = 0; i < graph->size; i++) | |

{ | |

if (find (i) != i) | |

continue; | |

if (i < FIRST_REF_NODE) | |

fprintf (file, "\"%s\"", get_varinfo (i)->name); | |

else | |

fprintf (file, "\"*%s\"", get_varinfo (i - FIRST_REF_NODE)->name); | |

if (graph->complex[i].exists ()) | |

{ | |

unsigned j; | |

constraint_t c; | |

fprintf (file, " [label=\"\\N\\n"); | |

for (j = 0; graph->complex[i].iterate (j, &c); ++j) | |

{ | |

dump_constraint (file, c); | |

fprintf (file, "\\l"); | |

} | |

fprintf (file, "\"]"); | |

} | |

fprintf (file, ";\n"); | |

} | |

/* Go over the edges. */ | |

fprintf (file, "\n // Edges in the constraint graph:\n"); | |

for (i = 0; i < graph->size; i++) | |

{ | |

unsigned j; | |

bitmap_iterator bi; | |

if (find (i) != i) | |

continue; | |

EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[i], 0, j, bi) | |

{ | |

unsigned to = find (j); | |

if (i == to) | |

continue; | |

if (i < FIRST_REF_NODE) | |

fprintf (file, "\"%s\"", get_varinfo (i)->name); | |

else | |

fprintf (file, "\"*%s\"", get_varinfo (i - FIRST_REF_NODE)->name); | |

fprintf (file, " -> "); | |

if (to < FIRST_REF_NODE) | |

fprintf (file, "\"%s\"", get_varinfo (to)->name); | |

else | |

fprintf (file, "\"*%s\"", get_varinfo (to - FIRST_REF_NODE)->name); | |

fprintf (file, ";\n"); | |

} | |

} | |

/* Prints the tail of the dot file. */ | |

fprintf (file, "}\n"); | |

} | |

/* Print out the constraint graph to stderr. */ | |

DEBUG_FUNCTION void | |

debug_constraint_graph (void) | |

{ | |

dump_constraint_graph (stderr); | |

} | |

/* SOLVER FUNCTIONS | |

The solver is a simple worklist solver, that works on the following | |

algorithm: | |

sbitmap changed_nodes = all zeroes; | |

changed_count = 0; | |

For each node that is not already collapsed: | |

changed_count++; | |

set bit in changed nodes | |

while (changed_count > 0) | |

{ | |

compute topological ordering for constraint graph | |

find and collapse cycles in the constraint graph (updating | |

changed if necessary) | |

for each node (n) in the graph in topological order: | |

changed_count--; | |

Process each complex constraint associated with the node, | |

updating changed if necessary. | |

For each outgoing edge from n, propagate the solution from n to | |

the destination of the edge, updating changed as necessary. | |

} */ | |

/* Return true if two constraint expressions A and B are equal. */ | |

static bool | |

constraint_expr_equal (struct constraint_expr a, struct constraint_expr b) | |

{ | |

return a.type == b.type && a.var == b.var && a.offset == b.offset; | |

} | |

/* Return true if constraint expression A is less than constraint expression | |

B. This is just arbitrary, but consistent, in order to give them an | |

ordering. */ | |

static bool | |

constraint_expr_less (struct constraint_expr a, struct constraint_expr b) | |

{ | |

if (a.type == b.type) | |

{ | |

if (a.var == b.var) | |

return a.offset < b.offset; | |

else | |

return a.var < b.var; | |

} | |

else | |

return a.type < b.type; | |

} | |

/* Return true if constraint A is less than constraint B. This is just | |

arbitrary, but consistent, in order to give them an ordering. */ | |

static bool | |

constraint_less (const constraint_t &a, const constraint_t &b) | |

{ | |

if (constraint_expr_less (a->lhs, b->lhs)) | |

return true; | |

else if (constraint_expr_less (b->lhs, a->lhs)) | |

return false; | |

else | |

return constraint_expr_less (a->rhs, b->rhs); | |

} | |

/* Return true if two constraints A and B are equal. */ | |

static bool | |

constraint_equal (struct constraint a, struct constraint b) | |

{ | |

return constraint_expr_equal (a.lhs, b.lhs) | |

&& constraint_expr_equal (a.rhs, b.rhs); | |

} | |

/* Find a constraint LOOKFOR in the sorted constraint vector VEC */ | |

static constraint_t | |

constraint_vec_find (vec<constraint_t> vec, | |

struct constraint lookfor) | |

{ | |

unsigned int place; | |

constraint_t found; | |

if (!vec.exists ()) | |

return NULL; | |

place = vec.lower_bound (&lookfor, constraint_less); | |

if (place >= vec.length ()) | |

return NULL; | |

found = vec[place]; | |

if (!constraint_equal (*found, lookfor)) | |

return NULL; | |

return found; | |

} | |

/* Union two constraint vectors, TO and FROM. Put the result in TO. */ | |

static void | |

constraint_set_union (vec<constraint_t> *to, | |

vec<constraint_t> *from) | |

{ | |

int i; | |

constraint_t c; | |

FOR_EACH_VEC_ELT (*from, i, c) | |

{ | |

if (constraint_vec_find (*to, *c) == NULL) | |

{ | |

unsigned int place = to->lower_bound (c, constraint_less); | |

to->safe_insert (place, c); | |

} | |

} | |

} | |

/* Expands the solution in SET to all sub-fields of variables included. | |

Union the expanded result into RESULT. */ | |

static void | |

solution_set_expand (bitmap result, bitmap set) | |

{ | |

bitmap_iterator bi; | |

bitmap vars = NULL; | |

unsigned j; | |

/* In a first pass record all variables we need to add all | |

sub-fields off. This avoids quadratic behavior. */ | |

EXECUTE_IF_SET_IN_BITMAP (set, 0, j, bi) | |

{ | |

varinfo_t v = get_varinfo (j); | |

if (v->is_artificial_var | |

|| v->is_full_var) | |

continue; | |

v = lookup_vi_for_tree (v->decl); | |

if (vars == NULL) | |

vars = BITMAP_ALLOC (NULL); | |

bitmap_set_bit (vars, v->id); | |

} | |

/* In the second pass now do the addition to the solution and | |

to speed up solving add it to the delta as well. */ | |

if (vars != NULL) | |

{ | |

EXECUTE_IF_SET_IN_BITMAP (vars, 0, j, bi) | |

{ | |

varinfo_t v = get_varinfo (j); | |

for (; v != NULL; v = v->next) | |

bitmap_set_bit (result, v->id); | |

} | |

BITMAP_FREE (vars); | |

} | |

} | |

/* Take a solution set SET, add OFFSET to each member of the set, and | |

overwrite SET with the result when done. */ | |

static void | |

solution_set_add (bitmap set, HOST_WIDE_INT offset) | |

{ | |

bitmap result = BITMAP_ALLOC (&iteration_obstack); | |

unsigned int i; | |

bitmap_iterator bi; | |

/* If the offset is unknown we have to expand the solution to | |

all subfields. */ | |

if (offset == UNKNOWN_OFFSET) | |

{ | |

solution_set_expand (set, set); | |

return; | |

} | |

EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi) | |

{ | |

varinfo_t vi = get_varinfo (i); | |

/* If this is a variable with just one field just set its bit | |

in the result. */ | |

if (vi->is_artificial_var | |

|| vi->is_unknown_size_var | |

|| vi->is_full_var) | |

bitmap_set_bit (result, i); | |

else | |

{ | |

HOST_WIDE_INT fieldoffset = vi->offset + offset; | |

unsigned HOST_WIDE_INT size = vi->size; | |

/* If the offset makes the pointer point to before the | |

variable use offset zero for the field lookup. */ | |

if (fieldoffset < 0) | |

vi = lookup_vi_for_tree (vi->decl); | |

else | |

vi = first_or_preceding_vi_for_offset (vi, fieldoffset); | |

do | |

{ | |

bitmap_set_bit (result, vi->id); | |

if (!vi->next) | |

break; | |

/* We have to include all fields that overlap the current field | |

shifted by offset. */ | |

vi = vi->next; | |

} | |

while (vi->offset < fieldoffset + size); | |

} | |

} | |

bitmap_copy (set, result); | |

BITMAP_FREE (result); | |

} | |

/* Union solution sets TO and FROM, and add INC to each member of FROM in the | |

process. */ | |

static bool | |

set_union_with_increment (bitmap to, bitmap from, HOST_WIDE_INT inc) | |

{ | |

if (inc == 0) | |

return bitmap_ior_into (to, from); | |

else | |

{ | |

bitmap tmp; | |

bool res; | |

tmp = BITMAP_ALLOC (&iteration_obstack); | |

bitmap_copy (tmp, from); | |

solution_set_add (tmp, inc); | |

res = bitmap_ior_into (to, tmp); | |

BITMAP_FREE (tmp); | |

return res; | |

} | |

} | |

/* Insert constraint C into the list of complex constraints for graph | |

node VAR. */ | |

static void | |

insert_into_complex (constraint_graph_t graph, | |

unsigned int var, constraint_t c) | |

{ | |

vec<constraint_t> complex = graph->complex[var]; | |

unsigned int place = complex.lower_bound (c, constraint_less); | |

/* Only insert constraints that do not already exist. */ | |

if (place >= complex.length () | |

|| !constraint_equal (*c, *complex[place])) | |

graph->complex[var].safe_insert (place, c); | |

} | |

/* Condense two variable nodes into a single variable node, by moving | |

all associated info from SRC to TO. */ | |

static void | |

merge_node_constraints (constraint_graph_t graph, unsigned int to, | |

unsigned int from) | |

{ | |

unsigned int i; | |

constraint_t c; | |

gcc_assert (find (from) == to); | |

/* Move all complex constraints from src node into to node */ | |

FOR_EACH_VEC_ELT (graph->complex[from], i, c) | |

{ | |

/* In complex constraints for node src, we may have either | |

a = *src, and *src = a, or an offseted constraint which are | |

always added to the rhs node's constraints. */ | |

if (c->rhs.type == DEREF) | |

c->rhs.var = to; | |

else if (c->lhs.type == DEREF) | |

c->lhs.var = to; | |

else | |

c->rhs.var = to; | |

} | |

constraint_set_union (&graph->complex[to], &graph->complex[from]); | |

graph->complex[from].release (); | |

} | |

/* Remove edges involving NODE from GRAPH. */ | |

static void | |

clear_edges_for_node (constraint_graph_t graph, unsigned int node) | |

{ | |

if (graph->succs[node]) | |

BITMAP_FREE (graph->succs[node]); | |

} | |

/* Merge GRAPH nodes FROM and TO into node TO. */ | |

static void | |

merge_graph_nodes (constraint_graph_t graph, unsigned int to, | |

unsigned int from) | |

{ | |

if (graph->indirect_cycles[from] != -1) | |

{ | |

/* If we have indirect cycles with the from node, and we have | |

none on the to node, the to node has indirect cycles from the | |

from node now that they are unified. | |

If indirect cycles exist on both, unify the nodes that they | |

are in a cycle with, since we know they are in a cycle with | |

each other. */ | |

if (graph->indirect_cycles[to] == -1) | |

graph->indirect_cycles[to] = graph->indirect_cycles[from]; | |

} | |

/* Merge all the successor edges. */ | |

if (graph->succs[from]) | |

{ | |

if (!graph->succs[to]) | |

graph->succs[to] = BITMAP_ALLOC (&pta_obstack); | |

bitmap_ior_into (graph->succs[to], | |

graph->succs[from]); | |

} | |

clear_edges_for_node (graph, from); | |

} | |

/* Add an indirect graph edge to GRAPH, going from TO to FROM if | |

it doesn't exist in the graph already. */ | |

static void | |

add_implicit_graph_edge (constraint_graph_t graph, unsigned int to, | |

unsigned int from) | |

{ | |

if (to == from) | |

return; | |

if (!graph->implicit_preds[to]) | |

graph->implicit_preds[to] = BITMAP_ALLOC (&predbitmap_obstack); | |

if (bitmap_set_bit (graph->implicit_preds[to], from)) | |

stats.num_implicit_edges++; | |

} | |

/* Add a predecessor graph edge to GRAPH, going from TO to FROM if | |

it doesn't exist in the graph already. | |

Return false if the edge already existed, true otherwise. */ | |

static void | |

add_pred_graph_edge (constraint_graph_t graph, unsigned int to, | |

unsigned int from) | |

{ | |

if (!graph->preds[to]) | |

graph->preds[to] = BITMAP_ALLOC (&predbitmap_obstack); | |

bitmap_set_bit (graph->preds[to], from); | |

} | |

/* Add a graph edge to GRAPH, going from FROM to TO if | |

it doesn't exist in the graph already. | |

Return false if the edge already existed, true otherwise. */ | |

static bool | |

add_graph_edge (constraint_graph_t graph, unsigned int to, | |

unsigned int from) | |

{ | |

if (to == from) | |

{ | |

return false; | |

} | |

else | |

{ | |

bool r = false; | |

if (!graph->succs[from]) | |

graph->succs[from] = BITMAP_ALLOC (&pta_obstack); | |

if (bitmap_set_bit (graph->succs[from], to)) | |

{ | |

r = true; | |

if (to < FIRST_REF_NODE && from < FIRST_REF_NODE) | |

stats.num_edges++; | |

} | |

return r; | |

} | |

} | |

/* Return true if {DEST.SRC} is an existing graph edge in GRAPH. */ | |

static bool | |

valid_graph_edge (constraint_graph_t graph, unsigned int src, | |

unsigned int dest) | |

{ | |

return (graph->succs[dest] | |

&& bitmap_bit_p (graph->succs[dest], src)); | |

} | |

/* Initialize the constraint graph structure to contain SIZE nodes. */ | |

static void | |

init_graph (unsigned int size) | |

{ | |

unsigned int j; | |

graph = XCNEW (struct constraint_graph); | |

graph->size = size; | |

graph->succs = XCNEWVEC (bitmap, graph->size); | |

graph->indirect_cycles = XNEWVEC (int, graph->size); | |

graph->rep = XNEWVEC (unsigned int, graph->size); | |

/* ??? Macros do not support template types with multiple arguments, | |

so we use a typedef to work around it. */ | |

typedef vec<constraint_t> vec_constraint_t_heap; | |

graph->complex = XCNEWVEC (vec_constraint_t_heap, size); | |

graph->pe = XCNEWVEC (unsigned int, graph->size); | |

graph->pe_rep = XNEWVEC (int, graph->size); | |

for (j = 0; j < graph->size; j++) | |

{ | |

graph->rep[j] = j; | |

graph->pe_rep[j] = -1; | |

graph->indirect_cycles[j] = -1; | |

} | |

} | |

/* Build the constraint graph, adding only predecessor edges right now. */ | |

static void | |

build_pred_graph (void) | |

{ | |

int i; | |

constraint_t c; | |

unsigned int j; | |

graph->implicit_preds = XCNEWVEC (bitmap, graph->size); | |

graph->preds = XCNEWVEC (bitmap, graph->size); | |

graph->pointer_label = XCNEWVEC (unsigned int, graph->size); | |

graph->loc_label = XCNEWVEC (unsigned int, graph->size); | |

graph->pointed_by = XCNEWVEC (bitmap, graph->size); | |

graph->points_to = XCNEWVEC (bitmap, graph->size); | |

graph->eq_rep = XNEWVEC (int, graph->size); | |

graph->direct_nodes = sbitmap_alloc (graph->size); | |

graph->address_taken = BITMAP_ALLOC (&predbitmap_obstack); | |

bitmap_clear (graph->direct_nodes); | |

for (j = 0; j < FIRST_REF_NODE; j++) | |

{ | |

if (!get_varinfo (j)->is_special_var) | |

bitmap_set_bit (graph->direct_nodes, j); | |

} | |

for (j = 0; j < graph->size; j++) | |

graph->eq_rep[j] = -1; | |

for (j = 0; j < varmap.length (); j++) | |

graph->indirect_cycles[j] = -1; | |

FOR_EACH_VEC_ELT (constraints, i, c) | |

{ | |

struct constraint_expr lhs = c->lhs; | |

struct constraint_expr rhs = c->rhs; | |

unsigned int lhsvar = lhs.var; | |

unsigned int rhsvar = rhs.var; | |

if (lhs.type == DEREF) | |

{ | |

/* *x = y. */ | |

if (rhs.offset == 0 && lhs.offset == 0 && rhs.type == SCALAR) | |

add_pred_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar); | |

} | |

else if (rhs.type == DEREF) | |

{ | |

/* x = *y */ | |

if (rhs.offset == 0 && lhs.offset == 0 && lhs.type == SCALAR) | |

add_pred_graph_edge (graph, lhsvar, FIRST_REF_NODE + rhsvar); | |

else | |

bitmap_clear_bit (graph->direct_nodes, lhsvar); | |

} | |

else if (rhs.type == ADDRESSOF) | |

{ | |

varinfo_t v; | |

/* x = &y */ | |

if (graph->points_to[lhsvar] == NULL) | |

graph->points_to[lhsvar] = BITMAP_ALLOC (&predbitmap_obstack); | |

bitmap_set_bit (graph->points_to[lhsvar], rhsvar); | |

if (graph->pointed_by[rhsvar] == NULL) | |

graph->pointed_by[rhsvar] = BITMAP_ALLOC (&predbitmap_obstack); | |

bitmap_set_bit (graph->pointed_by[rhsvar], lhsvar); | |

/* Implicitly, *x = y */ | |

add_implicit_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar); | |

/* All related variables are no longer direct nodes. */ | |

bitmap_clear_bit (graph->direct_nodes, rhsvar); | |

v = get_varinfo (rhsvar); | |

if (!v->is_full_var) | |

{ | |

v = lookup_vi_for_tree (v->decl); | |

do | |

{ | |

bitmap_clear_bit (graph->direct_nodes, v->id); | |

v = v->next; | |

} | |

while (v != NULL); | |

} | |

bitmap_set_bit (graph->address_taken, rhsvar); | |

} | |

else if (lhsvar > anything_id | |

&& lhsvar != rhsvar && lhs.offset == 0 && rhs.offset == 0) | |

{ | |

/* x = y */ | |

add_pred_graph_edge (graph, lhsvar, rhsvar); | |

/* Implicitly, *x = *y */ | |

add_implicit_graph_edge (graph, FIRST_REF_NODE + lhsvar, | |

FIRST_REF_NODE + rhsvar); | |

} | |

else if (lhs.offset != 0 || rhs.offset != 0) | |

{ | |

if (rhs.offset != 0) | |

bitmap_clear_bit (graph->direct_nodes, lhs.var); | |

else if (lhs.offset != 0) | |

bitmap_clear_bit (graph->direct_nodes, rhs.var); | |

} | |

} | |

} | |

/* Build the constraint graph, adding successor edges. */ | |

static void | |

build_succ_graph (void) | |

{ | |

unsigned i, t; | |

constraint_t c; | |

FOR_EACH_VEC_ELT (constraints, i, c) | |

{ | |

struct constraint_expr lhs; | |

struct constraint_expr rhs; | |

unsigned int lhsvar; | |

unsigned int rhsvar; | |

if (!c) | |

continue; | |

lhs = c->lhs; | |

rhs = c->rhs; | |

lhsvar = find (lhs.var); | |

rhsvar = find (rhs.var); | |

if (lhs.type == DEREF) | |

{ | |

if (rhs.offset == 0 && lhs.offset == 0 && rhs.type == SCALAR) | |

add_graph_edge (graph, FIRST_REF_NODE + lhsvar, rhsvar); | |

} | |

else if (rhs.type == DEREF) | |

{ | |

if (rhs.offset == 0 && lhs.offset == 0 && lhs.type == SCALAR) | |

add_graph_edge (graph, lhsvar, FIRST_REF_NODE + rhsvar); | |

} | |

else if (rhs.type == ADDRESSOF) | |

{ | |

/* x = &y */ | |

gcc_assert (find (rhs.var) == rhs.var); | |

bitmap_set_bit (get_varinfo (lhsvar)->solution, rhsvar); | |

} | |

else if (lhsvar > anything_id | |

&& lhsvar != rhsvar && lhs.offset == 0 && rhs.offset == 0) | |

{ | |

add_graph_edge (graph, lhsvar, rhsvar); | |

} | |

} | |

/* Add edges from STOREDANYTHING to all non-direct nodes that can | |

receive pointers. */ | |

t = find (storedanything_id); | |

for (i = integer_id + 1; i < FIRST_REF_NODE; ++i) | |

{ | |

if (!bitmap_bit_p (graph->direct_nodes, i) | |

&& get_varinfo (i)->may_have_pointers) | |

add_graph_edge (graph, find (i), t); | |

} | |

/* Everything stored to ANYTHING also potentially escapes. */ | |

add_graph_edge (graph, find (escaped_id), t); | |

} | |

/* Changed variables on the last iteration. */ | |

static bitmap changed; | |

/* Strongly Connected Component visitation info. */ | |

struct scc_info | |

{ | |

sbitmap visited; | |

sbitmap deleted; | |

unsigned int *dfs; | |

unsigned int *node_mapping; | |

int current_index; | |

vec<unsigned> scc_stack; | |

}; | |

/* Recursive routine to find strongly connected components in GRAPH. | |

SI is the SCC info to store the information in, and N is the id of current | |

graph node we are processing. | |

This is Tarjan's strongly connected component finding algorithm, as | |

modified by Nuutila to keep only non-root nodes on the stack. | |

The algorithm can be found in "On finding the strongly connected | |

connected components in a directed graph" by Esko Nuutila and Eljas | |

Soisalon-Soininen, in Information Processing Letters volume 49, | |

number 1, pages 9-14. */ | |

static void | |

scc_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n) | |

{ | |

unsigned int i; | |

bitmap_iterator bi; | |

unsigned int my_dfs; | |

bitmap_set_bit (si->visited, n); | |

si->dfs[n] = si->current_index ++; | |

my_dfs = si->dfs[n]; | |

/* Visit all the successors. */ | |

EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[n], 0, i, bi) | |

{ | |

unsigned int w; | |

if (i > LAST_REF_NODE) | |

break; | |

w = find (i); | |

if (bitmap_bit_p (si->deleted, w)) | |

continue; | |

if (!bitmap_bit_p (si->visited, w)) | |

scc_visit (graph, si, w); | |

{ | |

unsigned int t = find (w); | |

unsigned int nnode = find (n); | |

gcc_assert (nnode == n); | |

if (si->dfs[t] < si->dfs[nnode]) | |

si->dfs[n] = si->dfs[t]; | |

} | |

} | |

/* See if any components have been identified. */ | |

if (si->dfs[n] == my_dfs) | |

{ | |

if (si->scc_stack.length () > 0 | |

&& si->dfs[si->scc_stack.last ()] >= my_dfs) | |

{ | |

bitmap scc = BITMAP_ALLOC (NULL); | |

unsigned int lowest_node; | |

bitmap_iterator bi; | |

bitmap_set_bit (scc, n); | |

while (si->scc_stack.length () != 0 | |

&& si->dfs[si->scc_stack.last ()] >= my_dfs) | |

{ | |

unsigned int w = si->scc_stack.pop (); | |

bitmap_set_bit (scc, w); | |

} | |

lowest_node = bitmap_first_set_bit (scc); | |

gcc_assert (lowest_node < FIRST_REF_NODE); | |

/* Collapse the SCC nodes into a single node, and mark the | |

indirect cycles. */ | |

EXECUTE_IF_SET_IN_BITMAP (scc, 0, i, bi) | |

{ | |

if (i < FIRST_REF_NODE) | |

{ | |

if (unite (lowest_node, i)) | |

unify_nodes (graph, lowest_node, i, false); | |

} | |

else | |

{ | |

unite (lowest_node, i); | |

graph->indirect_cycles[i - FIRST_REF_NODE] = lowest_node; | |

} | |

} | |

} | |

bitmap_set_bit (si->deleted, n); | |

} | |

else | |

si->scc_stack.safe_push (n); | |

} | |

/* Unify node FROM into node TO, updating the changed count if | |

necessary when UPDATE_CHANGED is true. */ | |

static void | |

unify_nodes (constraint_graph_t graph, unsigned int to, unsigned int from, | |

bool update_changed) | |

{ | |

gcc_assert (to != from && find (to) == to); | |

if (dump_file && (dump_flags & TDF_DETAILS)) | |

fprintf (dump_file, "Unifying %s to %s\n", | |

get_varinfo (from)->name, | |

get_varinfo (to)->name); | |

if (update_changed) | |

stats.unified_vars_dynamic++; | |

else | |

stats.unified_vars_static++; | |

merge_graph_nodes (graph, to, from); | |

merge_node_constraints (graph, to, from); | |

/* Mark TO as changed if FROM was changed. If TO was already marked | |

as changed, decrease the changed count. */ | |

if (update_changed | |

&& bitmap_bit_p (changed, from)) | |

{ | |

bitmap_clear_bit (changed, from); | |

bitmap_set_bit (changed, to); | |

} | |

if (get_varinfo (from)->solution) | |

{ | |

/* If the solution changes because of the merging, we need to mark | |

the variable as changed. */ | |

if (bitmap_ior_into (get_varinfo (to)->solution, | |

get_varinfo (from)->solution)) | |

{ | |

if (update_changed) | |

bitmap_set_bit (changed, to); | |

} | |

BITMAP_FREE (get_varinfo (from)->solution); | |

if (get_varinfo (from)->oldsolution) | |

BITMAP_FREE (get_varinfo (from)->oldsolution); | |

if (stats.iterations > 0 | |

&& get_varinfo (to)->oldsolution) | |

BITMAP_FREE (get_varinfo (to)->oldsolution); | |

} | |

if (valid_graph_edge (graph, to, to)) | |

{ | |

if (graph->succs[to]) | |

bitmap_clear_bit (graph->succs[to], to); | |

} | |

} | |

/* Information needed to compute the topological ordering of a graph. */ | |

struct topo_info | |

{ | |

/* sbitmap of visited nodes. */ | |

sbitmap visited; | |

/* Array that stores the topological order of the graph, *in | |

reverse*. */ | |

vec<unsigned> topo_order; | |

}; | |

/* Initialize and return a topological info structure. */ | |

static struct topo_info * | |

init_topo_info (void) | |

{ | |

size_t size = graph->size; | |

struct topo_info *ti = XNEW (struct topo_info); | |

ti->visited = sbitmap_alloc (size); | |

bitmap_clear (ti->visited); | |

ti->topo_order.create (1); | |

return ti; | |

} | |

/* Free the topological sort info pointed to by TI. */ | |

static void | |

free_topo_info (struct topo_info *ti) | |

{ | |

sbitmap_free (ti->visited); | |

ti->topo_order.release (); | |

free (ti); | |

} | |

/* Visit the graph in topological order, and store the order in the | |

topo_info structure. */ | |

static void | |

topo_visit (constraint_graph_t graph, struct topo_info *ti, | |

unsigned int n) | |

{ | |

bitmap_iterator bi; | |

unsigned int j; | |

bitmap_set_bit (ti->visited, n); | |

if (graph->succs[n]) | |

EXECUTE_IF_SET_IN_BITMAP (graph->succs[n], 0, j, bi) | |

{ | |

if (!bitmap_bit_p (ti->visited, j)) | |

topo_visit (graph, ti, j); | |

} | |

ti->topo_order.safe_push (n); | |

} | |

/* Process a constraint C that represents x = *(y + off), using DELTA as the | |

starting solution for y. */ | |

static void | |

do_sd_constraint (constraint_graph_t graph, constraint_t c, | |

bitmap delta) | |

{ | |

unsigned int lhs = c->lhs.var; | |

bool flag = false; | |

bitmap sol = get_varinfo (lhs)->solution; | |

unsigned int j; | |

bitmap_iterator bi; | |

HOST_WIDE_INT roffset = c->rhs.offset; | |

/* Our IL does not allow this. */ | |

gcc_assert (c->lhs.offset == 0); | |

/* If the solution of Y contains anything it is good enough to transfer | |

this to the LHS. */ | |

if (bitmap_bit_p (delta, anything_id)) | |

{ | |

flag |= bitmap_set_bit (sol, anything_id); | |

goto done; | |

} | |

/* If we do not know at with offset the rhs is dereferenced compute | |

the reachability set of DELTA, conservatively assuming it is | |

dereferenced at all valid offsets. */ | |

if (roffset == UNKNOWN_OFFSET) | |

{ | |

solution_set_expand (delta, delta); | |

/* No further offset processing is necessary. */ | |

roffset = 0; | |

} | |

/* For each variable j in delta (Sol(y)), add | |

an edge in the graph from j to x, and union Sol(j) into Sol(x). */ | |

EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi) | |

{ | |

varinfo_t v = get_varinfo (j); | |

HOST_WIDE_INT fieldoffset = v->offset + roffset; | |

unsigned HOST_WIDE_INT size = v->size; | |

unsigned int t; | |

if (v->is_full_var) | |

; | |

else if (roffset != 0) | |

{ | |

if (fieldoffset < 0) | |

v = lookup_vi_for_tree (v->decl); | |

else | |

v = first_or_preceding_vi_for_offset (v, fieldoffset); | |

} | |

/* We have to include all fields that overlap the current field | |

shifted by roffset. */ | |

do | |

{ | |

t = find (v->id); | |

/* Adding edges from the special vars is pointless. | |

They don't have sets that can change. */ | |

if (get_varinfo (t)->is_special_var) | |

flag |= bitmap_ior_into (sol, get_varinfo (t)->solution); | |

/* Merging the solution from ESCAPED needlessly increases | |

the set. Use ESCAPED as representative instead. */ | |

else if (v->id == escaped_id) | |

flag |= bitmap_set_bit (sol, escaped_id); | |

else if (v->may_have_pointers | |

&& add_graph_edge (graph, lhs, t)) | |

flag |= bitmap_ior_into (sol, get_varinfo (t)->solution); | |

if (v->is_full_var | |

|| v->next == NULL) | |

break; | |

v = v->next; | |

} | |

while (v->offset < fieldoffset + size); | |

} | |

done: | |

/* If the LHS solution changed, mark the var as changed. */ | |

if (flag) | |

{ | |

get_varinfo (lhs)->solution = sol; | |

bitmap_set_bit (changed, lhs); | |

} | |

} | |

/* Process a constraint C that represents *(x + off) = y using DELTA | |

as the starting solution for x. */ | |

static void | |

do_ds_constraint (constraint_t c, bitmap delta) | |

{ | |

unsigned int rhs = c->rhs.var; | |

bitmap sol = get_varinfo (rhs)->solution; | |

unsigned int j; | |

bitmap_iterator bi; | |

HOST_WIDE_INT loff = c->lhs.offset; | |

bool escaped_p = false; | |

/* Our IL does not allow this. */ | |

gcc_assert (c->rhs.offset == 0); | |

/* If the solution of y contains ANYTHING simply use the ANYTHING | |

solution. This avoids needlessly increasing the points-to sets. */ | |

if (bitmap_bit_p (sol, anything_id)) | |

sol = get_varinfo (find (anything_id))->solution; | |

/* If the solution for x contains ANYTHING we have to merge the | |

solution of y into all pointer variables which we do via | |

STOREDANYTHING. */ | |

if (bitmap_bit_p (delta, anything_id)) | |

{ | |

unsigned t = find (storedanything_id); | |

if (add_graph_edge (graph, t, rhs)) | |

{ | |

if (bitmap_ior_into (get_varinfo (t)->solution, sol)) | |

bitmap_set_bit (changed, t); | |

} | |

return; | |

} | |

/* If we do not know at with offset the rhs is dereferenced compute | |

the reachability set of DELTA, conservatively assuming it is | |

dereferenced at all valid offsets. */ | |

if (loff == UNKNOWN_OFFSET) | |

{ | |

solution_set_expand (delta, delta); | |

loff = 0; | |

} | |

/* For each member j of delta (Sol(x)), add an edge from y to j and | |

union Sol(y) into Sol(j) */ | |

EXECUTE_IF_SET_IN_BITMAP (delta, 0, j, bi) | |

{ | |

varinfo_t v = get_varinfo (j); | |

unsigned int t; | |

HOST_WIDE_INT fieldoffset = v->offset + loff; | |

unsigned HOST_WIDE_INT size = v->size; | |

if (v->is_full_var) | |

; | |

else if (loff != 0) | |

{ | |

if (fieldoffset < 0) | |

v = lookup_vi_for_tree (v->decl); | |

else | |

v = first_or_preceding_vi_for_offset (v, fieldoffset); | |

} | |

/* We have to include all fields that overlap the current field | |

shifted by loff. */ | |

do | |

{ | |

if (v->may_have_pointers) | |

{ | |

/* If v is a global variable then this is an escape point. */ | |

if (v->is_global_var | |

&& !escaped_p) | |

{ | |

t = find (escaped_id); | |

if (add_graph_edge (graph, t, rhs) | |

&& bitmap_ior_into (get_varinfo (t)->solution, sol)) | |

bitmap_set_bit (changed, t); | |

/* Enough to let rhs escape once. */ | |

escaped_p = true; | |

} | |

if (v->is_special_var) | |

break; | |

t = find (v->id); | |

if (add_graph_edge (graph, t, rhs) | |

&& bitmap_ior_into (get_varinfo (t)->solution, sol)) | |

bitmap_set_bit (changed, t); | |

} | |

if (v->is_full_var | |

|| v->next == NULL) | |

break; | |

v = v->next; | |

} | |

while (v->offset < fieldoffset + size); | |

} | |

} | |

/* Handle a non-simple (simple meaning requires no iteration), | |

constraint (IE *x = &y, x = *y, *x = y, and x = y with offsets involved). */ | |

static void | |

do_complex_constraint (constraint_graph_t graph, constraint_t c, bitmap delta) | |

{ | |

if (c->lhs.type == DEREF) | |

{ | |

if (c->rhs.type == ADDRESSOF) | |

{ | |

gcc_unreachable(); | |

} | |

else | |

{ | |

/* *x = y */ | |

do_ds_constraint (c, delta); | |

} | |

} | |

else if (c->rhs.type == DEREF) | |

{ | |

/* x = *y */ | |

if (!(get_varinfo (c->lhs.var)->is_special_var)) | |

do_sd_constraint (graph, c, delta); | |

} | |

else | |

{ | |

bitmap tmp; | |

bitmap solution; | |

bool flag = false; | |

gcc_assert (c->rhs.type == SCALAR && c->lhs.type == SCALAR); | |

solution = get_varinfo (c->rhs.var)->solution; | |

tmp = get_varinfo (c->lhs.var)->solution; | |

flag = set_union_with_increment (tmp, solution, c->rhs.offset); | |

if (flag) | |

{ | |

get_varinfo (c->lhs.var)->solution = tmp; | |

bitmap_set_bit (changed, c->lhs.var); | |

} | |

} | |

} | |

/* Initialize and return a new SCC info structure. */ | |

static struct scc_info * | |

init_scc_info (size_t size) | |

{ | |

struct scc_info *si = XNEW (struct scc_info); | |

size_t i; | |

si->current_index = 0; | |

si->visited = sbitmap_alloc (size); | |

bitmap_clear (si->visited); | |

si->deleted = sbitmap_alloc (size); | |

bitmap_clear (si->deleted); | |

si->node_mapping = XNEWVEC (unsigned int, size); | |

si->dfs = XCNEWVEC (unsigned int, size); | |

for (i = 0; i < size; i++) | |

si->node_mapping[i] = i; | |

si->scc_stack.create (1); | |

return si; | |

} | |

/* Free an SCC info structure pointed to by SI */ | |

static void | |

free_scc_info (struct scc_info *si) | |

{ | |

sbitmap_free (si->visited); | |

sbitmap_free (si->deleted); | |

free (si->node_mapping); | |

free (si->dfs); | |

si->scc_stack.release (); | |

free (si); | |

} | |

/* Find indirect cycles in GRAPH that occur, using strongly connected | |

components, and note them in the indirect cycles map. | |

This technique comes from Ben Hardekopf and Calvin Lin, | |

"It Pays to be Lazy: Fast and Accurate Pointer Analysis for Millions of | |

Lines of Code", submitted to PLDI 2007. */ | |

static void | |

find_indirect_cycles (constraint_graph_t graph) | |

{ | |

unsigned int i; | |

unsigned int size = graph->size; | |

struct scc_info *si = init_scc_info (size); | |

for (i = 0; i < MIN (LAST_REF_NODE, size); i ++ ) | |

if (!bitmap_bit_p (si->visited, i) && find (i) == i) | |

scc_visit (graph, si, i); | |

free_scc_info (si); | |

} | |

/* Compute a topological ordering for GRAPH, and store the result in the | |

topo_info structure TI. */ | |

static void | |

compute_topo_order (constraint_graph_t graph, | |

struct topo_info *ti) | |

{ | |

unsigned int i; | |

unsigned int size = graph->size; | |

for (i = 0; i != size; ++i) | |

if (!bitmap_bit_p (ti->visited, i) && find (i) == i) | |

topo_visit (graph, ti, i); | |

} | |

/* Structure used to for hash value numbering of pointer equivalence | |

classes. */ | |

typedef struct equiv_class_label | |

{ | |

hashval_t hashcode; | |

unsigned int equivalence_class; | |

bitmap labels; | |

} *equiv_class_label_t; | |

typedef const struct equiv_class_label *const_equiv_class_label_t; | |

/* A hashtable for mapping a bitmap of labels->pointer equivalence | |

classes. */ | |

static htab_t pointer_equiv_class_table; | |

/* A hashtable for mapping a bitmap of labels->location equivalence | |

classes. */ | |

static htab_t location_equiv_class_table; | |

/* Hash function for a equiv_class_label_t */ | |

static hashval_t | |

equiv_class_label_hash (const void *p) | |

{ | |

const_equiv_class_label_t const ecl = (const_equiv_class_label_t) p; | |

return ecl->hashcode; | |

} | |

/* Equality function for two equiv_class_label_t's. */ | |

static int | |

equiv_class_label_eq (const void *p1, const void *p2) | |

{ | |

const_equiv_class_label_t const eql1 = (const_equiv_class_label_t) p1; | |

const_equiv_class_label_t const eql2 = (const_equiv_class_label_t) p2; | |

return (eql1->hashcode == eql2->hashcode | |

&& bitmap_equal_p (eql1->labels, eql2->labels)); | |

} | |

/* Lookup a equivalence class in TABLE by the bitmap of LABELS with | |

hash HAS it contains. Sets *REF_LABELS to the bitmap LABELS | |

is equivalent to. */ | |

static equiv_class_label * | |

equiv_class_lookup_or_add (htab_t table, bitmap labels) | |

{ | |

equiv_class_label **slot; | |

equiv_class_label ecl; | |

ecl.labels = labels; | |

ecl.hashcode = bitmap_hash (labels); | |

slot = (equiv_class_label **) htab_find_slot_with_hash (table, &ecl, | |

ecl.hashcode, INSERT); | |

if (!*slot) | |

{ | |

*slot = XNEW (struct equiv_class_label); | |

(*slot)->labels = labels; | |

(*slot)->hashcode = ecl.hashcode; | |

(*slot)->equivalence_class = 0; | |

} | |

return *slot; | |

} | |

/* Perform offline variable substitution. | |

This is a worst case quadratic time way of identifying variables | |

that must have equivalent points-to sets, including those caused by | |

static cycles, and single entry subgraphs, in the constraint graph. | |

The technique is described in "Exploiting Pointer and Location | |

Equivalence to Optimize Pointer Analysis. In the 14th International | |

Static Analysis Symposium (SAS), August 2007." It is known as the | |

"HU" algorithm, and is equivalent to value numbering the collapsed | |

constraint graph including evaluating unions. | |

The general method of finding equivalence classes is as follows: | |

Add fake nodes (REF nodes) and edges for *a = b and a = *b constraints. | |

Initialize all non-REF nodes to be direct nodes. | |

For each constraint a = a U {b}, we set pts(a) = pts(a) u {fresh | |

variable} | |

For each constraint containing the dereference, we also do the same | |

thing. | |

We then compute SCC's in the graph and unify nodes in the same SCC, | |

including pts sets. | |

For each non-collapsed node x: | |

Visit all unvisited explicit incoming edges. | |

Ignoring all non-pointers, set pts(x) = Union of pts(a) for y | |

where y->x. | |

Lookup the equivalence class for pts(x). | |

If we found one, equivalence_class(x) = found class. | |

Otherwise, equivalence_class(x) = new class, and new_class is | |

added to the lookup table. | |

All direct nodes with the same equivalence class can be replaced | |

with a single representative node. | |

All unlabeled nodes (label == 0) are not pointers and all edges | |

involving them can be eliminated. | |

We perform these optimizations during rewrite_constraints | |

In addition to pointer equivalence class finding, we also perform | |

location equivalence class finding. This is the set of variables | |

that always appear together in points-to sets. We use this to | |

compress the size of the points-to sets. */ | |

/* Current maximum pointer equivalence class id. */ | |

static int pointer_equiv_class; | |

/* Current maximum location equivalence class id. */ | |

static int location_equiv_class; | |

/* Recursive routine to find strongly connected components in GRAPH, | |

and label it's nodes with DFS numbers. */ | |

static void | |

condense_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n) | |

{ | |

unsigned int i; | |

bitmap_iterator bi; | |

unsigned int my_dfs; | |

gcc_assert (si->node_mapping[n] == n); | |

bitmap_set_bit (si->visited, n); | |

si->dfs[n] = si->current_index ++; | |

my_dfs = si->dfs[n]; | |

/* Visit all the successors. */ | |

EXECUTE_IF_IN_NONNULL_BITMAP (graph->preds[n], 0, i, bi) | |

{ | |

unsigned int w = si->node_mapping[i]; | |

if (bitmap_bit_p (si->deleted, w)) | |

continue; | |

if (!bitmap_bit_p (si->visited, w)) | |

condense_visit (graph, si, w); | |

{ | |

unsigned int t = si->node_mapping[w]; | |

unsigned int nnode = si->node_mapping[n]; | |

gcc_assert (nnode == n); | |

if (si->dfs[t] < si->dfs[nnode]) | |

si->dfs[n] = si->dfs[t]; | |

} | |

} | |

/* Visit all the implicit predecessors. */ | |

EXECUTE_IF_IN_NONNULL_BITMAP (graph->implicit_preds[n], 0, i, bi) | |

{ | |

unsigned int w = si->node_mapping[i]; | |

if (bitmap_bit_p (si->deleted, w)) | |

continue; | |

if (!bitmap_bit_p (si->visited, w)) | |

condense_visit (graph, si, w); | |

{ | |

unsigned int t = si->node_mapping[w]; | |

unsigned int nnode = si->node_mapping[n]; | |

gcc_assert (nnode == n); | |

if (si->dfs[t] < si->dfs[nnode]) | |

si->dfs[n] = si->dfs[t]; | |

} | |

} | |

/* See if any components have been identified. */ | |

if (si->dfs[n] == my_dfs) | |

{ | |

while (si->scc_stack.length () != 0 | |

&& si->dfs[si->scc_stack.last ()] >= my_dfs) | |

{ | |

unsigned int w = si->scc_stack.pop (); | |

si->node_mapping[w] = n; | |

if (!bitmap_bit_p (graph->direct_nodes, w)) | |

bitmap_clear_bit (graph->direct_nodes, n); | |

/* Unify our nodes. */ | |

if (graph->preds[w]) | |

{ | |

if (!graph->preds[n]) | |

graph->preds[n] = BITMAP_ALLOC (&predbitmap_obstack); | |

bitmap_ior_into (graph->preds[n], graph->preds[w]); | |

} | |

if (graph->implicit_preds[w]) | |

{ | |

if (!graph->implicit_preds[n]) | |

graph->implicit_preds[n] = BITMAP_ALLOC (&predbitmap_obstack); | |

bitmap_ior_into (graph->implicit_preds[n], | |

graph->implicit_preds[w]); | |

} | |

if (graph->points_to[w]) | |

{ | |

if (!graph->points_to[n]) | |

graph->points_to[n] = BITMAP_ALLOC (&predbitmap_obstack); | |

bitmap_ior_into (graph->points_to[n], | |

graph->points_to[w]); | |

} | |

} | |

bitmap_set_bit (si->deleted, n); | |

} | |

else | |

si->scc_stack.safe_push (n); | |

} | |

/* Label pointer equivalences. */ | |

static void | |

label_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n) | |

{ | |

unsigned int i, first_pred; | |

bitmap_iterator bi; | |

bitmap_set_bit (si->visited, n); | |

/* Label and union our incoming edges's points to sets. */ | |

first_pred = -1U; | |

EXECUTE_IF_IN_NONNULL_BITMAP (graph->preds[n], 0, i, bi) | |

{ | |

unsigned int w = si->node_mapping[i]; | |

if (!bitmap_bit_p (si->visited, w)) | |

label_visit (graph, si, w); | |

/* Skip unused edges */ | |

if (w == n || graph->pointer_label[w] == 0) | |

continue; | |

if (graph->points_to[w]) | |

{ | |

if (!graph->points_to[n]) | |

{ | |

if (first_pred == -1U) | |

first_pred = w; | |

else | |

{ | |

graph->points_to[n] = BITMAP_ALLOC (&predbitmap_obstack); | |

bitmap_ior (graph->points_to[n], | |

graph->points_to[first_pred], | |

graph->points_to[w]); | |

} | |

} | |

else | |

bitmap_ior_into(graph->points_to[n], graph->points_to[w]); | |

} | |

} | |

/* Indirect nodes get fresh variables and a new pointer equiv class. */ | |

if (!bitmap_bit_p (graph->direct_nodes, n)) | |

{ | |

if (!graph->points_to[n]) | |

{ | |

graph->points_to[n] = BITMAP_ALLOC (&predbitmap_obstack); | |

if (first_pred != -1U) | |

bitmap_copy (graph->points_to[n], graph->points_to[first_pred]); | |

} | |

bitmap_set_bit (graph->points_to[n], FIRST_REF_NODE + n); | |

graph->pointer_label[n] = pointer_equiv_class++; | |

equiv_class_label_t ecl; | |

ecl = equiv_class_lookup_or_add (pointer_equiv_class_table, | |

graph->points_to[n]); | |

ecl->equivalence_class = graph->pointer_label[n]; | |

return; | |

} | |

/* If there was only a single non-empty predecessor the pointer equiv | |

class is the same. */ | |

if (!graph->points_to[n]) | |

{ | |

if (first_pred != -1U) | |

{ | |

graph->pointer_label[n] = graph->pointer_label[first_pred]; | |

graph->points_to[n] = graph->points_to[first_pred]; | |

} | |

return; | |

} | |

if (!bitmap_empty_p (graph->points_to[n])) | |

{ | |

equiv_class_label_t ecl; | |

ecl = equiv_class_lookup_or_add (pointer_equiv_class_table, | |

graph->points_to[n]); | |

if (ecl->equivalence_class == 0) | |

ecl->equivalence_class = pointer_equiv_class++; | |

else | |

{ | |

BITMAP_FREE (graph->points_to[n]); | |

graph->points_to[n] = ecl->labels; | |

} | |

graph->pointer_label[n] = ecl->equivalence_class; | |

} | |

} | |

/* Perform offline variable substitution, discovering equivalence | |

classes, and eliminating non-pointer variables. */ | |

static struct scc_info * | |

perform_var_substitution (constraint_graph_t graph) | |

{ | |

unsigned int i; | |

unsigned int size = graph->size; | |

struct scc_info *si = init_scc_info (size); | |

bitmap_obstack_initialize (&iteration_obstack); | |

pointer_equiv_class_table = htab_create (511, equiv_class_label_hash, | |

equiv_class_label_eq, free); | |

location_equiv_class_table = htab_create (511, equiv_class_label_hash, | |

equiv_class_label_eq, free); | |

pointer_equiv_class = 1; | |

location_equiv_class = 1; | |

/* Condense the nodes, which means to find SCC's, count incoming | |

predecessors, and unite nodes in SCC's. */ | |

for (i = 0; i < FIRST_REF_NODE; i++) | |

if (!bitmap_bit_p (si->visited, si->node_mapping[i])) | |

condense_visit (graph, si, si->node_mapping[i]); | |

bitmap_clear (si->visited); | |

/* Actually the label the nodes for pointer equivalences */ | |

for (i = 0; i < FIRST_REF_NODE; i++) | |

if (!bitmap_bit_p (si->visited, si->node_mapping[i])) | |

label_visit (graph, si, si->node_mapping[i]); | |

/* Calculate location equivalence labels. */ | |

for (i = 0; i < FIRST_REF_NODE; i++) | |

{ | |

bitmap pointed_by; | |

bitmap_iterator bi; | |

unsigned int j; | |

if (!graph->pointed_by[i]) | |

continue; | |

pointed_by = BITMAP_ALLOC (&iteration_obstack); | |

/* Translate the pointed-by mapping for pointer equivalence | |

labels. */ | |

EXECUTE_IF_SET_IN_BITMAP (graph->pointed_by[i], 0, j, bi) | |

{ | |

bitmap_set_bit (pointed_by, | |

graph->pointer_label[si->node_mapping[j]]); | |

} | |

/* The original pointed_by is now dead. */ | |

BITMAP_FREE (graph->pointed_by[i]); | |

/* Look up the location equivalence label if one exists, or make | |

one otherwise. */ | |

equiv_class_label_t ecl; | |

ecl = equiv_class_lookup_or_add (location_equiv_class_table, pointed_by); | |

if (ecl->equivalence_class == 0) | |

ecl->equivalence_class = location_equiv_class++; | |

else | |

{ | |

if (dump_file && (dump_flags & TDF_DETAILS)) | |

fprintf (dump_file, "Found location equivalence for node %s\n", | |

get_varinfo (i)->name); | |

BITMAP_FREE (pointed_by); | |

} | |

graph->loc_label[i] = ecl->equivalence_class; | |

} | |

if (dump_file && (dump_flags & TDF_DETAILS)) | |

for (i = 0; i < FIRST_REF_NODE; i++) | |

{ | |

unsigned j = si->node_mapping[i]; | |

if (j != i) | |

{ | |

fprintf (dump_file, "%s node id %d ", | |

bitmap_bit_p (graph->direct_nodes, i) | |

? "Direct" : "Indirect", i); | |

if (i < FIRST_REF_NODE) | |

fprintf (dump_file, "\"%s\"", get_varinfo (i)->name); | |

else | |

fprintf (dump_file, "\"*%s\"", | |

get_varinfo (i - FIRST_REF_NODE)->name); | |

fprintf (dump_file, " mapped to SCC leader node id %d ", j); | |

if (j < FIRST_REF_NODE) | |

fprintf (dump_file, "\"%s\"\n", get_varinfo (j)->name); | |

else | |

fprintf (dump_file, "\"*%s\"\n", | |

get_varinfo (j - FIRST_REF_NODE)->name); | |

} | |

else | |

{ | |

fprintf (dump_file, | |

"Equivalence classes for %s node id %d ", | |

bitmap_bit_p (graph->direct_nodes, i) | |

? "direct" : "indirect", i); | |

if (i < FIRST_REF_NODE) | |

fprintf (dump_file, "\"%s\"", get_varinfo (i)->name); | |

else | |

fprintf (dump_file, "\"*%s\"", | |

get_varinfo (i - FIRST_REF_NODE)->name); | |

fprintf (dump_file, | |

": pointer %d, location %d\n", | |

graph->pointer_label[i], graph->loc_label[i]); | |

} | |

} | |

/* Quickly eliminate our non-pointer variables. */ | |

for (i = 0; i < FIRST_REF_NODE; i++) | |

{ | |

unsigned int node = si->node_mapping[i]; | |

if (graph->pointer_label[node] == 0) | |

{ | |

if (dump_file && (dump_flags & TDF_DETAILS)) | |

fprintf (dump_file, | |

"%s is a non-pointer variable, eliminating edges.\n", | |

get_varinfo (node)->name); | |

stats.nonpointer_vars++; | |

clear_edges_for_node (graph, node); | |

} | |

} | |

return si; | |

} | |

/* Free information that was only necessary for variable | |

substitution. */ | |

static void | |

free_var_substitution_info (struct scc_info *si) | |

{ | |

free_scc_info (si); | |

free (graph->pointer_label); | |

free (graph->loc_label); | |

free (graph->pointed_by); | |

free (graph->points_to); | |

free (graph->eq_rep); | |

sbitmap_free (graph->direct_nodes); | |

htab_delete (pointer_equiv_class_table); | |

htab_delete (location_equiv_class_table); | |

bitmap_obstack_release (&iteration_obstack); | |

} | |

/* Return an existing node that is equivalent to NODE, which has | |

equivalence class LABEL, if one exists. Return NODE otherwise. */ | |

static unsigned int | |

find_equivalent_node (constraint_graph_t graph, | |

unsigned int node, unsigned int label) | |

{ | |

/* If the address version of this variable is unused, we can | |

substitute it for anything else with the same label. | |

Otherwise, we know the pointers are equivalent, but not the | |

locations, and we can unite them later. */ | |

if (!bitmap_bit_p (graph->address_taken, node)) | |

{ | |

gcc_assert (label < graph->size); | |

if (graph->eq_rep[label] != -1) | |

{ | |

/* Unify the two variables since we know they are equivalent. */ | |

if (unite (graph->eq_rep[label], node)) | |

unify_nodes (graph, graph->eq_rep[label], node, false); | |

return graph->eq_rep[label]; | |

} | |

else | |

{ | |

graph->eq_rep[label] = node; | |

graph->pe_rep[label] = node; | |

} | |

} | |

else | |

{ | |

gcc_assert (label < graph->size); | |

graph->pe[node] = label; | |

if (graph->pe_rep[label] == -1) | |

graph->pe_rep[label] = node; | |

} | |

return node; | |

} | |

/* Unite pointer equivalent but not location equivalent nodes in | |

GRAPH. This may only be performed once variable substitution is | |

finished. */ | |

static void | |

unite_pointer_equivalences (constraint_graph_t graph) | |

{ | |

unsigned int i; | |

/* Go through the pointer equivalences and unite them to their | |

representative, if they aren't already. */ | |

for (i = 0; i < FIRST_REF_NODE; i++) | |

{ | |

unsigned int label = graph->pe[i]; | |

if (label) | |

{ | |

int label_rep = graph->pe_rep[label]; | |

if (label_rep == -1) | |

continue; | |

label_rep = find (label_rep); | |

if (label_rep >= 0 && unite (label_rep, find (i))) | |

unify_nodes (graph, label_rep, i, false); | |

} | |

} | |

} | |

/* Move complex constraints to the GRAPH nodes they belong to. */ | |

static void | |

move_complex_constraints (constraint_graph_t graph) | |

{ | |

int i; | |

constraint_t c; | |

FOR_EACH_VEC_ELT (constraints, i, c) | |

{ | |

if (c) | |

{ | |

struct constraint_expr lhs = c->lhs; | |

struct constraint_expr rhs = c->rhs; | |

if (lhs.type == DEREF) | |

{ | |

insert_into_complex (graph, lhs.var, c); | |

} | |

else if (rhs.type == DEREF) | |

{ | |

if (!(get_varinfo (lhs.var)->is_special_var)) | |

insert_into_complex (graph, rhs.var, c); | |

} | |

else if (rhs.type != ADDRESSOF && lhs.var > anything_id | |

&& (lhs.offset != 0 || rhs.offset != 0)) | |

{ | |

insert_into_complex (graph, rhs.var, c); | |

} | |

} | |

} | |

} | |

/* Optimize and rewrite complex constraints while performing | |

collapsing of equivalent nodes. SI is the SCC_INFO that is the | |

result of perform_variable_substitution. */ | |

static void | |

rewrite_constraints (constraint_graph_t graph, | |

struct scc_info *si) | |

{ | |

int i; | |

unsigned int j; | |

constraint_t c; | |

for (j = 0; j < graph->size; j++) | |

gcc_assert (find (j) == j); | |

FOR_EACH_VEC_ELT (constraints, i, c) | |

{ | |

struct constraint_expr lhs = c->lhs; | |

struct constraint_expr rhs = c->rhs; | |

unsigned int lhsvar = find (lhs.var); | |

unsigned int rhsvar = find (rhs.var); | |

unsigned int lhsnode, rhsnode; | |

unsigned int lhslabel, rhslabel; | |

lhsnode = si->node_mapping[lhsvar]; | |

rhsnode = si->node_mapping[rhsvar]; | |

lhslabel = graph->pointer_label[lhsnode]; | |

rhslabel = graph->pointer_label[rhsnode]; | |

/* See if it is really a non-pointer variable, and if so, ignore | |

the constraint. */ | |

if (lhslabel == 0) | |

{ | |

if (dump_file && (dump_flags & TDF_DETAILS)) | |

{ | |

fprintf (dump_file, "%s is a non-pointer variable," | |

"ignoring constraint:", | |

get_varinfo (lhs.var)->name); | |

dump_constraint (dump_file, c); | |

fprintf (dump_file, "\n"); | |

} | |

constraints[i] = NULL; | |

continue; | |

} | |

if (rhslabel == 0) | |

{ | |

if (dump_file && (dump_flags & TDF_DETAILS)) | |

{ | |

fprintf (dump_file, "%s is a non-pointer variable," | |

"ignoring constraint:", | |

get_varinfo (rhs.var)->name); | |

dump_constraint (dump_file, c); | |

fprintf (dump_file, "\n"); | |

} | |

constraints[i] = NULL; | |

continue; | |

} | |

lhsvar = find_equivalent_node (graph, lhsvar, lhslabel); | |

rhsvar = find_equivalent_node (graph, rhsvar, rhslabel); | |

c->lhs.var = lhsvar; | |

c->rhs.var = rhsvar; | |

} | |

} | |

/* Eliminate indirect cycles involving NODE. Return true if NODE was | |

part of an SCC, false otherwise. */ | |

static bool | |

eliminate_indirect_cycles (unsigned int node) | |

{ | |

if (graph->indirect_cycles[node] != -1 | |

&& !bitmap_empty_p (get_varinfo (node)->solution)) | |

{ | |

unsigned int i; | |

vec<unsigned> queue = vNULL; | |

int queuepos; | |

unsigned int to = find (graph->indirect_cycles[node]); | |

bitmap_iterator bi; | |

/* We can't touch the solution set and call unify_nodes | |

at the same time, because unify_nodes is going to do | |

bitmap unions into it. */ | |

EXECUTE_IF_SET_IN_BITMAP (get_varinfo (node)->solution, 0, i, bi) | |

{ | |

if (find (i) == i && i != to) | |

{ | |

if (unite (to, i)) | |

queue.safe_push (i); | |

} | |

} | |

for (queuepos = 0; | |

queue.iterate (queuepos, &i); | |

queuepos++) | |

{ | |

unify_nodes (graph, to, i, true); | |

} | |

queue.release (); | |

return true; | |

} | |

return false; | |

} | |

/* Solve the constraint graph GRAPH using our worklist solver. | |

This is based on the PW* family of solvers from the "Efficient Field | |

Sensitive Pointer Analysis for C" paper. | |

It works by iterating over all the graph nodes, processing the complex | |

constraints and propagating the copy constraints, until everything stops | |

changed. This corresponds to steps 6-8 in the solving list given above. */ | |

static void | |

solve_graph (constraint_graph_t graph) | |

{ | |

unsigned int size = graph->size; | |

unsigned int i; | |

bitmap pts; | |

changed = BITMAP_ALLOC (NULL); | |

/* Mark all initial non-collapsed nodes as changed. */ | |

for (i = 0; i < size; i++) | |

{ | |

varinfo_t ivi = get_varinfo (i); | |

if (find (i) == i && !bitmap_empty_p (ivi->solution) | |

&& ((graph->succs[i] && !bitmap_empty_p (graph->succs[i])) | |

|| graph->complex[i].length () > 0)) | |

bitmap_set_bit (changed, i); | |

} | |

/* Allocate a bitmap to be used to store the changed bits. */ | |

pts = BITMAP_ALLOC (&pta_obstack); | |

while (!bitmap_empty_p (changed)) | |

{ | |

unsigned int i; | |

struct topo_info *ti = init_topo_info (); | |

stats.iterations++; | |

bitmap_obstack_initialize (&iteration_obstack); | |

compute_topo_order (graph, ti); | |

while (ti->topo_order.length () != 0) | |

{ | |

i = ti->topo_order.pop (); | |

/* If this variable is not a representative, skip it. */ | |

if (find (i) != i) | |

continue; | |

/* In certain indirect cycle cases, we may merge this | |

variable to another. */ | |

if (eliminate_indirect_cycles (i) && find (i) != i) | |

continue; | |

/* If the node has changed, we need to process the | |

complex constraints and outgoing edges again. */ | |

if (bitmap_clear_bit (changed, i)) | |

{ | |

unsigned int j; | |

constraint_t c; | |

bitmap solution; | |

vec<constraint_t> complex = graph->complex[i]; | |

varinfo_t vi = get_varinfo (i); | |

bool solution_empty; | |

/* Compute the changed set of solution bits. */ | |

if (vi->oldsolution) | |

bitmap_and_compl (pts, vi->solution, vi->oldsolution); | |

else | |

bitmap_copy (pts, vi->solution); | |

if (bitmap_empty_p (pts)) | |

continue; | |

if (vi->oldsolution) | |

bitmap_ior_into (vi->oldsolution, pts); | |

else | |

{ | |

vi->oldsolution = BITMAP_ALLOC (&oldpta_obstack); | |

bitmap_copy (vi->oldsolution, pts); | |

} | |

solution = vi->solution; | |

solution_empty = bitmap_empty_p (solution); | |

/* Process the complex constraints */ | |

FOR_EACH_VEC_ELT (complex, j, c) | |

{ | |

/* XXX: This is going to unsort the constraints in | |

some cases, which will occasionally add duplicate | |

constraints during unification. This does not | |

affect correctness. */ | |

c->lhs.var = find (c->lhs.var); | |

c->rhs.var = find (c->rhs.var); | |

/* The only complex constraint that can change our | |

solution to non-empty, given an empty solution, | |

is a constraint where the lhs side is receiving | |

some set from elsewhere. */ | |

if (!solution_empty || c->lhs.type != DEREF) | |

do_complex_constraint (graph, c, pts); | |

} | |

solution_empty = bitmap_empty_p (solution); | |

if (!solution_empty) | |

{ | |

bitmap_iterator bi; | |

unsigned eff_escaped_id = find (escaped_id); | |

/* Propagate solution to all successors. */ | |

EXECUTE_IF_IN_NONNULL_BITMAP (graph->succs[i], | |

0, j, bi) | |

{ | |

bitmap tmp; | |

bool flag; | |

unsigned int to = find (j); | |

tmp = get_varinfo (to)->solution; | |

flag = false; | |

/* Don't try to propagate to ourselves. */ | |

if (to == i) | |

continue; | |

/* If we propagate from ESCAPED use ESCAPED as | |

placeholder. */ | |

if (i == eff_escaped_id) | |

flag = bitmap_set_bit (tmp, escaped_id); | |

else | |

flag = set_union_with_increment (tmp, pts, 0); | |

if (flag) | |

{ | |

get_varinfo (to)->solution = tmp; | |

bitmap_set_bit (changed, to); | |

} | |

} | |

} | |

} | |

} | |

free_topo_info (ti); | |

bitmap_obstack_release (&iteration_obstack); | |

} | |

BITMAP_FREE (pts); | |

BITMAP_FREE (changed); | |

bitmap_obstack_release (&oldpta_obstack); | |

} | |

/* Map from trees to variable infos. */ | |

static struct pointer_map_t *vi_for_tree; | |

/* Insert ID as the variable id for tree T in the vi_for_tree map. */ | |

static void | |

insert_vi_for_tree (tree t, varinfo_t vi) | |

{ | |

void **slot = pointer_map_insert (vi_for_tree, t); | |

gcc_assert (vi); | |

gcc_assert (*slot == NULL); | |

*slot = vi; | |

} | |

/* Find the variable info for tree T in VI_FOR_TREE. If T does not | |

exist in the map, return NULL, otherwise, return the varinfo we found. */ | |

static varinfo_t | |

lookup_vi_for_tree (tree t) | |

{ | |

void **slot = pointer_map_contains (vi_for_tree, t); | |

if (slot == NULL) | |

return NULL; | |

return (varinfo_t) *slot; | |

} | |

/* Return a printable name for DECL */ | |

static const char * | |

alias_get_name (tree decl) | |

{ | |

const char *res = NULL; | |

char *temp; | |

int num_printed = 0; | |

if (!dump_file) | |

return "NULL"; | |

if (TREE_CODE (decl) == SSA_NAME) | |

{ | |

res = get_name (decl); | |

if (res) | |

num_printed = asprintf (&temp, "%s_%u", res, SSA_NAME_VERSION (decl)); | |

else | |

num_printed = asprintf (&temp, "_%u", SSA_NAME_VERSION (decl)); | |

if (num_printed > 0) | |

{ | |

res = ggc_strdup (temp); | |

free (temp); | |

} | |

} | |

else if (DECL_P (decl)) | |

{ | |

if (DECL_ASSEMBLER_NAME_SET_P (decl)) | |

res = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); | |

else | |

{ | |

res = get_name (decl); | |

if (!res) | |

{ | |

num_printed = asprintf (&temp, "D.%u", DECL_UID (decl)); | |

if (num_printed > 0) | |

{ | |

res = ggc_strdup (temp); | |

free (temp); | |

} | |

} | |

} | |

} | |

if (res != NULL) | |

return res; | |

return "NULL"; | |

} | |

/* Find the variable id for tree T in the map. | |

If T doesn't exist in the map, create an entry for it and return it. */ | |

static varinfo_t | |

get_vi_for_tree (tree t) | |

{ | |

void **slot = pointer_map_contains (vi_for_tree, t); | |

if (slot == NULL) | |

return get_varinfo (create_variable_info_for (t, alias_get_name (t))); | |

return (varinfo_t) *slot; | |

} | |

/* Get a scalar constraint expression for a new temporary variable. */ | |

static struct constraint_expr | |

new_scalar_tmp_constraint_exp (const char *name) | |

{ | |

struct constraint_expr tmp; | |

varinfo_t vi; | |

vi = new_var_info (NULL_TREE, name); | |

vi->offset = 0; | |

vi->size = -1; | |

vi->fullsize = -1; | |

vi->is_full_var = 1; | |

tmp.var = vi->id; | |

tmp.type = SCALAR; | |

tmp.offset = 0; | |

return tmp; | |

} | |

/* Get a constraint expression vector from an SSA_VAR_P node. | |

If address_p is true, the result will be taken its address of. */ | |

static void | |

get_constraint_for_ssa_var (tree t, vec<ce_s> *results, bool address_p) | |

{ | |

struct constraint_expr cexpr; | |

varinfo_t vi; | |

/* We allow FUNCTION_DECLs here even though it doesn't make much sense. */ | |

gcc_assert (TREE_CODE (t) == SSA_NAME || DECL_P (t)); | |

/* For parameters, get at the points-to set for the actual parm | |

decl. */ | |

if (TREE_CODE (t) == SSA_NAME | |

&& SSA_NAME_IS_DEFAULT_DEF (t) | |

&& (TREE_CODE (SSA_NAME_VAR (t)) == PARM_DECL | |

|| TREE_CODE (SSA_NAME_VAR (t)) == RESULT_DECL)) | |

{ | |

get_constraint_for_ssa_var (SSA_NAME_VAR (t), results, address_p); | |

return; | |

} | |

/* For global variables resort to the alias target. */ | |

if (TREE_CODE (t) == VAR_DECL | |

&& (TREE_STATIC (t) || DECL_EXTERNAL (t))) | |

{ | |

struct varpool_node *node = varpool_get_node (t); | |

if (node && node->alias) | |

{ | |

node = varpool_variable_node (node, NULL); | |

t = node->symbol.decl; | |

} | |

} | |

vi = get_vi_for_tree (t); | |

cexpr.var = vi->id; | |

cexpr.type = SCALAR; | |

cexpr.offset = 0; | |

/* If we determine the result is "anything", and we know this is readonly, | |

say it points to readonly memory instead. */ | |

if (cexpr.var == anything_id && TREE_READONLY (t)) | |

{ | |

gcc_unreachable (); | |

cexpr.type = ADDRESSOF; | |

cexpr.var = readonly_id; | |

} | |

/* If we are not taking the address of the constraint expr, add all | |

sub-fiels of the variable as well. */ | |

if (!address_p | |

&& !vi->is_full_var) | |

{ | |

for (; vi; vi = vi->next) | |

{ | |

cexpr.var = vi->id; | |

results->safe_push (cexpr); | |

} | |

return; | |

} | |

results->safe_push (cexpr); | |

} | |

/* Process constraint T, performing various simplifications and then | |

adding it to our list of overall constraints. */ | |

static void | |

process_constraint (constraint_t t) | |

{ | |

struct constraint_expr rhs = t->rhs; | |

struct constraint_expr lhs = t->lhs; | |

gcc_assert (rhs.var < varmap.length ()); | |

gcc_assert (lhs.var < varmap.length ()); | |

/* If we didn't get any useful constraint from the lhs we get | |

&ANYTHING as fallback from get_constraint_for. Deal with | |

it here by turning it into *ANYTHING. */ | |

if (lhs.type == ADDRESSOF | |

&& lhs.var == anything_id) | |

lhs.type = DEREF; | |

/* ADDRESSOF on the lhs is invalid. */ | |

gcc_assert (lhs.type != ADDRESSOF); | |

/* We shouldn't add constraints from things that cannot have pointers. | |

It's not completely trivial to avoid in the callers, so do it here. */ | |

if (rhs.type != ADDRESSOF | |

&& !get_varinfo (rhs.var)->may_have_pointers) | |

return; | |

/* Likewise adding to the solution of a non-pointer var isn't useful. */ | |

if (!get_varinfo (lhs.var)->may_have_pointers) | |

return; | |

/* This can happen in our IR with things like n->a = *p */ | |

if (rhs.type == DEREF && lhs.type == DEREF && rhs.var != anything_id) | |

{ | |

/* Split into tmp = *rhs, *lhs = tmp */ | |

struct constraint_expr tmplhs; | |

tmplhs = new_scalar_tmp_constraint_exp ("doubledereftmp"); | |

process_constraint (new_constraint (tmplhs, rhs)); | |

process_constraint (new_constraint (lhs, tmplhs)); | |

} | |

else if (rhs.type == ADDRESSOF && lhs.type == DEREF) | |

{ | |

/* Split into tmp = &rhs, *lhs = tmp */ | |

struct constraint_expr tmplhs; | |

tmplhs = new_scalar_tmp_constraint_exp ("derefaddrtmp"); | |

process_constraint (new_constraint (tmplhs, rhs)); | |

process_constraint (new_constraint (lhs, tmplhs)); | |

} | |

else | |

{ | |

gcc_assert (rhs.type != ADDRESSOF || rhs.offset == 0); | |

constraints.safe_push (t); | |

} | |

} | |

/* Return the position, in bits, of FIELD_DECL from the beginning of its | |

structure. */ | |

static HOST_WIDE_INT | |

bitpos_of_field (const tree fdecl) | |

{ | |

if (!host_integerp (DECL_FIELD_OFFSET (fdecl), 0) | |

|| !host_integerp (DECL_FIELD_BIT_OFFSET (fdecl), 0)) | |

return -1; | |

return (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (fdecl)) * BITS_PER_UNIT | |

+ TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (fdecl))); | |

} | |

/* Get constraint expressions for offsetting PTR by OFFSET. Stores the | |

resulting constraint expressions in *RESULTS. */ | |

static void | |

get_constraint_for_ptr_offset (tree ptr, tree offset, | |

vec<ce_s> *results) | |

{ | |

struct constraint_expr c; | |

unsigned int j, n; | |

HOST_WIDE_INT rhsoffset; | |

/* If we do not do field-sensitive PTA adding offsets to pointers | |

does not change the points-to solution. */ | |

if (!use_field_sensitive) | |

{ | |

get_constraint_for_rhs (ptr, results); | |

return; | |

} | |

/* If the offset is not a non-negative integer constant that fits | |

in a HOST_WIDE_INT, we have to fall back to a conservative | |

solution which includes all sub-fields of all pointed-to | |

variables of ptr. */ | |

if (offset == NULL_TREE | |

|| TREE_CODE (offset) != INTEGER_CST) | |

rhsoffset = UNKNOWN_OFFSET; | |

else | |

{ | |

/* Sign-extend the offset. */ | |

double_int soffset = tree_to_double_int (offset) | |

.sext (TYPE_PRECISION (TREE_TYPE (offset))); | |

if (!soffset.fits_shwi ()) | |

rhsoffset = UNKNOWN_OFFSET; | |

else | |

{ | |

/* Make sure the bit-offset also fits. */ | |

HOST_WIDE_INT rhsunitoffset = soffset.low; | |

rhsoffset = rhsunitoffset * BITS_PER_UNIT; | |

if (rhsunitoffset != rhsoffset / BITS_PER_UNIT) | |

rhsoffset = UNKNOWN_OFFSET; | |

} | |

} | |

get_constraint_for_rhs (ptr, results); | |

if (rhsoffset == 0) | |

return; | |

/* As we are eventually appending to the solution do not use | |

vec::iterate here. */ | |

n = results->length (); | |

for (j = 0; j < n; j++) | |

{ | |

varinfo_t curr; | |

c = (*results)[j]; | |

curr = get_varinfo (c.var); | |

if (c.type == ADDRESSOF | |

/* If this varinfo represents a full variable just use it. */ | |

&& curr->is_full_var) | |

c.offset = 0; | |

else if (c.type == ADDRESSOF | |

/* If we do not know the offset add all subfields. */ | |

&& rhsoffset == UNKNOWN_OFFSET) | |

{ | |

varinfo_t temp = lookup_vi_for_tree (curr->decl); | |

do | |

{ | |

struct constraint_expr c2; | |

c2.var = temp->id; | |

c2.type = ADDRESSOF; | |

c2.offset = 0; | |

if (c2.var != c.var) | |

results->safe_push (c2); | |

temp = temp->next; | |

} | |

while (temp); | |

} | |

else if (c.type == ADDRESSOF) | |

{ | |

varinfo_t temp; | |

unsigned HOST_WIDE_INT offset = curr->offset + rhsoffset; | |

/* If curr->offset + rhsoffset is less than zero adjust it. */ | |

if (rhsoffset < 0 | |

&& curr->offset < offset) | |

offset = 0; | |

/* We have to include all fields that overlap the current | |

field shifted by rhsoffset. And we include at least | |

the last or the first field of the variable to represent | |

reachability of off-bound addresses, in particular &object + 1, | |

conservatively correct. */ | |

temp = first_or_preceding_vi_for_offset (curr, offset); | |

c.var = temp->id; | |

c.offset = 0; | |

temp = temp->next; | |

while (temp | |

&& temp->offset < offset + curr->size) | |

{ | |

struct constraint_expr c2; | |

c2.var = temp->id; | |

c2.type = ADDRESSOF; | |

c2.offset = 0; | |

results->safe_push (c2); | |

temp = temp->next; | |

} | |

} | |

else | |

c.offset = rhsoffset; | |

(*results)[j] = c; | |

} | |

} | |

/* Given a COMPONENT_REF T, return the constraint_expr vector for it. | |

If address_p is true the result will be taken its address of. | |

If lhs_p is true then the constraint expression is assumed to be used | |

as the lhs. */ | |

static void | |

get_constraint_for_component_ref (tree t, vec<ce_s> *results, | |

bool address_p, bool lhs_p) | |

{ | |

tree orig_t = t; | |

HOST_WIDE_INT bitsize = -1; | |

HOST_WIDE_INT bitmaxsize = -1; | |

HOST_WIDE_INT bitpos; | |

tree forzero; | |

/* Some people like to do cute things like take the address of | |

&0->a.b */ | |

forzero = t; | |

while (handled_component_p (forzero) | |

|| INDIRECT_REF_P (forzero) | |

|| TREE_CODE (forzero) == MEM_REF) | |

forzero = TREE_OPERAND (forzero, 0); | |

if (CONSTANT_CLASS_P (forzero) && integer_zerop (forzero)) | |

{ | |

struct constraint_expr temp; | |

temp.offset = 0; | |

temp.var = integer_id; | |

temp.type = SCALAR; | |

results->safe_push (temp); | |

return; | |

} | |

/* Handle type-punning through unions. If we are extracting a pointer | |

from a union via a possibly type-punning access that pointer | |

points to anything, similar to a conversion of an integer to | |

a pointer. */ | |

if (!lhs_p) | |

{ | |

tree u; | |

for (u = t; | |

TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF; | |

u = TREE_OPERAND (u, 0)) | |

if (TREE_CODE (u) == COMPONENT_REF | |

&& TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE) | |

{ | |

struct constraint_expr temp; | |

temp.offset = 0; | |

temp.var = anything_id; | |

temp.type = ADDRESSOF; | |

results->safe_push (temp); | |

return; | |

} | |

} | |

t = get_ref_base_and_extent (t, &bitpos, &bitsize, &bitmaxsize); | |

/* Pretend to take the address of the base, we'll take care of | |

adding the required subset of sub-fields below. */ | |

get_constraint_for_1 (t, results, true, lhs_p); | |

gcc_assert (results->length () == 1); | |

struct constraint_expr &result = results->last (); | |

if (result.type == SCALAR | |

&& get_varinfo (result.var)->is_full_var) | |

/* For single-field vars do not bother about the offset. */ | |

result.offset = 0; | |

else if (result.type == SCALAR) | |

{ | |

/* In languages like C, you can access one past the end of an | |

array. You aren't allowed to dereference it, so we can | |

ignore this constraint. When we handle pointer subtraction, | |

we may have to do something cute here. */ | |

if ((unsigned HOST_WIDE_INT)bitpos < get_varinfo (result.var)->fullsize | |

&& bitmaxsize != 0) | |

{ | |

/* It's also not true that the constraint will actually start at the | |

right offset, it may start in some padding. We only care about | |

setting the constraint to the first actual field it touches, so | |

walk to find it. */ | |

struct constraint_expr cexpr = result; | |

varinfo_t curr; | |

results->pop (); | |

cexpr.offset = 0; | |

for (curr = get_varinfo (cexpr.var); curr; curr = curr->next) | |

{ | |

if (ranges_overlap_p (curr->offset, curr->size, | |

bitpos, bitmaxsize)) | |

{ | |

cexpr.var = curr->id; | |

results->safe_push (cexpr); | |

if (address_p) | |

break; | |

} | |

} | |

/* If we are going to take the address of this field then | |

to be able to compute reachability correctly add at least | |

the last field of the variable. */ | |

if (address_p && results->length () == 0) | |

{ | |

curr = get_varinfo (cexpr.var); | |

while (curr->next != NULL) | |

curr = curr->next; | |

cexpr.var = curr->id; | |

results->safe_push (cexpr); | |

} | |

else if (results->length () == 0) | |

/* Assert that we found *some* field there. The user couldn't be | |

accessing *only* padding. */ | |

/* Still the user could access one past the end of an array | |

embedded in a struct resulting in accessing *only* padding. */ | |

/* Or accessing only padding via type-punning to a type | |

that has a filed just in padding space. */ | |

{ | |

cexpr.type = SCALAR; | |

cexpr.var = anything_id; | |

cexpr.offset = 0; | |

results->safe_push (cexpr); | |

} | |

} | |

else if (bitmaxsize == 0) | |

{ | |

if (dump_file && (dump_flags & TDF_DETAILS)) | |

fprintf (dump_file, "Access to zero-sized part of variable," | |

"ignoring\n"); | |

} | |

else | |

if (dump_file && (dump_flags & TDF_DETAILS)) | |

fprintf (dump_file, "Access to past the end of variable, ignoring\n"); | |

} | |

else if (result.type == DEREF) | |

{ | |

/* If we do not know exactly where the access goes say so. Note | |

that only for non-structure accesses we know that we access | |

at most one subfiled of any variable. */ | |

if (bitpos == -1 | |

|| bitsize != bitmaxsize | |

|| AGGREGATE_TYPE_P (TREE_TYPE (orig_t)) | |

|| result.offset == UNKNOWN_OFFSET) | |

result.offset = UNKNOWN_OFFSET; | |

else | |

result.offset += bitpos; | |

} | |

else if (result.type == ADDRESSOF) | |

{ | |

/* We can end up here for component references on a | |

VIEW_CONVERT_EXPR <>(&foobar). */ | |

result.type = SCALAR; | |

result.var = anything_id; | |

result.offset = 0; | |

} | |

else | |

gcc_unreachable (); | |

} | |

/* Dereference the constraint expression CONS, and return the result. | |

DEREF (ADDRESSOF) = SCALAR | |

DEREF (SCALAR) = DEREF | |

DEREF (DEREF) = (temp = DEREF1; result = DEREF(temp)) | |

This is needed so that we can handle dereferencing DEREF constraints. */ | |

static void | |

do_deref (vec<ce_s> *constraints) | |

{ | |

struct constraint_expr *c; | |

unsigned int i = 0; | |

FOR_EACH_VEC_ELT (*constraints, i, c) | |

{ | |

if (c->type == SCALAR) | |

c->type = DEREF; | |

else if (c->type == ADDRESSOF) | |

c->type = SCALAR; | |

else if (c->type == DEREF) | |

{ | |

struct constraint_expr tmplhs; | |

tmplhs = new_scalar_tmp_constraint_exp ("dereftmp"); | |

process_constraint (new_constraint (tmplhs, *c)); | |

c->var = tmplhs.var; | |

} | |

else | |

gcc_unreachable (); | |

} | |

} | |

/* Given a tree T, return the constraint expression for taking the | |

address of it. */ | |

static void | |

get_constraint_for_address_of (tree t, vec<ce_s> *results) | |