1 /* Alias analysis for GNU C
2 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3 2007 Free Software Foundation, Inc.
4 Contributed by John Carr (jfc@mit.edu).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
25 #include "coretypes.h"
34 #include "hard-reg-set.h"
35 #include "basic-block.h"
40 #include "splay-tree.h"
42 #include "langhooks.h"
47 #include "tree-pass.h"
48 #include "ipa-type-escape.h"
51 /* The aliasing API provided here solves related but different problems:
53 Say there exists (in c)
67 Consider the four questions:
69 Can a store to x1 interfere with px2->y1?
70 Can a store to x1 interfere with px2->z2?
72 Can a store to x1 change the value pointed to by with py?
73 Can a store to x1 change the value pointed to by with pz?
75 The answer to these questions can be yes, yes, yes, and maybe.
77 The first two questions can be answered with a simple examination
78 of the type system. If structure X contains a field of type Y then
79 a store thru a pointer to an X can overwrite any field that is
80 contained (recursively) in an X (unless we know that px1 != px2).
82 The last two of the questions can be solved in the same way as the
83 first two questions but this is too conservative. The observation
84 is that in some cases analysis we can know if which (if any) fields
85 are addressed and if those addresses are used in bad ways. This
86 analysis may be language specific. In C, arbitrary operations may
87 be applied to pointers. However, there is some indication that
88 this may be too conservative for some C++ types.
90 The pass ipa-type-escape does this analysis for the types whose
91 instances do not escape across the compilation boundary.
93 Historically in GCC, these two problems were combined and a single
94 data structure was used to represent the solution to these
95 problems. We now have two similar but different data structures,
96 The data structure to solve the last two question is similar to the
97 first, but does not contain have the fields in it whose address are
98 never taken. For types that do escape the compilation unit, the
99 data structures will have identical information.
102 /* The alias sets assigned to MEMs assist the back-end in determining
103 which MEMs can alias which other MEMs. In general, two MEMs in
104 different alias sets cannot alias each other, with one important
105 exception. Consider something like:
107 struct S { int i; double d; };
109 a store to an `S' can alias something of either type `int' or type
110 `double'. (However, a store to an `int' cannot alias a `double'
111 and vice versa.) We indicate this via a tree structure that looks
119 (The arrows are directed and point downwards.)
120 In this situation we say the alias set for `struct S' is the
121 `superset' and that those for `int' and `double' are `subsets'.
123 To see whether two alias sets can point to the same memory, we must
124 see if either alias set is a subset of the other. We need not trace
125 past immediate descendants, however, since we propagate all
126 grandchildren up one level.
128 Alias set zero is implicitly a superset of all other alias sets.
129 However, this is no actual entry for alias set zero. It is an
130 error to attempt to explicitly construct a subset of zero. */
132 struct alias_set_entry GTY(())
134 /* The alias set number, as stored in MEM_ALIAS_SET. */
135 HOST_WIDE_INT alias_set;
137 /* The children of the alias set. These are not just the immediate
138 children, but, in fact, all descendants. So, if we have:
140 struct T { struct S s; float f; }
142 continuing our example above, the children here will be all of
143 `int', `double', `float', and `struct S'. */
144 splay_tree GTY((param1_is (int), param2_is (int))) children;
146 /* Nonzero if would have a child of zero: this effectively makes this
147 alias set the same as alias set zero. */
150 typedef struct alias_set_entry *alias_set_entry;
152 static int rtx_equal_for_memref_p (rtx, rtx);
153 static int memrefs_conflict_p (int, rtx, int, rtx, HOST_WIDE_INT);
154 static void record_set (rtx, rtx, void *);
155 static int base_alias_check (rtx, rtx, enum machine_mode,
157 static rtx find_base_value (rtx);
158 static int mems_in_disjoint_alias_sets_p (rtx, rtx);
159 static int insert_subset_children (splay_tree_node, void*);
160 static tree find_base_decl (tree);
161 static alias_set_entry get_alias_set_entry (HOST_WIDE_INT);
162 static rtx fixed_scalar_and_varying_struct_p (rtx, rtx, rtx, rtx,
164 static int aliases_everything_p (rtx);
165 static bool nonoverlapping_component_refs_p (tree, tree);
166 static tree decl_for_component_ref (tree);
167 static rtx adjust_offset_for_component_ref (tree, rtx);
168 static int nonoverlapping_memrefs_p (rtx, rtx);
169 static int write_dependence_p (rtx, rtx, int);
171 static void memory_modified_1 (rtx, rtx, void *);
172 static void record_alias_subset (HOST_WIDE_INT, HOST_WIDE_INT);
174 /* Set up all info needed to perform alias analysis on memory references. */
176 /* Returns the size in bytes of the mode of X. */
177 #define SIZE_FOR_MODE(X) (GET_MODE_SIZE (GET_MODE (X)))
179 /* Returns nonzero if MEM1 and MEM2 do not alias because they are in
180 different alias sets. We ignore alias sets in functions making use
181 of variable arguments because the va_arg macros on some systems are
183 #define DIFFERENT_ALIAS_SETS_P(MEM1, MEM2) \
184 mems_in_disjoint_alias_sets_p (MEM1, MEM2)
186 /* Cap the number of passes we make over the insns propagating alias
187 information through set chains. 10 is a completely arbitrary choice. */
188 #define MAX_ALIAS_LOOP_PASSES 10
190 /* reg_base_value[N] gives an address to which register N is related.
191 If all sets after the first add or subtract to the current value
192 or otherwise modify it so it does not point to a different top level
193 object, reg_base_value[N] is equal to the address part of the source
196 A base address can be an ADDRESS, SYMBOL_REF, or LABEL_REF. ADDRESS
197 expressions represent certain special values: function arguments and
198 the stack, frame, and argument pointers.
200 The contents of an ADDRESS is not normally used, the mode of the
201 ADDRESS determines whether the ADDRESS is a function argument or some
202 other special value. Pointer equality, not rtx_equal_p, determines whether
203 two ADDRESS expressions refer to the same base address.
205 The only use of the contents of an ADDRESS is for determining if the
206 current function performs nonlocal memory memory references for the
207 purposes of marking the function as a constant function. */
209 static GTY(()) VEC(rtx,gc) *reg_base_value;
210 static rtx *new_reg_base_value;
212 /* We preserve the copy of old array around to avoid amount of garbage
213 produced. About 8% of garbage produced were attributed to this
215 static GTY((deletable)) VEC(rtx,gc) *old_reg_base_value;
217 /* Static hunks of RTL used by the aliasing code; these are initialized
218 once per function to avoid unnecessary RTL allocations. */
219 static GTY (()) rtx static_reg_base_value[FIRST_PSEUDO_REGISTER];
221 #define REG_BASE_VALUE(X) \
222 (REGNO (X) < VEC_length (rtx, reg_base_value) \
223 ? VEC_index (rtx, reg_base_value, REGNO (X)) : 0)
225 /* Vector indexed by N giving the initial (unchanging) value known for
226 pseudo-register N. This array is initialized in init_alias_analysis,
227 and does not change until end_alias_analysis is called. */
228 static GTY((length("reg_known_value_size"))) rtx *reg_known_value;
230 /* Indicates number of valid entries in reg_known_value. */
231 static GTY(()) unsigned int reg_known_value_size;
233 /* Vector recording for each reg_known_value whether it is due to a
234 REG_EQUIV note. Future passes (viz., reload) may replace the
235 pseudo with the equivalent expression and so we account for the
236 dependences that would be introduced if that happens.
238 The REG_EQUIV notes created in assign_parms may mention the arg
239 pointer, and there are explicit insns in the RTL that modify the
240 arg pointer. Thus we must ensure that such insns don't get
241 scheduled across each other because that would invalidate the
242 REG_EQUIV notes. One could argue that the REG_EQUIV notes are
243 wrong, but solving the problem in the scheduler will likely give
244 better code, so we do it here. */
245 static bool *reg_known_equiv_p;
247 /* True when scanning insns from the start of the rtl to the
248 NOTE_INSN_FUNCTION_BEG note. */
249 static bool copying_arguments;
251 DEF_VEC_P(alias_set_entry);
252 DEF_VEC_ALLOC_P(alias_set_entry,gc);
254 /* The splay-tree used to store the various alias set entries. */
255 static GTY (()) VEC(alias_set_entry,gc) *alias_sets;
257 /* Returns a pointer to the alias set entry for ALIAS_SET, if there is
258 such an entry, or NULL otherwise. */
260 static inline alias_set_entry
261 get_alias_set_entry (HOST_WIDE_INT alias_set)
263 return VEC_index (alias_set_entry, alias_sets, alias_set);
266 /* Returns nonzero if the alias sets for MEM1 and MEM2 are such that
267 the two MEMs cannot alias each other. */
270 mems_in_disjoint_alias_sets_p (rtx mem1, rtx mem2)
272 /* Perform a basic sanity check. Namely, that there are no alias sets
273 if we're not using strict aliasing. This helps to catch bugs
274 whereby someone uses PUT_CODE, but doesn't clear MEM_ALIAS_SET, or
275 where a MEM is allocated in some way other than by the use of
276 gen_rtx_MEM, and the MEM_ALIAS_SET is not cleared. If we begin to
277 use alias sets to indicate that spilled registers cannot alias each
278 other, we might need to remove this check. */
279 gcc_assert (flag_strict_aliasing
280 || (!MEM_ALIAS_SET (mem1) && !MEM_ALIAS_SET (mem2)));
282 return ! alias_sets_conflict_p (MEM_ALIAS_SET (mem1), MEM_ALIAS_SET (mem2));
285 /* Insert the NODE into the splay tree given by DATA. Used by
286 record_alias_subset via splay_tree_foreach. */
289 insert_subset_children (splay_tree_node node, void *data)
291 splay_tree_insert ((splay_tree) data, node->key, node->value);
296 /* Return true if the first alias set is a subset of the second. */
299 alias_set_subset_of (HOST_WIDE_INT set1, HOST_WIDE_INT set2)
303 /* Everything is a subset of the "aliases everything" set. */
307 /* Otherwise, check if set1 is a subset of set2. */
308 ase = get_alias_set_entry (set2);
310 && (splay_tree_lookup (ase->children,
311 (splay_tree_key) set1)))
316 /* Return 1 if the two specified alias sets may conflict. */
319 alias_sets_conflict_p (HOST_WIDE_INT set1, HOST_WIDE_INT set2)
324 if (alias_sets_must_conflict_p (set1, set2))
327 /* See if the first alias set is a subset of the second. */
328 ase = get_alias_set_entry (set1);
330 && (ase->has_zero_child
331 || splay_tree_lookup (ase->children,
332 (splay_tree_key) set2)))
335 /* Now do the same, but with the alias sets reversed. */
336 ase = get_alias_set_entry (set2);
338 && (ase->has_zero_child
339 || splay_tree_lookup (ase->children,
340 (splay_tree_key) set1)))
343 /* The two alias sets are distinct and neither one is the
344 child of the other. Therefore, they cannot conflict. */
348 /* Return 1 if the two specified alias sets will always conflict. */
351 alias_sets_must_conflict_p (HOST_WIDE_INT set1, HOST_WIDE_INT set2)
353 if (set1 == 0 || set2 == 0 || set1 == set2)
359 /* Return 1 if any MEM object of type T1 will always conflict (using the
360 dependency routines in this file) with any MEM object of type T2.
361 This is used when allocating temporary storage. If T1 and/or T2 are
362 NULL_TREE, it means we know nothing about the storage. */
365 objects_must_conflict_p (tree t1, tree t2)
367 HOST_WIDE_INT set1, set2;
369 /* If neither has a type specified, we don't know if they'll conflict
370 because we may be using them to store objects of various types, for
371 example the argument and local variables areas of inlined functions. */
372 if (t1 == 0 && t2 == 0)
375 /* If they are the same type, they must conflict. */
377 /* Likewise if both are volatile. */
378 || (t1 != 0 && TYPE_VOLATILE (t1) && t2 != 0 && TYPE_VOLATILE (t2)))
381 set1 = t1 ? get_alias_set (t1) : 0;
382 set2 = t2 ? get_alias_set (t2) : 0;
384 /* We can't use alias_sets_conflict_p because we must make sure
385 that every subtype of t1 will conflict with every subtype of
386 t2 for which a pair of subobjects of these respective subtypes
387 overlaps on the stack. */
388 return alias_sets_must_conflict_p (set1, set2);
391 /* T is an expression with pointer type. Find the DECL on which this
392 expression is based. (For example, in `a[i]' this would be `a'.)
393 If there is no such DECL, or a unique decl cannot be determined,
394 NULL_TREE is returned. */
397 find_base_decl (tree t)
401 if (t == 0 || t == error_mark_node || ! POINTER_TYPE_P (TREE_TYPE (t)))
404 /* If this is a declaration, return it. If T is based on a restrict
405 qualified decl, return that decl. */
408 if (TREE_CODE (t) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (t))
409 t = DECL_GET_RESTRICT_BASE (t);
413 /* Handle general expressions. It would be nice to deal with
414 COMPONENT_REFs here. If we could tell that `a' and `b' were the
415 same, then `a->f' and `b->f' are also the same. */
416 switch (TREE_CODE_CLASS (TREE_CODE (t)))
419 return find_base_decl (TREE_OPERAND (t, 0));
422 /* Return 0 if found in neither or both are the same. */
423 d0 = find_base_decl (TREE_OPERAND (t, 0));
424 d1 = find_base_decl (TREE_OPERAND (t, 1));
439 /* Return true if all nested component references handled by
440 get_inner_reference in T are such that we should use the alias set
441 provided by the object at the heart of T.
443 This is true for non-addressable components (which don't have their
444 own alias set), as well as components of objects in alias set zero.
445 This later point is a special case wherein we wish to override the
446 alias set used by the component, but we don't have per-FIELD_DECL
447 assignable alias sets. */
450 component_uses_parent_alias_set (tree t)
454 /* If we're at the end, it vacuously uses its own alias set. */
455 if (!handled_component_p (t))
458 switch (TREE_CODE (t))
461 if (DECL_NONADDRESSABLE_P (TREE_OPERAND (t, 1)))
466 case ARRAY_RANGE_REF:
467 if (TYPE_NONALIASED_COMPONENT (TREE_TYPE (TREE_OPERAND (t, 0))))
476 /* Bitfields and casts are never addressable. */
480 t = TREE_OPERAND (t, 0);
481 if (get_alias_set (TREE_TYPE (t)) == 0)
486 /* Return the alias set for T, which may be either a type or an
487 expression. Call language-specific routine for help, if needed. */
490 get_alias_set (tree t)
494 /* If we're not doing any alias analysis, just assume everything
495 aliases everything else. Also return 0 if this or its type is
497 if (! flag_strict_aliasing || t == error_mark_node
499 && (TREE_TYPE (t) == 0 || TREE_TYPE (t) == error_mark_node)))
502 /* We can be passed either an expression or a type. This and the
503 language-specific routine may make mutually-recursive calls to each other
504 to figure out what to do. At each juncture, we see if this is a tree
505 that the language may need to handle specially. First handle things that
511 /* Remove any nops, then give the language a chance to do
512 something with this tree before we look at it. */
514 set = lang_hooks.get_alias_set (t);
518 /* First see if the actual object referenced is an INDIRECT_REF from a
519 restrict-qualified pointer or a "void *". */
520 while (handled_component_p (inner))
522 inner = TREE_OPERAND (inner, 0);
526 /* Check for accesses through restrict-qualified pointers. */
527 if (INDIRECT_REF_P (inner))
529 tree decl = find_base_decl (TREE_OPERAND (inner, 0));
531 if (decl && DECL_POINTER_ALIAS_SET_KNOWN_P (decl))
533 /* If we haven't computed the actual alias set, do it now. */
534 if (DECL_POINTER_ALIAS_SET (decl) == -2)
536 tree pointed_to_type = TREE_TYPE (TREE_TYPE (decl));
538 /* No two restricted pointers can point at the same thing.
539 However, a restricted pointer can point at the same thing
540 as an unrestricted pointer, if that unrestricted pointer
541 is based on the restricted pointer. So, we make the
542 alias set for the restricted pointer a subset of the
543 alias set for the type pointed to by the type of the
545 HOST_WIDE_INT pointed_to_alias_set
546 = get_alias_set (pointed_to_type);
548 if (pointed_to_alias_set == 0)
549 /* It's not legal to make a subset of alias set zero. */
550 DECL_POINTER_ALIAS_SET (decl) = 0;
551 else if (AGGREGATE_TYPE_P (pointed_to_type))
552 /* For an aggregate, we must treat the restricted
553 pointer the same as an ordinary pointer. If we
554 were to make the type pointed to by the
555 restricted pointer a subset of the pointed-to
556 type, then we would believe that other subsets
557 of the pointed-to type (such as fields of that
558 type) do not conflict with the type pointed to
559 by the restricted pointer. */
560 DECL_POINTER_ALIAS_SET (decl)
561 = pointed_to_alias_set;
564 DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
565 record_alias_subset (pointed_to_alias_set,
566 DECL_POINTER_ALIAS_SET (decl));
570 /* We use the alias set indicated in the declaration. */
571 return DECL_POINTER_ALIAS_SET (decl);
574 /* If we have an INDIRECT_REF via a void pointer, we don't
575 know anything about what that might alias. Likewise if the
576 pointer is marked that way. */
577 else if (TREE_CODE (TREE_TYPE (inner)) == VOID_TYPE
578 || (TYPE_REF_CAN_ALIAS_ALL
579 (TREE_TYPE (TREE_OPERAND (inner, 0)))))
583 /* For non-addressable fields we return the alias set of the
584 outermost object that could have its address taken. If this
585 is an SFT use the precomputed value. */
586 if (TREE_CODE (t) == STRUCT_FIELD_TAG
587 && SFT_NONADDRESSABLE_P (t))
588 return SFT_ALIAS_SET (t);
590 /* Otherwise, pick up the outermost object that we could have a pointer
591 to, processing conversions as above. */
592 while (component_uses_parent_alias_set (t))
594 t = TREE_OPERAND (t, 0);
598 /* If we've already determined the alias set for a decl, just return
599 it. This is necessary for C++ anonymous unions, whose component
600 variables don't look like union members (boo!). */
601 if (TREE_CODE (t) == VAR_DECL
602 && DECL_RTL_SET_P (t) && MEM_P (DECL_RTL (t)))
603 return MEM_ALIAS_SET (DECL_RTL (t));
605 /* Now all we care about is the type. */
609 /* Variant qualifiers don't affect the alias set, so get the main
610 variant. If this is a type with a known alias set, return it. */
611 t = TYPE_MAIN_VARIANT (t);
612 if (TYPE_ALIAS_SET_KNOWN_P (t))
613 return TYPE_ALIAS_SET (t);
615 /* See if the language has special handling for this type. */
616 set = lang_hooks.get_alias_set (t);
620 /* There are no objects of FUNCTION_TYPE, so there's no point in
621 using up an alias set for them. (There are, of course, pointers
622 and references to functions, but that's different.) */
623 else if (TREE_CODE (t) == FUNCTION_TYPE
624 || TREE_CODE (t) == METHOD_TYPE)
627 /* Unless the language specifies otherwise, let vector types alias
628 their components. This avoids some nasty type punning issues in
629 normal usage. And indeed lets vectors be treated more like an
631 else if (TREE_CODE (t) == VECTOR_TYPE)
632 set = get_alias_set (TREE_TYPE (t));
635 /* Otherwise make a new alias set for this type. */
636 set = new_alias_set ();
638 TYPE_ALIAS_SET (t) = set;
640 /* If this is an aggregate type, we must record any component aliasing
642 if (AGGREGATE_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE)
643 record_component_aliases (t);
648 /* Return a brand-new alias set. */
653 if (flag_strict_aliasing)
656 VEC_safe_push (alias_set_entry, gc, alias_sets, 0);
657 VEC_safe_push (alias_set_entry, gc, alias_sets, 0);
658 return VEC_length (alias_set_entry, alias_sets) - 1;
664 /* Indicate that things in SUBSET can alias things in SUPERSET, but that
665 not everything that aliases SUPERSET also aliases SUBSET. For example,
666 in C, a store to an `int' can alias a load of a structure containing an
667 `int', and vice versa. But it can't alias a load of a 'double' member
668 of the same structure. Here, the structure would be the SUPERSET and
669 `int' the SUBSET. This relationship is also described in the comment at
670 the beginning of this file.
672 This function should be called only once per SUPERSET/SUBSET pair.
674 It is illegal for SUPERSET to be zero; everything is implicitly a
675 subset of alias set zero. */
678 record_alias_subset (HOST_WIDE_INT superset, HOST_WIDE_INT subset)
680 alias_set_entry superset_entry;
681 alias_set_entry subset_entry;
683 /* It is possible in complex type situations for both sets to be the same,
684 in which case we can ignore this operation. */
685 if (superset == subset)
688 gcc_assert (superset);
690 superset_entry = get_alias_set_entry (superset);
691 if (superset_entry == 0)
693 /* Create an entry for the SUPERSET, so that we have a place to
694 attach the SUBSET. */
695 superset_entry = ggc_alloc (sizeof (struct alias_set_entry));
696 superset_entry->alias_set = superset;
697 superset_entry->children
698 = splay_tree_new_ggc (splay_tree_compare_ints);
699 superset_entry->has_zero_child = 0;
700 VEC_replace (alias_set_entry, alias_sets, superset, superset_entry);
704 superset_entry->has_zero_child = 1;
707 subset_entry = get_alias_set_entry (subset);
708 /* If there is an entry for the subset, enter all of its children
709 (if they are not already present) as children of the SUPERSET. */
712 if (subset_entry->has_zero_child)
713 superset_entry->has_zero_child = 1;
715 splay_tree_foreach (subset_entry->children, insert_subset_children,
716 superset_entry->children);
719 /* Enter the SUBSET itself as a child of the SUPERSET. */
720 splay_tree_insert (superset_entry->children,
721 (splay_tree_key) subset, 0);
725 /* Record that component types of TYPE, if any, are part of that type for
726 aliasing purposes. For record types, we only record component types
727 for fields that are marked addressable. For array types, we always
728 record the component types, so the front end should not call this
729 function if the individual component aren't addressable. */
732 record_component_aliases (tree type)
734 HOST_WIDE_INT superset = get_alias_set (type);
740 switch (TREE_CODE (type))
743 if (! TYPE_NONALIASED_COMPONENT (type))
744 record_alias_subset (superset, get_alias_set (TREE_TYPE (type)));
749 case QUAL_UNION_TYPE:
750 /* Recursively record aliases for the base classes, if there are any. */
751 if (TYPE_BINFO (type))
754 tree binfo, base_binfo;
756 for (binfo = TYPE_BINFO (type), i = 0;
757 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
758 record_alias_subset (superset,
759 get_alias_set (BINFO_TYPE (base_binfo)));
761 for (field = TYPE_FIELDS (type); field != 0; field = TREE_CHAIN (field))
762 if (TREE_CODE (field) == FIELD_DECL && ! DECL_NONADDRESSABLE_P (field))
763 record_alias_subset (superset, get_alias_set (TREE_TYPE (field)));
767 record_alias_subset (superset, get_alias_set (TREE_TYPE (type)));
775 /* Allocate an alias set for use in storing and reading from the varargs
778 static GTY(()) HOST_WIDE_INT varargs_set = -1;
781 get_varargs_alias_set (void)
784 /* We now lower VA_ARG_EXPR, and there's currently no way to attach the
785 varargs alias set to an INDIRECT_REF (FIXME!), so we can't
786 consistently use the varargs alias set for loads from the varargs
787 area. So don't use it anywhere. */
790 if (varargs_set == -1)
791 varargs_set = new_alias_set ();
797 /* Likewise, but used for the fixed portions of the frame, e.g., register
800 static GTY(()) HOST_WIDE_INT frame_set = -1;
803 get_frame_alias_set (void)
806 frame_set = new_alias_set ();
811 /* Inside SRC, the source of a SET, find a base address. */
814 find_base_value (rtx src)
818 switch (GET_CODE (src))
826 /* At the start of a function, argument registers have known base
827 values which may be lost later. Returning an ADDRESS
828 expression here allows optimization based on argument values
829 even when the argument registers are used for other purposes. */
830 if (regno < FIRST_PSEUDO_REGISTER && copying_arguments)
831 return new_reg_base_value[regno];
833 /* If a pseudo has a known base value, return it. Do not do this
834 for non-fixed hard regs since it can result in a circular
835 dependency chain for registers which have values at function entry.
837 The test above is not sufficient because the scheduler may move
838 a copy out of an arg reg past the NOTE_INSN_FUNCTION_BEGIN. */
839 if ((regno >= FIRST_PSEUDO_REGISTER || fixed_regs[regno])
840 && regno < VEC_length (rtx, reg_base_value))
842 /* If we're inside init_alias_analysis, use new_reg_base_value
843 to reduce the number of relaxation iterations. */
844 if (new_reg_base_value && new_reg_base_value[regno]
845 && DF_REG_DEF_COUNT (regno) == 1)
846 return new_reg_base_value[regno];
848 if (VEC_index (rtx, reg_base_value, regno))
849 return VEC_index (rtx, reg_base_value, regno);
855 /* Check for an argument passed in memory. Only record in the
856 copying-arguments block; it is too hard to track changes
858 if (copying_arguments
859 && (XEXP (src, 0) == arg_pointer_rtx
860 || (GET_CODE (XEXP (src, 0)) == PLUS
861 && XEXP (XEXP (src, 0), 0) == arg_pointer_rtx)))
862 return gen_rtx_ADDRESS (VOIDmode, src);
867 if (GET_CODE (src) != PLUS && GET_CODE (src) != MINUS)
870 /* ... fall through ... */
875 rtx temp, src_0 = XEXP (src, 0), src_1 = XEXP (src, 1);
877 /* If either operand is a REG that is a known pointer, then it
879 if (REG_P (src_0) && REG_POINTER (src_0))
880 return find_base_value (src_0);
881 if (REG_P (src_1) && REG_POINTER (src_1))
882 return find_base_value (src_1);
884 /* If either operand is a REG, then see if we already have
885 a known value for it. */
888 temp = find_base_value (src_0);
895 temp = find_base_value (src_1);
900 /* If either base is named object or a special address
901 (like an argument or stack reference), then use it for the
904 && (GET_CODE (src_0) == SYMBOL_REF
905 || GET_CODE (src_0) == LABEL_REF
906 || (GET_CODE (src_0) == ADDRESS
907 && GET_MODE (src_0) != VOIDmode)))
911 && (GET_CODE (src_1) == SYMBOL_REF
912 || GET_CODE (src_1) == LABEL_REF
913 || (GET_CODE (src_1) == ADDRESS
914 && GET_MODE (src_1) != VOIDmode)))
917 /* Guess which operand is the base address:
918 If either operand is a symbol, then it is the base. If
919 either operand is a CONST_INT, then the other is the base. */
920 if (GET_CODE (src_1) == CONST_INT || CONSTANT_P (src_0))
921 return find_base_value (src_0);
922 else if (GET_CODE (src_0) == CONST_INT || CONSTANT_P (src_1))
923 return find_base_value (src_1);
929 /* The standard form is (lo_sum reg sym) so look only at the
931 return find_base_value (XEXP (src, 1));
934 /* If the second operand is constant set the base
935 address to the first operand. */
936 if (GET_CODE (XEXP (src, 1)) == CONST_INT && INTVAL (XEXP (src, 1)) != 0)
937 return find_base_value (XEXP (src, 0));
941 if (GET_MODE_SIZE (GET_MODE (src)) < GET_MODE_SIZE (Pmode))
951 return find_base_value (XEXP (src, 0));
954 case SIGN_EXTEND: /* used for NT/Alpha pointers */
956 rtx temp = find_base_value (XEXP (src, 0));
958 if (temp != 0 && CONSTANT_P (temp))
959 temp = convert_memory_address (Pmode, temp);
971 /* Called from init_alias_analysis indirectly through note_stores. */
973 /* While scanning insns to find base values, reg_seen[N] is nonzero if
974 register N has been set in this function. */
975 static char *reg_seen;
977 /* Addresses which are known not to alias anything else are identified
978 by a unique integer. */
979 static int unique_id;
982 record_set (rtx dest, rtx set, void *data ATTRIBUTE_UNUSED)
991 regno = REGNO (dest);
993 gcc_assert (regno < VEC_length (rtx, reg_base_value));
995 /* If this spans multiple hard registers, then we must indicate that every
996 register has an unusable value. */
997 if (regno < FIRST_PSEUDO_REGISTER)
998 n = hard_regno_nregs[regno][GET_MODE (dest)];
1005 reg_seen[regno + n] = 1;
1006 new_reg_base_value[regno + n] = 0;
1013 /* A CLOBBER wipes out any old value but does not prevent a previously
1014 unset register from acquiring a base address (i.e. reg_seen is not
1016 if (GET_CODE (set) == CLOBBER)
1018 new_reg_base_value[regno] = 0;
1021 src = SET_SRC (set);
1025 if (reg_seen[regno])
1027 new_reg_base_value[regno] = 0;
1030 reg_seen[regno] = 1;
1031 new_reg_base_value[regno] = gen_rtx_ADDRESS (Pmode,
1032 GEN_INT (unique_id++));
1036 /* If this is not the first set of REGNO, see whether the new value
1037 is related to the old one. There are two cases of interest:
1039 (1) The register might be assigned an entirely new value
1040 that has the same base term as the original set.
1042 (2) The set might be a simple self-modification that
1043 cannot change REGNO's base value.
1045 If neither case holds, reject the original base value as invalid.
1046 Note that the following situation is not detected:
1048 extern int x, y; int *p = &x; p += (&y-&x);
1050 ANSI C does not allow computing the difference of addresses
1051 of distinct top level objects. */
1052 if (new_reg_base_value[regno] != 0
1053 && find_base_value (src) != new_reg_base_value[regno])
1054 switch (GET_CODE (src))
1058 if (XEXP (src, 0) != dest && XEXP (src, 1) != dest)
1059 new_reg_base_value[regno] = 0;
1062 /* If the value we add in the PLUS is also a valid base value,
1063 this might be the actual base value, and the original value
1066 rtx other = NULL_RTX;
1068 if (XEXP (src, 0) == dest)
1069 other = XEXP (src, 1);
1070 else if (XEXP (src, 1) == dest)
1071 other = XEXP (src, 0);
1073 if (! other || find_base_value (other))
1074 new_reg_base_value[regno] = 0;
1078 if (XEXP (src, 0) != dest || GET_CODE (XEXP (src, 1)) != CONST_INT)
1079 new_reg_base_value[regno] = 0;
1082 new_reg_base_value[regno] = 0;
1085 /* If this is the first set of a register, record the value. */
1086 else if ((regno >= FIRST_PSEUDO_REGISTER || ! fixed_regs[regno])
1087 && ! reg_seen[regno] && new_reg_base_value[regno] == 0)
1088 new_reg_base_value[regno] = find_base_value (src);
1090 reg_seen[regno] = 1;
1093 /* If a value is known for REGNO, return it. */
1096 get_reg_known_value (unsigned int regno)
1098 if (regno >= FIRST_PSEUDO_REGISTER)
1100 regno -= FIRST_PSEUDO_REGISTER;
1101 if (regno < reg_known_value_size)
1102 return reg_known_value[regno];
1110 set_reg_known_value (unsigned int regno, rtx val)
1112 if (regno >= FIRST_PSEUDO_REGISTER)
1114 regno -= FIRST_PSEUDO_REGISTER;
1115 if (regno < reg_known_value_size)
1116 reg_known_value[regno] = val;
1120 /* Similarly for reg_known_equiv_p. */
1123 get_reg_known_equiv_p (unsigned int regno)
1125 if (regno >= FIRST_PSEUDO_REGISTER)
1127 regno -= FIRST_PSEUDO_REGISTER;
1128 if (regno < reg_known_value_size)
1129 return reg_known_equiv_p[regno];
1135 set_reg_known_equiv_p (unsigned int regno, bool val)
1137 if (regno >= FIRST_PSEUDO_REGISTER)
1139 regno -= FIRST_PSEUDO_REGISTER;
1140 if (regno < reg_known_value_size)
1141 reg_known_equiv_p[regno] = val;
1146 /* Returns a canonical version of X, from the point of view alias
1147 analysis. (For example, if X is a MEM whose address is a register,
1148 and the register has a known value (say a SYMBOL_REF), then a MEM
1149 whose address is the SYMBOL_REF is returned.) */
1154 /* Recursively look for equivalences. */
1155 if (REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER)
1157 rtx t = get_reg_known_value (REGNO (x));
1161 return canon_rtx (t);
1164 if (GET_CODE (x) == PLUS)
1166 rtx x0 = canon_rtx (XEXP (x, 0));
1167 rtx x1 = canon_rtx (XEXP (x, 1));
1169 if (x0 != XEXP (x, 0) || x1 != XEXP (x, 1))
1171 if (GET_CODE (x0) == CONST_INT)
1172 return plus_constant (x1, INTVAL (x0));
1173 else if (GET_CODE (x1) == CONST_INT)
1174 return plus_constant (x0, INTVAL (x1));
1175 return gen_rtx_PLUS (GET_MODE (x), x0, x1);
1179 /* This gives us much better alias analysis when called from
1180 the loop optimizer. Note we want to leave the original
1181 MEM alone, but need to return the canonicalized MEM with
1182 all the flags with their original values. */
1184 x = replace_equiv_address_nv (x, canon_rtx (XEXP (x, 0)));
1189 /* Return 1 if X and Y are identical-looking rtx's.
1190 Expect that X and Y has been already canonicalized.
1192 We use the data in reg_known_value above to see if two registers with
1193 different numbers are, in fact, equivalent. */
1196 rtx_equal_for_memref_p (rtx x, rtx y)
1203 if (x == 0 && y == 0)
1205 if (x == 0 || y == 0)
1211 code = GET_CODE (x);
1212 /* Rtx's of different codes cannot be equal. */
1213 if (code != GET_CODE (y))
1216 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
1217 (REG:SI x) and (REG:HI x) are NOT equivalent. */
1219 if (GET_MODE (x) != GET_MODE (y))
1222 /* Some RTL can be compared without a recursive examination. */
1226 return REGNO (x) == REGNO (y);
1229 return XEXP (x, 0) == XEXP (y, 0);
1232 return XSTR (x, 0) == XSTR (y, 0);
1237 /* There's no need to compare the contents of CONST_DOUBLEs or
1238 CONST_INTs because pointer equality is a good enough
1239 comparison for these nodes. */
1246 /* canon_rtx knows how to handle plus. No need to canonicalize. */
1248 return ((rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0))
1249 && rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 1)))
1250 || (rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 1))
1251 && rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 0))));
1252 /* For commutative operations, the RTX match if the operand match in any
1253 order. Also handle the simple binary and unary cases without a loop. */
1254 if (COMMUTATIVE_P (x))
1256 rtx xop0 = canon_rtx (XEXP (x, 0));
1257 rtx yop0 = canon_rtx (XEXP (y, 0));
1258 rtx yop1 = canon_rtx (XEXP (y, 1));
1260 return ((rtx_equal_for_memref_p (xop0, yop0)
1261 && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)), yop1))
1262 || (rtx_equal_for_memref_p (xop0, yop1)
1263 && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)), yop0)));
1265 else if (NON_COMMUTATIVE_P (x))
1267 return (rtx_equal_for_memref_p (canon_rtx (XEXP (x, 0)),
1268 canon_rtx (XEXP (y, 0)))
1269 && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)),
1270 canon_rtx (XEXP (y, 1))));
1272 else if (UNARY_P (x))
1273 return rtx_equal_for_memref_p (canon_rtx (XEXP (x, 0)),
1274 canon_rtx (XEXP (y, 0)));
1276 /* Compare the elements. If any pair of corresponding elements
1277 fail to match, return 0 for the whole things.
1279 Limit cases to types which actually appear in addresses. */
1281 fmt = GET_RTX_FORMAT (code);
1282 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1287 if (XINT (x, i) != XINT (y, i))
1292 /* Two vectors must have the same length. */
1293 if (XVECLEN (x, i) != XVECLEN (y, i))
1296 /* And the corresponding elements must match. */
1297 for (j = 0; j < XVECLEN (x, i); j++)
1298 if (rtx_equal_for_memref_p (canon_rtx (XVECEXP (x, i, j)),
1299 canon_rtx (XVECEXP (y, i, j))) == 0)
1304 if (rtx_equal_for_memref_p (canon_rtx (XEXP (x, i)),
1305 canon_rtx (XEXP (y, i))) == 0)
1309 /* This can happen for asm operands. */
1311 if (strcmp (XSTR (x, i), XSTR (y, i)))
1315 /* This can happen for an asm which clobbers memory. */
1319 /* It is believed that rtx's at this level will never
1320 contain anything but integers and other rtx's,
1321 except for within LABEL_REFs and SYMBOL_REFs. */
1330 find_base_term (rtx x)
1333 struct elt_loc_list *l;
1335 #if defined (FIND_BASE_TERM)
1336 /* Try machine-dependent ways to find the base term. */
1337 x = FIND_BASE_TERM (x);
1340 switch (GET_CODE (x))
1343 return REG_BASE_VALUE (x);
1346 if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (Pmode))
1356 return find_base_term (XEXP (x, 0));
1359 case SIGN_EXTEND: /* Used for Alpha/NT pointers */
1361 rtx temp = find_base_term (XEXP (x, 0));
1363 if (temp != 0 && CONSTANT_P (temp))
1364 temp = convert_memory_address (Pmode, temp);
1370 val = CSELIB_VAL_PTR (x);
1373 for (l = val->locs; l; l = l->next)
1374 if ((x = find_base_term (l->loc)) != 0)
1380 if (GET_CODE (x) != PLUS && GET_CODE (x) != MINUS)
1387 rtx tmp1 = XEXP (x, 0);
1388 rtx tmp2 = XEXP (x, 1);
1390 /* This is a little bit tricky since we have to determine which of
1391 the two operands represents the real base address. Otherwise this
1392 routine may return the index register instead of the base register.
1394 That may cause us to believe no aliasing was possible, when in
1395 fact aliasing is possible.
1397 We use a few simple tests to guess the base register. Additional
1398 tests can certainly be added. For example, if one of the operands
1399 is a shift or multiply, then it must be the index register and the
1400 other operand is the base register. */
1402 if (tmp1 == pic_offset_table_rtx && CONSTANT_P (tmp2))
1403 return find_base_term (tmp2);
1405 /* If either operand is known to be a pointer, then use it
1406 to determine the base term. */
1407 if (REG_P (tmp1) && REG_POINTER (tmp1))
1408 return find_base_term (tmp1);
1410 if (REG_P (tmp2) && REG_POINTER (tmp2))
1411 return find_base_term (tmp2);
1413 /* Neither operand was known to be a pointer. Go ahead and find the
1414 base term for both operands. */
1415 tmp1 = find_base_term (tmp1);
1416 tmp2 = find_base_term (tmp2);
1418 /* If either base term is named object or a special address
1419 (like an argument or stack reference), then use it for the
1422 && (GET_CODE (tmp1) == SYMBOL_REF
1423 || GET_CODE (tmp1) == LABEL_REF
1424 || (GET_CODE (tmp1) == ADDRESS
1425 && GET_MODE (tmp1) != VOIDmode)))
1429 && (GET_CODE (tmp2) == SYMBOL_REF
1430 || GET_CODE (tmp2) == LABEL_REF
1431 || (GET_CODE (tmp2) == ADDRESS
1432 && GET_MODE (tmp2) != VOIDmode)))
1435 /* We could not determine which of the two operands was the
1436 base register and which was the index. So we can determine
1437 nothing from the base alias check. */
1442 if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) != 0)
1443 return find_base_term (XEXP (x, 0));
1455 /* Return 0 if the addresses X and Y are known to point to different
1456 objects, 1 if they might be pointers to the same object. */
1459 base_alias_check (rtx x, rtx y, enum machine_mode x_mode,
1460 enum machine_mode y_mode)
1462 rtx x_base = find_base_term (x);
1463 rtx y_base = find_base_term (y);
1465 /* If the address itself has no known base see if a known equivalent
1466 value has one. If either address still has no known base, nothing
1467 is known about aliasing. */
1472 if (! flag_expensive_optimizations || (x_c = canon_rtx (x)) == x)
1475 x_base = find_base_term (x_c);
1483 if (! flag_expensive_optimizations || (y_c = canon_rtx (y)) == y)
1486 y_base = find_base_term (y_c);
1491 /* If the base addresses are equal nothing is known about aliasing. */
1492 if (rtx_equal_p (x_base, y_base))
1495 /* The base addresses of the read and write are different expressions.
1496 If they are both symbols and they are not accessed via AND, there is
1497 no conflict. We can bring knowledge of object alignment into play
1498 here. For example, on alpha, "char a, b;" can alias one another,
1499 though "char a; long b;" cannot. */
1500 if (GET_CODE (x_base) != ADDRESS && GET_CODE (y_base) != ADDRESS)
1502 if (GET_CODE (x) == AND && GET_CODE (y) == AND)
1504 if (GET_CODE (x) == AND
1505 && (GET_CODE (XEXP (x, 1)) != CONST_INT
1506 || (int) GET_MODE_UNIT_SIZE (y_mode) < -INTVAL (XEXP (x, 1))))
1508 if (GET_CODE (y) == AND
1509 && (GET_CODE (XEXP (y, 1)) != CONST_INT
1510 || (int) GET_MODE_UNIT_SIZE (x_mode) < -INTVAL (XEXP (y, 1))))
1512 /* Differing symbols never alias. */
1516 /* If one address is a stack reference there can be no alias:
1517 stack references using different base registers do not alias,
1518 a stack reference can not alias a parameter, and a stack reference
1519 can not alias a global. */
1520 if ((GET_CODE (x_base) == ADDRESS && GET_MODE (x_base) == Pmode)
1521 || (GET_CODE (y_base) == ADDRESS && GET_MODE (y_base) == Pmode))
1524 if (! flag_argument_noalias)
1527 if (flag_argument_noalias > 1)
1530 /* Weak noalias assertion (arguments are distinct, but may match globals). */
1531 return ! (GET_MODE (x_base) == VOIDmode && GET_MODE (y_base) == VOIDmode);
1534 /* Convert the address X into something we can use. This is done by returning
1535 it unchanged unless it is a value; in the latter case we call cselib to get
1536 a more useful rtx. */
1542 struct elt_loc_list *l;
1544 if (GET_CODE (x) != VALUE)
1546 v = CSELIB_VAL_PTR (x);
1549 for (l = v->locs; l; l = l->next)
1550 if (CONSTANT_P (l->loc))
1552 for (l = v->locs; l; l = l->next)
1553 if (!REG_P (l->loc) && !MEM_P (l->loc))
1556 return v->locs->loc;
1561 /* Return the address of the (N_REFS + 1)th memory reference to ADDR
1562 where SIZE is the size in bytes of the memory reference. If ADDR
1563 is not modified by the memory reference then ADDR is returned. */
1566 addr_side_effect_eval (rtx addr, int size, int n_refs)
1570 switch (GET_CODE (addr))
1573 offset = (n_refs + 1) * size;
1576 offset = -(n_refs + 1) * size;
1579 offset = n_refs * size;
1582 offset = -n_refs * size;
1590 addr = gen_rtx_PLUS (GET_MODE (addr), XEXP (addr, 0),
1593 addr = XEXP (addr, 0);
1594 addr = canon_rtx (addr);
1599 /* Return nonzero if X and Y (memory addresses) could reference the
1600 same location in memory. C is an offset accumulator. When
1601 C is nonzero, we are testing aliases between X and Y + C.
1602 XSIZE is the size in bytes of the X reference,
1603 similarly YSIZE is the size in bytes for Y.
1604 Expect that canon_rtx has been already called for X and Y.
1606 If XSIZE or YSIZE is zero, we do not know the amount of memory being
1607 referenced (the reference was BLKmode), so make the most pessimistic
1610 If XSIZE or YSIZE is negative, we may access memory outside the object
1611 being referenced as a side effect. This can happen when using AND to
1612 align memory references, as is done on the Alpha.
1614 Nice to notice that varying addresses cannot conflict with fp if no
1615 local variables had their addresses taken, but that's too hard now. */
1618 memrefs_conflict_p (int xsize, rtx x, int ysize, rtx y, HOST_WIDE_INT c)
1620 if (GET_CODE (x) == VALUE)
1622 if (GET_CODE (y) == VALUE)
1624 if (GET_CODE (x) == HIGH)
1626 else if (GET_CODE (x) == LO_SUM)
1629 x = addr_side_effect_eval (x, xsize, 0);
1630 if (GET_CODE (y) == HIGH)
1632 else if (GET_CODE (y) == LO_SUM)
1635 y = addr_side_effect_eval (y, ysize, 0);
1637 if (rtx_equal_for_memref_p (x, y))
1639 if (xsize <= 0 || ysize <= 0)
1641 if (c >= 0 && xsize > c)
1643 if (c < 0 && ysize+c > 0)
1648 /* This code used to check for conflicts involving stack references and
1649 globals but the base address alias code now handles these cases. */
1651 if (GET_CODE (x) == PLUS)
1653 /* The fact that X is canonicalized means that this
1654 PLUS rtx is canonicalized. */
1655 rtx x0 = XEXP (x, 0);
1656 rtx x1 = XEXP (x, 1);
1658 if (GET_CODE (y) == PLUS)
1660 /* The fact that Y is canonicalized means that this
1661 PLUS rtx is canonicalized. */
1662 rtx y0 = XEXP (y, 0);
1663 rtx y1 = XEXP (y, 1);
1665 if (rtx_equal_for_memref_p (x1, y1))
1666 return memrefs_conflict_p (xsize, x0, ysize, y0, c);
1667 if (rtx_equal_for_memref_p (x0, y0))
1668 return memrefs_conflict_p (xsize, x1, ysize, y1, c);
1669 if (GET_CODE (x1) == CONST_INT)
1671 if (GET_CODE (y1) == CONST_INT)
1672 return memrefs_conflict_p (xsize, x0, ysize, y0,
1673 c - INTVAL (x1) + INTVAL (y1));
1675 return memrefs_conflict_p (xsize, x0, ysize, y,
1678 else if (GET_CODE (y1) == CONST_INT)
1679 return memrefs_conflict_p (xsize, x, ysize, y0, c + INTVAL (y1));
1683 else if (GET_CODE (x1) == CONST_INT)
1684 return memrefs_conflict_p (xsize, x0, ysize, y, c - INTVAL (x1));
1686 else if (GET_CODE (y) == PLUS)
1688 /* The fact that Y is canonicalized means that this
1689 PLUS rtx is canonicalized. */
1690 rtx y0 = XEXP (y, 0);
1691 rtx y1 = XEXP (y, 1);
1693 if (GET_CODE (y1) == CONST_INT)
1694 return memrefs_conflict_p (xsize, x, ysize, y0, c + INTVAL (y1));
1699 if (GET_CODE (x) == GET_CODE (y))
1700 switch (GET_CODE (x))
1704 /* Handle cases where we expect the second operands to be the
1705 same, and check only whether the first operand would conflict
1708 rtx x1 = canon_rtx (XEXP (x, 1));
1709 rtx y1 = canon_rtx (XEXP (y, 1));
1710 if (! rtx_equal_for_memref_p (x1, y1))
1712 x0 = canon_rtx (XEXP (x, 0));
1713 y0 = canon_rtx (XEXP (y, 0));
1714 if (rtx_equal_for_memref_p (x0, y0))
1715 return (xsize == 0 || ysize == 0
1716 || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
1718 /* Can't properly adjust our sizes. */
1719 if (GET_CODE (x1) != CONST_INT)
1721 xsize /= INTVAL (x1);
1722 ysize /= INTVAL (x1);
1724 return memrefs_conflict_p (xsize, x0, ysize, y0, c);
1731 /* Treat an access through an AND (e.g. a subword access on an Alpha)
1732 as an access with indeterminate size. Assume that references
1733 besides AND are aligned, so if the size of the other reference is
1734 at least as large as the alignment, assume no other overlap. */
1735 if (GET_CODE (x) == AND && GET_CODE (XEXP (x, 1)) == CONST_INT)
1737 if (GET_CODE (y) == AND || ysize < -INTVAL (XEXP (x, 1)))
1739 return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)), ysize, y, c);
1741 if (GET_CODE (y) == AND && GET_CODE (XEXP (y, 1)) == CONST_INT)
1743 /* ??? If we are indexing far enough into the array/structure, we
1744 may yet be able to determine that we can not overlap. But we
1745 also need to that we are far enough from the end not to overlap
1746 a following reference, so we do nothing with that for now. */
1747 if (GET_CODE (x) == AND || xsize < -INTVAL (XEXP (y, 1)))
1749 return memrefs_conflict_p (xsize, x, ysize, canon_rtx (XEXP (y, 0)), c);
1754 if (GET_CODE (x) == CONST_INT && GET_CODE (y) == CONST_INT)
1756 c += (INTVAL (y) - INTVAL (x));
1757 return (xsize <= 0 || ysize <= 0
1758 || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
1761 if (GET_CODE (x) == CONST)
1763 if (GET_CODE (y) == CONST)
1764 return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)),
1765 ysize, canon_rtx (XEXP (y, 0)), c);
1767 return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)),
1770 if (GET_CODE (y) == CONST)
1771 return memrefs_conflict_p (xsize, x, ysize,
1772 canon_rtx (XEXP (y, 0)), c);
1775 return (xsize <= 0 || ysize <= 0
1776 || (rtx_equal_for_memref_p (x, y)
1777 && ((c >= 0 && xsize > c) || (c < 0 && ysize+c > 0))));
1784 /* Functions to compute memory dependencies.
1786 Since we process the insns in execution order, we can build tables
1787 to keep track of what registers are fixed (and not aliased), what registers
1788 are varying in known ways, and what registers are varying in unknown
1791 If both memory references are volatile, then there must always be a
1792 dependence between the two references, since their order can not be
1793 changed. A volatile and non-volatile reference can be interchanged
1796 A MEM_IN_STRUCT reference at a non-AND varying address can never
1797 conflict with a non-MEM_IN_STRUCT reference at a fixed address. We
1798 also must allow AND addresses, because they may generate accesses
1799 outside the object being referenced. This is used to generate
1800 aligned addresses from unaligned addresses, for instance, the alpha
1801 storeqi_unaligned pattern. */
1803 /* Read dependence: X is read after read in MEM takes place. There can
1804 only be a dependence here if both reads are volatile. */
1807 read_dependence (rtx mem, rtx x)
1809 return MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem);
1812 /* Returns MEM1 if and only if MEM1 is a scalar at a fixed address and
1813 MEM2 is a reference to a structure at a varying address, or returns
1814 MEM2 if vice versa. Otherwise, returns NULL_RTX. If a non-NULL
1815 value is returned MEM1 and MEM2 can never alias. VARIES_P is used
1816 to decide whether or not an address may vary; it should return
1817 nonzero whenever variation is possible.
1818 MEM1_ADDR and MEM2_ADDR are the addresses of MEM1 and MEM2. */
1821 fixed_scalar_and_varying_struct_p (rtx mem1, rtx mem2, rtx mem1_addr,
1823 int (*varies_p) (rtx, int))
1825 if (! flag_strict_aliasing)
1828 if (MEM_ALIAS_SET (mem2)
1829 && MEM_SCALAR_P (mem1) && MEM_IN_STRUCT_P (mem2)
1830 && !varies_p (mem1_addr, 1) && varies_p (mem2_addr, 1))
1831 /* MEM1 is a scalar at a fixed address; MEM2 is a struct at a
1835 if (MEM_ALIAS_SET (mem1)
1836 && MEM_IN_STRUCT_P (mem1) && MEM_SCALAR_P (mem2)
1837 && varies_p (mem1_addr, 1) && !varies_p (mem2_addr, 1))
1838 /* MEM2 is a scalar at a fixed address; MEM1 is a struct at a
1845 /* Returns nonzero if something about the mode or address format MEM1
1846 indicates that it might well alias *anything*. */
1849 aliases_everything_p (rtx mem)
1851 if (GET_CODE (XEXP (mem, 0)) == AND)
1852 /* If the address is an AND, it's very hard to know at what it is
1853 actually pointing. */
1859 /* Return true if we can determine that the fields referenced cannot
1860 overlap for any pair of objects. */
1863 nonoverlapping_component_refs_p (tree x, tree y)
1865 tree fieldx, fieldy, typex, typey, orig_y;
1869 /* The comparison has to be done at a common type, since we don't
1870 know how the inheritance hierarchy works. */
1874 fieldx = TREE_OPERAND (x, 1);
1875 typex = TYPE_MAIN_VARIANT (DECL_FIELD_CONTEXT (fieldx));
1880 fieldy = TREE_OPERAND (y, 1);
1881 typey = TYPE_MAIN_VARIANT (DECL_FIELD_CONTEXT (fieldy));
1886 y = TREE_OPERAND (y, 0);
1888 while (y && TREE_CODE (y) == COMPONENT_REF);
1890 x = TREE_OPERAND (x, 0);
1892 while (x && TREE_CODE (x) == COMPONENT_REF);
1893 /* Never found a common type. */
1897 /* If we're left with accessing different fields of a structure,
1899 if (TREE_CODE (typex) == RECORD_TYPE
1900 && fieldx != fieldy)
1903 /* The comparison on the current field failed. If we're accessing
1904 a very nested structure, look at the next outer level. */
1905 x = TREE_OPERAND (x, 0);
1906 y = TREE_OPERAND (y, 0);
1909 && TREE_CODE (x) == COMPONENT_REF
1910 && TREE_CODE (y) == COMPONENT_REF);
1915 /* Look at the bottom of the COMPONENT_REF list for a DECL, and return it. */
1918 decl_for_component_ref (tree x)
1922 x = TREE_OPERAND (x, 0);
1924 while (x && TREE_CODE (x) == COMPONENT_REF);
1926 return x && DECL_P (x) ? x : NULL_TREE;
1929 /* Walk up the COMPONENT_REF list and adjust OFFSET to compensate for the
1930 offset of the field reference. */
1933 adjust_offset_for_component_ref (tree x, rtx offset)
1935 HOST_WIDE_INT ioffset;
1940 ioffset = INTVAL (offset);
1943 tree offset = component_ref_field_offset (x);
1944 tree field = TREE_OPERAND (x, 1);
1946 if (! host_integerp (offset, 1))
1948 ioffset += (tree_low_cst (offset, 1)
1949 + (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1952 x = TREE_OPERAND (x, 0);
1954 while (x && TREE_CODE (x) == COMPONENT_REF);
1956 return GEN_INT (ioffset);
1959 /* Return nonzero if we can determine the exprs corresponding to memrefs
1960 X and Y and they do not overlap. */
1963 nonoverlapping_memrefs_p (rtx x, rtx y)
1965 tree exprx = MEM_EXPR (x), expry = MEM_EXPR (y);
1968 rtx moffsetx, moffsety;
1969 HOST_WIDE_INT offsetx = 0, offsety = 0, sizex, sizey, tem;
1971 /* Unless both have exprs, we can't tell anything. */
1972 if (exprx == 0 || expry == 0)
1975 /* If both are field references, we may be able to determine something. */
1976 if (TREE_CODE (exprx) == COMPONENT_REF
1977 && TREE_CODE (expry) == COMPONENT_REF
1978 && nonoverlapping_component_refs_p (exprx, expry))
1982 /* If the field reference test failed, look at the DECLs involved. */
1983 moffsetx = MEM_OFFSET (x);
1984 if (TREE_CODE (exprx) == COMPONENT_REF)
1986 if (TREE_CODE (expry) == VAR_DECL
1987 && POINTER_TYPE_P (TREE_TYPE (expry)))
1989 tree field = TREE_OPERAND (exprx, 1);
1990 tree fieldcontext = DECL_FIELD_CONTEXT (field);
1991 if (ipa_type_escape_field_does_not_clobber_p (fieldcontext,
1996 tree t = decl_for_component_ref (exprx);
1999 moffsetx = adjust_offset_for_component_ref (exprx, moffsetx);
2003 else if (INDIRECT_REF_P (exprx))
2005 exprx = TREE_OPERAND (exprx, 0);
2006 if (flag_argument_noalias < 2
2007 || TREE_CODE (exprx) != PARM_DECL)
2011 moffsety = MEM_OFFSET (y);
2012 if (TREE_CODE (expry) == COMPONENT_REF)
2014 if (TREE_CODE (exprx) == VAR_DECL
2015 && POINTER_TYPE_P (TREE_TYPE (exprx)))
2017 tree field = TREE_OPERAND (expry, 1);
2018 tree fieldcontext = DECL_FIELD_CONTEXT (field);
2019 if (ipa_type_escape_field_does_not_clobber_p (fieldcontext,
2024 tree t = decl_for_component_ref (expry);
2027 moffsety = adjust_offset_for_component_ref (expry, moffsety);
2031 else if (INDIRECT_REF_P (expry))
2033 expry = TREE_OPERAND (expry, 0);
2034 if (flag_argument_noalias < 2
2035 || TREE_CODE (expry) != PARM_DECL)
2039 if (! DECL_P (exprx) || ! DECL_P (expry))
2042 rtlx = DECL_RTL (exprx);
2043 rtly = DECL_RTL (expry);
2045 /* If either RTL is not a MEM, it must be a REG or CONCAT, meaning they
2046 can't overlap unless they are the same because we never reuse that part
2047 of the stack frame used for locals for spilled pseudos. */
2048 if ((!MEM_P (rtlx) || !MEM_P (rtly))
2049 && ! rtx_equal_p (rtlx, rtly))
2052 /* Get the base and offsets of both decls. If either is a register, we
2053 know both are and are the same, so use that as the base. The only
2054 we can avoid overlap is if we can deduce that they are nonoverlapping
2055 pieces of that decl, which is very rare. */
2056 basex = MEM_P (rtlx) ? XEXP (rtlx, 0) : rtlx;
2057 if (GET_CODE (basex) == PLUS && GET_CODE (XEXP (basex, 1)) == CONST_INT)
2058 offsetx = INTVAL (XEXP (basex, 1)), basex = XEXP (basex, 0);
2060 basey = MEM_P (rtly) ? XEXP (rtly, 0) : rtly;
2061 if (GET_CODE (basey) == PLUS && GET_CODE (XEXP (basey, 1)) == CONST_INT)
2062 offsety = INTVAL (XEXP (basey, 1)), basey = XEXP (basey, 0);
2064 /* If the bases are different, we know they do not overlap if both
2065 are constants or if one is a constant and the other a pointer into the
2066 stack frame. Otherwise a different base means we can't tell if they
2068 if (! rtx_equal_p (basex, basey))
2069 return ((CONSTANT_P (basex) && CONSTANT_P (basey))
2070 || (CONSTANT_P (basex) && REG_P (basey)
2071 && REGNO_PTR_FRAME_P (REGNO (basey)))
2072 || (CONSTANT_P (basey) && REG_P (basex)
2073 && REGNO_PTR_FRAME_P (REGNO (basex))));
2075 sizex = (!MEM_P (rtlx) ? (int) GET_MODE_SIZE (GET_MODE (rtlx))
2076 : MEM_SIZE (rtlx) ? INTVAL (MEM_SIZE (rtlx))
2078 sizey = (!MEM_P (rtly) ? (int) GET_MODE_SIZE (GET_MODE (rtly))
2079 : MEM_SIZE (rtly) ? INTVAL (MEM_SIZE (rtly)) :
2082 /* If we have an offset for either memref, it can update the values computed
2085 offsetx += INTVAL (moffsetx), sizex -= INTVAL (moffsetx);
2087 offsety += INTVAL (moffsety), sizey -= INTVAL (moffsety);
2089 /* If a memref has both a size and an offset, we can use the smaller size.
2090 We can't do this if the offset isn't known because we must view this
2091 memref as being anywhere inside the DECL's MEM. */
2092 if (MEM_SIZE (x) && moffsetx)
2093 sizex = INTVAL (MEM_SIZE (x));
2094 if (MEM_SIZE (y) && moffsety)
2095 sizey = INTVAL (MEM_SIZE (y));
2097 /* Put the values of the memref with the lower offset in X's values. */
2098 if (offsetx > offsety)
2100 tem = offsetx, offsetx = offsety, offsety = tem;
2101 tem = sizex, sizex = sizey, sizey = tem;
2104 /* If we don't know the size of the lower-offset value, we can't tell
2105 if they conflict. Otherwise, we do the test. */
2106 return sizex >= 0 && offsety >= offsetx + sizex;
2109 /* True dependence: X is read after store in MEM takes place. */
2112 true_dependence (rtx mem, enum machine_mode mem_mode, rtx x,
2113 int (*varies) (rtx, int))
2115 rtx x_addr, mem_addr;
2118 if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
2121 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
2122 This is used in epilogue deallocation functions, and in cselib. */
2123 if (GET_MODE (x) == BLKmode && GET_CODE (XEXP (x, 0)) == SCRATCH)
2125 if (GET_MODE (mem) == BLKmode && GET_CODE (XEXP (mem, 0)) == SCRATCH)
2127 if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER
2128 || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER)
2131 if (DIFFERENT_ALIAS_SETS_P (x, mem))
2134 /* Read-only memory is by definition never modified, and therefore can't
2135 conflict with anything. We don't expect to find read-only set on MEM,
2136 but stupid user tricks can produce them, so don't die. */
2137 if (MEM_READONLY_P (x))
2140 if (nonoverlapping_memrefs_p (mem, x))
2143 if (mem_mode == VOIDmode)
2144 mem_mode = GET_MODE (mem);
2146 x_addr = get_addr (XEXP (x, 0));
2147 mem_addr = get_addr (XEXP (mem, 0));
2149 base = find_base_term (x_addr);
2150 if (base && (GET_CODE (base) == LABEL_REF
2151 || (GET_CODE (base) == SYMBOL_REF
2152 && CONSTANT_POOL_ADDRESS_P (base))))
2155 if (! base_alias_check (x_addr, mem_addr, GET_MODE (x), mem_mode))
2158 x_addr = canon_rtx (x_addr);
2159 mem_addr = canon_rtx (mem_addr);
2161 if (! memrefs_conflict_p (GET_MODE_SIZE (mem_mode), mem_addr,
2162 SIZE_FOR_MODE (x), x_addr, 0))
2165 if (aliases_everything_p (x))
2168 /* We cannot use aliases_everything_p to test MEM, since we must look
2169 at MEM_MODE, rather than GET_MODE (MEM). */
2170 if (mem_mode == QImode || GET_CODE (mem_addr) == AND)
2173 /* In true_dependence we also allow BLKmode to alias anything. Why
2174 don't we do this in anti_dependence and output_dependence? */
2175 if (mem_mode == BLKmode || GET_MODE (x) == BLKmode)
2178 return ! fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr,
2182 /* Canonical true dependence: X is read after store in MEM takes place.
2183 Variant of true_dependence which assumes MEM has already been
2184 canonicalized (hence we no longer do that here).
2185 The mem_addr argument has been added, since true_dependence computed
2186 this value prior to canonicalizing. */
2189 canon_true_dependence (rtx mem, enum machine_mode mem_mode, rtx mem_addr,
2190 rtx x, int (*varies) (rtx, int))
2194 if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
2197 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
2198 This is used in epilogue deallocation functions. */
2199 if (GET_MODE (x) == BLKmode && GET_CODE (XEXP (x, 0)) == SCRATCH)
2201 if (GET_MODE (mem) == BLKmode && GET_CODE (XEXP (mem, 0)) == SCRATCH)
2203 if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER
2204 || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER)
2207 if (DIFFERENT_ALIAS_SETS_P (x, mem))
2210 /* Read-only memory is by definition never modified, and therefore can't
2211 conflict with anything. We don't expect to find read-only set on MEM,
2212 but stupid user tricks can produce them, so don't die. */
2213 if (MEM_READONLY_P (x))
2216 if (nonoverlapping_memrefs_p (x, mem))
2219 x_addr = get_addr (XEXP (x, 0));
2221 if (! base_alias_check (x_addr, mem_addr, GET_MODE (x), mem_mode))
2224 x_addr = canon_rtx (x_addr);
2225 if (! memrefs_conflict_p (GET_MODE_SIZE (mem_mode), mem_addr,
2226 SIZE_FOR_MODE (x), x_addr, 0))
2229 if (aliases_everything_p (x))
2232 /* We cannot use aliases_everything_p to test MEM, since we must look
2233 at MEM_MODE, rather than GET_MODE (MEM). */
2234 if (mem_mode == QImode || GET_CODE (mem_addr) == AND)
2237 /* In true_dependence we also allow BLKmode to alias anything. Why
2238 don't we do this in anti_dependence and output_dependence? */
2239 if (mem_mode == BLKmode || GET_MODE (x) == BLKmode)
2242 return ! fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr,
2246 /* Returns nonzero if a write to X might alias a previous read from
2247 (or, if WRITEP is nonzero, a write to) MEM. */
2250 write_dependence_p (rtx mem, rtx x, int writep)
2252 rtx x_addr, mem_addr;
2256 if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
2259 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
2260 This is used in epilogue deallocation functions. */
2261 if (GET_MODE (x) == BLKmode && GET_CODE (XEXP (x, 0)) == SCRATCH)
2263 if (GET_MODE (mem) == BLKmode && GET_CODE (XEXP (mem, 0)) == SCRATCH)
2265 if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER
2266 || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER)
2269 if (DIFFERENT_ALIAS_SETS_P (x, mem))
2272 /* A read from read-only memory can't conflict with read-write memory. */
2273 if (!writep && MEM_READONLY_P (mem))
2276 if (nonoverlapping_memrefs_p (x, mem))
2279 x_addr = get_addr (XEXP (x, 0));
2280 mem_addr = get_addr (XEXP (mem, 0));
2284 base = find_base_term (mem_addr);
2285 if (base && (GET_CODE (base) == LABEL_REF
2286 || (GET_CODE (base) == SYMBOL_REF
2287 && CONSTANT_POOL_ADDRESS_P (base))))
2291 if (! base_alias_check (x_addr, mem_addr, GET_MODE (x),
2295 x_addr = canon_rtx (x_addr);
2296 mem_addr = canon_rtx (mem_addr);
2298 if (!memrefs_conflict_p (SIZE_FOR_MODE (mem), mem_addr,
2299 SIZE_FOR_MODE (x), x_addr, 0))
2303 = fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr,
2306 return (!(fixed_scalar == mem && !aliases_everything_p (x))
2307 && !(fixed_scalar == x && !aliases_everything_p (mem)));
2310 /* Anti dependence: X is written after read in MEM takes place. */
2313 anti_dependence (rtx mem, rtx x)
2315 return write_dependence_p (mem, x, /*writep=*/0);
2318 /* Output dependence: X is written after store in MEM takes place. */
2321 output_dependence (rtx mem, rtx x)
2323 return write_dependence_p (mem, x, /*writep=*/1);
2328 init_alias_once (void)
2332 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2333 /* Check whether this register can hold an incoming pointer
2334 argument. FUNCTION_ARG_REGNO_P tests outgoing register
2335 numbers, so translate if necessary due to register windows. */
2336 if (FUNCTION_ARG_REGNO_P (OUTGOING_REGNO (i))
2337 && HARD_REGNO_MODE_OK (i, Pmode))
2338 static_reg_base_value[i]
2339 = gen_rtx_ADDRESS (VOIDmode, gen_rtx_REG (Pmode, i));
2341 static_reg_base_value[STACK_POINTER_REGNUM]
2342 = gen_rtx_ADDRESS (Pmode, stack_pointer_rtx);
2343 static_reg_base_value[ARG_POINTER_REGNUM]
2344 = gen_rtx_ADDRESS (Pmode, arg_pointer_rtx);
2345 static_reg_base_value[FRAME_POINTER_REGNUM]
2346 = gen_rtx_ADDRESS (Pmode, frame_pointer_rtx);
2347 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
2348 static_reg_base_value[HARD_FRAME_POINTER_REGNUM]
2349 = gen_rtx_ADDRESS (Pmode, hard_frame_pointer_rtx);
2353 /* Set MEMORY_MODIFIED when X modifies DATA (that is assumed
2354 to be memory reference. */
2355 static bool memory_modified;
2357 memory_modified_1 (rtx x, rtx pat ATTRIBUTE_UNUSED, void *data)
2361 if (anti_dependence (x, (rtx)data) || output_dependence (x, (rtx)data))
2362 memory_modified = true;
2367 /* Return true when INSN possibly modify memory contents of MEM
2368 (i.e. address can be modified). */
2370 memory_modified_in_insn_p (rtx mem, rtx insn)
2374 memory_modified = false;
2375 note_stores (PATTERN (insn), memory_modified_1, mem);
2376 return memory_modified;
2379 /* Initialize the aliasing machinery. Initialize the REG_KNOWN_VALUE
2383 init_alias_analysis (void)
2385 unsigned int maxreg = max_reg_num ();
2391 timevar_push (TV_ALIAS_ANALYSIS);
2393 reg_known_value_size = maxreg - FIRST_PSEUDO_REGISTER;
2394 reg_known_value = ggc_calloc (reg_known_value_size, sizeof (rtx));
2395 reg_known_equiv_p = xcalloc (reg_known_value_size, sizeof (bool));
2397 /* If we have memory allocated from the previous run, use it. */
2398 if (old_reg_base_value)
2399 reg_base_value = old_reg_base_value;
2402 VEC_truncate (rtx, reg_base_value, 0);
2404 VEC_safe_grow_cleared (rtx, gc, reg_base_value, maxreg);
2406 new_reg_base_value = XNEWVEC (rtx, maxreg);
2407 reg_seen = XNEWVEC (char, maxreg);
2409 /* The basic idea is that each pass through this loop will use the
2410 "constant" information from the previous pass to propagate alias
2411 information through another level of assignments.
2413 This could get expensive if the assignment chains are long. Maybe
2414 we should throttle the number of iterations, possibly based on
2415 the optimization level or flag_expensive_optimizations.
2417 We could propagate more information in the first pass by making use
2418 of DF_REG_DEF_COUNT to determine immediately that the alias information
2419 for a pseudo is "constant".
2421 A program with an uninitialized variable can cause an infinite loop
2422 here. Instead of doing a full dataflow analysis to detect such problems
2423 we just cap the number of iterations for the loop.
2425 The state of the arrays for the set chain in question does not matter
2426 since the program has undefined behavior. */
2431 /* Assume nothing will change this iteration of the loop. */
2434 /* We want to assign the same IDs each iteration of this loop, so
2435 start counting from zero each iteration of the loop. */
2438 /* We're at the start of the function each iteration through the
2439 loop, so we're copying arguments. */
2440 copying_arguments = true;
2442 /* Wipe the potential alias information clean for this pass. */
2443 memset (new_reg_base_value, 0, maxreg * sizeof (rtx));
2445 /* Wipe the reg_seen array clean. */
2446 memset (reg_seen, 0, maxreg);
2448 /* Mark all hard registers which may contain an address.
2449 The stack, frame and argument pointers may contain an address.
2450 An argument register which can hold a Pmode value may contain
2451 an address even if it is not in BASE_REGS.
2453 The address expression is VOIDmode for an argument and
2454 Pmode for other registers. */
2456 memcpy (new_reg_base_value, static_reg_base_value,
2457 FIRST_PSEUDO_REGISTER * sizeof (rtx));
2459 /* Walk the insns adding values to the new_reg_base_value array. */
2460 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2466 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
2467 /* The prologue/epilogue insns are not threaded onto the
2468 insn chain until after reload has completed. Thus,
2469 there is no sense wasting time checking if INSN is in
2470 the prologue/epilogue until after reload has completed. */
2471 if (reload_completed
2472 && prologue_epilogue_contains (insn))
2476 /* If this insn has a noalias note, process it, Otherwise,
2477 scan for sets. A simple set will have no side effects
2478 which could change the base value of any other register. */
2480 if (GET_CODE (PATTERN (insn)) == SET
2481 && REG_NOTES (insn) != 0
2482 && find_reg_note (insn, REG_NOALIAS, NULL_RTX))
2483 record_set (SET_DEST (PATTERN (insn)), NULL_RTX, NULL);
2485 note_stores (PATTERN (insn), record_set, NULL);
2487 set = single_set (insn);
2490 && REG_P (SET_DEST (set))
2491 && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
2493 unsigned int regno = REGNO (SET_DEST (set));
2494 rtx src = SET_SRC (set);
2497 note = find_reg_equal_equiv_note (insn);
2498 if (note && REG_NOTE_KIND (note) == REG_EQUAL
2499 && DF_REG_DEF_COUNT (regno) != 1)
2502 if (note != NULL_RTX
2503 && GET_CODE (XEXP (note, 0)) != EXPR_LIST
2504 && ! rtx_varies_p (XEXP (note, 0), 1)
2505 && ! reg_overlap_mentioned_p (SET_DEST (set),
2508 set_reg_known_value (regno, XEXP (note, 0));
2509 set_reg_known_equiv_p (regno,
2510 REG_NOTE_KIND (note) == REG_EQUIV);
2512 else if (DF_REG_DEF_COUNT (regno) == 1
2513 && GET_CODE (src) == PLUS
2514 && REG_P (XEXP (src, 0))
2515 && (t = get_reg_known_value (REGNO (XEXP (src, 0))))
2516 && GET_CODE (XEXP (src, 1)) == CONST_INT)
2518 t = plus_constant (t, INTVAL (XEXP (src, 1)));
2519 set_reg_known_value (regno, t);
2520 set_reg_known_equiv_p (regno, 0);
2522 else if (DF_REG_DEF_COUNT (regno) == 1
2523 && ! rtx_varies_p (src, 1))
2525 set_reg_known_value (regno, src);
2526 set_reg_known_equiv_p (regno, 0);
2530 else if (NOTE_P (insn)
2531 && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
2532 copying_arguments = false;
2535 /* Now propagate values from new_reg_base_value to reg_base_value. */
2536 gcc_assert (maxreg == (unsigned int) max_reg_num ());
2538 for (ui = 0; ui < maxreg; ui++)
2540 if (new_reg_base_value[ui]
2541 && new_reg_base_value[ui] != VEC_index (rtx, reg_base_value, ui)
2542 && ! rtx_equal_p (new_reg_base_value[ui],
2543 VEC_index (rtx, reg_base_value, ui)))
2545 VEC_replace (rtx, reg_base_value, ui, new_reg_base_value[ui]);
2550 while (changed && ++pass < MAX_ALIAS_LOOP_PASSES);
2552 /* Fill in the remaining entries. */
2553 for (i = 0; i < (int)reg_known_value_size; i++)
2554 if (reg_known_value[i] == 0)
2555 reg_known_value[i] = regno_reg_rtx[i + FIRST_PSEUDO_REGISTER];
2558 free (new_reg_base_value);
2559 new_reg_base_value = 0;
2562 timevar_pop (TV_ALIAS_ANALYSIS);
2566 end_alias_analysis (void)
2568 old_reg_base_value = reg_base_value;
2569 ggc_free (reg_known_value);
2570 reg_known_value = 0;
2571 reg_known_value_size = 0;
2572 free (reg_known_equiv_p);
2573 reg_known_equiv_p = 0;
2576 #include "gt-alias.h"