Mercurial > hg > CbC > CbC_gcc
annotate gcc/alias.c @ 132:d34655255c78
update gcc-8.2
| author | mir3636 |
|---|---|
| date | Thu, 25 Oct 2018 10:21:07 +0900 |
| parents | 84e7813d76e9 |
| children | 1830386684a0 |
| rev | line source |
|---|---|
| 0 | 1 /* Alias analysis for GNU C |
| 131 | 2 Copyright (C) 1997-2018 Free Software Foundation, Inc. |
| 0 | 3 Contributed by John Carr (jfc@mit.edu). |
| 4 | |
| 5 This file is part of GCC. | |
| 6 | |
| 7 GCC is free software; you can redistribute it and/or modify it under | |
| 8 the terms of the GNU General Public License as published by the Free | |
| 9 Software Foundation; either version 3, or (at your option) any later | |
| 10 version. | |
| 11 | |
| 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with GCC; see the file COPYING3. If not see | |
| 19 <http://www.gnu.org/licenses/>. */ | |
| 20 | |
| 21 #include "config.h" | |
| 22 #include "system.h" | |
| 23 #include "coretypes.h" | |
| 111 | 24 #include "backend.h" |
| 25 #include "target.h" | |
| 0 | 26 #include "rtl.h" |
| 27 #include "tree.h" | |
| 111 | 28 #include "gimple.h" |
| 29 #include "df.h" | |
| 30 #include "memmodel.h" | |
| 0 | 31 #include "tm_p.h" |
| 111 | 32 #include "gimple-ssa.h" |
| 0 | 33 #include "emit-rtl.h" |
| 111 | 34 #include "alias.h" |
| 35 #include "fold-const.h" | |
| 36 #include "varasm.h" | |
| 0 | 37 #include "cselib.h" |
| 38 #include "langhooks.h" | |
| 111 | 39 #include "cfganal.h" |
| 40 #include "rtl-iter.h" | |
| 0 | 41 #include "cgraph.h" |
| 42 | |
| 43 /* The aliasing API provided here solves related but different problems: | |
| 44 | |
| 45 Say there exists (in c) | |
| 46 | |
| 47 struct X { | |
| 48 struct Y y1; | |
| 49 struct Z z2; | |
| 50 } x1, *px1, *px2; | |
| 51 | |
| 52 struct Y y2, *py; | |
| 53 struct Z z2, *pz; | |
| 54 | |
| 55 | |
| 111 | 56 py = &x1.y1; |
| 0 | 57 px2 = &x1; |
| 58 | |
| 59 Consider the four questions: | |
| 60 | |
| 61 Can a store to x1 interfere with px2->y1? | |
| 62 Can a store to x1 interfere with px2->z2? | |
| 63 Can a store to x1 change the value pointed to by with py? | |
| 64 Can a store to x1 change the value pointed to by with pz? | |
| 65 | |
| 66 The answer to these questions can be yes, yes, yes, and maybe. | |
| 67 | |
| 68 The first two questions can be answered with a simple examination | |
| 69 of the type system. If structure X contains a field of type Y then | |
| 111 | 70 a store through a pointer to an X can overwrite any field that is |
| 0 | 71 contained (recursively) in an X (unless we know that px1 != px2). |
| 72 | |
| 111 | 73 The last two questions can be solved in the same way as the first |
| 74 two questions but this is too conservative. The observation is | |
| 75 that in some cases we can know which (if any) fields are addressed | |
| 76 and if those addresses are used in bad ways. This analysis may be | |
| 77 language specific. In C, arbitrary operations may be applied to | |
| 78 pointers. However, there is some indication that this may be too | |
| 79 conservative for some C++ types. | |
| 0 | 80 |
| 81 The pass ipa-type-escape does this analysis for the types whose | |
| 82 instances do not escape across the compilation boundary. | |
| 83 | |
| 84 Historically in GCC, these two problems were combined and a single | |
| 111 | 85 data structure that was used to represent the solution to these |
| 0 | 86 problems. We now have two similar but different data structures, |
| 111 | 87 The data structure to solve the last two questions is similar to |
| 88 the first, but does not contain the fields whose address are never | |
| 89 taken. For types that do escape the compilation unit, the data | |
| 90 structures will have identical information. | |
| 0 | 91 */ |
| 92 | |
| 93 /* The alias sets assigned to MEMs assist the back-end in determining | |
| 94 which MEMs can alias which other MEMs. In general, two MEMs in | |
| 95 different alias sets cannot alias each other, with one important | |
| 96 exception. Consider something like: | |
| 97 | |
| 98 struct S { int i; double d; }; | |
| 99 | |
| 100 a store to an `S' can alias something of either type `int' or type | |
| 101 `double'. (However, a store to an `int' cannot alias a `double' | |
| 102 and vice versa.) We indicate this via a tree structure that looks | |
| 103 like: | |
| 104 struct S | |
| 105 / \ | |
| 106 / \ | |
| 107 |/_ _\| | |
| 108 int double | |
| 109 | |
| 110 (The arrows are directed and point downwards.) | |
| 111 In this situation we say the alias set for `struct S' is the | |
| 112 `superset' and that those for `int' and `double' are `subsets'. | |
| 113 | |
| 114 To see whether two alias sets can point to the same memory, we must | |
| 115 see if either alias set is a subset of the other. We need not trace | |
| 116 past immediate descendants, however, since we propagate all | |
| 117 grandchildren up one level. | |
| 118 | |
| 119 Alias set zero is implicitly a superset of all other alias sets. | |
| 120 However, this is no actual entry for alias set zero. It is an | |
| 121 error to attempt to explicitly construct a subset of zero. */ | |
| 122 | |
| 111 | 123 struct alias_set_hash : int_hash <int, INT_MIN, INT_MIN + 1> {}; |
| 124 | |
| 125 struct GTY(()) alias_set_entry { | |
| 0 | 126 /* The alias set number, as stored in MEM_ALIAS_SET. */ |
| 127 alias_set_type alias_set; | |
| 128 | |
| 129 /* Nonzero if would have a child of zero: this effectively makes this | |
| 130 alias set the same as alias set zero. */ | |
| 111 | 131 bool has_zero_child; |
| 132 /* Nonzero if alias set corresponds to pointer type itself (i.e. not to | |
| 133 aggregate contaiing pointer. | |
| 134 This is used for a special case where we need an universal pointer type | |
| 135 compatible with all other pointer types. */ | |
| 136 bool is_pointer; | |
| 137 /* Nonzero if is_pointer or if one of childs have has_pointer set. */ | |
| 138 bool has_pointer; | |
| 0 | 139 |
| 140 /* The children of the alias set. These are not just the immediate | |
| 141 children, but, in fact, all descendants. So, if we have: | |
| 142 | |
| 143 struct T { struct S s; float f; } | |
| 144 | |
| 145 continuing our example above, the children here will be all of | |
| 146 `int', `double', `float', and `struct S'. */ | |
| 111 | 147 hash_map<alias_set_hash, int> *children; |
| 0 | 148 }; |
| 149 | |
| 150 static int rtx_equal_for_memref_p (const_rtx, const_rtx); | |
| 151 static void record_set (rtx, const_rtx, void *); | |
| 111 | 152 static int base_alias_check (rtx, rtx, rtx, rtx, machine_mode, |
| 153 machine_mode); | |
| 0 | 154 static rtx find_base_value (rtx); |
| 155 static int mems_in_disjoint_alias_sets_p (const_rtx, const_rtx); | |
| 111 | 156 static alias_set_entry *get_alias_set_entry (alias_set_type); |
| 0 | 157 static tree decl_for_component_ref (tree); |
| 111 | 158 static int write_dependence_p (const_rtx, |
| 159 const_rtx, machine_mode, rtx, | |
| 160 bool, bool, bool); | |
| 161 static int compare_base_symbol_refs (const_rtx, const_rtx); | |
| 0 | 162 |
| 163 static void memory_modified_1 (rtx, const_rtx, void *); | |
| 164 | |
| 111 | 165 /* Query statistics for the different low-level disambiguators. |
| 166 A high-level query may trigger multiple of them. */ | |
| 167 | |
| 168 static struct { | |
| 169 unsigned long long num_alias_zero; | |
| 170 unsigned long long num_same_alias_set; | |
| 171 unsigned long long num_same_objects; | |
| 172 unsigned long long num_volatile; | |
| 173 unsigned long long num_dag; | |
| 174 unsigned long long num_universal; | |
| 175 unsigned long long num_disambiguated; | |
| 176 } alias_stats; | |
| 177 | |
| 178 | |
| 0 | 179 /* Set up all info needed to perform alias analysis on memory references. */ |
| 180 | |
| 181 /* Returns the size in bytes of the mode of X. */ | |
| 182 #define SIZE_FOR_MODE(X) (GET_MODE_SIZE (GET_MODE (X))) | |
| 183 | |
| 184 /* Cap the number of passes we make over the insns propagating alias | |
| 111 | 185 information through set chains. |
| 186 ??? 10 is a completely arbitrary choice. This should be based on the | |
| 187 maximum loop depth in the CFG, but we do not have this information | |
| 188 available (even if current_loops _is_ available). */ | |
| 0 | 189 #define MAX_ALIAS_LOOP_PASSES 10 |
| 190 | |
| 191 /* reg_base_value[N] gives an address to which register N is related. | |
| 192 If all sets after the first add or subtract to the current value | |
| 193 or otherwise modify it so it does not point to a different top level | |
| 194 object, reg_base_value[N] is equal to the address part of the source | |
| 195 of the first set. | |
| 196 | |
| 197 A base address can be an ADDRESS, SYMBOL_REF, or LABEL_REF. ADDRESS | |
| 111 | 198 expressions represent three types of base: |
| 199 | |
| 200 1. incoming arguments. There is just one ADDRESS to represent all | |
| 201 arguments, since we do not know at this level whether accesses | |
| 202 based on different arguments can alias. The ADDRESS has id 0. | |
| 203 | |
| 204 2. stack_pointer_rtx, frame_pointer_rtx, hard_frame_pointer_rtx | |
| 205 (if distinct from frame_pointer_rtx) and arg_pointer_rtx. | |
| 206 Each of these rtxes has a separate ADDRESS associated with it, | |
| 207 each with a negative id. | |
| 208 | |
| 209 GCC is (and is required to be) precise in which register it | |
| 210 chooses to access a particular region of stack. We can therefore | |
| 211 assume that accesses based on one of these rtxes do not alias | |
| 212 accesses based on another of these rtxes. | |
| 213 | |
| 214 3. bases that are derived from malloc()ed memory (REG_NOALIAS). | |
| 215 Each such piece of memory has a separate ADDRESS associated | |
| 216 with it, each with an id greater than 0. | |
| 217 | |
| 218 Accesses based on one ADDRESS do not alias accesses based on other | |
| 219 ADDRESSes. Accesses based on ADDRESSes in groups (2) and (3) do not | |
| 220 alias globals either; the ADDRESSes have Pmode to indicate this. | |
| 221 The ADDRESS in group (1) _may_ alias globals; it has VOIDmode to | |
| 222 indicate this. */ | |
| 223 | |
| 224 static GTY(()) vec<rtx, va_gc> *reg_base_value; | |
| 0 | 225 static rtx *new_reg_base_value; |
| 226 | |
| 111 | 227 /* The single VOIDmode ADDRESS that represents all argument bases. |
| 228 It has id 0. */ | |
| 229 static GTY(()) rtx arg_base_value; | |
| 230 | |
| 231 /* Used to allocate unique ids to each REG_NOALIAS ADDRESS. */ | |
| 232 static int unique_id; | |
| 233 | |
| 0 | 234 /* We preserve the copy of old array around to avoid amount of garbage |
| 235 produced. About 8% of garbage produced were attributed to this | |
| 236 array. */ | |
| 111 | 237 static GTY((deletable)) vec<rtx, va_gc> *old_reg_base_value; |
| 238 | |
| 239 /* Values of XINT (address, 0) of Pmode ADDRESS rtxes for special | |
| 240 registers. */ | |
| 241 #define UNIQUE_BASE_VALUE_SP -1 | |
| 242 #define UNIQUE_BASE_VALUE_ARGP -2 | |
| 243 #define UNIQUE_BASE_VALUE_FP -3 | |
| 244 #define UNIQUE_BASE_VALUE_HFP -4 | |
| 0 | 245 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
246 #define static_reg_base_value \ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
247 (this_target_rtl->x_static_reg_base_value) |
| 0 | 248 |
| 111 | 249 #define REG_BASE_VALUE(X) \ |
| 250 (REGNO (X) < vec_safe_length (reg_base_value) \ | |
| 251 ? (*reg_base_value)[REGNO (X)] : 0) | |
| 0 | 252 |
| 253 /* Vector indexed by N giving the initial (unchanging) value known for | |
| 111 | 254 pseudo-register N. This vector is initialized in init_alias_analysis, |
| 0 | 255 and does not change until end_alias_analysis is called. */ |
| 111 | 256 static GTY(()) vec<rtx, va_gc> *reg_known_value; |
| 0 | 257 |
| 258 /* Vector recording for each reg_known_value whether it is due to a | |
| 259 REG_EQUIV note. Future passes (viz., reload) may replace the | |
| 260 pseudo with the equivalent expression and so we account for the | |
| 261 dependences that would be introduced if that happens. | |
| 262 | |
| 263 The REG_EQUIV notes created in assign_parms may mention the arg | |
| 264 pointer, and there are explicit insns in the RTL that modify the | |
| 265 arg pointer. Thus we must ensure that such insns don't get | |
| 266 scheduled across each other because that would invalidate the | |
| 267 REG_EQUIV notes. One could argue that the REG_EQUIV notes are | |
| 268 wrong, but solving the problem in the scheduler will likely give | |
| 269 better code, so we do it here. */ | |
| 111 | 270 static sbitmap reg_known_equiv_p; |
| 0 | 271 |
| 272 /* True when scanning insns from the start of the rtl to the | |
| 273 NOTE_INSN_FUNCTION_BEG note. */ | |
| 274 static bool copying_arguments; | |
| 275 | |
| 276 | |
| 277 /* The splay-tree used to store the various alias set entries. */ | |
| 111 | 278 static GTY (()) vec<alias_set_entry *, va_gc> *alias_sets; |
| 0 | 279 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
280 /* Build a decomposed reference object for querying the alias-oracle |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
281 from the MEM rtx and store it in *REF. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
282 Returns false if MEM is not suitable for the alias-oracle. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
283 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
284 static bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
285 ao_ref_from_mem (ao_ref *ref, const_rtx mem) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
286 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
287 tree expr = MEM_EXPR (mem); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
288 tree base; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
289 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
290 if (!expr) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
291 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
292 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
293 ao_ref_init (ref, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
294 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
295 /* Get the base of the reference and see if we have to reject or |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
296 adjust it. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
297 base = ao_ref_base (ref); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
298 if (base == NULL_TREE) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
299 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
300 |
| 111 | 301 /* The tree oracle doesn't like bases that are neither decls |
| 302 nor indirect references of SSA names. */ | |
| 303 if (!(DECL_P (base) | |
| 304 || (TREE_CODE (base) == MEM_REF | |
| 305 && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME) | |
| 306 || (TREE_CODE (base) == TARGET_MEM_REF | |
| 307 && TREE_CODE (TMR_BASE (base)) == SSA_NAME))) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
308 return false; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
309 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
310 /* If this is a reference based on a partitioned decl replace the |
| 111 | 311 base with a MEM_REF of the pointer representative we |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
312 created during stack slot partitioning. */ |
| 111 | 313 if (VAR_P (base) |
| 314 && ! is_global_var (base) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
315 && cfun->gimple_df->decls_to_pointers != NULL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
316 { |
| 111 | 317 tree *namep = cfun->gimple_df->decls_to_pointers->get (base); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
318 if (namep) |
| 111 | 319 ref->base = build_simple_mem_ref (*namep); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
320 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
321 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
322 ref->ref_alias_set = MEM_ALIAS_SET (mem); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
323 |
| 111 | 324 /* If MEM_OFFSET or MEM_SIZE are unknown what we got from MEM_EXPR |
| 325 is conservative, so trust it. */ | |
| 326 if (!MEM_OFFSET_KNOWN_P (mem) | |
| 327 || !MEM_SIZE_KNOWN_P (mem)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
328 return true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
329 |
| 111 | 330 /* If MEM_OFFSET/MEM_SIZE get us outside of ref->offset/ref->max_size |
| 331 drop ref->ref. */ | |
| 131 | 332 if (maybe_lt (MEM_OFFSET (mem), 0) |
| 333 || (ref->max_size_known_p () | |
| 334 && maybe_gt ((MEM_OFFSET (mem) + MEM_SIZE (mem)) * BITS_PER_UNIT, | |
| 335 ref->max_size))) | |
| 111 | 336 ref->ref = NULL_TREE; |
| 337 | |
| 338 /* Refine size and offset we got from analyzing MEM_EXPR by using | |
| 339 MEM_SIZE and MEM_OFFSET. */ | |
| 340 | |
| 341 ref->offset += MEM_OFFSET (mem) * BITS_PER_UNIT; | |
| 342 ref->size = MEM_SIZE (mem) * BITS_PER_UNIT; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
343 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
344 /* The MEM may extend into adjacent fields, so adjust max_size if |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
345 necessary. */ |
| 131 | 346 if (ref->max_size_known_p ()) |
| 347 ref->max_size = upper_bound (ref->max_size, ref->size); | |
| 348 | |
| 349 /* If MEM_OFFSET and MEM_SIZE might get us outside of the base object of | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
350 the MEM_EXPR punt. This happens for STRICT_ALIGNMENT targets a lot. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
351 if (MEM_EXPR (mem) != get_spill_slot_decl (false) |
| 131 | 352 && (maybe_lt (ref->offset, 0) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
353 || (DECL_P (ref->base) |
| 111 | 354 && (DECL_SIZE (ref->base) == NULL_TREE |
| 131 | 355 || !poly_int_tree_p (DECL_SIZE (ref->base)) |
| 356 || maybe_lt (wi::to_poly_offset (DECL_SIZE (ref->base)), | |
| 357 ref->offset + ref->size))))) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
358 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
359 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
360 return true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
361 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
362 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
363 /* Query the alias-oracle on whether the two memory rtx X and MEM may |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
364 alias. If TBAA_P is set also apply TBAA. Returns true if the |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
365 two rtxen may alias, false otherwise. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
366 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
367 static bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
368 rtx_refs_may_alias_p (const_rtx x, const_rtx mem, bool tbaa_p) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
369 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
370 ao_ref ref1, ref2; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
371 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
372 if (!ao_ref_from_mem (&ref1, x) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
373 || !ao_ref_from_mem (&ref2, mem)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
374 return true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
375 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
376 return refs_may_alias_p_1 (&ref1, &ref2, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
377 tbaa_p |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
378 && MEM_ALIAS_SET (x) != 0 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
379 && MEM_ALIAS_SET (mem) != 0); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
380 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
381 |
| 0 | 382 /* Returns a pointer to the alias set entry for ALIAS_SET, if there is |
| 383 such an entry, or NULL otherwise. */ | |
| 384 | |
| 111 | 385 static inline alias_set_entry * |
| 0 | 386 get_alias_set_entry (alias_set_type alias_set) |
| 387 { | |
| 111 | 388 return (*alias_sets)[alias_set]; |
| 0 | 389 } |
| 390 | |
| 391 /* Returns nonzero if the alias sets for MEM1 and MEM2 are such that | |
| 392 the two MEMs cannot alias each other. */ | |
| 393 | |
| 394 static inline int | |
| 395 mems_in_disjoint_alias_sets_p (const_rtx mem1, const_rtx mem2) | |
| 396 { | |
| 111 | 397 return (flag_strict_aliasing |
| 398 && ! alias_sets_conflict_p (MEM_ALIAS_SET (mem1), | |
| 399 MEM_ALIAS_SET (mem2))); | |
| 0 | 400 } |
| 401 | |
| 402 /* Return true if the first alias set is a subset of the second. */ | |
| 403 | |
| 404 bool | |
| 405 alias_set_subset_of (alias_set_type set1, alias_set_type set2) | |
| 406 { | |
| 111 | 407 alias_set_entry *ase2; |
| 408 | |
| 409 /* Disable TBAA oracle with !flag_strict_aliasing. */ | |
| 410 if (!flag_strict_aliasing) | |
| 411 return true; | |
| 0 | 412 |
| 413 /* Everything is a subset of the "aliases everything" set. */ | |
| 414 if (set2 == 0) | |
| 415 return true; | |
| 416 | |
| 111 | 417 /* Check if set1 is a subset of set2. */ |
| 418 ase2 = get_alias_set_entry (set2); | |
| 419 if (ase2 != 0 | |
| 420 && (ase2->has_zero_child | |
| 421 || (ase2->children && ase2->children->get (set1)))) | |
| 0 | 422 return true; |
| 111 | 423 |
| 424 /* As a special case we consider alias set of "void *" to be both subset | |
| 425 and superset of every alias set of a pointer. This extra symmetry does | |
| 426 not matter for alias_sets_conflict_p but it makes aliasing_component_refs_p | |
| 427 to return true on the following testcase: | |
| 428 | |
| 429 void *ptr; | |
| 430 char **ptr2=(char **)&ptr; | |
| 431 *ptr2 = ... | |
| 432 | |
| 433 Additionally if a set contains universal pointer, we consider every pointer | |
| 434 to be a subset of it, but we do not represent this explicitely - doing so | |
| 435 would require us to update transitive closure each time we introduce new | |
| 436 pointer type. This makes aliasing_component_refs_p to return true | |
| 437 on the following testcase: | |
| 438 | |
| 439 struct a {void *ptr;} | |
| 440 char **ptr = (char **)&a.ptr; | |
| 441 ptr = ... | |
| 442 | |
| 443 This makes void * truly universal pointer type. See pointer handling in | |
| 444 get_alias_set for more details. */ | |
| 445 if (ase2 && ase2->has_pointer) | |
| 446 { | |
| 447 alias_set_entry *ase1 = get_alias_set_entry (set1); | |
| 448 | |
| 449 if (ase1 && ase1->is_pointer) | |
| 450 { | |
| 451 alias_set_type voidptr_set = TYPE_ALIAS_SET (ptr_type_node); | |
| 452 /* If one is ptr_type_node and other is pointer, then we consider | |
| 453 them subset of each other. */ | |
| 454 if (set1 == voidptr_set || set2 == voidptr_set) | |
| 455 return true; | |
| 456 /* If SET2 contains universal pointer's alias set, then we consdier | |
| 457 every (non-universal) pointer. */ | |
| 458 if (ase2->children && set1 != voidptr_set | |
| 459 && ase2->children->get (voidptr_set)) | |
| 460 return true; | |
| 461 } | |
| 462 } | |
| 0 | 463 return false; |
| 464 } | |
| 465 | |
| 466 /* Return 1 if the two specified alias sets may conflict. */ | |
| 467 | |
| 468 int | |
| 469 alias_sets_conflict_p (alias_set_type set1, alias_set_type set2) | |
| 470 { | |
| 111 | 471 alias_set_entry *ase1; |
| 472 alias_set_entry *ase2; | |
| 0 | 473 |
| 474 /* The easy case. */ | |
| 475 if (alias_sets_must_conflict_p (set1, set2)) | |
| 476 return 1; | |
| 477 | |
| 478 /* See if the first alias set is a subset of the second. */ | |
| 111 | 479 ase1 = get_alias_set_entry (set1); |
| 480 if (ase1 != 0 | |
| 481 && ase1->children && ase1->children->get (set2)) | |
| 482 { | |
| 483 ++alias_stats.num_dag; | |
| 484 return 1; | |
| 485 } | |
| 0 | 486 |
| 487 /* Now do the same, but with the alias sets reversed. */ | |
| 111 | 488 ase2 = get_alias_set_entry (set2); |
| 489 if (ase2 != 0 | |
| 490 && ase2->children && ase2->children->get (set1)) | |
| 491 { | |
| 492 ++alias_stats.num_dag; | |
| 493 return 1; | |
| 494 } | |
| 495 | |
| 496 /* We want void * to be compatible with any other pointer without | |
| 497 really dropping it to alias set 0. Doing so would make it | |
| 498 compatible with all non-pointer types too. | |
| 499 | |
| 500 This is not strictly necessary by the C/C++ language | |
| 501 standards, but avoids common type punning mistakes. In | |
| 502 addition to that, we need the existence of such universal | |
| 503 pointer to implement Fortran's C_PTR type (which is defined as | |
| 504 type compatible with all C pointers). */ | |
| 505 if (ase1 && ase2 && ase1->has_pointer && ase2->has_pointer) | |
| 506 { | |
| 507 alias_set_type voidptr_set = TYPE_ALIAS_SET (ptr_type_node); | |
| 508 | |
| 509 /* If one of the sets corresponds to universal pointer, | |
| 510 we consider it to conflict with anything that is | |
| 511 or contains pointer. */ | |
| 512 if (set1 == voidptr_set || set2 == voidptr_set) | |
| 513 { | |
| 514 ++alias_stats.num_universal; | |
| 515 return true; | |
| 516 } | |
| 517 /* If one of sets is (non-universal) pointer and the other | |
| 518 contains universal pointer, we also get conflict. */ | |
| 519 if (ase1->is_pointer && set2 != voidptr_set | |
| 520 && ase2->children && ase2->children->get (voidptr_set)) | |
| 521 { | |
| 522 ++alias_stats.num_universal; | |
| 523 return true; | |
| 524 } | |
| 525 if (ase2->is_pointer && set1 != voidptr_set | |
| 526 && ase1->children && ase1->children->get (voidptr_set)) | |
| 527 { | |
| 528 ++alias_stats.num_universal; | |
| 529 return true; | |
| 530 } | |
| 531 } | |
| 532 | |
| 533 ++alias_stats.num_disambiguated; | |
| 0 | 534 |
| 535 /* The two alias sets are distinct and neither one is the | |
| 536 child of the other. Therefore, they cannot conflict. */ | |
| 537 return 0; | |
| 538 } | |
| 539 | |
| 540 /* Return 1 if the two specified alias sets will always conflict. */ | |
| 541 | |
| 542 int | |
| 543 alias_sets_must_conflict_p (alias_set_type set1, alias_set_type set2) | |
| 544 { | |
| 111 | 545 /* Disable TBAA oracle with !flag_strict_aliasing. */ |
| 546 if (!flag_strict_aliasing) | |
| 0 | 547 return 1; |
| 111 | 548 if (set1 == 0 || set2 == 0) |
| 549 { | |
| 550 ++alias_stats.num_alias_zero; | |
| 551 return 1; | |
| 552 } | |
| 553 if (set1 == set2) | |
| 554 { | |
| 555 ++alias_stats.num_same_alias_set; | |
| 556 return 1; | |
| 557 } | |
| 0 | 558 |
| 559 return 0; | |
| 560 } | |
| 561 | |
| 562 /* Return 1 if any MEM object of type T1 will always conflict (using the | |
| 563 dependency routines in this file) with any MEM object of type T2. | |
| 564 This is used when allocating temporary storage. If T1 and/or T2 are | |
| 565 NULL_TREE, it means we know nothing about the storage. */ | |
| 566 | |
| 567 int | |
| 568 objects_must_conflict_p (tree t1, tree t2) | |
| 569 { | |
| 570 alias_set_type set1, set2; | |
| 571 | |
| 572 /* If neither has a type specified, we don't know if they'll conflict | |
| 573 because we may be using them to store objects of various types, for | |
| 574 example the argument and local variables areas of inlined functions. */ | |
| 575 if (t1 == 0 && t2 == 0) | |
| 576 return 0; | |
| 577 | |
| 578 /* If they are the same type, they must conflict. */ | |
| 111 | 579 if (t1 == t2) |
| 580 { | |
| 581 ++alias_stats.num_same_objects; | |
| 582 return 1; | |
| 583 } | |
| 584 /* Likewise if both are volatile. */ | |
| 585 if (t1 != 0 && TYPE_VOLATILE (t1) && t2 != 0 && TYPE_VOLATILE (t2)) | |
| 586 { | |
| 587 ++alias_stats.num_volatile; | |
| 588 return 1; | |
| 589 } | |
| 0 | 590 |
| 591 set1 = t1 ? get_alias_set (t1) : 0; | |
| 592 set2 = t2 ? get_alias_set (t2) : 0; | |
| 593 | |
| 594 /* We can't use alias_sets_conflict_p because we must make sure | |
| 595 that every subtype of t1 will conflict with every subtype of | |
| 596 t2 for which a pair of subobjects of these respective subtypes | |
| 597 overlaps on the stack. */ | |
| 598 return alias_sets_must_conflict_p (set1, set2); | |
| 599 } | |
| 600 | |
| 111 | 601 /* Return the outermost parent of component present in the chain of |
| 602 component references handled by get_inner_reference in T with the | |
| 603 following property: | |
| 604 - the component is non-addressable, or | |
| 605 - the parent has alias set zero, | |
| 606 or NULL_TREE if no such parent exists. In the former cases, the alias | |
| 607 set of this parent is the alias set that must be used for T itself. */ | |
| 608 | |
| 609 tree | |
| 610 component_uses_parent_alias_set_from (const_tree t) | |
| 0 | 611 { |
| 111 | 612 const_tree found = NULL_TREE; |
| 613 | |
| 614 if (AGGREGATE_TYPE_P (TREE_TYPE (t)) | |
| 615 && TYPE_TYPELESS_STORAGE (TREE_TYPE (t))) | |
| 616 return const_cast <tree> (t); | |
| 617 | |
| 618 while (handled_component_p (t)) | |
| 0 | 619 { |
| 620 switch (TREE_CODE (t)) | |
| 621 { | |
| 622 case COMPONENT_REF: | |
| 623 if (DECL_NONADDRESSABLE_P (TREE_OPERAND (t, 1))) | |
| 111 | 624 found = t; |
| 625 /* Permit type-punning when accessing a union, provided the access | |
| 626 is directly through the union. For example, this code does not | |
| 627 permit taking the address of a union member and then storing | |
| 628 through it. Even the type-punning allowed here is a GCC | |
| 629 extension, albeit a common and useful one; the C standard says | |
| 630 that such accesses have implementation-defined behavior. */ | |
| 631 else if (TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == UNION_TYPE) | |
| 632 found = t; | |
| 0 | 633 break; |
| 634 | |
| 635 case ARRAY_REF: | |
| 636 case ARRAY_RANGE_REF: | |
| 637 if (TYPE_NONALIASED_COMPONENT (TREE_TYPE (TREE_OPERAND (t, 0)))) | |
| 111 | 638 found = t; |
| 0 | 639 break; |
| 640 | |
| 641 case REALPART_EXPR: | |
| 642 case IMAGPART_EXPR: | |
| 643 break; | |
| 644 | |
| 111 | 645 case BIT_FIELD_REF: |
| 646 case VIEW_CONVERT_EXPR: | |
| 0 | 647 /* Bitfields and casts are never addressable. */ |
| 111 | 648 found = t; |
| 649 break; | |
| 650 | |
| 651 default: | |
| 652 gcc_unreachable (); | |
| 0 | 653 } |
| 654 | |
| 111 | 655 if (get_alias_set (TREE_TYPE (TREE_OPERAND (t, 0))) == 0) |
| 656 found = t; | |
| 657 | |
| 0 | 658 t = TREE_OPERAND (t, 0); |
| 659 } | |
| 111 | 660 |
| 661 if (found) | |
| 662 return TREE_OPERAND (found, 0); | |
| 663 | |
| 664 return NULL_TREE; | |
| 665 } | |
| 666 | |
| 667 | |
| 668 /* Return whether the pointer-type T effective for aliasing may | |
| 669 access everything and thus the reference has to be assigned | |
| 670 alias-set zero. */ | |
| 671 | |
| 672 static bool | |
| 673 ref_all_alias_ptr_type_p (const_tree t) | |
| 674 { | |
| 675 return (TREE_CODE (TREE_TYPE (t)) == VOID_TYPE | |
| 676 || TYPE_REF_CAN_ALIAS_ALL (t)); | |
| 0 | 677 } |
| 678 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
679 /* Return the alias set for the memory pointed to by T, which may be |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
680 either a type or an expression. Return -1 if there is nothing |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
681 special about dereferencing T. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
682 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
683 static alias_set_type |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
684 get_deref_alias_set_1 (tree t) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
685 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
686 /* All we care about is the type. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
687 if (! TYPE_P (t)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
688 t = TREE_TYPE (t); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
689 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
690 /* If we have an INDIRECT_REF via a void pointer, we don't |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
691 know anything about what that might alias. Likewise if the |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
692 pointer is marked that way. */ |
| 111 | 693 if (ref_all_alias_ptr_type_p (t)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
694 return 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
695 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
696 return -1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
697 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
698 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
699 /* Return the alias set for the memory pointed to by T, which may be |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
700 either a type or an expression. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
701 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
702 alias_set_type |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
703 get_deref_alias_set (tree t) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
704 { |
| 111 | 705 /* If we're not doing any alias analysis, just assume everything |
| 706 aliases everything else. */ | |
| 707 if (!flag_strict_aliasing) | |
| 708 return 0; | |
| 709 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
710 alias_set_type set = get_deref_alias_set_1 (t); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
711 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
712 /* Fall back to the alias-set of the pointed-to type. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
713 if (set == -1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
714 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
715 if (! TYPE_P (t)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
716 t = TREE_TYPE (t); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
717 set = get_alias_set (TREE_TYPE (t)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
718 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
719 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
720 return set; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
721 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
722 |
| 111 | 723 /* Return the pointer-type relevant for TBAA purposes from the |
| 724 memory reference tree *T or NULL_TREE in which case *T is | |
| 725 adjusted to point to the outermost component reference that | |
| 726 can be used for assigning an alias set. */ | |
| 727 | |
| 728 static tree | |
| 729 reference_alias_ptr_type_1 (tree *t) | |
| 730 { | |
| 731 tree inner; | |
| 732 | |
| 733 /* Get the base object of the reference. */ | |
| 734 inner = *t; | |
| 735 while (handled_component_p (inner)) | |
| 736 { | |
| 737 /* If there is a VIEW_CONVERT_EXPR in the chain we cannot use | |
| 738 the type of any component references that wrap it to | |
| 739 determine the alias-set. */ | |
| 740 if (TREE_CODE (inner) == VIEW_CONVERT_EXPR) | |
| 741 *t = TREE_OPERAND (inner, 0); | |
| 742 inner = TREE_OPERAND (inner, 0); | |
| 743 } | |
| 744 | |
| 745 /* Handle pointer dereferences here, they can override the | |
| 746 alias-set. */ | |
| 747 if (INDIRECT_REF_P (inner) | |
| 748 && ref_all_alias_ptr_type_p (TREE_TYPE (TREE_OPERAND (inner, 0)))) | |
| 749 return TREE_TYPE (TREE_OPERAND (inner, 0)); | |
| 750 else if (TREE_CODE (inner) == TARGET_MEM_REF) | |
| 751 return TREE_TYPE (TMR_OFFSET (inner)); | |
| 752 else if (TREE_CODE (inner) == MEM_REF | |
| 753 && ref_all_alias_ptr_type_p (TREE_TYPE (TREE_OPERAND (inner, 1)))) | |
| 754 return TREE_TYPE (TREE_OPERAND (inner, 1)); | |
| 755 | |
| 756 /* If the innermost reference is a MEM_REF that has a | |
| 757 conversion embedded treat it like a VIEW_CONVERT_EXPR above, | |
| 758 using the memory access type for determining the alias-set. */ | |
| 759 if (TREE_CODE (inner) == MEM_REF | |
| 760 && (TYPE_MAIN_VARIANT (TREE_TYPE (inner)) | |
| 761 != TYPE_MAIN_VARIANT | |
| 762 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (inner, 1)))))) | |
| 763 return TREE_TYPE (TREE_OPERAND (inner, 1)); | |
| 764 | |
| 765 /* Otherwise, pick up the outermost object that we could have | |
| 766 a pointer to. */ | |
| 767 tree tem = component_uses_parent_alias_set_from (*t); | |
| 768 if (tem) | |
| 769 *t = tem; | |
| 770 | |
| 771 return NULL_TREE; | |
| 772 } | |
| 773 | |
| 774 /* Return the pointer-type relevant for TBAA purposes from the | |
| 775 gimple memory reference tree T. This is the type to be used for | |
| 776 the offset operand of MEM_REF or TARGET_MEM_REF replacements of T | |
| 777 and guarantees that get_alias_set will return the same alias | |
| 778 set for T and the replacement. */ | |
| 779 | |
| 780 tree | |
| 781 reference_alias_ptr_type (tree t) | |
| 782 { | |
| 783 /* If the frontend assigns this alias-set zero, preserve that. */ | |
| 784 if (lang_hooks.get_alias_set (t) == 0) | |
| 785 return ptr_type_node; | |
| 786 | |
| 787 tree ptype = reference_alias_ptr_type_1 (&t); | |
| 788 /* If there is a given pointer type for aliasing purposes, return it. */ | |
| 789 if (ptype != NULL_TREE) | |
| 790 return ptype; | |
| 791 | |
| 792 /* Otherwise build one from the outermost component reference we | |
| 793 may use. */ | |
| 794 if (TREE_CODE (t) == MEM_REF | |
| 795 || TREE_CODE (t) == TARGET_MEM_REF) | |
| 796 return TREE_TYPE (TREE_OPERAND (t, 1)); | |
| 797 else | |
| 798 return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (t))); | |
| 799 } | |
| 800 | |
| 801 /* Return whether the pointer-types T1 and T2 used to determine | |
| 802 two alias sets of two references will yield the same answer | |
| 803 from get_deref_alias_set. */ | |
| 804 | |
| 805 bool | |
| 806 alias_ptr_types_compatible_p (tree t1, tree t2) | |
| 807 { | |
| 808 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) | |
| 809 return true; | |
| 810 | |
| 811 if (ref_all_alias_ptr_type_p (t1) | |
| 812 || ref_all_alias_ptr_type_p (t2)) | |
| 813 return false; | |
| 814 | |
| 815 return (TYPE_MAIN_VARIANT (TREE_TYPE (t1)) | |
| 816 == TYPE_MAIN_VARIANT (TREE_TYPE (t2))); | |
| 817 } | |
| 818 | |
| 819 /* Create emptry alias set entry. */ | |
| 820 | |
| 821 alias_set_entry * | |
| 822 init_alias_set_entry (alias_set_type set) | |
| 823 { | |
| 824 alias_set_entry *ase = ggc_alloc<alias_set_entry> (); | |
| 825 ase->alias_set = set; | |
| 826 ase->children = NULL; | |
| 827 ase->has_zero_child = false; | |
| 828 ase->is_pointer = false; | |
| 829 ase->has_pointer = false; | |
| 830 gcc_checking_assert (!get_alias_set_entry (set)); | |
| 831 (*alias_sets)[set] = ase; | |
| 832 return ase; | |
| 833 } | |
| 834 | |
| 0 | 835 /* Return the alias set for T, which may be either a type or an |
| 836 expression. Call language-specific routine for help, if needed. */ | |
| 837 | |
| 838 alias_set_type | |
| 839 get_alias_set (tree t) | |
| 840 { | |
| 841 alias_set_type set; | |
| 842 | |
| 111 | 843 /* We can not give up with -fno-strict-aliasing because we need to build |
| 844 proper type representation for possible functions which are build with | |
| 845 -fstrict-aliasing. */ | |
| 846 | |
| 847 /* return 0 if this or its type is an error. */ | |
| 848 if (t == error_mark_node | |
| 0 | 849 || (! TYPE_P (t) |
| 850 && (TREE_TYPE (t) == 0 || TREE_TYPE (t) == error_mark_node))) | |
| 851 return 0; | |
| 852 | |
| 853 /* We can be passed either an expression or a type. This and the | |
| 854 language-specific routine may make mutually-recursive calls to each other | |
| 855 to figure out what to do. At each juncture, we see if this is a tree | |
| 856 that the language may need to handle specially. First handle things that | |
| 857 aren't types. */ | |
| 858 if (! TYPE_P (t)) | |
| 859 { | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
860 /* Give the language a chance to do something with this tree |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
861 before we look at it. */ |
| 0 | 862 STRIP_NOPS (t); |
| 863 set = lang_hooks.get_alias_set (t); | |
| 864 if (set != -1) | |
| 865 return set; | |
| 866 | |
| 111 | 867 /* Get the alias pointer-type to use or the outermost object |
| 868 that we could have a pointer to. */ | |
| 869 tree ptype = reference_alias_ptr_type_1 (&t); | |
| 870 if (ptype != NULL) | |
| 871 return get_deref_alias_set (ptype); | |
| 0 | 872 |
| 873 /* If we've already determined the alias set for a decl, just return | |
| 874 it. This is necessary for C++ anonymous unions, whose component | |
| 875 variables don't look like union members (boo!). */ | |
| 111 | 876 if (VAR_P (t) |
| 0 | 877 && DECL_RTL_SET_P (t) && MEM_P (DECL_RTL (t))) |
| 878 return MEM_ALIAS_SET (DECL_RTL (t)); | |
| 879 | |
| 880 /* Now all we care about is the type. */ | |
| 881 t = TREE_TYPE (t); | |
| 882 } | |
| 883 | |
| 884 /* Variant qualifiers don't affect the alias set, so get the main | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
885 variant. */ |
| 0 | 886 t = TYPE_MAIN_VARIANT (t); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
887 |
| 111 | 888 if (AGGREGATE_TYPE_P (t) |
| 889 && TYPE_TYPELESS_STORAGE (t)) | |
| 890 return 0; | |
| 891 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
892 /* Always use the canonical type as well. If this is a type that |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
893 requires structural comparisons to identify compatible types |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
894 use alias set zero. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
895 if (TYPE_STRUCTURAL_EQUALITY_P (t)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
896 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
897 /* Allow the language to specify another alias set for this |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
898 type. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
899 set = lang_hooks.get_alias_set (t); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
900 if (set != -1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
901 return set; |
| 111 | 902 /* Handle structure type equality for pointer types, arrays and vectors. |
| 903 This is easy to do, because the code bellow ignore canonical types on | |
| 904 these anyway. This is important for LTO, where TYPE_CANONICAL for | |
| 905 pointers can not be meaningfuly computed by the frotnend. */ | |
| 906 if (canonical_type_used_p (t)) | |
| 907 { | |
| 908 /* In LTO we set canonical types for all types where it makes | |
| 909 sense to do so. Double check we did not miss some type. */ | |
| 910 gcc_checking_assert (!in_lto_p || !type_with_alias_set_p (t)); | |
| 911 return 0; | |
| 912 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
913 } |
| 111 | 914 else |
| 915 { | |
| 916 t = TYPE_CANONICAL (t); | |
| 917 gcc_checking_assert (!TYPE_STRUCTURAL_EQUALITY_P (t)); | |
| 918 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
919 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
920 /* If this is a type with a known alias set, return it. */ |
| 111 | 921 gcc_checking_assert (t == TYPE_MAIN_VARIANT (t)); |
| 0 | 922 if (TYPE_ALIAS_SET_KNOWN_P (t)) |
| 923 return TYPE_ALIAS_SET (t); | |
| 924 | |
| 925 /* We don't want to set TYPE_ALIAS_SET for incomplete types. */ | |
| 926 if (!COMPLETE_TYPE_P (t)) | |
| 927 { | |
| 928 /* For arrays with unknown size the conservative answer is the | |
| 929 alias set of the element type. */ | |
| 930 if (TREE_CODE (t) == ARRAY_TYPE) | |
| 931 return get_alias_set (TREE_TYPE (t)); | |
| 932 | |
| 933 /* But return zero as a conservative answer for incomplete types. */ | |
| 934 return 0; | |
| 935 } | |
| 936 | |
| 937 /* See if the language has special handling for this type. */ | |
| 938 set = lang_hooks.get_alias_set (t); | |
| 939 if (set != -1) | |
| 940 return set; | |
| 941 | |
| 942 /* There are no objects of FUNCTION_TYPE, so there's no point in | |
| 943 using up an alias set for them. (There are, of course, pointers | |
| 944 and references to functions, but that's different.) */ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
945 else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE) |
| 0 | 946 set = 0; |
| 947 | |
| 948 /* Unless the language specifies otherwise, let vector types alias | |
| 949 their components. This avoids some nasty type punning issues in | |
| 950 normal usage. And indeed lets vectors be treated more like an | |
| 951 array slice. */ | |
| 952 else if (TREE_CODE (t) == VECTOR_TYPE) | |
| 953 set = get_alias_set (TREE_TYPE (t)); | |
| 954 | |
| 955 /* Unless the language specifies otherwise, treat array types the | |
| 956 same as their components. This avoids the asymmetry we get | |
| 957 through recording the components. Consider accessing a | |
| 958 character(kind=1) through a reference to a character(kind=1)[1:1]. | |
| 959 Or consider if we want to assign integer(kind=4)[0:D.1387] and | |
| 960 integer(kind=4)[4] the same alias set or not. | |
| 961 Just be pragmatic here and make sure the array and its element | |
| 962 type get the same alias set assigned. */ | |
| 111 | 963 else if (TREE_CODE (t) == ARRAY_TYPE |
| 964 && (!TYPE_NONALIASED_COMPONENT (t) | |
| 965 || TYPE_STRUCTURAL_EQUALITY_P (t))) | |
| 0 | 966 set = get_alias_set (TREE_TYPE (t)); |
| 967 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
968 /* From the former common C and C++ langhook implementation: |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
969 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
970 Unfortunately, there is no canonical form of a pointer type. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
971 In particular, if we have `typedef int I', then `int *', and |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
972 `I *' are different types. So, we have to pick a canonical |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
973 representative. We do this below. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
974 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
975 Technically, this approach is actually more conservative that |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
976 it needs to be. In particular, `const int *' and `int *' |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
977 should be in different alias sets, according to the C and C++ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
978 standard, since their types are not the same, and so, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
979 technically, an `int **' and `const int **' cannot point at |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
980 the same thing. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
981 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
982 But, the standard is wrong. In particular, this code is |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
983 legal C++: |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
984 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
985 int *ip; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
986 int **ipp = &ip; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
987 const int* const* cipp = ipp; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
988 And, it doesn't make sense for that to be legal unless you |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
989 can dereference IPP and CIPP. So, we ignore cv-qualifiers on |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
990 the pointed-to types. This issue has been reported to the |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
991 C++ committee. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
992 |
| 111 | 993 For this reason go to canonical type of the unqalified pointer type. |
| 994 Until GCC 6 this code set all pointers sets to have alias set of | |
| 995 ptr_type_node but that is a bad idea, because it prevents disabiguations | |
| 996 in between pointers. For Firefox this accounts about 20% of all | |
| 997 disambiguations in the program. */ | |
| 998 else if (POINTER_TYPE_P (t) && t != ptr_type_node) | |
| 999 { | |
| 1000 tree p; | |
| 1001 auto_vec <bool, 8> reference; | |
| 1002 | |
| 1003 /* Unnest all pointers and references. | |
| 1004 We also want to make pointer to array/vector equivalent to pointer to | |
| 1005 its element (see the reasoning above). Skip all those types, too. */ | |
| 1006 for (p = t; POINTER_TYPE_P (p) | |
| 1007 || (TREE_CODE (p) == ARRAY_TYPE | |
| 1008 && (!TYPE_NONALIASED_COMPONENT (p) | |
| 1009 || !COMPLETE_TYPE_P (p) | |
| 1010 || TYPE_STRUCTURAL_EQUALITY_P (p))) | |
| 1011 || TREE_CODE (p) == VECTOR_TYPE; | |
| 1012 p = TREE_TYPE (p)) | |
| 1013 { | |
| 1014 /* Ada supports recusive pointers. Instead of doing recrusion check | |
| 1015 just give up once the preallocated space of 8 elements is up. | |
| 1016 In this case just punt to void * alias set. */ | |
| 1017 if (reference.length () == 8) | |
| 1018 { | |
| 1019 p = ptr_type_node; | |
| 1020 break; | |
| 1021 } | |
| 1022 if (TREE_CODE (p) == REFERENCE_TYPE) | |
| 1023 /* In LTO we want languages that use references to be compatible | |
| 1024 with languages that use pointers. */ | |
| 1025 reference.safe_push (true && !in_lto_p); | |
| 1026 if (TREE_CODE (p) == POINTER_TYPE) | |
| 1027 reference.safe_push (false); | |
| 1028 } | |
| 1029 p = TYPE_MAIN_VARIANT (p); | |
| 1030 | |
| 1031 /* Make void * compatible with char * and also void **. | |
| 1032 Programs are commonly violating TBAA by this. | |
| 1033 | |
| 1034 We also make void * to conflict with every pointer | |
| 1035 (see record_component_aliases) and thus it is safe it to use it for | |
| 1036 pointers to types with TYPE_STRUCTURAL_EQUALITY_P. */ | |
| 1037 if (TREE_CODE (p) == VOID_TYPE || TYPE_STRUCTURAL_EQUALITY_P (p)) | |
| 1038 set = get_alias_set (ptr_type_node); | |
| 1039 else | |
| 1040 { | |
| 1041 /* Rebuild pointer type starting from canonical types using | |
| 1042 unqualified pointers and references only. This way all such | |
| 1043 pointers will have the same alias set and will conflict with | |
| 1044 each other. | |
| 1045 | |
| 1046 Most of time we already have pointers or references of a given type. | |
| 1047 If not we build new one just to be sure that if someone later | |
| 1048 (probably only middle-end can, as we should assign all alias | |
| 1049 classes only after finishing translation unit) builds the pointer | |
| 1050 type, the canonical type will match. */ | |
| 1051 p = TYPE_CANONICAL (p); | |
| 1052 while (!reference.is_empty ()) | |
| 1053 { | |
| 1054 if (reference.pop ()) | |
| 1055 p = build_reference_type (p); | |
| 1056 else | |
| 1057 p = build_pointer_type (p); | |
| 1058 gcc_checking_assert (p == TYPE_MAIN_VARIANT (p)); | |
| 1059 /* build_pointer_type should always return the canonical type. | |
| 1060 For LTO TYPE_CANOINCAL may be NULL, because we do not compute | |
| 1061 them. Be sure that frontends do not glob canonical types of | |
| 1062 pointers in unexpected way and that p == TYPE_CANONICAL (p) | |
| 1063 in all other cases. */ | |
| 1064 gcc_checking_assert (!TYPE_CANONICAL (p) | |
| 1065 || p == TYPE_CANONICAL (p)); | |
| 1066 } | |
| 1067 | |
| 1068 /* Assign the alias set to both p and t. | |
| 1069 We can not call get_alias_set (p) here as that would trigger | |
| 1070 infinite recursion when p == t. In other cases it would just | |
| 1071 trigger unnecesary legwork of rebuilding the pointer again. */ | |
| 1072 gcc_checking_assert (p == TYPE_MAIN_VARIANT (p)); | |
| 1073 if (TYPE_ALIAS_SET_KNOWN_P (p)) | |
| 1074 set = TYPE_ALIAS_SET (p); | |
| 1075 else | |
| 1076 { | |
| 1077 set = new_alias_set (); | |
| 1078 TYPE_ALIAS_SET (p) = set; | |
| 1079 } | |
| 1080 } | |
| 1081 } | |
| 1082 /* Alias set of ptr_type_node is special and serve as universal pointer which | |
| 1083 is TBAA compatible with every other pointer type. Be sure we have the | |
| 1084 alias set built even for LTO which otherwise keeps all TYPE_CANONICAL | |
| 1085 of pointer types NULL. */ | |
| 1086 else if (t == ptr_type_node) | |
| 1087 set = new_alias_set (); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1088 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1089 /* Otherwise make a new alias set for this type. */ |
| 0 | 1090 else |
| 111 | 1091 { |
| 1092 /* Each canonical type gets its own alias set, so canonical types | |
| 1093 shouldn't form a tree. It doesn't really matter for types | |
| 1094 we handle specially above, so only check it where it possibly | |
| 1095 would result in a bogus alias set. */ | |
| 1096 gcc_checking_assert (TYPE_CANONICAL (t) == t); | |
| 1097 | |
| 1098 set = new_alias_set (); | |
| 1099 } | |
| 0 | 1100 |
| 1101 TYPE_ALIAS_SET (t) = set; | |
| 1102 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1103 /* If this is an aggregate type or a complex type, we must record any |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1104 component aliasing information. */ |
| 0 | 1105 if (AGGREGATE_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE) |
| 1106 record_component_aliases (t); | |
| 1107 | |
| 111 | 1108 /* We treat pointer types specially in alias_set_subset_of. */ |
| 1109 if (POINTER_TYPE_P (t) && set) | |
| 1110 { | |
| 1111 alias_set_entry *ase = get_alias_set_entry (set); | |
| 1112 if (!ase) | |
| 1113 ase = init_alias_set_entry (set); | |
| 1114 ase->is_pointer = true; | |
| 1115 ase->has_pointer = true; | |
| 1116 } | |
| 1117 | |
| 0 | 1118 return set; |
| 1119 } | |
| 1120 | |
| 1121 /* Return a brand-new alias set. */ | |
| 1122 | |
| 1123 alias_set_type | |
| 1124 new_alias_set (void) | |
| 1125 { | |
| 111 | 1126 if (alias_sets == 0) |
| 1127 vec_safe_push (alias_sets, (alias_set_entry *) NULL); | |
| 1128 vec_safe_push (alias_sets, (alias_set_entry *) NULL); | |
| 1129 return alias_sets->length () - 1; | |
| 0 | 1130 } |
| 1131 | |
| 1132 /* Indicate that things in SUBSET can alias things in SUPERSET, but that | |
| 1133 not everything that aliases SUPERSET also aliases SUBSET. For example, | |
| 1134 in C, a store to an `int' can alias a load of a structure containing an | |
| 1135 `int', and vice versa. But it can't alias a load of a 'double' member | |
| 1136 of the same structure. Here, the structure would be the SUPERSET and | |
| 1137 `int' the SUBSET. This relationship is also described in the comment at | |
| 1138 the beginning of this file. | |
| 1139 | |
| 1140 This function should be called only once per SUPERSET/SUBSET pair. | |
| 1141 | |
| 1142 It is illegal for SUPERSET to be zero; everything is implicitly a | |
| 1143 subset of alias set zero. */ | |
| 1144 | |
| 1145 void | |
| 1146 record_alias_subset (alias_set_type superset, alias_set_type subset) | |
| 1147 { | |
| 111 | 1148 alias_set_entry *superset_entry; |
| 1149 alias_set_entry *subset_entry; | |
| 0 | 1150 |
| 1151 /* It is possible in complex type situations for both sets to be the same, | |
| 1152 in which case we can ignore this operation. */ | |
| 1153 if (superset == subset) | |
| 1154 return; | |
| 1155 | |
| 1156 gcc_assert (superset); | |
| 1157 | |
| 1158 superset_entry = get_alias_set_entry (superset); | |
| 1159 if (superset_entry == 0) | |
| 1160 { | |
| 1161 /* Create an entry for the SUPERSET, so that we have a place to | |
| 1162 attach the SUBSET. */ | |
| 111 | 1163 superset_entry = init_alias_set_entry (superset); |
| 0 | 1164 } |
| 1165 | |
| 1166 if (subset == 0) | |
| 1167 superset_entry->has_zero_child = 1; | |
| 1168 else | |
| 1169 { | |
| 1170 subset_entry = get_alias_set_entry (subset); | |
| 111 | 1171 if (!superset_entry->children) |
| 1172 superset_entry->children | |
| 1173 = hash_map<alias_set_hash, int>::create_ggc (64); | |
| 0 | 1174 /* If there is an entry for the subset, enter all of its children |
| 1175 (if they are not already present) as children of the SUPERSET. */ | |
| 1176 if (subset_entry) | |
| 1177 { | |
| 1178 if (subset_entry->has_zero_child) | |
| 111 | 1179 superset_entry->has_zero_child = true; |
| 1180 if (subset_entry->has_pointer) | |
| 1181 superset_entry->has_pointer = true; | |
| 1182 | |
| 1183 if (subset_entry->children) | |
| 1184 { | |
| 1185 hash_map<alias_set_hash, int>::iterator iter | |
| 1186 = subset_entry->children->begin (); | |
| 1187 for (; iter != subset_entry->children->end (); ++iter) | |
| 1188 superset_entry->children->put ((*iter).first, (*iter).second); | |
| 1189 } | |
| 0 | 1190 } |
| 1191 | |
| 1192 /* Enter the SUBSET itself as a child of the SUPERSET. */ | |
| 111 | 1193 superset_entry->children->put (subset, 0); |
| 0 | 1194 } |
| 1195 } | |
| 1196 | |
| 1197 /* Record that component types of TYPE, if any, are part of that type for | |
| 1198 aliasing purposes. For record types, we only record component types | |
| 1199 for fields that are not marked non-addressable. For array types, we | |
| 1200 only record the component type if it is not marked non-aliased. */ | |
| 1201 | |
| 1202 void | |
| 1203 record_component_aliases (tree type) | |
| 1204 { | |
| 1205 alias_set_type superset = get_alias_set (type); | |
| 1206 tree field; | |
| 1207 | |
| 1208 if (superset == 0) | |
| 1209 return; | |
| 1210 | |
| 1211 switch (TREE_CODE (type)) | |
| 1212 { | |
| 1213 case RECORD_TYPE: | |
| 1214 case UNION_TYPE: | |
| 1215 case QUAL_UNION_TYPE: | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1216 for (field = TYPE_FIELDS (type); field != 0; field = DECL_CHAIN (field)) |
| 0 | 1217 if (TREE_CODE (field) == FIELD_DECL && !DECL_NONADDRESSABLE_P (field)) |
| 111 | 1218 { |
| 1219 /* LTO type merging does not make any difference between | |
| 1220 component pointer types. We may have | |
| 1221 | |
| 1222 struct foo {int *a;}; | |
| 1223 | |
| 1224 as TYPE_CANONICAL of | |
| 1225 | |
| 1226 struct bar {float *a;}; | |
| 1227 | |
| 1228 Because accesses to int * and float * do not alias, we would get | |
| 1229 false negative when accessing the same memory location by | |
| 1230 float ** and bar *. We thus record the canonical type as: | |
| 1231 | |
| 1232 struct {void *a;}; | |
| 1233 | |
| 1234 void * is special cased and works as a universal pointer type. | |
| 1235 Accesses to it conflicts with accesses to any other pointer | |
| 1236 type. */ | |
| 1237 tree t = TREE_TYPE (field); | |
| 1238 if (in_lto_p) | |
| 1239 { | |
| 1240 /* VECTOR_TYPE and ARRAY_TYPE share the alias set with their | |
| 1241 element type and that type has to be normalized to void *, | |
| 1242 too, in the case it is a pointer. */ | |
| 1243 while (!canonical_type_used_p (t) && !POINTER_TYPE_P (t)) | |
| 1244 { | |
| 1245 gcc_checking_assert (TYPE_STRUCTURAL_EQUALITY_P (t)); | |
| 1246 t = TREE_TYPE (t); | |
| 1247 } | |
| 1248 if (POINTER_TYPE_P (t)) | |
| 1249 t = ptr_type_node; | |
| 1250 else if (flag_checking) | |
| 1251 gcc_checking_assert (get_alias_set (t) | |
| 1252 == get_alias_set (TREE_TYPE (field))); | |
| 1253 } | |
| 1254 | |
| 1255 record_alias_subset (superset, get_alias_set (t)); | |
| 1256 } | |
| 0 | 1257 break; |
| 1258 | |
| 1259 case COMPLEX_TYPE: | |
| 1260 record_alias_subset (superset, get_alias_set (TREE_TYPE (type))); | |
| 1261 break; | |
| 1262 | |
| 1263 /* VECTOR_TYPE and ARRAY_TYPE share the alias set with their | |
| 1264 element type. */ | |
| 1265 | |
| 1266 default: | |
| 1267 break; | |
| 1268 } | |
| 1269 } | |
| 1270 | |
| 1271 /* Allocate an alias set for use in storing and reading from the varargs | |
| 1272 spill area. */ | |
| 1273 | |
| 1274 static GTY(()) alias_set_type varargs_set = -1; | |
| 1275 | |
| 1276 alias_set_type | |
| 1277 get_varargs_alias_set (void) | |
| 1278 { | |
| 1279 #if 1 | |
| 1280 /* We now lower VA_ARG_EXPR, and there's currently no way to attach the | |
| 1281 varargs alias set to an INDIRECT_REF (FIXME!), so we can't | |
| 1282 consistently use the varargs alias set for loads from the varargs | |
| 1283 area. So don't use it anywhere. */ | |
| 1284 return 0; | |
| 1285 #else | |
| 1286 if (varargs_set == -1) | |
| 1287 varargs_set = new_alias_set (); | |
| 1288 | |
| 1289 return varargs_set; | |
| 1290 #endif | |
| 1291 } | |
| 1292 | |
| 1293 /* Likewise, but used for the fixed portions of the frame, e.g., register | |
| 1294 save areas. */ | |
| 1295 | |
| 1296 static GTY(()) alias_set_type frame_set = -1; | |
| 1297 | |
| 1298 alias_set_type | |
| 1299 get_frame_alias_set (void) | |
| 1300 { | |
| 1301 if (frame_set == -1) | |
| 1302 frame_set = new_alias_set (); | |
| 1303 | |
| 1304 return frame_set; | |
| 1305 } | |
| 1306 | |
| 111 | 1307 /* Create a new, unique base with id ID. */ |
| 1308 | |
| 1309 static rtx | |
| 1310 unique_base_value (HOST_WIDE_INT id) | |
| 1311 { | |
| 1312 return gen_rtx_ADDRESS (Pmode, id); | |
| 1313 } | |
| 1314 | |
| 1315 /* Return true if accesses based on any other base value cannot alias | |
| 1316 those based on X. */ | |
| 1317 | |
| 1318 static bool | |
| 1319 unique_base_value_p (rtx x) | |
| 1320 { | |
| 1321 return GET_CODE (x) == ADDRESS && GET_MODE (x) == Pmode; | |
| 1322 } | |
| 1323 | |
| 1324 /* Return true if X is known to be a base value. */ | |
| 1325 | |
| 1326 static bool | |
| 1327 known_base_value_p (rtx x) | |
| 1328 { | |
| 1329 switch (GET_CODE (x)) | |
| 1330 { | |
| 1331 case LABEL_REF: | |
| 1332 case SYMBOL_REF: | |
| 1333 return true; | |
| 1334 | |
| 1335 case ADDRESS: | |
| 1336 /* Arguments may or may not be bases; we don't know for sure. */ | |
| 1337 return GET_MODE (x) != VOIDmode; | |
| 1338 | |
| 1339 default: | |
| 1340 return false; | |
| 1341 } | |
| 1342 } | |
| 1343 | |
| 0 | 1344 /* Inside SRC, the source of a SET, find a base address. */ |
| 1345 | |
| 1346 static rtx | |
| 1347 find_base_value (rtx src) | |
| 1348 { | |
| 1349 unsigned int regno; | |
| 131 | 1350 scalar_int_mode int_mode; |
| 0 | 1351 |
| 1352 #if defined (FIND_BASE_TERM) | |
| 1353 /* Try machine-dependent ways to find the base term. */ | |
| 1354 src = FIND_BASE_TERM (src); | |
| 1355 #endif | |
| 1356 | |
| 1357 switch (GET_CODE (src)) | |
| 1358 { | |
| 1359 case SYMBOL_REF: | |
| 1360 case LABEL_REF: | |
| 1361 return src; | |
| 1362 | |
| 1363 case REG: | |
| 1364 regno = REGNO (src); | |
| 1365 /* At the start of a function, argument registers have known base | |
| 1366 values which may be lost later. Returning an ADDRESS | |
| 1367 expression here allows optimization based on argument values | |
| 1368 even when the argument registers are used for other purposes. */ | |
| 1369 if (regno < FIRST_PSEUDO_REGISTER && copying_arguments) | |
| 1370 return new_reg_base_value[regno]; | |
| 1371 | |
| 1372 /* If a pseudo has a known base value, return it. Do not do this | |
| 1373 for non-fixed hard regs since it can result in a circular | |
| 1374 dependency chain for registers which have values at function entry. | |
| 1375 | |
| 1376 The test above is not sufficient because the scheduler may move | |
| 1377 a copy out of an arg reg past the NOTE_INSN_FUNCTION_BEGIN. */ | |
| 1378 if ((regno >= FIRST_PSEUDO_REGISTER || fixed_regs[regno]) | |
| 111 | 1379 && regno < vec_safe_length (reg_base_value)) |
| 0 | 1380 { |
| 1381 /* If we're inside init_alias_analysis, use new_reg_base_value | |
| 1382 to reduce the number of relaxation iterations. */ | |
| 1383 if (new_reg_base_value && new_reg_base_value[regno] | |
| 1384 && DF_REG_DEF_COUNT (regno) == 1) | |
| 1385 return new_reg_base_value[regno]; | |
| 1386 | |
| 111 | 1387 if ((*reg_base_value)[regno]) |
| 1388 return (*reg_base_value)[regno]; | |
| 0 | 1389 } |
| 1390 | |
| 1391 return 0; | |
| 1392 | |
| 1393 case MEM: | |
| 1394 /* Check for an argument passed in memory. Only record in the | |
| 1395 copying-arguments block; it is too hard to track changes | |
| 1396 otherwise. */ | |
| 1397 if (copying_arguments | |
| 1398 && (XEXP (src, 0) == arg_pointer_rtx | |
| 1399 || (GET_CODE (XEXP (src, 0)) == PLUS | |
| 1400 && XEXP (XEXP (src, 0), 0) == arg_pointer_rtx))) | |
| 111 | 1401 return arg_base_value; |
| 0 | 1402 return 0; |
| 1403 | |
| 1404 case CONST: | |
| 1405 src = XEXP (src, 0); | |
| 1406 if (GET_CODE (src) != PLUS && GET_CODE (src) != MINUS) | |
| 1407 break; | |
| 1408 | |
| 111 | 1409 /* fall through */ |
| 0 | 1410 |
| 1411 case PLUS: | |
| 1412 case MINUS: | |
| 1413 { | |
| 1414 rtx temp, src_0 = XEXP (src, 0), src_1 = XEXP (src, 1); | |
| 1415 | |
| 1416 /* If either operand is a REG that is a known pointer, then it | |
| 1417 is the base. */ | |
| 1418 if (REG_P (src_0) && REG_POINTER (src_0)) | |
| 1419 return find_base_value (src_0); | |
| 1420 if (REG_P (src_1) && REG_POINTER (src_1)) | |
| 1421 return find_base_value (src_1); | |
| 1422 | |
| 1423 /* If either operand is a REG, then see if we already have | |
| 1424 a known value for it. */ | |
| 1425 if (REG_P (src_0)) | |
| 1426 { | |
| 1427 temp = find_base_value (src_0); | |
| 1428 if (temp != 0) | |
| 1429 src_0 = temp; | |
| 1430 } | |
| 1431 | |
| 1432 if (REG_P (src_1)) | |
| 1433 { | |
| 1434 temp = find_base_value (src_1); | |
| 1435 if (temp!= 0) | |
| 1436 src_1 = temp; | |
| 1437 } | |
| 1438 | |
| 1439 /* If either base is named object or a special address | |
| 1440 (like an argument or stack reference), then use it for the | |
| 1441 base term. */ | |
| 111 | 1442 if (src_0 != 0 && known_base_value_p (src_0)) |
| 0 | 1443 return src_0; |
| 1444 | |
| 111 | 1445 if (src_1 != 0 && known_base_value_p (src_1)) |
| 0 | 1446 return src_1; |
| 1447 | |
| 1448 /* Guess which operand is the base address: | |
| 1449 If either operand is a symbol, then it is the base. If | |
| 1450 either operand is a CONST_INT, then the other is the base. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1451 if (CONST_INT_P (src_1) || CONSTANT_P (src_0)) |
| 0 | 1452 return find_base_value (src_0); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1453 else if (CONST_INT_P (src_0) || CONSTANT_P (src_1)) |
| 0 | 1454 return find_base_value (src_1); |
| 1455 | |
| 1456 return 0; | |
| 1457 } | |
| 1458 | |
| 1459 case LO_SUM: | |
| 1460 /* The standard form is (lo_sum reg sym) so look only at the | |
| 1461 second operand. */ | |
| 1462 return find_base_value (XEXP (src, 1)); | |
| 1463 | |
| 1464 case AND: | |
| 1465 /* If the second operand is constant set the base | |
| 1466 address to the first operand. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1467 if (CONST_INT_P (XEXP (src, 1)) && INTVAL (XEXP (src, 1)) != 0) |
| 0 | 1468 return find_base_value (XEXP (src, 0)); |
| 1469 return 0; | |
| 1470 | |
| 1471 case TRUNCATE: | |
| 111 | 1472 /* As we do not know which address space the pointer is referring to, we can |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1473 handle this only if the target does not support different pointer or |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1474 address modes depending on the address space. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1475 if (!target_default_pointer_address_modes_p ()) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1476 break; |
| 131 | 1477 if (!is_a <scalar_int_mode> (GET_MODE (src), &int_mode) |
| 1478 || GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (Pmode)) | |
| 0 | 1479 break; |
| 1480 /* Fall through. */ | |
| 1481 case HIGH: | |
| 1482 case PRE_INC: | |
| 1483 case PRE_DEC: | |
| 1484 case POST_INC: | |
| 1485 case POST_DEC: | |
| 1486 case PRE_MODIFY: | |
| 1487 case POST_MODIFY: | |
| 1488 return find_base_value (XEXP (src, 0)); | |
| 1489 | |
| 1490 case ZERO_EXTEND: | |
| 1491 case SIGN_EXTEND: /* used for NT/Alpha pointers */ | |
| 111 | 1492 /* As we do not know which address space the pointer is referring to, we can |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1493 handle this only if the target does not support different pointer or |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1494 address modes depending on the address space. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1495 if (!target_default_pointer_address_modes_p ()) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1496 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1497 |
| 0 | 1498 { |
| 1499 rtx temp = find_base_value (XEXP (src, 0)); | |
| 1500 | |
| 1501 if (temp != 0 && CONSTANT_P (temp)) | |
| 1502 temp = convert_memory_address (Pmode, temp); | |
| 1503 | |
| 1504 return temp; | |
| 1505 } | |
| 1506 | |
| 1507 default: | |
| 1508 break; | |
| 1509 } | |
| 1510 | |
| 1511 return 0; | |
| 1512 } | |
| 1513 | |
| 111 | 1514 /* Called from init_alias_analysis indirectly through note_stores, |
| 1515 or directly if DEST is a register with a REG_NOALIAS note attached. | |
| 1516 SET is null in the latter case. */ | |
| 0 | 1517 |
| 1518 /* While scanning insns to find base values, reg_seen[N] is nonzero if | |
| 1519 register N has been set in this function. */ | |
| 111 | 1520 static sbitmap reg_seen; |
| 0 | 1521 |
| 1522 static void | |
| 1523 record_set (rtx dest, const_rtx set, void *data ATTRIBUTE_UNUSED) | |
| 1524 { | |
| 1525 unsigned regno; | |
| 1526 rtx src; | |
| 1527 int n; | |
| 1528 | |
| 1529 if (!REG_P (dest)) | |
| 1530 return; | |
| 1531 | |
| 1532 regno = REGNO (dest); | |
| 1533 | |
| 111 | 1534 gcc_checking_assert (regno < reg_base_value->length ()); |
| 1535 | |
| 1536 n = REG_NREGS (dest); | |
| 0 | 1537 if (n != 1) |
| 1538 { | |
| 1539 while (--n >= 0) | |
| 1540 { | |
| 111 | 1541 bitmap_set_bit (reg_seen, regno + n); |
| 0 | 1542 new_reg_base_value[regno + n] = 0; |
| 1543 } | |
| 1544 return; | |
| 1545 } | |
| 1546 | |
| 1547 if (set) | |
| 1548 { | |
| 1549 /* A CLOBBER wipes out any old value but does not prevent a previously | |
| 1550 unset register from acquiring a base address (i.e. reg_seen is not | |
| 1551 set). */ | |
| 1552 if (GET_CODE (set) == CLOBBER) | |
| 1553 { | |
| 1554 new_reg_base_value[regno] = 0; | |
| 1555 return; | |
| 1556 } | |
| 131 | 1557 /* A CLOBBER_HIGH only wipes out the old value if the mode of the old |
| 1558 value is greater than that of the clobber. */ | |
| 1559 else if (GET_CODE (set) == CLOBBER_HIGH) | |
| 1560 { | |
| 1561 if (new_reg_base_value[regno] != 0 | |
| 1562 && reg_is_clobbered_by_clobber_high ( | |
| 1563 regno, GET_MODE (new_reg_base_value[regno]), XEXP (set, 0))) | |
| 1564 new_reg_base_value[regno] = 0; | |
| 1565 return; | |
| 1566 } | |
| 1567 | |
| 0 | 1568 src = SET_SRC (set); |
| 1569 } | |
| 1570 else | |
| 1571 { | |
| 111 | 1572 /* There's a REG_NOALIAS note against DEST. */ |
| 1573 if (bitmap_bit_p (reg_seen, regno)) | |
| 0 | 1574 { |
| 1575 new_reg_base_value[regno] = 0; | |
| 1576 return; | |
| 1577 } | |
| 111 | 1578 bitmap_set_bit (reg_seen, regno); |
| 1579 new_reg_base_value[regno] = unique_base_value (unique_id++); | |
| 0 | 1580 return; |
| 1581 } | |
| 1582 | |
| 1583 /* If this is not the first set of REGNO, see whether the new value | |
| 1584 is related to the old one. There are two cases of interest: | |
| 1585 | |
| 1586 (1) The register might be assigned an entirely new value | |
| 1587 that has the same base term as the original set. | |
| 1588 | |
| 1589 (2) The set might be a simple self-modification that | |
| 1590 cannot change REGNO's base value. | |
| 1591 | |
| 1592 If neither case holds, reject the original base value as invalid. | |
| 1593 Note that the following situation is not detected: | |
| 1594 | |
| 1595 extern int x, y; int *p = &x; p += (&y-&x); | |
| 1596 | |
| 1597 ANSI C does not allow computing the difference of addresses | |
| 1598 of distinct top level objects. */ | |
| 1599 if (new_reg_base_value[regno] != 0 | |
| 1600 && find_base_value (src) != new_reg_base_value[regno]) | |
| 1601 switch (GET_CODE (src)) | |
| 1602 { | |
| 1603 case LO_SUM: | |
| 1604 case MINUS: | |
| 1605 if (XEXP (src, 0) != dest && XEXP (src, 1) != dest) | |
| 1606 new_reg_base_value[regno] = 0; | |
| 1607 break; | |
| 1608 case PLUS: | |
| 1609 /* If the value we add in the PLUS is also a valid base value, | |
| 1610 this might be the actual base value, and the original value | |
| 1611 an index. */ | |
| 1612 { | |
| 1613 rtx other = NULL_RTX; | |
| 1614 | |
| 1615 if (XEXP (src, 0) == dest) | |
| 1616 other = XEXP (src, 1); | |
| 1617 else if (XEXP (src, 1) == dest) | |
| 1618 other = XEXP (src, 0); | |
| 1619 | |
| 1620 if (! other || find_base_value (other)) | |
| 1621 new_reg_base_value[regno] = 0; | |
| 1622 break; | |
| 1623 } | |
| 1624 case AND: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1625 if (XEXP (src, 0) != dest || !CONST_INT_P (XEXP (src, 1))) |
| 0 | 1626 new_reg_base_value[regno] = 0; |
| 1627 break; | |
| 1628 default: | |
| 1629 new_reg_base_value[regno] = 0; | |
| 1630 break; | |
| 1631 } | |
| 1632 /* If this is the first set of a register, record the value. */ | |
| 1633 else if ((regno >= FIRST_PSEUDO_REGISTER || ! fixed_regs[regno]) | |
| 111 | 1634 && ! bitmap_bit_p (reg_seen, regno) && new_reg_base_value[regno] == 0) |
| 0 | 1635 new_reg_base_value[regno] = find_base_value (src); |
| 1636 | |
| 111 | 1637 bitmap_set_bit (reg_seen, regno); |
| 0 | 1638 } |
| 1639 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1640 /* Return REG_BASE_VALUE for REGNO. Selective scheduler uses this to avoid |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1641 using hard registers with non-null REG_BASE_VALUE for renaming. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1642 rtx |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1643 get_reg_base_value (unsigned int regno) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1644 { |
| 111 | 1645 return (*reg_base_value)[regno]; |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1646 } |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1647 |
| 0 | 1648 /* If a value is known for REGNO, return it. */ |
| 1649 | |
| 1650 rtx | |
| 1651 get_reg_known_value (unsigned int regno) | |
| 1652 { | |
| 1653 if (regno >= FIRST_PSEUDO_REGISTER) | |
| 1654 { | |
| 1655 regno -= FIRST_PSEUDO_REGISTER; | |
| 111 | 1656 if (regno < vec_safe_length (reg_known_value)) |
| 1657 return (*reg_known_value)[regno]; | |
| 0 | 1658 } |
| 1659 return NULL; | |
| 1660 } | |
| 1661 | |
| 1662 /* Set it. */ | |
| 1663 | |
| 1664 static void | |
| 1665 set_reg_known_value (unsigned int regno, rtx val) | |
| 1666 { | |
| 1667 if (regno >= FIRST_PSEUDO_REGISTER) | |
| 1668 { | |
| 1669 regno -= FIRST_PSEUDO_REGISTER; | |
| 111 | 1670 if (regno < vec_safe_length (reg_known_value)) |
| 1671 (*reg_known_value)[regno] = val; | |
| 0 | 1672 } |
| 1673 } | |
| 1674 | |
| 1675 /* Similarly for reg_known_equiv_p. */ | |
| 1676 | |
| 1677 bool | |
| 1678 get_reg_known_equiv_p (unsigned int regno) | |
| 1679 { | |
| 1680 if (regno >= FIRST_PSEUDO_REGISTER) | |
| 1681 { | |
| 1682 regno -= FIRST_PSEUDO_REGISTER; | |
| 111 | 1683 if (regno < vec_safe_length (reg_known_value)) |
| 1684 return bitmap_bit_p (reg_known_equiv_p, regno); | |
| 0 | 1685 } |
| 1686 return false; | |
| 1687 } | |
| 1688 | |
| 1689 static void | |
| 1690 set_reg_known_equiv_p (unsigned int regno, bool val) | |
| 1691 { | |
| 1692 if (regno >= FIRST_PSEUDO_REGISTER) | |
| 1693 { | |
| 1694 regno -= FIRST_PSEUDO_REGISTER; | |
| 111 | 1695 if (regno < vec_safe_length (reg_known_value)) |
| 1696 { | |
| 1697 if (val) | |
| 1698 bitmap_set_bit (reg_known_equiv_p, regno); | |
| 1699 else | |
| 1700 bitmap_clear_bit (reg_known_equiv_p, regno); | |
| 1701 } | |
| 0 | 1702 } |
| 1703 } | |
| 1704 | |
| 1705 | |
| 1706 /* Returns a canonical version of X, from the point of view alias | |
| 1707 analysis. (For example, if X is a MEM whose address is a register, | |
| 1708 and the register has a known value (say a SYMBOL_REF), then a MEM | |
| 1709 whose address is the SYMBOL_REF is returned.) */ | |
| 1710 | |
| 1711 rtx | |
| 1712 canon_rtx (rtx x) | |
| 1713 { | |
| 1714 /* Recursively look for equivalences. */ | |
| 1715 if (REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER) | |
| 1716 { | |
| 1717 rtx t = get_reg_known_value (REGNO (x)); | |
| 1718 if (t == x) | |
| 1719 return x; | |
| 1720 if (t) | |
| 1721 return canon_rtx (t); | |
| 1722 } | |
| 1723 | |
| 1724 if (GET_CODE (x) == PLUS) | |
| 1725 { | |
| 1726 rtx x0 = canon_rtx (XEXP (x, 0)); | |
| 1727 rtx x1 = canon_rtx (XEXP (x, 1)); | |
| 1728 | |
| 1729 if (x0 != XEXP (x, 0) || x1 != XEXP (x, 1)) | |
| 111 | 1730 return simplify_gen_binary (PLUS, GET_MODE (x), x0, x1); |
| 0 | 1731 } |
| 1732 | |
| 1733 /* This gives us much better alias analysis when called from | |
| 1734 the loop optimizer. Note we want to leave the original | |
| 1735 MEM alone, but need to return the canonicalized MEM with | |
| 1736 all the flags with their original values. */ | |
| 1737 else if (MEM_P (x)) | |
| 1738 x = replace_equiv_address_nv (x, canon_rtx (XEXP (x, 0))); | |
| 1739 | |
| 1740 return x; | |
| 1741 } | |
| 1742 | |
| 1743 /* Return 1 if X and Y are identical-looking rtx's. | |
| 1744 Expect that X and Y has been already canonicalized. | |
| 1745 | |
| 1746 We use the data in reg_known_value above to see if two registers with | |
| 1747 different numbers are, in fact, equivalent. */ | |
| 1748 | |
| 1749 static int | |
| 1750 rtx_equal_for_memref_p (const_rtx x, const_rtx y) | |
| 1751 { | |
| 1752 int i; | |
| 1753 int j; | |
| 1754 enum rtx_code code; | |
| 1755 const char *fmt; | |
| 1756 | |
| 1757 if (x == 0 && y == 0) | |
| 1758 return 1; | |
| 1759 if (x == 0 || y == 0) | |
| 1760 return 0; | |
| 1761 | |
| 1762 if (x == y) | |
| 1763 return 1; | |
| 1764 | |
| 1765 code = GET_CODE (x); | |
| 1766 /* Rtx's of different codes cannot be equal. */ | |
| 1767 if (code != GET_CODE (y)) | |
| 1768 return 0; | |
| 1769 | |
| 1770 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. | |
| 1771 (REG:SI x) and (REG:HI x) are NOT equivalent. */ | |
| 1772 | |
| 1773 if (GET_MODE (x) != GET_MODE (y)) | |
| 1774 return 0; | |
| 1775 | |
| 1776 /* Some RTL can be compared without a recursive examination. */ | |
| 1777 switch (code) | |
| 1778 { | |
| 1779 case REG: | |
| 1780 return REGNO (x) == REGNO (y); | |
| 1781 | |
| 1782 case LABEL_REF: | |
| 111 | 1783 return label_ref_label (x) == label_ref_label (y); |
| 0 | 1784 |
| 1785 case SYMBOL_REF: | |
| 111 | 1786 return compare_base_symbol_refs (x, y) == 1; |
| 1787 | |
| 1788 case ENTRY_VALUE: | |
| 1789 /* This is magic, don't go through canonicalization et al. */ | |
| 1790 return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y)); | |
| 0 | 1791 |
| 1792 case VALUE: | |
| 111 | 1793 CASE_CONST_UNIQUE: |
| 1794 /* Pointer equality guarantees equality for these nodes. */ | |
| 0 | 1795 return 0; |
| 1796 | |
| 1797 default: | |
| 1798 break; | |
| 1799 } | |
| 1800 | |
| 1801 /* canon_rtx knows how to handle plus. No need to canonicalize. */ | |
| 1802 if (code == PLUS) | |
| 1803 return ((rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0)) | |
| 1804 && rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 1))) | |
| 1805 || (rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 1)) | |
| 1806 && rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 0)))); | |
| 1807 /* For commutative operations, the RTX match if the operand match in any | |
| 1808 order. Also handle the simple binary and unary cases without a loop. */ | |
| 1809 if (COMMUTATIVE_P (x)) | |
| 1810 { | |
| 1811 rtx xop0 = canon_rtx (XEXP (x, 0)); | |
| 1812 rtx yop0 = canon_rtx (XEXP (y, 0)); | |
| 1813 rtx yop1 = canon_rtx (XEXP (y, 1)); | |
| 1814 | |
| 1815 return ((rtx_equal_for_memref_p (xop0, yop0) | |
| 1816 && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)), yop1)) | |
| 1817 || (rtx_equal_for_memref_p (xop0, yop1) | |
| 1818 && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)), yop0))); | |
| 1819 } | |
| 1820 else if (NON_COMMUTATIVE_P (x)) | |
| 1821 { | |
| 1822 return (rtx_equal_for_memref_p (canon_rtx (XEXP (x, 0)), | |
| 1823 canon_rtx (XEXP (y, 0))) | |
| 1824 && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)), | |
| 1825 canon_rtx (XEXP (y, 1)))); | |
| 1826 } | |
| 1827 else if (UNARY_P (x)) | |
| 1828 return rtx_equal_for_memref_p (canon_rtx (XEXP (x, 0)), | |
| 1829 canon_rtx (XEXP (y, 0))); | |
| 1830 | |
| 1831 /* Compare the elements. If any pair of corresponding elements | |
| 1832 fail to match, return 0 for the whole things. | |
| 1833 | |
| 1834 Limit cases to types which actually appear in addresses. */ | |
| 1835 | |
| 1836 fmt = GET_RTX_FORMAT (code); | |
| 1837 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) | |
| 1838 { | |
| 1839 switch (fmt[i]) | |
| 1840 { | |
| 1841 case 'i': | |
| 1842 if (XINT (x, i) != XINT (y, i)) | |
| 1843 return 0; | |
| 1844 break; | |
| 1845 | |
| 131 | 1846 case 'p': |
| 1847 if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y))) | |
| 1848 return 0; | |
| 1849 break; | |
| 1850 | |
| 0 | 1851 case 'E': |
| 1852 /* Two vectors must have the same length. */ | |
| 1853 if (XVECLEN (x, i) != XVECLEN (y, i)) | |
| 1854 return 0; | |
| 1855 | |
| 1856 /* And the corresponding elements must match. */ | |
| 1857 for (j = 0; j < XVECLEN (x, i); j++) | |
| 1858 if (rtx_equal_for_memref_p (canon_rtx (XVECEXP (x, i, j)), | |
| 1859 canon_rtx (XVECEXP (y, i, j))) == 0) | |
| 1860 return 0; | |
| 1861 break; | |
| 1862 | |
| 1863 case 'e': | |
| 1864 if (rtx_equal_for_memref_p (canon_rtx (XEXP (x, i)), | |
| 1865 canon_rtx (XEXP (y, i))) == 0) | |
| 1866 return 0; | |
| 1867 break; | |
| 1868 | |
| 1869 /* This can happen for asm operands. */ | |
| 1870 case 's': | |
| 1871 if (strcmp (XSTR (x, i), XSTR (y, i))) | |
| 1872 return 0; | |
| 1873 break; | |
| 1874 | |
| 1875 /* This can happen for an asm which clobbers memory. */ | |
| 1876 case '0': | |
| 1877 break; | |
| 1878 | |
| 1879 /* It is believed that rtx's at this level will never | |
| 1880 contain anything but integers and other rtx's, | |
| 1881 except for within LABEL_REFs and SYMBOL_REFs. */ | |
| 1882 default: | |
| 1883 gcc_unreachable (); | |
| 1884 } | |
| 1885 } | |
| 1886 return 1; | |
| 1887 } | |
| 1888 | |
| 111 | 1889 static rtx |
| 131 | 1890 find_base_term (rtx x, vec<std::pair<cselib_val *, |
| 1891 struct elt_loc_list *> > &visited_vals) | |
| 0 | 1892 { |
| 1893 cselib_val *val; | |
| 111 | 1894 struct elt_loc_list *l, *f; |
| 1895 rtx ret; | |
| 131 | 1896 scalar_int_mode int_mode; |
| 0 | 1897 |
| 1898 #if defined (FIND_BASE_TERM) | |
| 1899 /* Try machine-dependent ways to find the base term. */ | |
| 1900 x = FIND_BASE_TERM (x); | |
| 1901 #endif | |
| 1902 | |
| 1903 switch (GET_CODE (x)) | |
| 1904 { | |
| 1905 case REG: | |
| 1906 return REG_BASE_VALUE (x); | |
| 1907 | |
| 1908 case TRUNCATE: | |
| 111 | 1909 /* As we do not know which address space the pointer is referring to, we can |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1910 handle this only if the target does not support different pointer or |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1911 address modes depending on the address space. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1912 if (!target_default_pointer_address_modes_p ()) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1913 return 0; |
| 131 | 1914 if (!is_a <scalar_int_mode> (GET_MODE (x), &int_mode) |
| 1915 || GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (Pmode)) | |
| 0 | 1916 return 0; |
| 1917 /* Fall through. */ | |
| 1918 case HIGH: | |
| 1919 case PRE_INC: | |
| 1920 case PRE_DEC: | |
| 1921 case POST_INC: | |
| 1922 case POST_DEC: | |
| 1923 case PRE_MODIFY: | |
| 1924 case POST_MODIFY: | |
| 131 | 1925 return find_base_term (XEXP (x, 0), visited_vals); |
| 0 | 1926 |
| 1927 case ZERO_EXTEND: | |
| 1928 case SIGN_EXTEND: /* Used for Alpha/NT pointers */ | |
| 111 | 1929 /* As we do not know which address space the pointer is referring to, we can |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1930 handle this only if the target does not support different pointer or |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1931 address modes depending on the address space. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1932 if (!target_default_pointer_address_modes_p ()) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1933 return 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1934 |
| 0 | 1935 { |
| 131 | 1936 rtx temp = find_base_term (XEXP (x, 0), visited_vals); |
| 0 | 1937 |
| 1938 if (temp != 0 && CONSTANT_P (temp)) | |
| 1939 temp = convert_memory_address (Pmode, temp); | |
| 1940 | |
| 1941 return temp; | |
| 1942 } | |
| 1943 | |
| 1944 case VALUE: | |
| 1945 val = CSELIB_VAL_PTR (x); | |
| 111 | 1946 ret = NULL_RTX; |
| 1947 | |
| 0 | 1948 if (!val) |
| 111 | 1949 return ret; |
| 1950 | |
| 1951 if (cselib_sp_based_value_p (val)) | |
| 1952 return static_reg_base_value[STACK_POINTER_REGNUM]; | |
| 1953 | |
| 1954 f = val->locs; | |
| 131 | 1955 /* Reset val->locs to avoid infinite recursion. */ |
| 1956 if (f) | |
| 1957 visited_vals.safe_push (std::make_pair (val, f)); | |
| 111 | 1958 val->locs = NULL; |
| 1959 | |
| 1960 for (l = f; l; l = l->next) | |
| 1961 if (GET_CODE (l->loc) == VALUE | |
| 1962 && CSELIB_VAL_PTR (l->loc)->locs | |
| 1963 && !CSELIB_VAL_PTR (l->loc)->locs->next | |
| 1964 && CSELIB_VAL_PTR (l->loc)->locs->loc == x) | |
| 1965 continue; | |
| 131 | 1966 else if ((ret = find_base_term (l->loc, visited_vals)) != 0) |
| 111 | 1967 break; |
| 1968 | |
| 1969 return ret; | |
| 0 | 1970 |
|
19
58ad6c70ea60
update gcc from 4.4.0 to 4.4.1.
kent@firefly.cr.ie.u-ryukyu.ac.jp
parents:
0
diff
changeset
|
1971 case LO_SUM: |
|
58ad6c70ea60
update gcc from 4.4.0 to 4.4.1.
kent@firefly.cr.ie.u-ryukyu.ac.jp
parents:
0
diff
changeset
|
1972 /* The standard form is (lo_sum reg sym) so look only at the |
|
58ad6c70ea60
update gcc from 4.4.0 to 4.4.1.
kent@firefly.cr.ie.u-ryukyu.ac.jp
parents:
0
diff
changeset
|
1973 second operand. */ |
| 131 | 1974 return find_base_term (XEXP (x, 1), visited_vals); |
|
19
58ad6c70ea60
update gcc from 4.4.0 to 4.4.1.
kent@firefly.cr.ie.u-ryukyu.ac.jp
parents:
0
diff
changeset
|
1975 |
| 0 | 1976 case CONST: |
| 1977 x = XEXP (x, 0); | |
| 1978 if (GET_CODE (x) != PLUS && GET_CODE (x) != MINUS) | |
| 1979 return 0; | |
| 1980 /* Fall through. */ | |
| 1981 case PLUS: | |
| 1982 case MINUS: | |
| 1983 { | |
| 1984 rtx tmp1 = XEXP (x, 0); | |
| 1985 rtx tmp2 = XEXP (x, 1); | |
| 1986 | |
| 1987 /* This is a little bit tricky since we have to determine which of | |
| 1988 the two operands represents the real base address. Otherwise this | |
| 1989 routine may return the index register instead of the base register. | |
| 1990 | |
| 1991 That may cause us to believe no aliasing was possible, when in | |
| 1992 fact aliasing is possible. | |
| 1993 | |
| 1994 We use a few simple tests to guess the base register. Additional | |
| 1995 tests can certainly be added. For example, if one of the operands | |
| 1996 is a shift or multiply, then it must be the index register and the | |
| 1997 other operand is the base register. */ | |
| 1998 | |
| 1999 if (tmp1 == pic_offset_table_rtx && CONSTANT_P (tmp2)) | |
| 131 | 2000 return find_base_term (tmp2, visited_vals); |
| 0 | 2001 |
| 111 | 2002 /* If either operand is known to be a pointer, then prefer it |
| 0 | 2003 to determine the base term. */ |
| 2004 if (REG_P (tmp1) && REG_POINTER (tmp1)) | |
| 111 | 2005 ; |
| 2006 else if (REG_P (tmp2) && REG_POINTER (tmp2)) | |
| 2007 std::swap (tmp1, tmp2); | |
| 2008 /* If second argument is constant which has base term, prefer it | |
| 2009 over variable tmp1. See PR64025. */ | |
| 2010 else if (CONSTANT_P (tmp2) && !CONST_INT_P (tmp2)) | |
| 2011 std::swap (tmp1, tmp2); | |
| 2012 | |
| 2013 /* Go ahead and find the base term for both operands. If either base | |
| 2014 term is from a pointer or is a named object or a special address | |
| 0 | 2015 (like an argument or stack reference), then use it for the |
| 2016 base term. */ | |
| 131 | 2017 rtx base = find_base_term (tmp1, visited_vals); |
| 111 | 2018 if (base != NULL_RTX |
| 2019 && ((REG_P (tmp1) && REG_POINTER (tmp1)) | |
| 2020 || known_base_value_p (base))) | |
| 2021 return base; | |
| 131 | 2022 base = find_base_term (tmp2, visited_vals); |
| 111 | 2023 if (base != NULL_RTX |
| 2024 && ((REG_P (tmp2) && REG_POINTER (tmp2)) | |
| 2025 || known_base_value_p (base))) | |
| 2026 return base; | |
| 0 | 2027 |
| 2028 /* We could not determine which of the two operands was the | |
| 2029 base register and which was the index. So we can determine | |
| 2030 nothing from the base alias check. */ | |
| 2031 return 0; | |
| 2032 } | |
| 2033 | |
| 2034 case AND: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2035 if (CONST_INT_P (XEXP (x, 1)) && INTVAL (XEXP (x, 1)) != 0) |
| 131 | 2036 return find_base_term (XEXP (x, 0), visited_vals); |
| 0 | 2037 return 0; |
| 2038 | |
| 2039 case SYMBOL_REF: | |
| 2040 case LABEL_REF: | |
| 2041 return x; | |
| 2042 | |
| 2043 default: | |
| 2044 return 0; | |
| 2045 } | |
| 2046 } | |
| 2047 | |
| 131 | 2048 /* Wrapper around the worker above which removes locs from visited VALUEs |
| 2049 to avoid visiting them multiple times. We unwind that changes here. */ | |
| 2050 | |
| 2051 static rtx | |
| 2052 find_base_term (rtx x) | |
| 2053 { | |
| 2054 auto_vec<std::pair<cselib_val *, struct elt_loc_list *>, 32> visited_vals; | |
| 2055 rtx res = find_base_term (x, visited_vals); | |
| 2056 for (unsigned i = 0; i < visited_vals.length (); ++i) | |
| 2057 visited_vals[i].first->locs = visited_vals[i].second; | |
| 2058 return res; | |
| 2059 } | |
| 2060 | |
| 111 | 2061 /* Return true if accesses to address X may alias accesses based |
| 2062 on the stack pointer. */ | |
| 2063 | |
| 2064 bool | |
| 2065 may_be_sp_based_p (rtx x) | |
| 2066 { | |
| 2067 rtx base = find_base_term (x); | |
| 2068 return !base || base == static_reg_base_value[STACK_POINTER_REGNUM]; | |
| 2069 } | |
| 2070 | |
| 2071 /* BASE1 and BASE2 are decls. Return 1 if they refer to same object, 0 | |
| 2072 if they refer to different objects and -1 if we can not decide. */ | |
| 2073 | |
| 2074 int | |
| 2075 compare_base_decls (tree base1, tree base2) | |
| 2076 { | |
| 2077 int ret; | |
| 2078 gcc_checking_assert (DECL_P (base1) && DECL_P (base2)); | |
| 2079 if (base1 == base2) | |
| 2080 return 1; | |
| 2081 | |
| 2082 /* If we have two register decls with register specification we | |
| 2083 cannot decide unless their assembler names are the same. */ | |
| 2084 if (DECL_REGISTER (base1) | |
| 2085 && DECL_REGISTER (base2) | |
| 2086 && HAS_DECL_ASSEMBLER_NAME_P (base1) | |
| 2087 && HAS_DECL_ASSEMBLER_NAME_P (base2) | |
| 2088 && DECL_ASSEMBLER_NAME_SET_P (base1) | |
| 2089 && DECL_ASSEMBLER_NAME_SET_P (base2)) | |
| 2090 { | |
| 2091 if (DECL_ASSEMBLER_NAME_RAW (base1) == DECL_ASSEMBLER_NAME_RAW (base2)) | |
| 2092 return 1; | |
| 2093 return -1; | |
| 2094 } | |
| 2095 | |
| 2096 /* Declarations of non-automatic variables may have aliases. All other | |
| 2097 decls are unique. */ | |
| 2098 if (!decl_in_symtab_p (base1) | |
| 2099 || !decl_in_symtab_p (base2)) | |
| 2100 return 0; | |
| 2101 | |
| 2102 /* Don't cause symbols to be inserted by the act of checking. */ | |
| 2103 symtab_node *node1 = symtab_node::get (base1); | |
| 2104 if (!node1) | |
| 2105 return 0; | |
| 2106 symtab_node *node2 = symtab_node::get (base2); | |
| 2107 if (!node2) | |
| 2108 return 0; | |
| 2109 | |
| 2110 ret = node1->equal_address_to (node2, true); | |
| 2111 return ret; | |
| 2112 } | |
| 2113 | |
| 2114 /* Same as compare_base_decls but for SYMBOL_REF. */ | |
| 2115 | |
| 2116 static int | |
| 2117 compare_base_symbol_refs (const_rtx x_base, const_rtx y_base) | |
| 2118 { | |
| 2119 tree x_decl = SYMBOL_REF_DECL (x_base); | |
| 2120 tree y_decl = SYMBOL_REF_DECL (y_base); | |
| 2121 bool binds_def = true; | |
| 2122 | |
| 2123 if (XSTR (x_base, 0) == XSTR (y_base, 0)) | |
| 2124 return 1; | |
| 2125 if (x_decl && y_decl) | |
| 2126 return compare_base_decls (x_decl, y_decl); | |
| 2127 if (x_decl || y_decl) | |
| 2128 { | |
| 2129 if (!x_decl) | |
| 2130 { | |
| 2131 std::swap (x_decl, y_decl); | |
| 2132 std::swap (x_base, y_base); | |
| 2133 } | |
| 2134 /* We handle specially only section anchors and assume that other | |
| 2135 labels may overlap with user variables in an arbitrary way. */ | |
| 2136 if (!SYMBOL_REF_HAS_BLOCK_INFO_P (y_base)) | |
| 2137 return -1; | |
| 2138 /* Anchors contains static VAR_DECLs and CONST_DECLs. We are safe | |
| 2139 to ignore CONST_DECLs because they are readonly. */ | |
| 2140 if (!VAR_P (x_decl) | |
| 2141 || (!TREE_STATIC (x_decl) && !TREE_PUBLIC (x_decl))) | |
| 2142 return 0; | |
| 2143 | |
| 2144 symtab_node *x_node = symtab_node::get_create (x_decl) | |
| 2145 ->ultimate_alias_target (); | |
| 2146 /* External variable can not be in section anchor. */ | |
| 2147 if (!x_node->definition) | |
| 2148 return 0; | |
| 2149 x_base = XEXP (DECL_RTL (x_node->decl), 0); | |
| 2150 /* If not in anchor, we can disambiguate. */ | |
| 2151 if (!SYMBOL_REF_HAS_BLOCK_INFO_P (x_base)) | |
| 2152 return 0; | |
| 2153 | |
| 2154 /* We have an alias of anchored variable. If it can be interposed; | |
| 2155 we must assume it may or may not alias its anchor. */ | |
| 2156 binds_def = decl_binds_to_current_def_p (x_decl); | |
| 2157 } | |
| 2158 /* If we have variable in section anchor, we can compare by offset. */ | |
| 2159 if (SYMBOL_REF_HAS_BLOCK_INFO_P (x_base) | |
| 2160 && SYMBOL_REF_HAS_BLOCK_INFO_P (y_base)) | |
| 2161 { | |
| 2162 if (SYMBOL_REF_BLOCK (x_base) != SYMBOL_REF_BLOCK (y_base)) | |
| 2163 return 0; | |
| 2164 if (SYMBOL_REF_BLOCK_OFFSET (x_base) == SYMBOL_REF_BLOCK_OFFSET (y_base)) | |
| 2165 return binds_def ? 1 : -1; | |
| 2166 if (SYMBOL_REF_ANCHOR_P (x_base) != SYMBOL_REF_ANCHOR_P (y_base)) | |
| 2167 return -1; | |
| 2168 return 0; | |
| 2169 } | |
| 2170 /* In general we assume that memory locations pointed to by different labels | |
| 2171 may overlap in undefined ways. */ | |
| 2172 return -1; | |
| 2173 } | |
| 2174 | |
| 0 | 2175 /* Return 0 if the addresses X and Y are known to point to different |
| 2176 objects, 1 if they might be pointers to the same object. */ | |
| 2177 | |
| 2178 static int | |
| 111 | 2179 base_alias_check (rtx x, rtx x_base, rtx y, rtx y_base, |
| 2180 machine_mode x_mode, machine_mode y_mode) | |
| 0 | 2181 { |
| 2182 /* If the address itself has no known base see if a known equivalent | |
| 2183 value has one. If either address still has no known base, nothing | |
| 2184 is known about aliasing. */ | |
| 2185 if (x_base == 0) | |
| 2186 { | |
| 2187 rtx x_c; | |
| 2188 | |
| 2189 if (! flag_expensive_optimizations || (x_c = canon_rtx (x)) == x) | |
| 2190 return 1; | |
| 2191 | |
| 2192 x_base = find_base_term (x_c); | |
| 2193 if (x_base == 0) | |
| 2194 return 1; | |
| 2195 } | |
| 2196 | |
| 2197 if (y_base == 0) | |
| 2198 { | |
| 2199 rtx y_c; | |
| 2200 if (! flag_expensive_optimizations || (y_c = canon_rtx (y)) == y) | |
| 2201 return 1; | |
| 2202 | |
| 2203 y_base = find_base_term (y_c); | |
| 2204 if (y_base == 0) | |
| 2205 return 1; | |
| 2206 } | |
| 2207 | |
| 2208 /* If the base addresses are equal nothing is known about aliasing. */ | |
| 2209 if (rtx_equal_p (x_base, y_base)) | |
| 2210 return 1; | |
| 2211 | |
| 2212 /* The base addresses are different expressions. If they are not accessed | |
| 2213 via AND, there is no conflict. We can bring knowledge of object | |
| 2214 alignment into play here. For example, on alpha, "char a, b;" can | |
| 111 | 2215 alias one another, though "char a; long b;" cannot. AND addresses may |
| 0 | 2216 implicitly alias surrounding objects; i.e. unaligned access in DImode |
| 2217 via AND address can alias all surrounding object types except those | |
| 2218 with aligment 8 or higher. */ | |
| 2219 if (GET_CODE (x) == AND && GET_CODE (y) == AND) | |
| 2220 return 1; | |
| 2221 if (GET_CODE (x) == AND | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2222 && (!CONST_INT_P (XEXP (x, 1)) |
| 0 | 2223 || (int) GET_MODE_UNIT_SIZE (y_mode) < -INTVAL (XEXP (x, 1)))) |
| 2224 return 1; | |
| 2225 if (GET_CODE (y) == AND | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2226 && (!CONST_INT_P (XEXP (y, 1)) |
| 0 | 2227 || (int) GET_MODE_UNIT_SIZE (x_mode) < -INTVAL (XEXP (y, 1)))) |
| 2228 return 1; | |
| 2229 | |
| 2230 /* Differing symbols not accessed via AND never alias. */ | |
| 111 | 2231 if (GET_CODE (x_base) == SYMBOL_REF && GET_CODE (y_base) == SYMBOL_REF) |
| 2232 return compare_base_symbol_refs (x_base, y_base) != 0; | |
| 2233 | |
| 0 | 2234 if (GET_CODE (x_base) != ADDRESS && GET_CODE (y_base) != ADDRESS) |
| 2235 return 0; | |
| 2236 | |
| 111 | 2237 if (unique_base_value_p (x_base) || unique_base_value_p (y_base)) |
| 0 | 2238 return 0; |
| 2239 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2240 return 1; |
| 0 | 2241 } |
| 2242 | |
| 111 | 2243 /* Return TRUE if EXPR refers to a VALUE whose uid is greater than |
| 2244 (or equal to) that of V. */ | |
| 2245 | |
| 2246 static bool | |
| 2247 refs_newer_value_p (const_rtx expr, rtx v) | |
| 2248 { | |
| 2249 int minuid = CSELIB_VAL_PTR (v)->uid; | |
| 2250 subrtx_iterator::array_type array; | |
| 2251 FOR_EACH_SUBRTX (iter, array, expr, NONCONST) | |
| 2252 if (GET_CODE (*iter) == VALUE && CSELIB_VAL_PTR (*iter)->uid >= minuid) | |
| 2253 return true; | |
| 2254 return false; | |
| 2255 } | |
| 2256 | |
| 0 | 2257 /* Convert the address X into something we can use. This is done by returning |
| 111 | 2258 it unchanged unless it is a VALUE or VALUE +/- constant; for VALUE |
| 2259 we call cselib to get a more useful rtx. */ | |
| 0 | 2260 |
| 2261 rtx | |
| 2262 get_addr (rtx x) | |
| 2263 { | |
| 2264 cselib_val *v; | |
| 2265 struct elt_loc_list *l; | |
| 2266 | |
| 2267 if (GET_CODE (x) != VALUE) | |
| 111 | 2268 { |
| 2269 if ((GET_CODE (x) == PLUS || GET_CODE (x) == MINUS) | |
| 2270 && GET_CODE (XEXP (x, 0)) == VALUE | |
| 2271 && CONST_SCALAR_INT_P (XEXP (x, 1))) | |
| 2272 { | |
| 2273 rtx op0 = get_addr (XEXP (x, 0)); | |
| 2274 if (op0 != XEXP (x, 0)) | |
| 2275 { | |
| 131 | 2276 poly_int64 c; |
| 111 | 2277 if (GET_CODE (x) == PLUS |
| 131 | 2278 && poly_int_rtx_p (XEXP (x, 1), &c)) |
| 2279 return plus_constant (GET_MODE (x), op0, c); | |
| 111 | 2280 return simplify_gen_binary (GET_CODE (x), GET_MODE (x), |
| 2281 op0, XEXP (x, 1)); | |
| 2282 } | |
| 2283 } | |
| 2284 return x; | |
| 2285 } | |
| 0 | 2286 v = CSELIB_VAL_PTR (x); |
| 2287 if (v) | |
| 2288 { | |
| 111 | 2289 bool have_equivs = cselib_have_permanent_equivalences (); |
| 2290 if (have_equivs) | |
| 2291 v = canonical_cselib_val (v); | |
| 0 | 2292 for (l = v->locs; l; l = l->next) |
| 2293 if (CONSTANT_P (l->loc)) | |
| 2294 return l->loc; | |
| 2295 for (l = v->locs; l; l = l->next) | |
| 111 | 2296 if (!REG_P (l->loc) && !MEM_P (l->loc) |
| 2297 /* Avoid infinite recursion when potentially dealing with | |
| 2298 var-tracking artificial equivalences, by skipping the | |
| 2299 equivalences themselves, and not choosing expressions | |
| 2300 that refer to newer VALUEs. */ | |
| 2301 && (!have_equivs | |
| 2302 || (GET_CODE (l->loc) != VALUE | |
| 2303 && !refs_newer_value_p (l->loc, x)))) | |
| 0 | 2304 return l->loc; |
| 111 | 2305 if (have_equivs) |
| 2306 { | |
| 2307 for (l = v->locs; l; l = l->next) | |
| 2308 if (REG_P (l->loc) | |
| 2309 || (GET_CODE (l->loc) != VALUE | |
| 2310 && !refs_newer_value_p (l->loc, x))) | |
| 2311 return l->loc; | |
| 2312 /* Return the canonical value. */ | |
| 2313 return v->val_rtx; | |
| 2314 } | |
| 0 | 2315 if (v->locs) |
| 2316 return v->locs->loc; | |
| 2317 } | |
| 2318 return x; | |
| 2319 } | |
| 2320 | |
| 2321 /* Return the address of the (N_REFS + 1)th memory reference to ADDR | |
| 2322 where SIZE is the size in bytes of the memory reference. If ADDR | |
| 2323 is not modified by the memory reference then ADDR is returned. */ | |
| 2324 | |
| 2325 static rtx | |
| 131 | 2326 addr_side_effect_eval (rtx addr, poly_int64 size, int n_refs) |
| 0 | 2327 { |
| 131 | 2328 poly_int64 offset = 0; |
| 0 | 2329 |
| 2330 switch (GET_CODE (addr)) | |
| 2331 { | |
| 2332 case PRE_INC: | |
| 2333 offset = (n_refs + 1) * size; | |
| 2334 break; | |
| 2335 case PRE_DEC: | |
| 2336 offset = -(n_refs + 1) * size; | |
| 2337 break; | |
| 2338 case POST_INC: | |
| 2339 offset = n_refs * size; | |
| 2340 break; | |
| 2341 case POST_DEC: | |
| 2342 offset = -n_refs * size; | |
| 2343 break; | |
| 2344 | |
| 2345 default: | |
| 2346 return addr; | |
| 2347 } | |
| 2348 | |
| 131 | 2349 addr = plus_constant (GET_MODE (addr), XEXP (addr, 0), offset); |
| 0 | 2350 addr = canon_rtx (addr); |
| 2351 | |
| 2352 return addr; | |
| 2353 } | |
| 2354 | |
| 111 | 2355 /* Return TRUE if an object X sized at XSIZE bytes and another object |
| 2356 Y sized at YSIZE bytes, starting C bytes after X, may overlap. If | |
| 2357 any of the sizes is zero, assume an overlap, otherwise use the | |
| 2358 absolute value of the sizes as the actual sizes. */ | |
| 2359 | |
| 2360 static inline bool | |
| 131 | 2361 offset_overlap_p (poly_int64 c, poly_int64 xsize, poly_int64 ysize) |
| 111 | 2362 { |
| 131 | 2363 if (known_eq (xsize, 0) || known_eq (ysize, 0)) |
| 2364 return true; | |
| 2365 | |
| 2366 if (maybe_ge (c, 0)) | |
| 2367 return maybe_gt (maybe_lt (xsize, 0) ? -xsize : xsize, c); | |
| 2368 else | |
| 2369 return maybe_gt (maybe_lt (ysize, 0) ? -ysize : ysize, -c); | |
| 111 | 2370 } |
| 2371 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2372 /* Return one if X and Y (memory addresses) reference the |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2373 same location in memory or if the references overlap. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2374 Return zero if they do not overlap, else return |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2375 minus one in which case they still might reference the same location. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2376 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2377 C is an offset accumulator. When |
| 0 | 2378 C is nonzero, we are testing aliases between X and Y + C. |
| 2379 XSIZE is the size in bytes of the X reference, | |
| 2380 similarly YSIZE is the size in bytes for Y. | |
| 2381 Expect that canon_rtx has been already called for X and Y. | |
| 2382 | |
| 2383 If XSIZE or YSIZE is zero, we do not know the amount of memory being | |
| 2384 referenced (the reference was BLKmode), so make the most pessimistic | |
| 2385 assumptions. | |
| 2386 | |
| 2387 If XSIZE or YSIZE is negative, we may access memory outside the object | |
| 2388 being referenced as a side effect. This can happen when using AND to | |
| 2389 align memory references, as is done on the Alpha. | |
| 2390 | |
| 2391 Nice to notice that varying addresses cannot conflict with fp if no | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2392 local variables had their addresses taken, but that's too hard now. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2393 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2394 ??? Contrary to the tree alias oracle this does not return |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2395 one for X + non-constant and Y + non-constant when X and Y are equal. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2396 If that is fixed the TBAA hack for union type-punning can be removed. */ |
| 0 | 2397 |
| 2398 static int | |
| 131 | 2399 memrefs_conflict_p (poly_int64 xsize, rtx x, poly_int64 ysize, rtx y, |
| 2400 poly_int64 c) | |
| 0 | 2401 { |
| 2402 if (GET_CODE (x) == VALUE) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2403 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2404 if (REG_P (y)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2405 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2406 struct elt_loc_list *l = NULL; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2407 if (CSELIB_VAL_PTR (x)) |
| 111 | 2408 for (l = canonical_cselib_val (CSELIB_VAL_PTR (x))->locs; |
| 2409 l; l = l->next) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2410 if (REG_P (l->loc) && rtx_equal_for_memref_p (l->loc, y)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2411 break; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2412 if (l) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2413 x = y; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2414 else |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2415 x = get_addr (x); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2416 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2417 /* Don't call get_addr if y is the same VALUE. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2418 else if (x != y) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2419 x = get_addr (x); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2420 } |
| 0 | 2421 if (GET_CODE (y) == VALUE) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2422 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2423 if (REG_P (x)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2424 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2425 struct elt_loc_list *l = NULL; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2426 if (CSELIB_VAL_PTR (y)) |
| 111 | 2427 for (l = canonical_cselib_val (CSELIB_VAL_PTR (y))->locs; |
| 2428 l; l = l->next) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2429 if (REG_P (l->loc) && rtx_equal_for_memref_p (l->loc, x)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2430 break; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2431 if (l) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2432 y = x; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2433 else |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2434 y = get_addr (y); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2435 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2436 /* Don't call get_addr if x is the same VALUE. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2437 else if (y != x) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2438 y = get_addr (y); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2439 } |
| 0 | 2440 if (GET_CODE (x) == HIGH) |
| 2441 x = XEXP (x, 0); | |
| 2442 else if (GET_CODE (x) == LO_SUM) | |
| 2443 x = XEXP (x, 1); | |
| 2444 else | |
| 131 | 2445 x = addr_side_effect_eval (x, maybe_lt (xsize, 0) ? -xsize : xsize, 0); |
| 0 | 2446 if (GET_CODE (y) == HIGH) |
| 2447 y = XEXP (y, 0); | |
| 2448 else if (GET_CODE (y) == LO_SUM) | |
| 2449 y = XEXP (y, 1); | |
| 2450 else | |
| 131 | 2451 y = addr_side_effect_eval (y, maybe_lt (ysize, 0) ? -ysize : ysize, 0); |
| 111 | 2452 |
| 2453 if (GET_CODE (x) == SYMBOL_REF && GET_CODE (y) == SYMBOL_REF) | |
| 0 | 2454 { |
| 111 | 2455 int cmp = compare_base_symbol_refs (x,y); |
| 2456 | |
| 2457 /* If both decls are the same, decide by offsets. */ | |
| 2458 if (cmp == 1) | |
| 2459 return offset_overlap_p (c, xsize, ysize); | |
| 2460 /* Assume a potential overlap for symbolic addresses that went | |
| 2461 through alignment adjustments (i.e., that have negative | |
| 2462 sizes), because we can't know how far they are from each | |
| 2463 other. */ | |
| 131 | 2464 if (maybe_lt (xsize, 0) || maybe_lt (ysize, 0)) |
| 111 | 2465 return -1; |
| 2466 /* If decls are different or we know by offsets that there is no overlap, | |
| 2467 we win. */ | |
| 2468 if (!cmp || !offset_overlap_p (c, xsize, ysize)) | |
| 2469 return 0; | |
| 2470 /* Decls may or may not be different and offsets overlap....*/ | |
| 2471 return -1; | |
| 2472 } | |
| 2473 else if (rtx_equal_for_memref_p (x, y)) | |
| 2474 { | |
| 2475 return offset_overlap_p (c, xsize, ysize); | |
| 0 | 2476 } |
| 2477 | |
| 2478 /* This code used to check for conflicts involving stack references and | |
| 2479 globals but the base address alias code now handles these cases. */ | |
| 2480 | |
| 2481 if (GET_CODE (x) == PLUS) | |
| 2482 { | |
| 2483 /* The fact that X is canonicalized means that this | |
| 2484 PLUS rtx is canonicalized. */ | |
| 2485 rtx x0 = XEXP (x, 0); | |
| 2486 rtx x1 = XEXP (x, 1); | |
| 2487 | |
| 111 | 2488 /* However, VALUEs might end up in different positions even in |
| 2489 canonical PLUSes. Comparing their addresses is enough. */ | |
| 2490 if (x0 == y) | |
| 2491 return memrefs_conflict_p (xsize, x1, ysize, const0_rtx, c); | |
| 2492 else if (x1 == y) | |
| 2493 return memrefs_conflict_p (xsize, x0, ysize, const0_rtx, c); | |
| 2494 | |
| 131 | 2495 poly_int64 cx1, cy1; |
| 0 | 2496 if (GET_CODE (y) == PLUS) |
| 2497 { | |
| 2498 /* The fact that Y is canonicalized means that this | |
| 2499 PLUS rtx is canonicalized. */ | |
| 2500 rtx y0 = XEXP (y, 0); | |
| 2501 rtx y1 = XEXP (y, 1); | |
| 2502 | |
| 111 | 2503 if (x0 == y1) |
| 2504 return memrefs_conflict_p (xsize, x1, ysize, y0, c); | |
| 2505 if (x1 == y0) | |
| 2506 return memrefs_conflict_p (xsize, x0, ysize, y1, c); | |
| 2507 | |
| 0 | 2508 if (rtx_equal_for_memref_p (x1, y1)) |
| 2509 return memrefs_conflict_p (xsize, x0, ysize, y0, c); | |
| 2510 if (rtx_equal_for_memref_p (x0, y0)) | |
| 2511 return memrefs_conflict_p (xsize, x1, ysize, y1, c); | |
| 131 | 2512 if (poly_int_rtx_p (x1, &cx1)) |
| 0 | 2513 { |
| 131 | 2514 if (poly_int_rtx_p (y1, &cy1)) |
| 0 | 2515 return memrefs_conflict_p (xsize, x0, ysize, y0, |
| 131 | 2516 c - cx1 + cy1); |
| 0 | 2517 else |
| 131 | 2518 return memrefs_conflict_p (xsize, x0, ysize, y, c - cx1); |
| 0 | 2519 } |
| 131 | 2520 else if (poly_int_rtx_p (y1, &cy1)) |
| 2521 return memrefs_conflict_p (xsize, x, ysize, y0, c + cy1); | |
| 0 | 2522 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2523 return -1; |
| 0 | 2524 } |
| 131 | 2525 else if (poly_int_rtx_p (x1, &cx1)) |
| 2526 return memrefs_conflict_p (xsize, x0, ysize, y, c - cx1); | |
| 0 | 2527 } |
| 2528 else if (GET_CODE (y) == PLUS) | |
| 2529 { | |
| 2530 /* The fact that Y is canonicalized means that this | |
| 2531 PLUS rtx is canonicalized. */ | |
| 2532 rtx y0 = XEXP (y, 0); | |
| 2533 rtx y1 = XEXP (y, 1); | |
| 2534 | |
| 111 | 2535 if (x == y0) |
| 2536 return memrefs_conflict_p (xsize, const0_rtx, ysize, y1, c); | |
| 2537 if (x == y1) | |
| 2538 return memrefs_conflict_p (xsize, const0_rtx, ysize, y0, c); | |
| 2539 | |
| 131 | 2540 poly_int64 cy1; |
| 2541 if (poly_int_rtx_p (y1, &cy1)) | |
| 2542 return memrefs_conflict_p (xsize, x, ysize, y0, c + cy1); | |
| 0 | 2543 else |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2544 return -1; |
| 0 | 2545 } |
| 2546 | |
| 2547 if (GET_CODE (x) == GET_CODE (y)) | |
| 2548 switch (GET_CODE (x)) | |
| 2549 { | |
| 2550 case MULT: | |
| 2551 { | |
| 2552 /* Handle cases where we expect the second operands to be the | |
| 2553 same, and check only whether the first operand would conflict | |
| 2554 or not. */ | |
| 2555 rtx x0, y0; | |
| 2556 rtx x1 = canon_rtx (XEXP (x, 1)); | |
| 2557 rtx y1 = canon_rtx (XEXP (y, 1)); | |
| 2558 if (! rtx_equal_for_memref_p (x1, y1)) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2559 return -1; |
| 0 | 2560 x0 = canon_rtx (XEXP (x, 0)); |
| 2561 y0 = canon_rtx (XEXP (y, 0)); | |
| 2562 if (rtx_equal_for_memref_p (x0, y0)) | |
| 111 | 2563 return offset_overlap_p (c, xsize, ysize); |
| 0 | 2564 |
| 2565 /* Can't properly adjust our sizes. */ | |
| 131 | 2566 poly_int64 c1; |
| 2567 if (!poly_int_rtx_p (x1, &c1) | |
| 2568 || !can_div_trunc_p (xsize, c1, &xsize) | |
| 2569 || !can_div_trunc_p (ysize, c1, &ysize) | |
| 2570 || !can_div_trunc_p (c, c1, &c)) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2571 return -1; |
| 0 | 2572 return memrefs_conflict_p (xsize, x0, ysize, y0, c); |
| 2573 } | |
| 2574 | |
| 2575 default: | |
| 2576 break; | |
| 2577 } | |
| 2578 | |
| 111 | 2579 /* Deal with alignment ANDs by adjusting offset and size so as to |
| 2580 cover the maximum range, without taking any previously known | |
| 2581 alignment into account. Make a size negative after such an | |
| 2582 adjustments, so that, if we end up with e.g. two SYMBOL_REFs, we | |
| 2583 assume a potential overlap, because they may end up in contiguous | |
| 2584 memory locations and the stricter-alignment access may span over | |
| 2585 part of both. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2586 if (GET_CODE (x) == AND && CONST_INT_P (XEXP (x, 1))) |
| 0 | 2587 { |
| 111 | 2588 HOST_WIDE_INT sc = INTVAL (XEXP (x, 1)); |
| 2589 unsigned HOST_WIDE_INT uc = sc; | |
| 2590 if (sc < 0 && pow2_or_zerop (-uc)) | |
| 2591 { | |
| 131 | 2592 if (maybe_gt (xsize, 0)) |
| 111 | 2593 xsize = -xsize; |
| 131 | 2594 if (maybe_ne (xsize, 0)) |
| 111 | 2595 xsize += sc + 1; |
| 2596 c -= sc + 1; | |
| 2597 return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)), | |
| 2598 ysize, y, c); | |
| 2599 } | |
| 0 | 2600 } |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2601 if (GET_CODE (y) == AND && CONST_INT_P (XEXP (y, 1))) |
| 0 | 2602 { |
| 111 | 2603 HOST_WIDE_INT sc = INTVAL (XEXP (y, 1)); |
| 2604 unsigned HOST_WIDE_INT uc = sc; | |
| 2605 if (sc < 0 && pow2_or_zerop (-uc)) | |
| 2606 { | |
| 131 | 2607 if (maybe_gt (ysize, 0)) |
| 111 | 2608 ysize = -ysize; |
| 131 | 2609 if (maybe_ne (ysize, 0)) |
| 111 | 2610 ysize += sc + 1; |
| 2611 c += sc + 1; | |
| 2612 return memrefs_conflict_p (xsize, x, | |
| 2613 ysize, canon_rtx (XEXP (y, 0)), c); | |
| 2614 } | |
| 0 | 2615 } |
| 2616 | |
| 2617 if (CONSTANT_P (x)) | |
| 2618 { | |
| 131 | 2619 poly_int64 cx, cy; |
| 2620 if (poly_int_rtx_p (x, &cx) && poly_int_rtx_p (y, &cy)) | |
| 0 | 2621 { |
| 131 | 2622 c += cy - cx; |
| 111 | 2623 return offset_overlap_p (c, xsize, ysize); |
| 0 | 2624 } |
| 2625 | |
| 2626 if (GET_CODE (x) == CONST) | |
| 2627 { | |
| 2628 if (GET_CODE (y) == CONST) | |
| 2629 return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)), | |
| 2630 ysize, canon_rtx (XEXP (y, 0)), c); | |
| 2631 else | |
| 2632 return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)), | |
| 2633 ysize, y, c); | |
| 2634 } | |
| 2635 if (GET_CODE (y) == CONST) | |
| 2636 return memrefs_conflict_p (xsize, x, ysize, | |
| 2637 canon_rtx (XEXP (y, 0)), c); | |
| 2638 | |
| 111 | 2639 /* Assume a potential overlap for symbolic addresses that went |
| 2640 through alignment adjustments (i.e., that have negative | |
| 2641 sizes), because we can't know how far they are from each | |
| 2642 other. */ | |
| 0 | 2643 if (CONSTANT_P (y)) |
| 131 | 2644 return (maybe_lt (xsize, 0) |
| 2645 || maybe_lt (ysize, 0) | |
| 2646 || offset_overlap_p (c, xsize, ysize)); | |
| 0 | 2647 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2648 return -1; |
| 0 | 2649 } |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2650 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2651 return -1; |
| 0 | 2652 } |
| 2653 | |
| 2654 /* Functions to compute memory dependencies. | |
| 2655 | |
| 2656 Since we process the insns in execution order, we can build tables | |
| 2657 to keep track of what registers are fixed (and not aliased), what registers | |
| 2658 are varying in known ways, and what registers are varying in unknown | |
| 2659 ways. | |
| 2660 | |
| 2661 If both memory references are volatile, then there must always be a | |
| 2662 dependence between the two references, since their order can not be | |
| 2663 changed. A volatile and non-volatile reference can be interchanged | |
| 2664 though. | |
| 2665 | |
| 111 | 2666 We also must allow AND addresses, because they may generate accesses |
| 2667 outside the object being referenced. This is used to generate aligned | |
| 2668 addresses from unaligned addresses, for instance, the alpha | |
| 0 | 2669 storeqi_unaligned pattern. */ |
| 2670 | |
| 2671 /* Read dependence: X is read after read in MEM takes place. There can | |
| 111 | 2672 only be a dependence here if both reads are volatile, or if either is |
| 2673 an explicit barrier. */ | |
| 0 | 2674 |
| 2675 int | |
| 2676 read_dependence (const_rtx mem, const_rtx x) | |
| 2677 { | |
| 111 | 2678 if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem)) |
| 2679 return true; | |
| 2680 if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER | |
| 2681 || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER) | |
| 2682 return true; | |
| 0 | 2683 return false; |
| 2684 } | |
| 2685 | |
| 2686 /* Look at the bottom of the COMPONENT_REF list for a DECL, and return it. */ | |
| 2687 | |
| 2688 static tree | |
| 2689 decl_for_component_ref (tree x) | |
| 2690 { | |
| 2691 do | |
| 2692 { | |
| 2693 x = TREE_OPERAND (x, 0); | |
| 2694 } | |
| 2695 while (x && TREE_CODE (x) == COMPONENT_REF); | |
| 2696 | |
| 2697 return x && DECL_P (x) ? x : NULL_TREE; | |
| 2698 } | |
| 2699 | |
| 111 | 2700 /* Walk up the COMPONENT_REF list in X and adjust *OFFSET to compensate |
| 2701 for the offset of the field reference. *KNOWN_P says whether the | |
| 2702 offset is known. */ | |
| 2703 | |
| 2704 static void | |
| 2705 adjust_offset_for_component_ref (tree x, bool *known_p, | |
| 131 | 2706 poly_int64 *offset) |
| 0 | 2707 { |
| 111 | 2708 if (!*known_p) |
| 2709 return; | |
| 0 | 2710 do |
| 2711 { | |
| 111 | 2712 tree xoffset = component_ref_field_offset (x); |
| 0 | 2713 tree field = TREE_OPERAND (x, 1); |
| 131 | 2714 if (!poly_int_tree_p (xoffset)) |
| 111 | 2715 { |
| 2716 *known_p = false; | |
| 2717 return; | |
| 2718 } | |
| 2719 | |
| 131 | 2720 poly_offset_int woffset |
| 2721 = (wi::to_poly_offset (xoffset) | |
| 111 | 2722 + (wi::to_offset (DECL_FIELD_BIT_OFFSET (field)) |
| 131 | 2723 >> LOG2_BITS_PER_UNIT) |
| 2724 + *offset); | |
| 2725 if (!woffset.to_shwi (offset)) | |
| 111 | 2726 { |
| 2727 *known_p = false; | |
| 2728 return; | |
| 2729 } | |
| 0 | 2730 |
| 2731 x = TREE_OPERAND (x, 0); | |
| 2732 } | |
| 2733 while (x && TREE_CODE (x) == COMPONENT_REF); | |
| 2734 } | |
| 2735 | |
| 2736 /* Return nonzero if we can determine the exprs corresponding to memrefs | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2737 X and Y and they do not overlap. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2738 If LOOP_VARIANT is set, skip offset-based disambiguation */ |
| 0 | 2739 |
| 2740 int | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2741 nonoverlapping_memrefs_p (const_rtx x, const_rtx y, bool loop_invariant) |
| 0 | 2742 { |
| 2743 tree exprx = MEM_EXPR (x), expry = MEM_EXPR (y); | |
| 2744 rtx rtlx, rtly; | |
| 2745 rtx basex, basey; | |
| 111 | 2746 bool moffsetx_known_p, moffsety_known_p; |
| 131 | 2747 poly_int64 moffsetx = 0, moffsety = 0; |
| 2748 poly_int64 offsetx = 0, offsety = 0, sizex, sizey; | |
| 0 | 2749 |
| 2750 /* Unless both have exprs, we can't tell anything. */ | |
| 2751 if (exprx == 0 || expry == 0) | |
| 2752 return 0; | |
| 2753 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2754 /* For spill-slot accesses make sure we have valid offsets. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2755 if ((exprx == get_spill_slot_decl (false) |
| 111 | 2756 && ! MEM_OFFSET_KNOWN_P (x)) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2757 || (expry == get_spill_slot_decl (false) |
| 111 | 2758 && ! MEM_OFFSET_KNOWN_P (y))) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2759 return 0; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2760 |
| 0 | 2761 /* If the field reference test failed, look at the DECLs involved. */ |
| 111 | 2762 moffsetx_known_p = MEM_OFFSET_KNOWN_P (x); |
| 2763 if (moffsetx_known_p) | |
| 2764 moffsetx = MEM_OFFSET (x); | |
| 0 | 2765 if (TREE_CODE (exprx) == COMPONENT_REF) |
| 2766 { | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2767 tree t = decl_for_component_ref (exprx); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2768 if (! t) |
| 0 | 2769 return 0; |
| 111 | 2770 adjust_offset_for_component_ref (exprx, &moffsetx_known_p, &moffsetx); |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2771 exprx = t; |
| 0 | 2772 } |
| 2773 | |
| 111 | 2774 moffsety_known_p = MEM_OFFSET_KNOWN_P (y); |
| 2775 if (moffsety_known_p) | |
| 2776 moffsety = MEM_OFFSET (y); | |
| 0 | 2777 if (TREE_CODE (expry) == COMPONENT_REF) |
| 2778 { | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2779 tree t = decl_for_component_ref (expry); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2780 if (! t) |
| 0 | 2781 return 0; |
| 111 | 2782 adjust_offset_for_component_ref (expry, &moffsety_known_p, &moffsety); |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2783 expry = t; |
| 0 | 2784 } |
| 2785 | |
| 2786 if (! DECL_P (exprx) || ! DECL_P (expry)) | |
| 2787 return 0; | |
| 2788 | |
| 111 | 2789 /* If we refer to different gimple registers, or one gimple register |
| 2790 and one non-gimple-register, we know they can't overlap. First, | |
| 2791 gimple registers don't have their addresses taken. Now, there | |
| 2792 could be more than one stack slot for (different versions of) the | |
| 2793 same gimple register, but we can presumably tell they don't | |
| 2794 overlap based on offsets from stack base addresses elsewhere. | |
| 2795 It's important that we don't proceed to DECL_RTL, because gimple | |
| 2796 registers may not pass DECL_RTL_SET_P, and make_decl_rtl won't be | |
| 2797 able to do anything about them since no SSA information will have | |
| 2798 remained to guide it. */ | |
| 2799 if (is_gimple_reg (exprx) || is_gimple_reg (expry)) | |
| 2800 return exprx != expry | |
| 2801 || (moffsetx_known_p && moffsety_known_p | |
| 2802 && MEM_SIZE_KNOWN_P (x) && MEM_SIZE_KNOWN_P (y) | |
| 2803 && !offset_overlap_p (moffsety - moffsetx, | |
| 2804 MEM_SIZE (x), MEM_SIZE (y))); | |
| 2805 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2806 /* With invalid code we can end up storing into the constant pool. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2807 Bail out to avoid ICEing when creating RTL for this. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2808 See gfortran.dg/lto/20091028-2_0.f90. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2809 if (TREE_CODE (exprx) == CONST_DECL |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2810 || TREE_CODE (expry) == CONST_DECL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2811 return 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2812 |
| 111 | 2813 /* If one decl is known to be a function or label in a function and |
| 2814 the other is some kind of data, they can't overlap. */ | |
| 2815 if ((TREE_CODE (exprx) == FUNCTION_DECL | |
| 2816 || TREE_CODE (exprx) == LABEL_DECL) | |
| 2817 != (TREE_CODE (expry) == FUNCTION_DECL | |
| 2818 || TREE_CODE (expry) == LABEL_DECL)) | |
| 2819 return 1; | |
| 2820 | |
| 2821 /* If either of the decls doesn't have DECL_RTL set (e.g. marked as | |
| 2822 living in multiple places), we can't tell anything. Exception | |
| 2823 are FUNCTION_DECLs for which we can create DECL_RTL on demand. */ | |
| 2824 if ((!DECL_RTL_SET_P (exprx) && TREE_CODE (exprx) != FUNCTION_DECL) | |
| 2825 || (!DECL_RTL_SET_P (expry) && TREE_CODE (expry) != FUNCTION_DECL)) | |
| 2826 return 0; | |
| 2827 | |
| 0 | 2828 rtlx = DECL_RTL (exprx); |
| 2829 rtly = DECL_RTL (expry); | |
| 2830 | |
| 2831 /* If either RTL is not a MEM, it must be a REG or CONCAT, meaning they | |
| 2832 can't overlap unless they are the same because we never reuse that part | |
| 2833 of the stack frame used for locals for spilled pseudos. */ | |
| 2834 if ((!MEM_P (rtlx) || !MEM_P (rtly)) | |
| 2835 && ! rtx_equal_p (rtlx, rtly)) | |
| 2836 return 1; | |
| 2837 | |
| 111 | 2838 /* If we have MEMs referring to different address spaces (which can |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2839 potentially overlap), we cannot easily tell from the addresses |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2840 whether the references overlap. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2841 if (MEM_P (rtlx) && MEM_P (rtly) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2842 && MEM_ADDR_SPACE (rtlx) != MEM_ADDR_SPACE (rtly)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2843 return 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2844 |
| 0 | 2845 /* Get the base and offsets of both decls. If either is a register, we |
| 2846 know both are and are the same, so use that as the base. The only | |
| 2847 we can avoid overlap is if we can deduce that they are nonoverlapping | |
| 2848 pieces of that decl, which is very rare. */ | |
| 2849 basex = MEM_P (rtlx) ? XEXP (rtlx, 0) : rtlx; | |
| 131 | 2850 basex = strip_offset_and_add (basex, &offsetx); |
| 0 | 2851 |
| 2852 basey = MEM_P (rtly) ? XEXP (rtly, 0) : rtly; | |
| 131 | 2853 basey = strip_offset_and_add (basey, &offsety); |
| 0 | 2854 |
| 2855 /* If the bases are different, we know they do not overlap if both | |
| 2856 are constants or if one is a constant and the other a pointer into the | |
| 2857 stack frame. Otherwise a different base means we can't tell if they | |
| 2858 overlap or not. */ | |
| 111 | 2859 if (compare_base_decls (exprx, expry) == 0) |
| 0 | 2860 return ((CONSTANT_P (basex) && CONSTANT_P (basey)) |
| 2861 || (CONSTANT_P (basex) && REG_P (basey) | |
| 2862 && REGNO_PTR_FRAME_P (REGNO (basey))) | |
| 2863 || (CONSTANT_P (basey) && REG_P (basex) | |
| 2864 && REGNO_PTR_FRAME_P (REGNO (basex)))); | |
| 2865 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2866 /* Offset based disambiguation not appropriate for loop invariant */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2867 if (loop_invariant) |
| 111 | 2868 return 0; |
| 2869 | |
| 2870 /* Offset based disambiguation is OK even if we do not know that the | |
| 2871 declarations are necessarily different | |
| 2872 (i.e. compare_base_decls (exprx, expry) == -1) */ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2873 |
| 131 | 2874 sizex = (!MEM_P (rtlx) ? poly_int64 (GET_MODE_SIZE (GET_MODE (rtlx))) |
| 111 | 2875 : MEM_SIZE_KNOWN_P (rtlx) ? MEM_SIZE (rtlx) |
| 0 | 2876 : -1); |
| 131 | 2877 sizey = (!MEM_P (rtly) ? poly_int64 (GET_MODE_SIZE (GET_MODE (rtly))) |
| 111 | 2878 : MEM_SIZE_KNOWN_P (rtly) ? MEM_SIZE (rtly) |
| 2879 : -1); | |
| 0 | 2880 |
| 2881 /* If we have an offset for either memref, it can update the values computed | |
| 2882 above. */ | |
| 111 | 2883 if (moffsetx_known_p) |
| 2884 offsetx += moffsetx, sizex -= moffsetx; | |
| 2885 if (moffsety_known_p) | |
| 2886 offsety += moffsety, sizey -= moffsety; | |
| 0 | 2887 |
| 2888 /* If a memref has both a size and an offset, we can use the smaller size. | |
| 2889 We can't do this if the offset isn't known because we must view this | |
| 2890 memref as being anywhere inside the DECL's MEM. */ | |
| 111 | 2891 if (MEM_SIZE_KNOWN_P (x) && moffsetx_known_p) |
| 2892 sizex = MEM_SIZE (x); | |
| 2893 if (MEM_SIZE_KNOWN_P (y) && moffsety_known_p) | |
| 2894 sizey = MEM_SIZE (y); | |
| 0 | 2895 |
| 131 | 2896 return !ranges_maybe_overlap_p (offsetx, sizex, offsety, sizey); |
| 0 | 2897 } |
| 2898 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2899 /* Helper for true_dependence and canon_true_dependence. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2900 Checks for true dependence: X is read after store in MEM takes place. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2901 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2902 If MEM_CANONICALIZED is FALSE, then X_ADDR and MEM_ADDR should be |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2903 NULL_RTX, and the canonical addresses of MEM and X are both computed |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2904 here. If MEM_CANONICALIZED, then MEM must be already canonicalized. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2905 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2906 If X_ADDR is non-NULL, it is used in preference of XEXP (x, 0). |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2907 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2908 Returns 1 if there is a true dependence, 0 otherwise. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2909 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2910 static int |
| 111 | 2911 true_dependence_1 (const_rtx mem, machine_mode mem_mode, rtx mem_addr, |
| 2912 const_rtx x, rtx x_addr, bool mem_canonicalized) | |
| 0 | 2913 { |
| 111 | 2914 rtx true_mem_addr; |
| 0 | 2915 rtx base; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2916 int ret; |
| 0 | 2917 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2918 gcc_checking_assert (mem_canonicalized ? (mem_addr != NULL_RTX) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2919 : (mem_addr == NULL_RTX && x_addr == NULL_RTX)); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2920 |
| 0 | 2921 if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem)) |
| 2922 return 1; | |
| 2923 | |
| 2924 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything. | |
| 2925 This is used in epilogue deallocation functions, and in cselib. */ | |
| 2926 if (GET_MODE (x) == BLKmode && GET_CODE (XEXP (x, 0)) == SCRATCH) | |
| 2927 return 1; | |
| 2928 if (GET_MODE (mem) == BLKmode && GET_CODE (XEXP (mem, 0)) == SCRATCH) | |
| 2929 return 1; | |
| 2930 if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER | |
| 2931 || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER) | |
| 2932 return 1; | |
| 2933 | |
| 111 | 2934 if (! x_addr) |
| 2935 x_addr = XEXP (x, 0); | |
| 2936 x_addr = get_addr (x_addr); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2937 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2938 if (! mem_addr) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2939 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2940 mem_addr = XEXP (mem, 0); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2941 if (mem_mode == VOIDmode) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2942 mem_mode = GET_MODE (mem); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2943 } |
| 111 | 2944 true_mem_addr = get_addr (mem_addr); |
| 2945 | |
| 2946 /* Read-only memory is by definition never modified, and therefore can't | |
| 2947 conflict with anything. However, don't assume anything when AND | |
| 2948 addresses are involved and leave to the code below to determine | |
| 2949 dependence. We don't expect to find read-only set on MEM, but | |
| 2950 stupid user tricks can produce them, so don't die. */ | |
| 2951 if (MEM_READONLY_P (x) | |
| 2952 && GET_CODE (x_addr) != AND | |
| 2953 && GET_CODE (true_mem_addr) != AND) | |
| 2954 return 0; | |
| 2955 | |
| 2956 /* If we have MEMs referring to different address spaces (which can | |
| 2957 potentially overlap), we cannot easily tell from the addresses | |
| 2958 whether the references overlap. */ | |
| 2959 if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x)) | |
| 2960 return 1; | |
| 0 | 2961 |
| 2962 base = find_base_term (x_addr); | |
| 2963 if (base && (GET_CODE (base) == LABEL_REF | |
| 2964 || (GET_CODE (base) == SYMBOL_REF | |
| 2965 && CONSTANT_POOL_ADDRESS_P (base)))) | |
| 2966 return 0; | |
| 2967 | |
| 111 | 2968 rtx mem_base = find_base_term (true_mem_addr); |
| 2969 if (! base_alias_check (x_addr, base, true_mem_addr, mem_base, | |
| 2970 GET_MODE (x), mem_mode)) | |
| 0 | 2971 return 0; |
| 2972 | |
| 2973 x_addr = canon_rtx (x_addr); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2974 if (!mem_canonicalized) |
| 111 | 2975 mem_addr = canon_rtx (true_mem_addr); |
| 0 | 2976 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2977 if ((ret = memrefs_conflict_p (GET_MODE_SIZE (mem_mode), mem_addr, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2978 SIZE_FOR_MODE (x), x_addr, 0)) != -1) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2979 return ret; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2980 |
| 111 | 2981 if (mems_in_disjoint_alias_sets_p (x, mem)) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2982 return 0; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2983 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2984 if (nonoverlapping_memrefs_p (mem, x, false)) |
| 0 | 2985 return 0; |
| 2986 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2987 return rtx_refs_may_alias_p (x, mem, true); |
| 0 | 2988 } |
| 2989 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2990 /* True dependence: X is read after store in MEM takes place. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2991 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2992 int |
| 111 | 2993 true_dependence (const_rtx mem, machine_mode mem_mode, const_rtx x) |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2994 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2995 return true_dependence_1 (mem, mem_mode, NULL_RTX, |
| 111 | 2996 x, NULL_RTX, /*mem_canonicalized=*/false); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2997 } |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2998 |
| 0 | 2999 /* Canonical true dependence: X is read after store in MEM takes place. |
| 3000 Variant of true_dependence which assumes MEM has already been | |
| 3001 canonicalized (hence we no longer do that here). | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3002 The mem_addr argument has been added, since true_dependence_1 computed |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3003 this value prior to canonicalizing. */ |
| 0 | 3004 |
| 3005 int | |
| 111 | 3006 canon_true_dependence (const_rtx mem, machine_mode mem_mode, rtx mem_addr, |
| 3007 const_rtx x, rtx x_addr) | |
| 0 | 3008 { |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3009 return true_dependence_1 (mem, mem_mode, mem_addr, |
| 111 | 3010 x, x_addr, /*mem_canonicalized=*/true); |
| 0 | 3011 } |
| 3012 | |
| 3013 /* Returns nonzero if a write to X might alias a previous read from | |
| 111 | 3014 (or, if WRITEP is true, a write to) MEM. |
| 3015 If X_CANONCALIZED is true, then X_ADDR is the canonicalized address of X, | |
| 3016 and X_MODE the mode for that access. | |
| 3017 If MEM_CANONICALIZED is true, MEM is canonicalized. */ | |
| 0 | 3018 |
| 3019 static int | |
| 111 | 3020 write_dependence_p (const_rtx mem, |
| 3021 const_rtx x, machine_mode x_mode, rtx x_addr, | |
| 3022 bool mem_canonicalized, bool x_canonicalized, bool writep) | |
| 0 | 3023 { |
| 111 | 3024 rtx mem_addr; |
| 3025 rtx true_mem_addr, true_x_addr; | |
| 0 | 3026 rtx base; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3027 int ret; |
| 0 | 3028 |
| 111 | 3029 gcc_checking_assert (x_canonicalized |
| 131 | 3030 ? (x_addr != NULL_RTX |
| 3031 && (x_mode != VOIDmode || GET_MODE (x) == VOIDmode)) | |
| 111 | 3032 : (x_addr == NULL_RTX && x_mode == VOIDmode)); |
| 3033 | |
| 0 | 3034 if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem)) |
| 3035 return 1; | |
| 3036 | |
| 3037 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything. | |
| 3038 This is used in epilogue deallocation functions. */ | |
| 3039 if (GET_MODE (x) == BLKmode && GET_CODE (XEXP (x, 0)) == SCRATCH) | |
| 3040 return 1; | |
| 3041 if (GET_MODE (mem) == BLKmode && GET_CODE (XEXP (mem, 0)) == SCRATCH) | |
| 3042 return 1; | |
| 3043 if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER | |
| 3044 || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER) | |
| 3045 return 1; | |
| 3046 | |
| 111 | 3047 if (!x_addr) |
| 3048 x_addr = XEXP (x, 0); | |
| 3049 true_x_addr = get_addr (x_addr); | |
| 3050 | |
| 3051 mem_addr = XEXP (mem, 0); | |
| 3052 true_mem_addr = get_addr (mem_addr); | |
| 3053 | |
| 3054 /* A read from read-only memory can't conflict with read-write memory. | |
| 3055 Don't assume anything when AND addresses are involved and leave to | |
| 3056 the code below to determine dependence. */ | |
| 3057 if (!writep | |
| 3058 && MEM_READONLY_P (mem) | |
| 3059 && GET_CODE (true_x_addr) != AND | |
| 3060 && GET_CODE (true_mem_addr) != AND) | |
| 0 | 3061 return 0; |
| 3062 | |
| 111 | 3063 /* If we have MEMs referring to different address spaces (which can |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
3064 potentially overlap), we cannot easily tell from the addresses |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
3065 whether the references overlap. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
3066 if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
3067 return 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
3068 |
| 111 | 3069 base = find_base_term (true_mem_addr); |
| 3070 if (! writep | |
| 3071 && base | |
| 3072 && (GET_CODE (base) == LABEL_REF | |
| 3073 || (GET_CODE (base) == SYMBOL_REF | |
| 3074 && CONSTANT_POOL_ADDRESS_P (base)))) | |
| 3075 return 0; | |
| 3076 | |
| 3077 rtx x_base = find_base_term (true_x_addr); | |
| 3078 if (! base_alias_check (true_x_addr, x_base, true_mem_addr, base, | |
| 3079 GET_MODE (x), GET_MODE (mem))) | |
| 3080 return 0; | |
| 3081 | |
| 3082 if (!x_canonicalized) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3083 { |
| 111 | 3084 x_addr = canon_rtx (true_x_addr); |
| 3085 x_mode = GET_MODE (x); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3086 } |
| 111 | 3087 if (!mem_canonicalized) |
| 3088 mem_addr = canon_rtx (true_mem_addr); | |
| 0 | 3089 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3090 if ((ret = memrefs_conflict_p (SIZE_FOR_MODE (mem), mem_addr, |
| 111 | 3091 GET_MODE_SIZE (x_mode), x_addr, 0)) != -1) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3092 return ret; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3093 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3094 if (nonoverlapping_memrefs_p (x, mem, false)) |
| 0 | 3095 return 0; |
| 3096 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
3097 return rtx_refs_may_alias_p (x, mem, false); |
| 0 | 3098 } |
| 3099 | |
| 3100 /* Anti dependence: X is written after read in MEM takes place. */ | |
| 3101 | |
| 3102 int | |
| 3103 anti_dependence (const_rtx mem, const_rtx x) | |
| 3104 { | |
| 111 | 3105 return write_dependence_p (mem, x, VOIDmode, NULL_RTX, |
| 3106 /*mem_canonicalized=*/false, | |
| 3107 /*x_canonicalized*/false, /*writep=*/false); | |
| 3108 } | |
| 3109 | |
| 3110 /* Likewise, but we already have a canonicalized MEM, and X_ADDR for X. | |
| 3111 Also, consider X in X_MODE (which might be from an enclosing | |
| 3112 STRICT_LOW_PART / ZERO_EXTRACT). | |
| 3113 If MEM_CANONICALIZED is true, MEM is canonicalized. */ | |
| 3114 | |
| 3115 int | |
| 3116 canon_anti_dependence (const_rtx mem, bool mem_canonicalized, | |
| 3117 const_rtx x, machine_mode x_mode, rtx x_addr) | |
| 3118 { | |
| 3119 return write_dependence_p (mem, x, x_mode, x_addr, | |
| 3120 mem_canonicalized, /*x_canonicalized=*/true, | |
| 3121 /*writep=*/false); | |
| 0 | 3122 } |
| 3123 | |
| 3124 /* Output dependence: X is written after store in MEM takes place. */ | |
| 3125 | |
| 3126 int | |
| 3127 output_dependence (const_rtx mem, const_rtx x) | |
| 3128 { | |
| 111 | 3129 return write_dependence_p (mem, x, VOIDmode, NULL_RTX, |
| 3130 /*mem_canonicalized=*/false, | |
| 3131 /*x_canonicalized*/false, /*writep=*/true); | |
| 3132 } | |
| 3133 | |
| 3134 /* Likewise, but we already have a canonicalized MEM, and X_ADDR for X. | |
| 3135 Also, consider X in X_MODE (which might be from an enclosing | |
| 3136 STRICT_LOW_PART / ZERO_EXTRACT). | |
| 3137 If MEM_CANONICALIZED is true, MEM is canonicalized. */ | |
| 3138 | |
| 3139 int | |
| 3140 canon_output_dependence (const_rtx mem, bool mem_canonicalized, | |
| 3141 const_rtx x, machine_mode x_mode, rtx x_addr) | |
| 3142 { | |
| 3143 return write_dependence_p (mem, x, x_mode, x_addr, | |
| 3144 mem_canonicalized, /*x_canonicalized=*/true, | |
| 3145 /*writep=*/true); | |
| 0 | 3146 } |
| 3147 | |
| 3148 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3149 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3150 /* Check whether X may be aliased with MEM. Don't do offset-based |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3151 memory disambiguation & TBAA. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3152 int |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3153 may_alias_p (const_rtx mem, const_rtx x) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3154 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3155 rtx x_addr, mem_addr; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3156 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3157 if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem)) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3158 return 1; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3159 |
| 111 | 3160 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything. |
| 3161 This is used in epilogue deallocation functions. */ | |
| 3162 if (GET_MODE (x) == BLKmode && GET_CODE (XEXP (x, 0)) == SCRATCH) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3163 return 1; |
| 111 | 3164 if (GET_MODE (mem) == BLKmode && GET_CODE (XEXP (mem, 0)) == SCRATCH) |
| 3165 return 1; | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3166 if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3167 || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3168 return 1; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3169 |
| 111 | 3170 x_addr = XEXP (x, 0); |
| 3171 x_addr = get_addr (x_addr); | |
| 3172 | |
| 3173 mem_addr = XEXP (mem, 0); | |
| 3174 mem_addr = get_addr (mem_addr); | |
| 3175 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3176 /* Read-only memory is by definition never modified, and therefore can't |
| 111 | 3177 conflict with anything. However, don't assume anything when AND |
| 3178 addresses are involved and leave to the code below to determine | |
| 3179 dependence. We don't expect to find read-only set on MEM, but | |
| 3180 stupid user tricks can produce them, so don't die. */ | |
| 3181 if (MEM_READONLY_P (x) | |
| 3182 && GET_CODE (x_addr) != AND | |
| 3183 && GET_CODE (mem_addr) != AND) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3184 return 0; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3185 |
| 111 | 3186 /* If we have MEMs referring to different address spaces (which can |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3187 potentially overlap), we cannot easily tell from the addresses |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3188 whether the references overlap. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3189 if (MEM_ADDR_SPACE (mem) != MEM_ADDR_SPACE (x)) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3190 return 1; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3191 |
| 111 | 3192 rtx x_base = find_base_term (x_addr); |
| 3193 rtx mem_base = find_base_term (mem_addr); | |
| 3194 if (! base_alias_check (x_addr, x_base, mem_addr, mem_base, | |
| 3195 GET_MODE (x), GET_MODE (mem_addr))) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3196 return 0; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3197 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3198 if (nonoverlapping_memrefs_p (mem, x, true)) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3199 return 0; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3200 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3201 /* TBAA not valid for loop_invarint */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3202 return rtx_refs_may_alias_p (x, mem, false); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3203 } |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3204 |
| 0 | 3205 void |
| 3206 init_alias_target (void) | |
| 3207 { | |
| 3208 int i; | |
| 3209 | |
| 111 | 3210 if (!arg_base_value) |
| 3211 arg_base_value = gen_rtx_ADDRESS (VOIDmode, 0); | |
| 3212 | |
| 0 | 3213 memset (static_reg_base_value, 0, sizeof static_reg_base_value); |
| 3214 | |
| 3215 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) | |
| 3216 /* Check whether this register can hold an incoming pointer | |
| 3217 argument. FUNCTION_ARG_REGNO_P tests outgoing register | |
| 3218 numbers, so translate if necessary due to register windows. */ | |
| 3219 if (FUNCTION_ARG_REGNO_P (OUTGOING_REGNO (i)) | |
| 111 | 3220 && targetm.hard_regno_mode_ok (i, Pmode)) |
| 3221 static_reg_base_value[i] = arg_base_value; | |
| 0 | 3222 |
| 131 | 3223 /* RTL code is required to be consistent about whether it uses the |
| 3224 stack pointer, the frame pointer or the argument pointer to | |
| 3225 access a given area of the frame. We can therefore use the | |
| 3226 base address to distinguish between the different areas. */ | |
| 0 | 3227 static_reg_base_value[STACK_POINTER_REGNUM] |
| 111 | 3228 = unique_base_value (UNIQUE_BASE_VALUE_SP); |
| 0 | 3229 static_reg_base_value[ARG_POINTER_REGNUM] |
| 111 | 3230 = unique_base_value (UNIQUE_BASE_VALUE_ARGP); |
| 0 | 3231 static_reg_base_value[FRAME_POINTER_REGNUM] |
| 111 | 3232 = unique_base_value (UNIQUE_BASE_VALUE_FP); |
| 131 | 3233 |
| 3234 /* The above rules extend post-reload, with eliminations applying | |
| 3235 consistently to each of the three pointers. Cope with cases in | |
| 3236 which the frame pointer is eliminated to the hard frame pointer | |
| 3237 rather than the stack pointer. */ | |
| 111 | 3238 if (!HARD_FRAME_POINTER_IS_FRAME_POINTER) |
| 3239 static_reg_base_value[HARD_FRAME_POINTER_REGNUM] | |
| 3240 = unique_base_value (UNIQUE_BASE_VALUE_HFP); | |
| 0 | 3241 } |
| 3242 | |
| 3243 /* Set MEMORY_MODIFIED when X modifies DATA (that is assumed | |
| 3244 to be memory reference. */ | |
| 3245 static bool memory_modified; | |
| 3246 static void | |
| 3247 memory_modified_1 (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data) | |
| 3248 { | |
| 3249 if (MEM_P (x)) | |
| 3250 { | |
| 3251 if (anti_dependence (x, (const_rtx)data) || output_dependence (x, (const_rtx)data)) | |
| 3252 memory_modified = true; | |
| 3253 } | |
| 3254 } | |
| 3255 | |
| 3256 | |
| 3257 /* Return true when INSN possibly modify memory contents of MEM | |
| 3258 (i.e. address can be modified). */ | |
| 3259 bool | |
| 3260 memory_modified_in_insn_p (const_rtx mem, const_rtx insn) | |
| 3261 { | |
| 3262 if (!INSN_P (insn)) | |
| 3263 return false; | |
| 111 | 3264 /* Conservatively assume all non-readonly MEMs might be modified in |
| 3265 calls. */ | |
| 3266 if (CALL_P (insn)) | |
| 3267 return true; | |
| 0 | 3268 memory_modified = false; |
| 3269 note_stores (PATTERN (insn), memory_modified_1, CONST_CAST_RTX(mem)); | |
| 3270 return memory_modified; | |
| 3271 } | |
| 3272 | |
| 3273 /* Initialize the aliasing machinery. Initialize the REG_KNOWN_VALUE | |
| 3274 array. */ | |
| 3275 | |
| 3276 void | |
| 3277 init_alias_analysis (void) | |
| 3278 { | |
| 3279 unsigned int maxreg = max_reg_num (); | |
| 3280 int changed, pass; | |
| 3281 int i; | |
| 3282 unsigned int ui; | |
| 111 | 3283 rtx_insn *insn; |
| 3284 rtx val; | |
| 3285 int rpo_cnt; | |
| 3286 int *rpo; | |
| 0 | 3287 |
| 3288 timevar_push (TV_ALIAS_ANALYSIS); | |
| 3289 | |
| 111 | 3290 vec_safe_grow_cleared (reg_known_value, maxreg - FIRST_PSEUDO_REGISTER); |
| 3291 reg_known_equiv_p = sbitmap_alloc (maxreg - FIRST_PSEUDO_REGISTER); | |
| 3292 bitmap_clear (reg_known_equiv_p); | |
| 0 | 3293 |
| 3294 /* If we have memory allocated from the previous run, use it. */ | |
| 3295 if (old_reg_base_value) | |
| 3296 reg_base_value = old_reg_base_value; | |
| 3297 | |
| 3298 if (reg_base_value) | |
| 111 | 3299 reg_base_value->truncate (0); |
| 3300 | |
| 3301 vec_safe_grow_cleared (reg_base_value, maxreg); | |
| 0 | 3302 |
| 3303 new_reg_base_value = XNEWVEC (rtx, maxreg); | |
| 111 | 3304 reg_seen = sbitmap_alloc (maxreg); |
| 0 | 3305 |
| 3306 /* The basic idea is that each pass through this loop will use the | |
| 3307 "constant" information from the previous pass to propagate alias | |
| 3308 information through another level of assignments. | |
| 3309 | |
| 111 | 3310 The propagation is done on the CFG in reverse post-order, to propagate |
| 3311 things forward as far as possible in each iteration. | |
| 3312 | |
| 0 | 3313 This could get expensive if the assignment chains are long. Maybe |
| 3314 we should throttle the number of iterations, possibly based on | |
| 3315 the optimization level or flag_expensive_optimizations. | |
| 3316 | |
| 3317 We could propagate more information in the first pass by making use | |
| 3318 of DF_REG_DEF_COUNT to determine immediately that the alias information | |
| 3319 for a pseudo is "constant". | |
| 3320 | |
| 3321 A program with an uninitialized variable can cause an infinite loop | |
| 3322 here. Instead of doing a full dataflow analysis to detect such problems | |
| 3323 we just cap the number of iterations for the loop. | |
| 3324 | |
| 3325 The state of the arrays for the set chain in question does not matter | |
| 3326 since the program has undefined behavior. */ | |
| 3327 | |
| 111 | 3328 rpo = XNEWVEC (int, n_basic_blocks_for_fn (cfun)); |
| 3329 rpo_cnt = pre_and_rev_post_order_compute (NULL, rpo, false); | |
| 3330 | |
| 3331 /* The prologue/epilogue insns are not threaded onto the | |
| 3332 insn chain until after reload has completed. Thus, | |
| 3333 there is no sense wasting time checking if INSN is in | |
| 3334 the prologue/epilogue until after reload has completed. */ | |
| 3335 bool could_be_prologue_epilogue = ((targetm.have_prologue () | |
| 3336 || targetm.have_epilogue ()) | |
| 3337 && reload_completed); | |
| 3338 | |
| 0 | 3339 pass = 0; |
| 3340 do | |
| 3341 { | |
| 3342 /* Assume nothing will change this iteration of the loop. */ | |
| 3343 changed = 0; | |
| 3344 | |
| 3345 /* We want to assign the same IDs each iteration of this loop, so | |
| 111 | 3346 start counting from one each iteration of the loop. */ |
| 3347 unique_id = 1; | |
| 0 | 3348 |
| 3349 /* We're at the start of the function each iteration through the | |
| 3350 loop, so we're copying arguments. */ | |
| 3351 copying_arguments = true; | |
| 3352 | |
| 3353 /* Wipe the potential alias information clean for this pass. */ | |
| 3354 memset (new_reg_base_value, 0, maxreg * sizeof (rtx)); | |
| 3355 | |
| 3356 /* Wipe the reg_seen array clean. */ | |
| 111 | 3357 bitmap_clear (reg_seen); |
| 3358 | |
| 3359 /* Initialize the alias information for this pass. */ | |
| 3360 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) | |
| 131 | 3361 if (static_reg_base_value[i] |
| 3362 /* Don't treat the hard frame pointer as special if we | |
| 3363 eliminated the frame pointer to the stack pointer instead. */ | |
| 3364 && !(i == HARD_FRAME_POINTER_REGNUM | |
| 3365 && reload_completed | |
| 3366 && !frame_pointer_needed | |
| 3367 && targetm.can_eliminate (FRAME_POINTER_REGNUM, | |
| 3368 STACK_POINTER_REGNUM))) | |
| 111 | 3369 { |
| 3370 new_reg_base_value[i] = static_reg_base_value[i]; | |
| 3371 bitmap_set_bit (reg_seen, i); | |
| 3372 } | |
| 0 | 3373 |
| 3374 /* Walk the insns adding values to the new_reg_base_value array. */ | |
| 111 | 3375 for (i = 0; i < rpo_cnt; i++) |
| 0 | 3376 { |
| 111 | 3377 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, rpo[i]); |
| 3378 FOR_BB_INSNS (bb, insn) | |
| 0 | 3379 { |
| 111 | 3380 if (NONDEBUG_INSN_P (insn)) |
| 0 | 3381 { |
| 111 | 3382 rtx note, set; |
| 3383 | |
| 3384 if (could_be_prologue_epilogue | |
| 3385 && prologue_epilogue_contains (insn)) | |
| 3386 continue; | |
| 3387 | |
| 3388 /* If this insn has a noalias note, process it, Otherwise, | |
| 3389 scan for sets. A simple set will have no side effects | |
| 3390 which could change the base value of any other register. */ | |
| 3391 | |
| 3392 if (GET_CODE (PATTERN (insn)) == SET | |
| 3393 && REG_NOTES (insn) != 0 | |
| 3394 && find_reg_note (insn, REG_NOALIAS, NULL_RTX)) | |
| 3395 record_set (SET_DEST (PATTERN (insn)), NULL_RTX, NULL); | |
| 3396 else | |
| 3397 note_stores (PATTERN (insn), record_set, NULL); | |
| 3398 | |
| 3399 set = single_set (insn); | |
| 3400 | |
| 3401 if (set != 0 | |
| 3402 && REG_P (SET_DEST (set)) | |
| 3403 && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER) | |
| 0 | 3404 { |
| 111 | 3405 unsigned int regno = REGNO (SET_DEST (set)); |
| 3406 rtx src = SET_SRC (set); | |
| 3407 rtx t; | |
| 3408 | |
| 3409 note = find_reg_equal_equiv_note (insn); | |
| 3410 if (note && REG_NOTE_KIND (note) == REG_EQUAL | |
| 3411 && DF_REG_DEF_COUNT (regno) != 1) | |
| 3412 note = NULL_RTX; | |
| 3413 | |
| 131 | 3414 poly_int64 offset; |
| 111 | 3415 if (note != NULL_RTX |
| 3416 && GET_CODE (XEXP (note, 0)) != EXPR_LIST | |
| 3417 && ! rtx_varies_p (XEXP (note, 0), 1) | |
| 3418 && ! reg_overlap_mentioned_p (SET_DEST (set), | |
| 3419 XEXP (note, 0))) | |
| 3420 { | |
| 3421 set_reg_known_value (regno, XEXP (note, 0)); | |
| 3422 set_reg_known_equiv_p (regno, | |
| 3423 REG_NOTE_KIND (note) == REG_EQUIV); | |
| 3424 } | |
| 3425 else if (DF_REG_DEF_COUNT (regno) == 1 | |
| 3426 && GET_CODE (src) == PLUS | |
| 3427 && REG_P (XEXP (src, 0)) | |
| 3428 && (t = get_reg_known_value (REGNO (XEXP (src, 0)))) | |
| 131 | 3429 && poly_int_rtx_p (XEXP (src, 1), &offset)) |
| 111 | 3430 { |
| 131 | 3431 t = plus_constant (GET_MODE (src), t, offset); |
| 111 | 3432 set_reg_known_value (regno, t); |
| 3433 set_reg_known_equiv_p (regno, false); | |
| 3434 } | |
| 3435 else if (DF_REG_DEF_COUNT (regno) == 1 | |
| 3436 && ! rtx_varies_p (src, 1)) | |
| 3437 { | |
| 3438 set_reg_known_value (regno, src); | |
| 3439 set_reg_known_equiv_p (regno, false); | |
| 3440 } | |
| 0 | 3441 } |
| 3442 } | |
| 111 | 3443 else if (NOTE_P (insn) |
| 3444 && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG) | |
| 3445 copying_arguments = false; | |
| 0 | 3446 } |
| 3447 } | |
| 3448 | |
| 3449 /* Now propagate values from new_reg_base_value to reg_base_value. */ | |
| 3450 gcc_assert (maxreg == (unsigned int) max_reg_num ()); | |
| 3451 | |
| 3452 for (ui = 0; ui < maxreg; ui++) | |
| 3453 { | |
| 3454 if (new_reg_base_value[ui] | |
| 111 | 3455 && new_reg_base_value[ui] != (*reg_base_value)[ui] |
| 3456 && ! rtx_equal_p (new_reg_base_value[ui], (*reg_base_value)[ui])) | |
| 0 | 3457 { |
| 111 | 3458 (*reg_base_value)[ui] = new_reg_base_value[ui]; |
| 0 | 3459 changed = 1; |
| 3460 } | |
| 3461 } | |
| 3462 } | |
| 3463 while (changed && ++pass < MAX_ALIAS_LOOP_PASSES); | |
| 111 | 3464 XDELETEVEC (rpo); |
| 0 | 3465 |
| 3466 /* Fill in the remaining entries. */ | |
| 111 | 3467 FOR_EACH_VEC_ELT (*reg_known_value, i, val) |
| 3468 { | |
| 3469 int regno = i + FIRST_PSEUDO_REGISTER; | |
| 3470 if (! val) | |
| 3471 set_reg_known_value (regno, regno_reg_rtx[regno]); | |
| 3472 } | |
| 0 | 3473 |
| 3474 /* Clean up. */ | |
| 3475 free (new_reg_base_value); | |
| 3476 new_reg_base_value = 0; | |
| 111 | 3477 sbitmap_free (reg_seen); |
| 0 | 3478 reg_seen = 0; |
| 3479 timevar_pop (TV_ALIAS_ANALYSIS); | |
| 3480 } | |
| 3481 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3482 /* Equate REG_BASE_VALUE (reg1) to REG_BASE_VALUE (reg2). |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3483 Special API for var-tracking pass purposes. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3484 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3485 void |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3486 vt_equate_reg_base_value (const_rtx reg1, const_rtx reg2) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3487 { |
| 111 | 3488 (*reg_base_value)[REGNO (reg1)] = REG_BASE_VALUE (reg2); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3489 } |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3490 |
| 0 | 3491 void |
| 3492 end_alias_analysis (void) | |
| 3493 { | |
| 3494 old_reg_base_value = reg_base_value; | |
| 111 | 3495 vec_free (reg_known_value); |
| 3496 sbitmap_free (reg_known_equiv_p); | |
| 0 | 3497 } |
| 3498 | |
| 111 | 3499 void |
| 3500 dump_alias_stats_in_alias_c (FILE *s) | |
| 3501 { | |
| 3502 fprintf (s, " TBAA oracle: %llu disambiguations %llu queries\n" | |
| 3503 " %llu are in alias set 0\n" | |
| 3504 " %llu queries asked about the same object\n" | |
| 3505 " %llu queries asked about the same alias set\n" | |
| 3506 " %llu access volatile\n" | |
| 3507 " %llu are dependent in the DAG\n" | |
| 3508 " %llu are aritificially in conflict with void *\n", | |
| 3509 alias_stats.num_disambiguated, | |
| 3510 alias_stats.num_alias_zero + alias_stats.num_same_alias_set | |
| 3511 + alias_stats.num_same_objects + alias_stats.num_volatile | |
| 3512 + alias_stats.num_dag + alias_stats.num_disambiguated | |
| 3513 + alias_stats.num_universal, | |
| 3514 alias_stats.num_alias_zero, alias_stats.num_same_alias_set, | |
| 3515 alias_stats.num_same_objects, alias_stats.num_volatile, | |
| 3516 alias_stats.num_dag, alias_stats.num_universal); | |
| 3517 } | |
| 0 | 3518 #include "gt-alias.h" |