1 /* Alias analysis for GNU C
2 Copyright (C) 1997-2015 Free Software Foundation, Inc.
3 Contributed by John Carr (jfc@mit.edu).
5 This file is part of GCC.
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
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
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/>. */
23 #include "coretypes.h"
29 #include "fold-const.h"
31 #include "hard-reg-set.h"
34 #include "insn-config.h"
44 #include "diagnostic-core.h"
45 #include "alloc-pool.h"
47 #include "langhooks.h"
51 #include "dominance.h"
55 #include "basic-block.h"
57 #include "tree-ssa-alias.h"
58 #include "internal-fn.h"
59 #include "gimple-expr.h"
61 #include "gimple-ssa.h"
64 /* The aliasing API provided here solves related but different problems:
66 Say there exists (in c)
80 Consider the four questions:
82 Can a store to x1 interfere with px2->y1?
83 Can a store to x1 interfere with px2->z2?
84 Can a store to x1 change the value pointed to by with py?
85 Can a store to x1 change the value pointed to by with pz?
87 The answer to these questions can be yes, yes, yes, and maybe.
89 The first two questions can be answered with a simple examination
90 of the type system. If structure X contains a field of type Y then
91 a store through a pointer to an X can overwrite any field that is
92 contained (recursively) in an X (unless we know that px1 != px2).
94 The last two questions can be solved in the same way as the first
95 two questions but this is too conservative. The observation is
96 that in some cases we can know which (if any) fields are addressed
97 and if those addresses are used in bad ways. This analysis may be
98 language specific. In C, arbitrary operations may be applied to
99 pointers. However, there is some indication that this may be too
100 conservative for some C++ types.
102 The pass ipa-type-escape does this analysis for the types whose
103 instances do not escape across the compilation boundary.
105 Historically in GCC, these two problems were combined and a single
106 data structure that was used to represent the solution to these
107 problems. We now have two similar but different data structures,
108 The data structure to solve the last two questions is similar to
109 the first, but does not contain the fields whose address are never
110 taken. For types that do escape the compilation unit, the data
111 structures will have identical information.
114 /* The alias sets assigned to MEMs assist the back-end in determining
115 which MEMs can alias which other MEMs. In general, two MEMs in
116 different alias sets cannot alias each other, with one important
117 exception. Consider something like:
119 struct S { int i; double d; };
121 a store to an `S' can alias something of either type `int' or type
122 `double'. (However, a store to an `int' cannot alias a `double'
123 and vice versa.) We indicate this via a tree structure that looks
131 (The arrows are directed and point downwards.)
132 In this situation we say the alias set for `struct S' is the
133 `superset' and that those for `int' and `double' are `subsets'.
135 To see whether two alias sets can point to the same memory, we must
136 see if either alias set is a subset of the other. We need not trace
137 past immediate descendants, however, since we propagate all
138 grandchildren up one level.
140 Alias set zero is implicitly a superset of all other alias sets.
141 However, this is no actual entry for alias set zero. It is an
142 error to attempt to explicitly construct a subset of zero. */
144 struct alias_set_hash
: int_hash
<int, INT_MIN
, INT_MIN
+ 1> {};
145 struct alias_set_traits
: simple_hashmap_traits
<alias_set_hash
> {};
147 struct GTY(()) alias_set_entry_d
{
148 /* The alias set number, as stored in MEM_ALIAS_SET. */
149 alias_set_type alias_set
;
151 /* The children of the alias set. These are not just the immediate
152 children, but, in fact, all descendants. So, if we have:
154 struct T { struct S s; float f; }
156 continuing our example above, the children here will be all of
157 `int', `double', `float', and `struct S'. */
158 hash_map
<int, int, alias_set_traits
> *children
;
160 /* Nonzero if would have a child of zero: this effectively makes this
161 alias set the same as alias set zero. */
163 /* Nonzero if alias set corresponds to pointer type itself (i.e. not to
164 aggregate contaiing pointer.
165 This is used for a special case where we need an universal pointer type
166 compatible with all other pointer types. */
168 /* Nonzero if is_pointer or if one of childs have has_pointer set. */
171 typedef struct alias_set_entry_d
*alias_set_entry
;
173 static int rtx_equal_for_memref_p (const_rtx
, const_rtx
);
174 static int memrefs_conflict_p (int, rtx
, int, rtx
, HOST_WIDE_INT
);
175 static void record_set (rtx
, const_rtx
, void *);
176 static int base_alias_check (rtx
, rtx
, rtx
, rtx
, machine_mode
,
178 static rtx
find_base_value (rtx
);
179 static int mems_in_disjoint_alias_sets_p (const_rtx
, const_rtx
);
180 static alias_set_entry
get_alias_set_entry (alias_set_type
);
181 static tree
decl_for_component_ref (tree
);
182 static int write_dependence_p (const_rtx
,
183 const_rtx
, machine_mode
, rtx
,
186 static void memory_modified_1 (rtx
, const_rtx
, void *);
188 /* Query statistics for the different low-level disambiguators.
189 A high-level query may trigger multiple of them. */
192 unsigned long long num_alias_zero
;
193 unsigned long long num_same_alias_set
;
194 unsigned long long num_same_objects
;
195 unsigned long long num_volatile
;
196 unsigned long long num_dag
;
197 unsigned long long num_universal
;
198 unsigned long long num_disambiguated
;
202 /* Set up all info needed to perform alias analysis on memory references. */
204 /* Returns the size in bytes of the mode of X. */
205 #define SIZE_FOR_MODE(X) (GET_MODE_SIZE (GET_MODE (X)))
207 /* Cap the number of passes we make over the insns propagating alias
208 information through set chains.
209 ??? 10 is a completely arbitrary choice. This should be based on the
210 maximum loop depth in the CFG, but we do not have this information
211 available (even if current_loops _is_ available). */
212 #define MAX_ALIAS_LOOP_PASSES 10
214 /* reg_base_value[N] gives an address to which register N is related.
215 If all sets after the first add or subtract to the current value
216 or otherwise modify it so it does not point to a different top level
217 object, reg_base_value[N] is equal to the address part of the source
220 A base address can be an ADDRESS, SYMBOL_REF, or LABEL_REF. ADDRESS
221 expressions represent three types of base:
223 1. incoming arguments. There is just one ADDRESS to represent all
224 arguments, since we do not know at this level whether accesses
225 based on different arguments can alias. The ADDRESS has id 0.
227 2. stack_pointer_rtx, frame_pointer_rtx, hard_frame_pointer_rtx
228 (if distinct from frame_pointer_rtx) and arg_pointer_rtx.
229 Each of these rtxes has a separate ADDRESS associated with it,
230 each with a negative id.
232 GCC is (and is required to be) precise in which register it
233 chooses to access a particular region of stack. We can therefore
234 assume that accesses based on one of these rtxes do not alias
235 accesses based on another of these rtxes.
237 3. bases that are derived from malloc()ed memory (REG_NOALIAS).
238 Each such piece of memory has a separate ADDRESS associated
239 with it, each with an id greater than 0.
241 Accesses based on one ADDRESS do not alias accesses based on other
242 ADDRESSes. Accesses based on ADDRESSes in groups (2) and (3) do not
243 alias globals either; the ADDRESSes have Pmode to indicate this.
244 The ADDRESS in group (1) _may_ alias globals; it has VOIDmode to
247 static GTY(()) vec
<rtx
, va_gc
> *reg_base_value
;
248 static rtx
*new_reg_base_value
;
250 /* The single VOIDmode ADDRESS that represents all argument bases.
252 static GTY(()) rtx arg_base_value
;
254 /* Used to allocate unique ids to each REG_NOALIAS ADDRESS. */
255 static int unique_id
;
257 /* We preserve the copy of old array around to avoid amount of garbage
258 produced. About 8% of garbage produced were attributed to this
260 static GTY((deletable
)) vec
<rtx
, va_gc
> *old_reg_base_value
;
262 /* Values of XINT (address, 0) of Pmode ADDRESS rtxes for special
264 #define UNIQUE_BASE_VALUE_SP -1
265 #define UNIQUE_BASE_VALUE_ARGP -2
266 #define UNIQUE_BASE_VALUE_FP -3
267 #define UNIQUE_BASE_VALUE_HFP -4
269 #define static_reg_base_value \
270 (this_target_rtl->x_static_reg_base_value)
272 #define REG_BASE_VALUE(X) \
273 (REGNO (X) < vec_safe_length (reg_base_value) \
274 ? (*reg_base_value)[REGNO (X)] : 0)
276 /* Vector indexed by N giving the initial (unchanging) value known for
277 pseudo-register N. This vector is initialized in init_alias_analysis,
278 and does not change until end_alias_analysis is called. */
279 static GTY(()) vec
<rtx
, va_gc
> *reg_known_value
;
281 /* Vector recording for each reg_known_value whether it is due to a
282 REG_EQUIV note. Future passes (viz., reload) may replace the
283 pseudo with the equivalent expression and so we account for the
284 dependences that would be introduced if that happens.
286 The REG_EQUIV notes created in assign_parms may mention the arg
287 pointer, and there are explicit insns in the RTL that modify the
288 arg pointer. Thus we must ensure that such insns don't get
289 scheduled across each other because that would invalidate the
290 REG_EQUIV notes. One could argue that the REG_EQUIV notes are
291 wrong, but solving the problem in the scheduler will likely give
292 better code, so we do it here. */
293 static sbitmap reg_known_equiv_p
;
295 /* True when scanning insns from the start of the rtl to the
296 NOTE_INSN_FUNCTION_BEG note. */
297 static bool copying_arguments
;
300 /* The splay-tree used to store the various alias set entries. */
301 static GTY (()) vec
<alias_set_entry
, va_gc
> *alias_sets
;
303 /* Build a decomposed reference object for querying the alias-oracle
304 from the MEM rtx and store it in *REF.
305 Returns false if MEM is not suitable for the alias-oracle. */
308 ao_ref_from_mem (ao_ref
*ref
, const_rtx mem
)
310 tree expr
= MEM_EXPR (mem
);
316 ao_ref_init (ref
, expr
);
318 /* Get the base of the reference and see if we have to reject or
320 base
= ao_ref_base (ref
);
321 if (base
== NULL_TREE
)
324 /* The tree oracle doesn't like bases that are neither decls
325 nor indirect references of SSA names. */
327 || (TREE_CODE (base
) == MEM_REF
328 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
)
329 || (TREE_CODE (base
) == TARGET_MEM_REF
330 && TREE_CODE (TMR_BASE (base
)) == SSA_NAME
)))
333 /* If this is a reference based on a partitioned decl replace the
334 base with a MEM_REF of the pointer representative we
335 created during stack slot partitioning. */
336 if (TREE_CODE (base
) == VAR_DECL
337 && ! is_global_var (base
)
338 && cfun
->gimple_df
->decls_to_pointers
!= NULL
)
340 tree
*namep
= cfun
->gimple_df
->decls_to_pointers
->get (base
);
342 ref
->base
= build_simple_mem_ref (*namep
);
345 ref
->ref_alias_set
= MEM_ALIAS_SET (mem
);
347 /* If MEM_OFFSET or MEM_SIZE are unknown what we got from MEM_EXPR
348 is conservative, so trust it. */
349 if (!MEM_OFFSET_KNOWN_P (mem
)
350 || !MEM_SIZE_KNOWN_P (mem
))
353 /* If the base decl is a parameter we can have negative MEM_OFFSET in
354 case of promoted subregs on bigendian targets. Trust the MEM_EXPR
356 if (MEM_OFFSET (mem
) < 0
357 && (MEM_SIZE (mem
) + MEM_OFFSET (mem
)) * BITS_PER_UNIT
== ref
->size
)
360 /* Otherwise continue and refine size and offset we got from analyzing
361 MEM_EXPR by using MEM_SIZE and MEM_OFFSET. */
363 ref
->offset
+= MEM_OFFSET (mem
) * BITS_PER_UNIT
;
364 ref
->size
= MEM_SIZE (mem
) * BITS_PER_UNIT
;
366 /* The MEM may extend into adjacent fields, so adjust max_size if
368 if (ref
->max_size
!= -1
369 && ref
->size
> ref
->max_size
)
370 ref
->max_size
= ref
->size
;
372 /* If MEM_OFFSET and MEM_SIZE get us outside of the base object of
373 the MEM_EXPR punt. This happens for STRICT_ALIGNMENT targets a lot. */
374 if (MEM_EXPR (mem
) != get_spill_slot_decl (false)
376 || (DECL_P (ref
->base
)
377 && (DECL_SIZE (ref
->base
) == NULL_TREE
378 || TREE_CODE (DECL_SIZE (ref
->base
)) != INTEGER_CST
379 || wi::ltu_p (wi::to_offset (DECL_SIZE (ref
->base
)),
380 ref
->offset
+ ref
->size
)))))
386 /* Query the alias-oracle on whether the two memory rtx X and MEM may
387 alias. If TBAA_P is set also apply TBAA. Returns true if the
388 two rtxen may alias, false otherwise. */
391 rtx_refs_may_alias_p (const_rtx x
, const_rtx mem
, bool tbaa_p
)
395 if (!ao_ref_from_mem (&ref1
, x
)
396 || !ao_ref_from_mem (&ref2
, mem
))
399 return refs_may_alias_p_1 (&ref1
, &ref2
,
401 && MEM_ALIAS_SET (x
) != 0
402 && MEM_ALIAS_SET (mem
) != 0);
405 /* Returns a pointer to the alias set entry for ALIAS_SET, if there is
406 such an entry, or NULL otherwise. */
408 static inline alias_set_entry
409 get_alias_set_entry (alias_set_type alias_set
)
411 return (*alias_sets
)[alias_set
];
414 /* Returns nonzero if the alias sets for MEM1 and MEM2 are such that
415 the two MEMs cannot alias each other. */
418 mems_in_disjoint_alias_sets_p (const_rtx mem1
, const_rtx mem2
)
420 return (flag_strict_aliasing
421 && ! alias_sets_conflict_p (MEM_ALIAS_SET (mem1
),
422 MEM_ALIAS_SET (mem2
)));
425 /* Return true if the first alias set is a subset of the second. */
428 alias_set_subset_of (alias_set_type set1
, alias_set_type set2
)
430 alias_set_entry ase2
;
432 /* Everything is a subset of the "aliases everything" set. */
436 /* Check if set1 is a subset of set2. */
437 ase2
= get_alias_set_entry (set2
);
439 && (ase2
->has_zero_child
440 || (ase2
->children
&& ase2
->children
->get (set1
))))
443 /* As a special case we consider alias set of "void *" to be both subset
444 and superset of every alias set of a pointer. This extra symmetry does
445 not matter for alias_sets_conflict_p but it makes aliasing_component_refs_p
446 to return true on the following testcase:
449 char **ptr2=(char **)&ptr;
452 Additionally if a set contains universal pointer, we consider every pointer
453 to be a subset of it, but we do not represent this explicitely - doing so
454 would require us to update transitive closure each time we introduce new
455 pointer type. This makes aliasing_component_refs_p to return true
456 on the following testcase:
458 struct a {void *ptr;}
459 char **ptr = (char **)&a.ptr;
462 This makes void * truly universal pointer type. See pointer handling in
463 get_alias_set for more details. */
464 if (ase2
&& ase2
->has_pointer
)
466 alias_set_entry ase1
= get_alias_set_entry (set1
);
468 if (ase1
&& ase1
->is_pointer
)
470 alias_set_type voidptr_set
= TYPE_ALIAS_SET (ptr_type_node
);
471 /* If one is ptr_type_node and other is pointer, then we consider
472 them subset of each other. */
473 if (set1
== voidptr_set
|| set2
== voidptr_set
)
475 /* If SET2 contains universal pointer's alias set, then we consdier
476 every (non-universal) pointer. */
477 if (ase2
->children
&& set1
!= voidptr_set
478 && ase2
->children
->get (voidptr_set
))
485 /* Return 1 if the two specified alias sets may conflict. */
488 alias_sets_conflict_p (alias_set_type set1
, alias_set_type set2
)
490 alias_set_entry ase1
;
491 alias_set_entry ase2
;
494 if (alias_sets_must_conflict_p (set1
, set2
))
497 /* See if the first alias set is a subset of the second. */
498 ase1
= get_alias_set_entry (set1
);
500 && ase1
->children
&& ase1
->children
->get (set2
))
502 ++alias_stats
.num_dag
;
506 /* Now do the same, but with the alias sets reversed. */
507 ase2
= get_alias_set_entry (set2
);
509 && ase2
->children
&& ase2
->children
->get (set1
))
511 ++alias_stats
.num_dag
;
515 /* We want void * to be compatible with any other pointer without
516 really dropping it to alias set 0. Doing so would make it
517 compatible with all non-pointer types too.
519 This is not strictly necessary by the C/C++ language
520 standards, but avoids common type punning mistakes. In
521 addition to that, we need the existence of such universal
522 pointer to implement Fortran's C_PTR type (which is defined as
523 type compatible with all C pointers). */
524 if (ase1
&& ase2
&& ase1
->has_pointer
&& ase2
->has_pointer
)
526 alias_set_type voidptr_set
= TYPE_ALIAS_SET (ptr_type_node
);
528 /* If one of the sets corresponds to universal pointer,
529 we consider it to conflict with anything that is
530 or contains pointer. */
531 if (set1
== voidptr_set
|| set2
== voidptr_set
)
533 ++alias_stats
.num_universal
;
536 /* If one of sets is (non-universal) pointer and the other
537 contains universal pointer, we also get conflict. */
538 if (ase1
->is_pointer
&& set2
!= voidptr_set
539 && ase2
->children
&& ase2
->children
->get (voidptr_set
))
541 ++alias_stats
.num_universal
;
544 if (ase2
->is_pointer
&& set1
!= voidptr_set
545 && ase1
->children
&& ase1
->children
->get (voidptr_set
))
547 ++alias_stats
.num_universal
;
552 ++alias_stats
.num_disambiguated
;
554 /* The two alias sets are distinct and neither one is the
555 child of the other. Therefore, they cannot conflict. */
559 /* Return 1 if the two specified alias sets will always conflict. */
562 alias_sets_must_conflict_p (alias_set_type set1
, alias_set_type set2
)
564 if (set1
== 0 || set2
== 0)
566 ++alias_stats
.num_alias_zero
;
571 ++alias_stats
.num_same_alias_set
;
578 /* Return 1 if any MEM object of type T1 will always conflict (using the
579 dependency routines in this file) with any MEM object of type T2.
580 This is used when allocating temporary storage. If T1 and/or T2 are
581 NULL_TREE, it means we know nothing about the storage. */
584 objects_must_conflict_p (tree t1
, tree t2
)
586 alias_set_type set1
, set2
;
588 /* If neither has a type specified, we don't know if they'll conflict
589 because we may be using them to store objects of various types, for
590 example the argument and local variables areas of inlined functions. */
591 if (t1
== 0 && t2
== 0)
594 /* If they are the same type, they must conflict. */
597 ++alias_stats
.num_same_objects
;
600 /* Likewise if both are volatile. */
601 if (t1
!= 0 && TYPE_VOLATILE (t1
) && t2
!= 0 && TYPE_VOLATILE (t2
))
603 ++alias_stats
.num_volatile
;
607 set1
= t1
? get_alias_set (t1
) : 0;
608 set2
= t2
? get_alias_set (t2
) : 0;
610 /* We can't use alias_sets_conflict_p because we must make sure
611 that every subtype of t1 will conflict with every subtype of
612 t2 for which a pair of subobjects of these respective subtypes
613 overlaps on the stack. */
614 return alias_sets_must_conflict_p (set1
, set2
);
617 /* Return the outermost parent of component present in the chain of
618 component references handled by get_inner_reference in T with the
620 - the component is non-addressable, or
621 - the parent has alias set zero,
622 or NULL_TREE if no such parent exists. In the former cases, the alias
623 set of this parent is the alias set that must be used for T itself. */
626 component_uses_parent_alias_set_from (const_tree t
)
628 const_tree found
= NULL_TREE
;
630 while (handled_component_p (t
))
632 switch (TREE_CODE (t
))
635 if (DECL_NONADDRESSABLE_P (TREE_OPERAND (t
, 1)))
640 case ARRAY_RANGE_REF
:
641 if (TYPE_NONALIASED_COMPONENT (TREE_TYPE (TREE_OPERAND (t
, 0))))
650 case VIEW_CONVERT_EXPR
:
651 /* Bitfields and casts are never addressable. */
659 if (get_alias_set (TREE_TYPE (TREE_OPERAND (t
, 0))) == 0)
662 t
= TREE_OPERAND (t
, 0);
666 return TREE_OPERAND (found
, 0);
672 /* Return whether the pointer-type T effective for aliasing may
673 access everything and thus the reference has to be assigned
677 ref_all_alias_ptr_type_p (const_tree t
)
679 return (TREE_CODE (TREE_TYPE (t
)) == VOID_TYPE
680 || TYPE_REF_CAN_ALIAS_ALL (t
));
683 /* Return the alias set for the memory pointed to by T, which may be
684 either a type or an expression. Return -1 if there is nothing
685 special about dereferencing T. */
687 static alias_set_type
688 get_deref_alias_set_1 (tree t
)
690 /* All we care about is the type. */
694 /* If we have an INDIRECT_REF via a void pointer, we don't
695 know anything about what that might alias. Likewise if the
696 pointer is marked that way. */
697 if (ref_all_alias_ptr_type_p (t
))
703 /* Return the alias set for the memory pointed to by T, which may be
704 either a type or an expression. */
707 get_deref_alias_set (tree t
)
709 /* If we're not doing any alias analysis, just assume everything
710 aliases everything else. */
711 if (!flag_strict_aliasing
)
714 alias_set_type set
= get_deref_alias_set_1 (t
);
716 /* Fall back to the alias-set of the pointed-to type. */
721 set
= get_alias_set (TREE_TYPE (t
));
727 /* Return the pointer-type relevant for TBAA purposes from the
728 memory reference tree *T or NULL_TREE in which case *T is
729 adjusted to point to the outermost component reference that
730 can be used for assigning an alias set. */
733 reference_alias_ptr_type_1 (tree
*t
)
737 /* Get the base object of the reference. */
739 while (handled_component_p (inner
))
741 /* If there is a VIEW_CONVERT_EXPR in the chain we cannot use
742 the type of any component references that wrap it to
743 determine the alias-set. */
744 if (TREE_CODE (inner
) == VIEW_CONVERT_EXPR
)
745 *t
= TREE_OPERAND (inner
, 0);
746 inner
= TREE_OPERAND (inner
, 0);
749 /* Handle pointer dereferences here, they can override the
751 if (INDIRECT_REF_P (inner
)
752 && ref_all_alias_ptr_type_p (TREE_TYPE (TREE_OPERAND (inner
, 0))))
753 return TREE_TYPE (TREE_OPERAND (inner
, 0));
754 else if (TREE_CODE (inner
) == TARGET_MEM_REF
)
755 return TREE_TYPE (TMR_OFFSET (inner
));
756 else if (TREE_CODE (inner
) == MEM_REF
757 && ref_all_alias_ptr_type_p (TREE_TYPE (TREE_OPERAND (inner
, 1))))
758 return TREE_TYPE (TREE_OPERAND (inner
, 1));
760 /* If the innermost reference is a MEM_REF that has a
761 conversion embedded treat it like a VIEW_CONVERT_EXPR above,
762 using the memory access type for determining the alias-set. */
763 if (TREE_CODE (inner
) == MEM_REF
764 && (TYPE_MAIN_VARIANT (TREE_TYPE (inner
))
766 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (inner
, 1))))))
767 return TREE_TYPE (TREE_OPERAND (inner
, 1));
769 /* Otherwise, pick up the outermost object that we could have
771 tree tem
= component_uses_parent_alias_set_from (*t
);
778 /* Return the pointer-type relevant for TBAA purposes from the
779 gimple memory reference tree T. This is the type to be used for
780 the offset operand of MEM_REF or TARGET_MEM_REF replacements of T
781 and guarantees that get_alias_set will return the same alias
782 set for T and the replacement. */
785 reference_alias_ptr_type (tree t
)
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
)
792 /* Otherwise build one from the outermost component reference we
794 if (TREE_CODE (t
) == MEM_REF
795 || TREE_CODE (t
) == TARGET_MEM_REF
)
796 return TREE_TYPE (TREE_OPERAND (t
, 1));
798 return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (t
)));
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. */
806 alias_ptr_types_compatible_p (tree t1
, tree t2
)
808 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
811 if (ref_all_alias_ptr_type_p (t1
)
812 || ref_all_alias_ptr_type_p (t2
))
815 return (TYPE_MAIN_VARIANT (TREE_TYPE (t1
))
816 == TYPE_MAIN_VARIANT (TREE_TYPE (t2
)));
819 /* Create emptry alias set entry. */
822 init_alias_set_entry (alias_set_type set
)
824 alias_set_entry ase
= ggc_alloc
<alias_set_entry_d
> ();
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
;
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. */
839 get_alias_set (tree t
)
843 /* If we're not doing any alias analysis, just assume everything
844 aliases everything else. Also return 0 if this or its type is
846 if (! flag_strict_aliasing
|| t
== error_mark_node
848 && (TREE_TYPE (t
) == 0 || TREE_TYPE (t
) == error_mark_node
)))
851 /* We can be passed either an expression or a type. This and the
852 language-specific routine may make mutually-recursive calls to each other
853 to figure out what to do. At each juncture, we see if this is a tree
854 that the language may need to handle specially. First handle things that
858 /* Give the language a chance to do something with this tree
859 before we look at it. */
861 set
= lang_hooks
.get_alias_set (t
);
865 /* Get the alias pointer-type to use or the outermost object
866 that we could have a pointer to. */
867 tree ptype
= reference_alias_ptr_type_1 (&t
);
869 return get_deref_alias_set (ptype
);
871 /* If we've already determined the alias set for a decl, just return
872 it. This is necessary for C++ anonymous unions, whose component
873 variables don't look like union members (boo!). */
874 if (TREE_CODE (t
) == VAR_DECL
875 && DECL_RTL_SET_P (t
) && MEM_P (DECL_RTL (t
)))
876 return MEM_ALIAS_SET (DECL_RTL (t
));
878 /* Now all we care about is the type. */
882 /* Variant qualifiers don't affect the alias set, so get the main
884 t
= TYPE_MAIN_VARIANT (t
);
886 /* Always use the canonical type as well. If this is a type that
887 requires structural comparisons to identify compatible types
888 use alias set zero. */
889 if (TYPE_STRUCTURAL_EQUALITY_P (t
))
891 /* Allow the language to specify another alias set for this
893 set
= lang_hooks
.get_alias_set (t
);
899 t
= TYPE_CANONICAL (t
);
901 /* The canonical type should not require structural equality checks. */
902 gcc_checking_assert (!TYPE_STRUCTURAL_EQUALITY_P (t
));
904 /* If this is a type with a known alias set, return it. */
905 if (TYPE_ALIAS_SET_KNOWN_P (t
))
906 return TYPE_ALIAS_SET (t
);
908 /* We don't want to set TYPE_ALIAS_SET for incomplete types. */
909 if (!COMPLETE_TYPE_P (t
))
911 /* For arrays with unknown size the conservative answer is the
912 alias set of the element type. */
913 if (TREE_CODE (t
) == ARRAY_TYPE
)
914 return get_alias_set (TREE_TYPE (t
));
916 /* But return zero as a conservative answer for incomplete types. */
920 /* See if the language has special handling for this type. */
921 set
= lang_hooks
.get_alias_set (t
);
925 /* There are no objects of FUNCTION_TYPE, so there's no point in
926 using up an alias set for them. (There are, of course, pointers
927 and references to functions, but that's different.) */
928 else if (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
)
931 /* Unless the language specifies otherwise, let vector types alias
932 their components. This avoids some nasty type punning issues in
933 normal usage. And indeed lets vectors be treated more like an
935 else if (TREE_CODE (t
) == VECTOR_TYPE
)
936 set
= get_alias_set (TREE_TYPE (t
));
938 /* Unless the language specifies otherwise, treat array types the
939 same as their components. This avoids the asymmetry we get
940 through recording the components. Consider accessing a
941 character(kind=1) through a reference to a character(kind=1)[1:1].
942 Or consider if we want to assign integer(kind=4)[0:D.1387] and
943 integer(kind=4)[4] the same alias set or not.
944 Just be pragmatic here and make sure the array and its element
945 type get the same alias set assigned. */
946 else if (TREE_CODE (t
) == ARRAY_TYPE
&& !TYPE_NONALIASED_COMPONENT (t
))
947 set
= get_alias_set (TREE_TYPE (t
));
949 /* From the former common C and C++ langhook implementation:
951 Unfortunately, there is no canonical form of a pointer type.
952 In particular, if we have `typedef int I', then `int *', and
953 `I *' are different types. So, we have to pick a canonical
954 representative. We do this below.
956 Technically, this approach is actually more conservative that
957 it needs to be. In particular, `const int *' and `int *'
958 should be in different alias sets, according to the C and C++
959 standard, since their types are not the same, and so,
960 technically, an `int **' and `const int **' cannot point at
963 But, the standard is wrong. In particular, this code is
968 const int* const* cipp = ipp;
969 And, it doesn't make sense for that to be legal unless you
970 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
971 the pointed-to types. This issue has been reported to the
974 For this reason go to canonical type of the unqalified pointer type.
975 Until GCC 6 this code set all pointers sets to have alias set of
976 ptr_type_node but that is a bad idea, because it prevents disabiguations
977 in between pointers. For Firefox this accounts about 20% of all
978 disambiguations in the program. */
979 else if (POINTER_TYPE_P (t
) && t
!= ptr_type_node
&& !in_lto_p
)
982 auto_vec
<bool, 8> reference
;
984 /* Unnest all pointers and references.
985 We also want to make pointer to array equivalent to pointer to its
986 element. So skip all array types, too. */
987 for (p
= t
; POINTER_TYPE_P (p
)
988 || (TREE_CODE (p
) == ARRAY_TYPE
&& !TYPE_NONALIASED_COMPONENT (p
));
991 if (TREE_CODE (p
) == REFERENCE_TYPE
)
992 reference
.safe_push (true);
993 if (TREE_CODE (p
) == POINTER_TYPE
)
994 reference
.safe_push (false);
996 p
= TYPE_MAIN_VARIANT (p
);
998 /* Make void * compatible with char * and also void **.
999 Programs are commonly violating TBAA by this.
1001 We also make void * to conflict with every pointer
1002 (see record_component_aliases) and thus it is safe it to use it for
1003 pointers to types with TYPE_STRUCTURAL_EQUALITY_P. */
1004 if (TREE_CODE (p
) == VOID_TYPE
|| TYPE_STRUCTURAL_EQUALITY_P (p
))
1005 set
= get_alias_set (ptr_type_node
);
1008 /* Rebuild pointer type from starting from canonical types using
1009 unqualified pointers and references only. This way all such
1010 pointers will have the same alias set and will conflict with
1013 Most of time we already have pointers or references of a given type.
1014 If not we build new one just to be sure that if someone later
1015 (probably only middle-end can, as we should assign all alias
1016 classes only after finishing translation unit) builds the pointer
1017 type, the canonical type will match. */
1018 p
= TYPE_CANONICAL (p
);
1019 while (!reference
.is_empty ())
1021 if (reference
.pop ())
1022 p
= build_reference_type (p
);
1024 p
= build_pointer_type (p
);
1025 p
= TYPE_CANONICAL (TYPE_MAIN_VARIANT (p
));
1027 gcc_checking_assert (TYPE_CANONICAL (p
) == p
);
1029 /* Assign the alias set to both p and t.
1030 We can not call get_alias_set (p) here as that would trigger
1031 infinite recursion when p == t. In other cases it would just
1032 trigger unnecesary legwork of rebuilding the pointer again. */
1033 if (TYPE_ALIAS_SET_KNOWN_P (p
))
1034 set
= TYPE_ALIAS_SET (p
);
1037 set
= new_alias_set ();
1038 TYPE_ALIAS_SET (p
) = set
;
1042 /* In LTO the rules above needs to be part of canonical type machinery.
1043 For now just punt. */
1044 else if (POINTER_TYPE_P (t
)
1045 && t
!= TYPE_CANONICAL (ptr_type_node
) && in_lto_p
)
1046 set
= get_alias_set (TYPE_CANONICAL (ptr_type_node
));
1048 /* Otherwise make a new alias set for this type. */
1051 /* Each canonical type gets its own alias set, so canonical types
1052 shouldn't form a tree. It doesn't really matter for types
1053 we handle specially above, so only check it where it possibly
1054 would result in a bogus alias set. */
1055 gcc_checking_assert (TYPE_CANONICAL (t
) == t
);
1057 set
= new_alias_set ();
1060 TYPE_ALIAS_SET (t
) = set
;
1062 /* If this is an aggregate type or a complex type, we must record any
1063 component aliasing information. */
1064 if (AGGREGATE_TYPE_P (t
) || TREE_CODE (t
) == COMPLEX_TYPE
)
1065 record_component_aliases (t
);
1067 /* We treat pointer types specially in alias_set_subset_of. */
1068 if (POINTER_TYPE_P (t
) && set
)
1070 alias_set_entry ase
= get_alias_set_entry (set
);
1072 ase
= init_alias_set_entry (set
);
1073 ase
->is_pointer
= true;
1074 ase
->has_pointer
= true;
1080 /* Return a brand-new alias set. */
1083 new_alias_set (void)
1085 if (flag_strict_aliasing
)
1087 if (alias_sets
== 0)
1088 vec_safe_push (alias_sets
, (alias_set_entry
) 0);
1089 vec_safe_push (alias_sets
, (alias_set_entry
) 0);
1090 return alias_sets
->length () - 1;
1096 /* Indicate that things in SUBSET can alias things in SUPERSET, but that
1097 not everything that aliases SUPERSET also aliases SUBSET. For example,
1098 in C, a store to an `int' can alias a load of a structure containing an
1099 `int', and vice versa. But it can't alias a load of a 'double' member
1100 of the same structure. Here, the structure would be the SUPERSET and
1101 `int' the SUBSET. This relationship is also described in the comment at
1102 the beginning of this file.
1104 This function should be called only once per SUPERSET/SUBSET pair.
1106 It is illegal for SUPERSET to be zero; everything is implicitly a
1107 subset of alias set zero. */
1110 record_alias_subset (alias_set_type superset
, alias_set_type subset
)
1112 alias_set_entry superset_entry
;
1113 alias_set_entry subset_entry
;
1115 /* It is possible in complex type situations for both sets to be the same,
1116 in which case we can ignore this operation. */
1117 if (superset
== subset
)
1120 gcc_assert (superset
);
1122 superset_entry
= get_alias_set_entry (superset
);
1123 if (superset_entry
== 0)
1125 /* Create an entry for the SUPERSET, so that we have a place to
1126 attach the SUBSET. */
1127 superset_entry
= init_alias_set_entry (superset
);
1131 superset_entry
->has_zero_child
= 1;
1134 subset_entry
= get_alias_set_entry (subset
);
1135 if (!superset_entry
->children
)
1136 superset_entry
->children
1137 = hash_map
<int, int, alias_set_traits
>::create_ggc (64);
1138 /* If there is an entry for the subset, enter all of its children
1139 (if they are not already present) as children of the SUPERSET. */
1142 if (subset_entry
->has_zero_child
)
1143 superset_entry
->has_zero_child
= true;
1144 if (subset_entry
->has_pointer
)
1145 superset_entry
->has_pointer
= true;
1147 if (subset_entry
->children
)
1149 hash_map
<int, int, alias_set_traits
>::iterator iter
1150 = subset_entry
->children
->begin ();
1151 for (; iter
!= subset_entry
->children
->end (); ++iter
)
1152 superset_entry
->children
->put ((*iter
).first
, (*iter
).second
);
1156 /* Enter the SUBSET itself as a child of the SUPERSET. */
1157 superset_entry
->children
->put (subset
, 0);
1161 /* Record that component types of TYPE, if any, are part of that type for
1162 aliasing purposes. For record types, we only record component types
1163 for fields that are not marked non-addressable. For array types, we
1164 only record the component type if it is not marked non-aliased. */
1167 record_component_aliases (tree type
)
1169 alias_set_type superset
= get_alias_set (type
);
1175 switch (TREE_CODE (type
))
1179 case QUAL_UNION_TYPE
:
1180 for (field
= TYPE_FIELDS (type
); field
!= 0; field
= DECL_CHAIN (field
))
1181 if (TREE_CODE (field
) == FIELD_DECL
&& !DECL_NONADDRESSABLE_P (field
))
1182 record_alias_subset (superset
, get_alias_set (TREE_TYPE (field
)));
1186 record_alias_subset (superset
, get_alias_set (TREE_TYPE (type
)));
1189 /* VECTOR_TYPE and ARRAY_TYPE share the alias set with their
1197 /* Allocate an alias set for use in storing and reading from the varargs
1200 static GTY(()) alias_set_type varargs_set
= -1;
1203 get_varargs_alias_set (void)
1206 /* We now lower VA_ARG_EXPR, and there's currently no way to attach the
1207 varargs alias set to an INDIRECT_REF (FIXME!), so we can't
1208 consistently use the varargs alias set for loads from the varargs
1209 area. So don't use it anywhere. */
1212 if (varargs_set
== -1)
1213 varargs_set
= new_alias_set ();
1219 /* Likewise, but used for the fixed portions of the frame, e.g., register
1222 static GTY(()) alias_set_type frame_set
= -1;
1225 get_frame_alias_set (void)
1227 if (frame_set
== -1)
1228 frame_set
= new_alias_set ();
1233 /* Create a new, unique base with id ID. */
1236 unique_base_value (HOST_WIDE_INT id
)
1238 return gen_rtx_ADDRESS (Pmode
, id
);
1241 /* Return true if accesses based on any other base value cannot alias
1242 those based on X. */
1245 unique_base_value_p (rtx x
)
1247 return GET_CODE (x
) == ADDRESS
&& GET_MODE (x
) == Pmode
;
1250 /* Return true if X is known to be a base value. */
1253 known_base_value_p (rtx x
)
1255 switch (GET_CODE (x
))
1262 /* Arguments may or may not be bases; we don't know for sure. */
1263 return GET_MODE (x
) != VOIDmode
;
1270 /* Inside SRC, the source of a SET, find a base address. */
1273 find_base_value (rtx src
)
1277 #if defined (FIND_BASE_TERM)
1278 /* Try machine-dependent ways to find the base term. */
1279 src
= FIND_BASE_TERM (src
);
1282 switch (GET_CODE (src
))
1289 regno
= REGNO (src
);
1290 /* At the start of a function, argument registers have known base
1291 values which may be lost later. Returning an ADDRESS
1292 expression here allows optimization based on argument values
1293 even when the argument registers are used for other purposes. */
1294 if (regno
< FIRST_PSEUDO_REGISTER
&& copying_arguments
)
1295 return new_reg_base_value
[regno
];
1297 /* If a pseudo has a known base value, return it. Do not do this
1298 for non-fixed hard regs since it can result in a circular
1299 dependency chain for registers which have values at function entry.
1301 The test above is not sufficient because the scheduler may move
1302 a copy out of an arg reg past the NOTE_INSN_FUNCTION_BEGIN. */
1303 if ((regno
>= FIRST_PSEUDO_REGISTER
|| fixed_regs
[regno
])
1304 && regno
< vec_safe_length (reg_base_value
))
1306 /* If we're inside init_alias_analysis, use new_reg_base_value
1307 to reduce the number of relaxation iterations. */
1308 if (new_reg_base_value
&& new_reg_base_value
[regno
]
1309 && DF_REG_DEF_COUNT (regno
) == 1)
1310 return new_reg_base_value
[regno
];
1312 if ((*reg_base_value
)[regno
])
1313 return (*reg_base_value
)[regno
];
1319 /* Check for an argument passed in memory. Only record in the
1320 copying-arguments block; it is too hard to track changes
1322 if (copying_arguments
1323 && (XEXP (src
, 0) == arg_pointer_rtx
1324 || (GET_CODE (XEXP (src
, 0)) == PLUS
1325 && XEXP (XEXP (src
, 0), 0) == arg_pointer_rtx
)))
1326 return arg_base_value
;
1330 src
= XEXP (src
, 0);
1331 if (GET_CODE (src
) != PLUS
&& GET_CODE (src
) != MINUS
)
1334 /* ... fall through ... */
1339 rtx temp
, src_0
= XEXP (src
, 0), src_1
= XEXP (src
, 1);
1341 /* If either operand is a REG that is a known pointer, then it
1343 if (REG_P (src_0
) && REG_POINTER (src_0
))
1344 return find_base_value (src_0
);
1345 if (REG_P (src_1
) && REG_POINTER (src_1
))
1346 return find_base_value (src_1
);
1348 /* If either operand is a REG, then see if we already have
1349 a known value for it. */
1352 temp
= find_base_value (src_0
);
1359 temp
= find_base_value (src_1
);
1364 /* If either base is named object or a special address
1365 (like an argument or stack reference), then use it for the
1367 if (src_0
!= 0 && known_base_value_p (src_0
))
1370 if (src_1
!= 0 && known_base_value_p (src_1
))
1373 /* Guess which operand is the base address:
1374 If either operand is a symbol, then it is the base. If
1375 either operand is a CONST_INT, then the other is the base. */
1376 if (CONST_INT_P (src_1
) || CONSTANT_P (src_0
))
1377 return find_base_value (src_0
);
1378 else if (CONST_INT_P (src_0
) || CONSTANT_P (src_1
))
1379 return find_base_value (src_1
);
1385 /* The standard form is (lo_sum reg sym) so look only at the
1387 return find_base_value (XEXP (src
, 1));
1390 /* If the second operand is constant set the base
1391 address to the first operand. */
1392 if (CONST_INT_P (XEXP (src
, 1)) && INTVAL (XEXP (src
, 1)) != 0)
1393 return find_base_value (XEXP (src
, 0));
1397 /* As we do not know which address space the pointer is referring to, we can
1398 handle this only if the target does not support different pointer or
1399 address modes depending on the address space. */
1400 if (!target_default_pointer_address_modes_p ())
1402 if (GET_MODE_SIZE (GET_MODE (src
)) < GET_MODE_SIZE (Pmode
))
1412 return find_base_value (XEXP (src
, 0));
1415 case SIGN_EXTEND
: /* used for NT/Alpha pointers */
1416 /* As we do not know which address space the pointer is referring to, we can
1417 handle this only if the target does not support different pointer or
1418 address modes depending on the address space. */
1419 if (!target_default_pointer_address_modes_p ())
1423 rtx temp
= find_base_value (XEXP (src
, 0));
1425 if (temp
!= 0 && CONSTANT_P (temp
))
1426 temp
= convert_memory_address (Pmode
, temp
);
1438 /* Called from init_alias_analysis indirectly through note_stores,
1439 or directly if DEST is a register with a REG_NOALIAS note attached.
1440 SET is null in the latter case. */
1442 /* While scanning insns to find base values, reg_seen[N] is nonzero if
1443 register N has been set in this function. */
1444 static sbitmap reg_seen
;
1447 record_set (rtx dest
, const_rtx set
, void *data ATTRIBUTE_UNUSED
)
1456 regno
= REGNO (dest
);
1458 gcc_checking_assert (regno
< reg_base_value
->length ());
1460 n
= REG_NREGS (dest
);
1465 bitmap_set_bit (reg_seen
, regno
+ n
);
1466 new_reg_base_value
[regno
+ n
] = 0;
1473 /* A CLOBBER wipes out any old value but does not prevent a previously
1474 unset register from acquiring a base address (i.e. reg_seen is not
1476 if (GET_CODE (set
) == CLOBBER
)
1478 new_reg_base_value
[regno
] = 0;
1481 src
= SET_SRC (set
);
1485 /* There's a REG_NOALIAS note against DEST. */
1486 if (bitmap_bit_p (reg_seen
, regno
))
1488 new_reg_base_value
[regno
] = 0;
1491 bitmap_set_bit (reg_seen
, regno
);
1492 new_reg_base_value
[regno
] = unique_base_value (unique_id
++);
1496 /* If this is not the first set of REGNO, see whether the new value
1497 is related to the old one. There are two cases of interest:
1499 (1) The register might be assigned an entirely new value
1500 that has the same base term as the original set.
1502 (2) The set might be a simple self-modification that
1503 cannot change REGNO's base value.
1505 If neither case holds, reject the original base value as invalid.
1506 Note that the following situation is not detected:
1508 extern int x, y; int *p = &x; p += (&y-&x);
1510 ANSI C does not allow computing the difference of addresses
1511 of distinct top level objects. */
1512 if (new_reg_base_value
[regno
] != 0
1513 && find_base_value (src
) != new_reg_base_value
[regno
])
1514 switch (GET_CODE (src
))
1518 if (XEXP (src
, 0) != dest
&& XEXP (src
, 1) != dest
)
1519 new_reg_base_value
[regno
] = 0;
1522 /* If the value we add in the PLUS is also a valid base value,
1523 this might be the actual base value, and the original value
1526 rtx other
= NULL_RTX
;
1528 if (XEXP (src
, 0) == dest
)
1529 other
= XEXP (src
, 1);
1530 else if (XEXP (src
, 1) == dest
)
1531 other
= XEXP (src
, 0);
1533 if (! other
|| find_base_value (other
))
1534 new_reg_base_value
[regno
] = 0;
1538 if (XEXP (src
, 0) != dest
|| !CONST_INT_P (XEXP (src
, 1)))
1539 new_reg_base_value
[regno
] = 0;
1542 new_reg_base_value
[regno
] = 0;
1545 /* If this is the first set of a register, record the value. */
1546 else if ((regno
>= FIRST_PSEUDO_REGISTER
|| ! fixed_regs
[regno
])
1547 && ! bitmap_bit_p (reg_seen
, regno
) && new_reg_base_value
[regno
] == 0)
1548 new_reg_base_value
[regno
] = find_base_value (src
);
1550 bitmap_set_bit (reg_seen
, regno
);
1553 /* Return REG_BASE_VALUE for REGNO. Selective scheduler uses this to avoid
1554 using hard registers with non-null REG_BASE_VALUE for renaming. */
1556 get_reg_base_value (unsigned int regno
)
1558 return (*reg_base_value
)[regno
];
1561 /* If a value is known for REGNO, return it. */
1564 get_reg_known_value (unsigned int regno
)
1566 if (regno
>= FIRST_PSEUDO_REGISTER
)
1568 regno
-= FIRST_PSEUDO_REGISTER
;
1569 if (regno
< vec_safe_length (reg_known_value
))
1570 return (*reg_known_value
)[regno
];
1578 set_reg_known_value (unsigned int regno
, rtx val
)
1580 if (regno
>= FIRST_PSEUDO_REGISTER
)
1582 regno
-= FIRST_PSEUDO_REGISTER
;
1583 if (regno
< vec_safe_length (reg_known_value
))
1584 (*reg_known_value
)[regno
] = val
;
1588 /* Similarly for reg_known_equiv_p. */
1591 get_reg_known_equiv_p (unsigned int regno
)
1593 if (regno
>= FIRST_PSEUDO_REGISTER
)
1595 regno
-= FIRST_PSEUDO_REGISTER
;
1596 if (regno
< vec_safe_length (reg_known_value
))
1597 return bitmap_bit_p (reg_known_equiv_p
, regno
);
1603 set_reg_known_equiv_p (unsigned int regno
, bool val
)
1605 if (regno
>= FIRST_PSEUDO_REGISTER
)
1607 regno
-= FIRST_PSEUDO_REGISTER
;
1608 if (regno
< vec_safe_length (reg_known_value
))
1611 bitmap_set_bit (reg_known_equiv_p
, regno
);
1613 bitmap_clear_bit (reg_known_equiv_p
, regno
);
1619 /* Returns a canonical version of X, from the point of view alias
1620 analysis. (For example, if X is a MEM whose address is a register,
1621 and the register has a known value (say a SYMBOL_REF), then a MEM
1622 whose address is the SYMBOL_REF is returned.) */
1627 /* Recursively look for equivalences. */
1628 if (REG_P (x
) && REGNO (x
) >= FIRST_PSEUDO_REGISTER
)
1630 rtx t
= get_reg_known_value (REGNO (x
));
1634 return canon_rtx (t
);
1637 if (GET_CODE (x
) == PLUS
)
1639 rtx x0
= canon_rtx (XEXP (x
, 0));
1640 rtx x1
= canon_rtx (XEXP (x
, 1));
1642 if (x0
!= XEXP (x
, 0) || x1
!= XEXP (x
, 1))
1644 if (CONST_INT_P (x0
))
1645 return plus_constant (GET_MODE (x
), x1
, INTVAL (x0
));
1646 else if (CONST_INT_P (x1
))
1647 return plus_constant (GET_MODE (x
), x0
, INTVAL (x1
));
1648 return gen_rtx_PLUS (GET_MODE (x
), x0
, x1
);
1652 /* This gives us much better alias analysis when called from
1653 the loop optimizer. Note we want to leave the original
1654 MEM alone, but need to return the canonicalized MEM with
1655 all the flags with their original values. */
1657 x
= replace_equiv_address_nv (x
, canon_rtx (XEXP (x
, 0)));
1662 /* Return 1 if X and Y are identical-looking rtx's.
1663 Expect that X and Y has been already canonicalized.
1665 We use the data in reg_known_value above to see if two registers with
1666 different numbers are, in fact, equivalent. */
1669 rtx_equal_for_memref_p (const_rtx x
, const_rtx y
)
1676 if (x
== 0 && y
== 0)
1678 if (x
== 0 || y
== 0)
1684 code
= GET_CODE (x
);
1685 /* Rtx's of different codes cannot be equal. */
1686 if (code
!= GET_CODE (y
))
1689 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
1690 (REG:SI x) and (REG:HI x) are NOT equivalent. */
1692 if (GET_MODE (x
) != GET_MODE (y
))
1695 /* Some RTL can be compared without a recursive examination. */
1699 return REGNO (x
) == REGNO (y
);
1702 return LABEL_REF_LABEL (x
) == LABEL_REF_LABEL (y
);
1705 return XSTR (x
, 0) == XSTR (y
, 0);
1708 /* This is magic, don't go through canonicalization et al. */
1709 return rtx_equal_p (ENTRY_VALUE_EXP (x
), ENTRY_VALUE_EXP (y
));
1713 /* Pointer equality guarantees equality for these nodes. */
1720 /* canon_rtx knows how to handle plus. No need to canonicalize. */
1722 return ((rtx_equal_for_memref_p (XEXP (x
, 0), XEXP (y
, 0))
1723 && rtx_equal_for_memref_p (XEXP (x
, 1), XEXP (y
, 1)))
1724 || (rtx_equal_for_memref_p (XEXP (x
, 0), XEXP (y
, 1))
1725 && rtx_equal_for_memref_p (XEXP (x
, 1), XEXP (y
, 0))));
1726 /* For commutative operations, the RTX match if the operand match in any
1727 order. Also handle the simple binary and unary cases without a loop. */
1728 if (COMMUTATIVE_P (x
))
1730 rtx xop0
= canon_rtx (XEXP (x
, 0));
1731 rtx yop0
= canon_rtx (XEXP (y
, 0));
1732 rtx yop1
= canon_rtx (XEXP (y
, 1));
1734 return ((rtx_equal_for_memref_p (xop0
, yop0
)
1735 && rtx_equal_for_memref_p (canon_rtx (XEXP (x
, 1)), yop1
))
1736 || (rtx_equal_for_memref_p (xop0
, yop1
)
1737 && rtx_equal_for_memref_p (canon_rtx (XEXP (x
, 1)), yop0
)));
1739 else if (NON_COMMUTATIVE_P (x
))
1741 return (rtx_equal_for_memref_p (canon_rtx (XEXP (x
, 0)),
1742 canon_rtx (XEXP (y
, 0)))
1743 && rtx_equal_for_memref_p (canon_rtx (XEXP (x
, 1)),
1744 canon_rtx (XEXP (y
, 1))));
1746 else if (UNARY_P (x
))
1747 return rtx_equal_for_memref_p (canon_rtx (XEXP (x
, 0)),
1748 canon_rtx (XEXP (y
, 0)));
1750 /* Compare the elements. If any pair of corresponding elements
1751 fail to match, return 0 for the whole things.
1753 Limit cases to types which actually appear in addresses. */
1755 fmt
= GET_RTX_FORMAT (code
);
1756 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1761 if (XINT (x
, i
) != XINT (y
, i
))
1766 /* Two vectors must have the same length. */
1767 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
1770 /* And the corresponding elements must match. */
1771 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1772 if (rtx_equal_for_memref_p (canon_rtx (XVECEXP (x
, i
, j
)),
1773 canon_rtx (XVECEXP (y
, i
, j
))) == 0)
1778 if (rtx_equal_for_memref_p (canon_rtx (XEXP (x
, i
)),
1779 canon_rtx (XEXP (y
, i
))) == 0)
1783 /* This can happen for asm operands. */
1785 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
1789 /* This can happen for an asm which clobbers memory. */
1793 /* It is believed that rtx's at this level will never
1794 contain anything but integers and other rtx's,
1795 except for within LABEL_REFs and SYMBOL_REFs. */
1804 find_base_term (rtx x
)
1807 struct elt_loc_list
*l
, *f
;
1810 #if defined (FIND_BASE_TERM)
1811 /* Try machine-dependent ways to find the base term. */
1812 x
= FIND_BASE_TERM (x
);
1815 switch (GET_CODE (x
))
1818 return REG_BASE_VALUE (x
);
1821 /* As we do not know which address space the pointer is referring to, we can
1822 handle this only if the target does not support different pointer or
1823 address modes depending on the address space. */
1824 if (!target_default_pointer_address_modes_p ())
1826 if (GET_MODE_SIZE (GET_MODE (x
)) < GET_MODE_SIZE (Pmode
))
1836 return find_base_term (XEXP (x
, 0));
1839 case SIGN_EXTEND
: /* Used for Alpha/NT pointers */
1840 /* As we do not know which address space the pointer is referring to, we can
1841 handle this only if the target does not support different pointer or
1842 address modes depending on the address space. */
1843 if (!target_default_pointer_address_modes_p ())
1847 rtx temp
= find_base_term (XEXP (x
, 0));
1849 if (temp
!= 0 && CONSTANT_P (temp
))
1850 temp
= convert_memory_address (Pmode
, temp
);
1856 val
= CSELIB_VAL_PTR (x
);
1862 if (cselib_sp_based_value_p (val
))
1863 return static_reg_base_value
[STACK_POINTER_REGNUM
];
1866 /* Temporarily reset val->locs to avoid infinite recursion. */
1869 for (l
= f
; l
; l
= l
->next
)
1870 if (GET_CODE (l
->loc
) == VALUE
1871 && CSELIB_VAL_PTR (l
->loc
)->locs
1872 && !CSELIB_VAL_PTR (l
->loc
)->locs
->next
1873 && CSELIB_VAL_PTR (l
->loc
)->locs
->loc
== x
)
1875 else if ((ret
= find_base_term (l
->loc
)) != 0)
1882 /* The standard form is (lo_sum reg sym) so look only at the
1884 return find_base_term (XEXP (x
, 1));
1888 if (GET_CODE (x
) != PLUS
&& GET_CODE (x
) != MINUS
)
1894 rtx tmp1
= XEXP (x
, 0);
1895 rtx tmp2
= XEXP (x
, 1);
1897 /* This is a little bit tricky since we have to determine which of
1898 the two operands represents the real base address. Otherwise this
1899 routine may return the index register instead of the base register.
1901 That may cause us to believe no aliasing was possible, when in
1902 fact aliasing is possible.
1904 We use a few simple tests to guess the base register. Additional
1905 tests can certainly be added. For example, if one of the operands
1906 is a shift or multiply, then it must be the index register and the
1907 other operand is the base register. */
1909 if (tmp1
== pic_offset_table_rtx
&& CONSTANT_P (tmp2
))
1910 return find_base_term (tmp2
);
1912 /* If either operand is known to be a pointer, then prefer it
1913 to determine the base term. */
1914 if (REG_P (tmp1
) && REG_POINTER (tmp1
))
1916 else if (REG_P (tmp2
) && REG_POINTER (tmp2
))
1917 std::swap (tmp1
, tmp2
);
1918 /* If second argument is constant which has base term, prefer it
1919 over variable tmp1. See PR64025. */
1920 else if (CONSTANT_P (tmp2
) && !CONST_INT_P (tmp2
))
1921 std::swap (tmp1
, tmp2
);
1923 /* Go ahead and find the base term for both operands. If either base
1924 term is from a pointer or is a named object or a special address
1925 (like an argument or stack reference), then use it for the
1927 rtx base
= find_base_term (tmp1
);
1928 if (base
!= NULL_RTX
1929 && ((REG_P (tmp1
) && REG_POINTER (tmp1
))
1930 || known_base_value_p (base
)))
1932 base
= find_base_term (tmp2
);
1933 if (base
!= NULL_RTX
1934 && ((REG_P (tmp2
) && REG_POINTER (tmp2
))
1935 || known_base_value_p (base
)))
1938 /* We could not determine which of the two operands was the
1939 base register and which was the index. So we can determine
1940 nothing from the base alias check. */
1945 if (CONST_INT_P (XEXP (x
, 1)) && INTVAL (XEXP (x
, 1)) != 0)
1946 return find_base_term (XEXP (x
, 0));
1958 /* Return true if accesses to address X may alias accesses based
1959 on the stack pointer. */
1962 may_be_sp_based_p (rtx x
)
1964 rtx base
= find_base_term (x
);
1965 return !base
|| base
== static_reg_base_value
[STACK_POINTER_REGNUM
];
1968 /* Return 0 if the addresses X and Y are known to point to different
1969 objects, 1 if they might be pointers to the same object. */
1972 base_alias_check (rtx x
, rtx x_base
, rtx y
, rtx y_base
,
1973 machine_mode x_mode
, machine_mode y_mode
)
1975 /* If the address itself has no known base see if a known equivalent
1976 value has one. If either address still has no known base, nothing
1977 is known about aliasing. */
1982 if (! flag_expensive_optimizations
|| (x_c
= canon_rtx (x
)) == x
)
1985 x_base
= find_base_term (x_c
);
1993 if (! flag_expensive_optimizations
|| (y_c
= canon_rtx (y
)) == y
)
1996 y_base
= find_base_term (y_c
);
2001 /* If the base addresses are equal nothing is known about aliasing. */
2002 if (rtx_equal_p (x_base
, y_base
))
2005 /* The base addresses are different expressions. If they are not accessed
2006 via AND, there is no conflict. We can bring knowledge of object
2007 alignment into play here. For example, on alpha, "char a, b;" can
2008 alias one another, though "char a; long b;" cannot. AND addesses may
2009 implicitly alias surrounding objects; i.e. unaligned access in DImode
2010 via AND address can alias all surrounding object types except those
2011 with aligment 8 or higher. */
2012 if (GET_CODE (x
) == AND
&& GET_CODE (y
) == AND
)
2014 if (GET_CODE (x
) == AND
2015 && (!CONST_INT_P (XEXP (x
, 1))
2016 || (int) GET_MODE_UNIT_SIZE (y_mode
) < -INTVAL (XEXP (x
, 1))))
2018 if (GET_CODE (y
) == AND
2019 && (!CONST_INT_P (XEXP (y
, 1))
2020 || (int) GET_MODE_UNIT_SIZE (x_mode
) < -INTVAL (XEXP (y
, 1))))
2023 /* Differing symbols not accessed via AND never alias. */
2024 if (GET_CODE (x_base
) != ADDRESS
&& GET_CODE (y_base
) != ADDRESS
)
2027 if (unique_base_value_p (x_base
) || unique_base_value_p (y_base
))
2033 /* Return TRUE if EXPR refers to a VALUE whose uid is greater than
2037 refs_newer_value_p (const_rtx expr
, rtx v
)
2039 int minuid
= CSELIB_VAL_PTR (v
)->uid
;
2040 subrtx_iterator::array_type array
;
2041 FOR_EACH_SUBRTX (iter
, array
, expr
, NONCONST
)
2042 if (GET_CODE (*iter
) == VALUE
&& CSELIB_VAL_PTR (*iter
)->uid
> minuid
)
2047 /* Convert the address X into something we can use. This is done by returning
2048 it unchanged unless it is a value; in the latter case we call cselib to get
2049 a more useful rtx. */
2055 struct elt_loc_list
*l
;
2057 if (GET_CODE (x
) != VALUE
)
2059 v
= CSELIB_VAL_PTR (x
);
2062 bool have_equivs
= cselib_have_permanent_equivalences ();
2064 v
= canonical_cselib_val (v
);
2065 for (l
= v
->locs
; l
; l
= l
->next
)
2066 if (CONSTANT_P (l
->loc
))
2068 for (l
= v
->locs
; l
; l
= l
->next
)
2069 if (!REG_P (l
->loc
) && !MEM_P (l
->loc
)
2070 /* Avoid infinite recursion when potentially dealing with
2071 var-tracking artificial equivalences, by skipping the
2072 equivalences themselves, and not choosing expressions
2073 that refer to newer VALUEs. */
2075 || (GET_CODE (l
->loc
) != VALUE
2076 && !refs_newer_value_p (l
->loc
, x
))))
2080 for (l
= v
->locs
; l
; l
= l
->next
)
2082 || (GET_CODE (l
->loc
) != VALUE
2083 && !refs_newer_value_p (l
->loc
, x
)))
2085 /* Return the canonical value. */
2089 return v
->locs
->loc
;
2094 /* Return the address of the (N_REFS + 1)th memory reference to ADDR
2095 where SIZE is the size in bytes of the memory reference. If ADDR
2096 is not modified by the memory reference then ADDR is returned. */
2099 addr_side_effect_eval (rtx addr
, int size
, int n_refs
)
2103 switch (GET_CODE (addr
))
2106 offset
= (n_refs
+ 1) * size
;
2109 offset
= -(n_refs
+ 1) * size
;
2112 offset
= n_refs
* size
;
2115 offset
= -n_refs
* size
;
2123 addr
= gen_rtx_PLUS (GET_MODE (addr
), XEXP (addr
, 0),
2124 gen_int_mode (offset
, GET_MODE (addr
)));
2126 addr
= XEXP (addr
, 0);
2127 addr
= canon_rtx (addr
);
2132 /* Return TRUE if an object X sized at XSIZE bytes and another object
2133 Y sized at YSIZE bytes, starting C bytes after X, may overlap. If
2134 any of the sizes is zero, assume an overlap, otherwise use the
2135 absolute value of the sizes as the actual sizes. */
2138 offset_overlap_p (HOST_WIDE_INT c
, int xsize
, int ysize
)
2140 return (xsize
== 0 || ysize
== 0
2143 : (abs (ysize
) > -c
)));
2146 /* Return one if X and Y (memory addresses) reference the
2147 same location in memory or if the references overlap.
2148 Return zero if they do not overlap, else return
2149 minus one in which case they still might reference the same location.
2151 C is an offset accumulator. When
2152 C is nonzero, we are testing aliases between X and Y + C.
2153 XSIZE is the size in bytes of the X reference,
2154 similarly YSIZE is the size in bytes for Y.
2155 Expect that canon_rtx has been already called for X and Y.
2157 If XSIZE or YSIZE is zero, we do not know the amount of memory being
2158 referenced (the reference was BLKmode), so make the most pessimistic
2161 If XSIZE or YSIZE is negative, we may access memory outside the object
2162 being referenced as a side effect. This can happen when using AND to
2163 align memory references, as is done on the Alpha.
2165 Nice to notice that varying addresses cannot conflict with fp if no
2166 local variables had their addresses taken, but that's too hard now.
2168 ??? Contrary to the tree alias oracle this does not return
2169 one for X + non-constant and Y + non-constant when X and Y are equal.
2170 If that is fixed the TBAA hack for union type-punning can be removed. */
2173 memrefs_conflict_p (int xsize
, rtx x
, int ysize
, rtx y
, HOST_WIDE_INT c
)
2175 if (GET_CODE (x
) == VALUE
)
2179 struct elt_loc_list
*l
= NULL
;
2180 if (CSELIB_VAL_PTR (x
))
2181 for (l
= canonical_cselib_val (CSELIB_VAL_PTR (x
))->locs
;
2183 if (REG_P (l
->loc
) && rtx_equal_for_memref_p (l
->loc
, y
))
2190 /* Don't call get_addr if y is the same VALUE. */
2194 if (GET_CODE (y
) == VALUE
)
2198 struct elt_loc_list
*l
= NULL
;
2199 if (CSELIB_VAL_PTR (y
))
2200 for (l
= canonical_cselib_val (CSELIB_VAL_PTR (y
))->locs
;
2202 if (REG_P (l
->loc
) && rtx_equal_for_memref_p (l
->loc
, x
))
2209 /* Don't call get_addr if x is the same VALUE. */
2213 if (GET_CODE (x
) == HIGH
)
2215 else if (GET_CODE (x
) == LO_SUM
)
2218 x
= addr_side_effect_eval (x
, abs (xsize
), 0);
2219 if (GET_CODE (y
) == HIGH
)
2221 else if (GET_CODE (y
) == LO_SUM
)
2224 y
= addr_side_effect_eval (y
, abs (ysize
), 0);
2226 if (rtx_equal_for_memref_p (x
, y
))
2228 return offset_overlap_p (c
, xsize
, ysize
);
2231 /* This code used to check for conflicts involving stack references and
2232 globals but the base address alias code now handles these cases. */
2234 if (GET_CODE (x
) == PLUS
)
2236 /* The fact that X is canonicalized means that this
2237 PLUS rtx is canonicalized. */
2238 rtx x0
= XEXP (x
, 0);
2239 rtx x1
= XEXP (x
, 1);
2241 if (GET_CODE (y
) == PLUS
)
2243 /* The fact that Y is canonicalized means that this
2244 PLUS rtx is canonicalized. */
2245 rtx y0
= XEXP (y
, 0);
2246 rtx y1
= XEXP (y
, 1);
2248 if (rtx_equal_for_memref_p (x1
, y1
))
2249 return memrefs_conflict_p (xsize
, x0
, ysize
, y0
, c
);
2250 if (rtx_equal_for_memref_p (x0
, y0
))
2251 return memrefs_conflict_p (xsize
, x1
, ysize
, y1
, c
);
2252 if (CONST_INT_P (x1
))
2254 if (CONST_INT_P (y1
))
2255 return memrefs_conflict_p (xsize
, x0
, ysize
, y0
,
2256 c
- INTVAL (x1
) + INTVAL (y1
));
2258 return memrefs_conflict_p (xsize
, x0
, ysize
, y
,
2261 else if (CONST_INT_P (y1
))
2262 return memrefs_conflict_p (xsize
, x
, ysize
, y0
, c
+ INTVAL (y1
));
2266 else if (CONST_INT_P (x1
))
2267 return memrefs_conflict_p (xsize
, x0
, ysize
, y
, c
- INTVAL (x1
));
2269 else if (GET_CODE (y
) == PLUS
)
2271 /* The fact that Y is canonicalized means that this
2272 PLUS rtx is canonicalized. */
2273 rtx y0
= XEXP (y
, 0);
2274 rtx y1
= XEXP (y
, 1);
2276 if (CONST_INT_P (y1
))
2277 return memrefs_conflict_p (xsize
, x
, ysize
, y0
, c
+ INTVAL (y1
));
2282 if (GET_CODE (x
) == GET_CODE (y
))
2283 switch (GET_CODE (x
))
2287 /* Handle cases where we expect the second operands to be the
2288 same, and check only whether the first operand would conflict
2291 rtx x1
= canon_rtx (XEXP (x
, 1));
2292 rtx y1
= canon_rtx (XEXP (y
, 1));
2293 if (! rtx_equal_for_memref_p (x1
, y1
))
2295 x0
= canon_rtx (XEXP (x
, 0));
2296 y0
= canon_rtx (XEXP (y
, 0));
2297 if (rtx_equal_for_memref_p (x0
, y0
))
2298 return offset_overlap_p (c
, xsize
, ysize
);
2300 /* Can't properly adjust our sizes. */
2301 if (!CONST_INT_P (x1
))
2303 xsize
/= INTVAL (x1
);
2304 ysize
/= INTVAL (x1
);
2306 return memrefs_conflict_p (xsize
, x0
, ysize
, y0
, c
);
2313 /* Deal with alignment ANDs by adjusting offset and size so as to
2314 cover the maximum range, without taking any previously known
2315 alignment into account. Make a size negative after such an
2316 adjustments, so that, if we end up with e.g. two SYMBOL_REFs, we
2317 assume a potential overlap, because they may end up in contiguous
2318 memory locations and the stricter-alignment access may span over
2320 if (GET_CODE (x
) == AND
&& CONST_INT_P (XEXP (x
, 1)))
2322 HOST_WIDE_INT sc
= INTVAL (XEXP (x
, 1));
2323 unsigned HOST_WIDE_INT uc
= sc
;
2324 if (sc
< 0 && -uc
== (uc
& -uc
))
2331 return memrefs_conflict_p (xsize
, canon_rtx (XEXP (x
, 0)),
2335 if (GET_CODE (y
) == AND
&& CONST_INT_P (XEXP (y
, 1)))
2337 HOST_WIDE_INT sc
= INTVAL (XEXP (y
, 1));
2338 unsigned HOST_WIDE_INT uc
= sc
;
2339 if (sc
< 0 && -uc
== (uc
& -uc
))
2346 return memrefs_conflict_p (xsize
, x
,
2347 ysize
, canon_rtx (XEXP (y
, 0)), c
);
2353 if (CONST_INT_P (x
) && CONST_INT_P (y
))
2355 c
+= (INTVAL (y
) - INTVAL (x
));
2356 return offset_overlap_p (c
, xsize
, ysize
);
2359 if (GET_CODE (x
) == CONST
)
2361 if (GET_CODE (y
) == CONST
)
2362 return memrefs_conflict_p (xsize
, canon_rtx (XEXP (x
, 0)),
2363 ysize
, canon_rtx (XEXP (y
, 0)), c
);
2365 return memrefs_conflict_p (xsize
, canon_rtx (XEXP (x
, 0)),
2368 if (GET_CODE (y
) == CONST
)
2369 return memrefs_conflict_p (xsize
, x
, ysize
,
2370 canon_rtx (XEXP (y
, 0)), c
);
2372 /* Assume a potential overlap for symbolic addresses that went
2373 through alignment adjustments (i.e., that have negative
2374 sizes), because we can't know how far they are from each
2377 return (xsize
< 0 || ysize
< 0 || offset_overlap_p (c
, xsize
, ysize
));
2385 /* Functions to compute memory dependencies.
2387 Since we process the insns in execution order, we can build tables
2388 to keep track of what registers are fixed (and not aliased), what registers
2389 are varying in known ways, and what registers are varying in unknown
2392 If both memory references are volatile, then there must always be a
2393 dependence between the two references, since their order can not be
2394 changed. A volatile and non-volatile reference can be interchanged
2397 We also must allow AND addresses, because they may generate accesses
2398 outside the object being referenced. This is used to generate aligned
2399 addresses from unaligned addresses, for instance, the alpha
2400 storeqi_unaligned pattern. */
2402 /* Read dependence: X is read after read in MEM takes place. There can
2403 only be a dependence here if both reads are volatile, or if either is
2404 an explicit barrier. */
2407 read_dependence (const_rtx mem
, const_rtx x
)
2409 if (MEM_VOLATILE_P (x
) && MEM_VOLATILE_P (mem
))
2411 if (MEM_ALIAS_SET (x
) == ALIAS_SET_MEMORY_BARRIER
2412 || MEM_ALIAS_SET (mem
) == ALIAS_SET_MEMORY_BARRIER
)
2417 /* Look at the bottom of the COMPONENT_REF list for a DECL, and return it. */
2420 decl_for_component_ref (tree x
)
2424 x
= TREE_OPERAND (x
, 0);
2426 while (x
&& TREE_CODE (x
) == COMPONENT_REF
);
2428 return x
&& DECL_P (x
) ? x
: NULL_TREE
;
2431 /* Walk up the COMPONENT_REF list in X and adjust *OFFSET to compensate
2432 for the offset of the field reference. *KNOWN_P says whether the
2436 adjust_offset_for_component_ref (tree x
, bool *known_p
,
2437 HOST_WIDE_INT
*offset
)
2443 tree xoffset
= component_ref_field_offset (x
);
2444 tree field
= TREE_OPERAND (x
, 1);
2445 if (TREE_CODE (xoffset
) != INTEGER_CST
)
2452 = (wi::to_offset (xoffset
)
2453 + wi::lrshift (wi::to_offset (DECL_FIELD_BIT_OFFSET (field
)),
2454 LOG2_BITS_PER_UNIT
));
2455 if (!wi::fits_uhwi_p (woffset
))
2460 *offset
+= woffset
.to_uhwi ();
2462 x
= TREE_OPERAND (x
, 0);
2464 while (x
&& TREE_CODE (x
) == COMPONENT_REF
);
2467 /* Return nonzero if we can determine the exprs corresponding to memrefs
2468 X and Y and they do not overlap.
2469 If LOOP_VARIANT is set, skip offset-based disambiguation */
2472 nonoverlapping_memrefs_p (const_rtx x
, const_rtx y
, bool loop_invariant
)
2474 tree exprx
= MEM_EXPR (x
), expry
= MEM_EXPR (y
);
2477 bool moffsetx_known_p
, moffsety_known_p
;
2478 HOST_WIDE_INT moffsetx
= 0, moffsety
= 0;
2479 HOST_WIDE_INT offsetx
= 0, offsety
= 0, sizex
, sizey
, tem
;
2481 /* Unless both have exprs, we can't tell anything. */
2482 if (exprx
== 0 || expry
== 0)
2485 /* For spill-slot accesses make sure we have valid offsets. */
2486 if ((exprx
== get_spill_slot_decl (false)
2487 && ! MEM_OFFSET_KNOWN_P (x
))
2488 || (expry
== get_spill_slot_decl (false)
2489 && ! MEM_OFFSET_KNOWN_P (y
)))
2492 /* If the field reference test failed, look at the DECLs involved. */
2493 moffsetx_known_p
= MEM_OFFSET_KNOWN_P (x
);
2494 if (moffsetx_known_p
)
2495 moffsetx
= MEM_OFFSET (x
);
2496 if (TREE_CODE (exprx
) == COMPONENT_REF
)
2498 tree t
= decl_for_component_ref (exprx
);
2501 adjust_offset_for_component_ref (exprx
, &moffsetx_known_p
, &moffsetx
);
2505 moffsety_known_p
= MEM_OFFSET_KNOWN_P (y
);
2506 if (moffsety_known_p
)
2507 moffsety
= MEM_OFFSET (y
);
2508 if (TREE_CODE (expry
) == COMPONENT_REF
)
2510 tree t
= decl_for_component_ref (expry
);
2513 adjust_offset_for_component_ref (expry
, &moffsety_known_p
, &moffsety
);
2517 if (! DECL_P (exprx
) || ! DECL_P (expry
))
2520 /* With invalid code we can end up storing into the constant pool.
2521 Bail out to avoid ICEing when creating RTL for this.
2522 See gfortran.dg/lto/20091028-2_0.f90. */
2523 if (TREE_CODE (exprx
) == CONST_DECL
2524 || TREE_CODE (expry
) == CONST_DECL
)
2527 rtlx
= DECL_RTL (exprx
);
2528 rtly
= DECL_RTL (expry
);
2530 /* If either RTL is not a MEM, it must be a REG or CONCAT, meaning they
2531 can't overlap unless they are the same because we never reuse that part
2532 of the stack frame used for locals for spilled pseudos. */
2533 if ((!MEM_P (rtlx
) || !MEM_P (rtly
))
2534 && ! rtx_equal_p (rtlx
, rtly
))
2537 /* If we have MEMs referring to different address spaces (which can
2538 potentially overlap), we cannot easily tell from the addresses
2539 whether the references overlap. */
2540 if (MEM_P (rtlx
) && MEM_P (rtly
)
2541 && MEM_ADDR_SPACE (rtlx
) != MEM_ADDR_SPACE (rtly
))
2544 /* Get the base and offsets of both decls. If either is a register, we
2545 know both are and are the same, so use that as the base. The only
2546 we can avoid overlap is if we can deduce that they are nonoverlapping
2547 pieces of that decl, which is very rare. */
2548 basex
= MEM_P (rtlx
) ? XEXP (rtlx
, 0) : rtlx
;
2549 if (GET_CODE (basex
) == PLUS
&& CONST_INT_P (XEXP (basex
, 1)))
2550 offsetx
= INTVAL (XEXP (basex
, 1)), basex
= XEXP (basex
, 0);
2552 basey
= MEM_P (rtly
) ? XEXP (rtly
, 0) : rtly
;
2553 if (GET_CODE (basey
) == PLUS
&& CONST_INT_P (XEXP (basey
, 1)))
2554 offsety
= INTVAL (XEXP (basey
, 1)), basey
= XEXP (basey
, 0);
2556 /* If the bases are different, we know they do not overlap if both
2557 are constants or if one is a constant and the other a pointer into the
2558 stack frame. Otherwise a different base means we can't tell if they
2560 if (! rtx_equal_p (basex
, basey
))
2561 return ((CONSTANT_P (basex
) && CONSTANT_P (basey
))
2562 || (CONSTANT_P (basex
) && REG_P (basey
)
2563 && REGNO_PTR_FRAME_P (REGNO (basey
)))
2564 || (CONSTANT_P (basey
) && REG_P (basex
)
2565 && REGNO_PTR_FRAME_P (REGNO (basex
))));
2567 /* Offset based disambiguation not appropriate for loop invariant */
2571 sizex
= (!MEM_P (rtlx
) ? (int) GET_MODE_SIZE (GET_MODE (rtlx
))
2572 : MEM_SIZE_KNOWN_P (rtlx
) ? MEM_SIZE (rtlx
)
2574 sizey
= (!MEM_P (rtly
) ? (int) GET_MODE_SIZE (GET_MODE (rtly
))
2575 : MEM_SIZE_KNOWN_P (rtly
) ? MEM_SIZE (rtly
)
2578 /* If we have an offset for either memref, it can update the values computed
2580 if (moffsetx_known_p
)
2581 offsetx
+= moffsetx
, sizex
-= moffsetx
;
2582 if (moffsety_known_p
)
2583 offsety
+= moffsety
, sizey
-= moffsety
;
2585 /* If a memref has both a size and an offset, we can use the smaller size.
2586 We can't do this if the offset isn't known because we must view this
2587 memref as being anywhere inside the DECL's MEM. */
2588 if (MEM_SIZE_KNOWN_P (x
) && moffsetx_known_p
)
2589 sizex
= MEM_SIZE (x
);
2590 if (MEM_SIZE_KNOWN_P (y
) && moffsety_known_p
)
2591 sizey
= MEM_SIZE (y
);
2593 /* Put the values of the memref with the lower offset in X's values. */
2594 if (offsetx
> offsety
)
2596 tem
= offsetx
, offsetx
= offsety
, offsety
= tem
;
2597 tem
= sizex
, sizex
= sizey
, sizey
= tem
;
2600 /* If we don't know the size of the lower-offset value, we can't tell
2601 if they conflict. Otherwise, we do the test. */
2602 return sizex
>= 0 && offsety
>= offsetx
+ sizex
;
2605 /* Helper for true_dependence and canon_true_dependence.
2606 Checks for true dependence: X is read after store in MEM takes place.
2608 If MEM_CANONICALIZED is FALSE, then X_ADDR and MEM_ADDR should be
2609 NULL_RTX, and the canonical addresses of MEM and X are both computed
2610 here. If MEM_CANONICALIZED, then MEM must be already canonicalized.
2612 If X_ADDR is non-NULL, it is used in preference of XEXP (x, 0).
2614 Returns 1 if there is a true dependence, 0 otherwise. */
2617 true_dependence_1 (const_rtx mem
, machine_mode mem_mode
, rtx mem_addr
,
2618 const_rtx x
, rtx x_addr
, bool mem_canonicalized
)
2624 gcc_checking_assert (mem_canonicalized
? (mem_addr
!= NULL_RTX
)
2625 : (mem_addr
== NULL_RTX
&& x_addr
== NULL_RTX
));
2627 if (MEM_VOLATILE_P (x
) && MEM_VOLATILE_P (mem
))
2630 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
2631 This is used in epilogue deallocation functions, and in cselib. */
2632 if (GET_MODE (x
) == BLKmode
&& GET_CODE (XEXP (x
, 0)) == SCRATCH
)
2634 if (GET_MODE (mem
) == BLKmode
&& GET_CODE (XEXP (mem
, 0)) == SCRATCH
)
2636 if (MEM_ALIAS_SET (x
) == ALIAS_SET_MEMORY_BARRIER
2637 || MEM_ALIAS_SET (mem
) == ALIAS_SET_MEMORY_BARRIER
)
2641 x_addr
= XEXP (x
, 0);
2642 x_addr
= get_addr (x_addr
);
2646 mem_addr
= XEXP (mem
, 0);
2647 if (mem_mode
== VOIDmode
)
2648 mem_mode
= GET_MODE (mem
);
2650 true_mem_addr
= get_addr (mem_addr
);
2652 /* Read-only memory is by definition never modified, and therefore can't
2653 conflict with anything. However, don't assume anything when AND
2654 addresses are involved and leave to the code below to determine
2655 dependence. We don't expect to find read-only set on MEM, but
2656 stupid user tricks can produce them, so don't die. */
2657 if (MEM_READONLY_P (x
)
2658 && GET_CODE (x_addr
) != AND
2659 && GET_CODE (true_mem_addr
) != AND
)
2662 /* If we have MEMs referring to different address spaces (which can
2663 potentially overlap), we cannot easily tell from the addresses
2664 whether the references overlap. */
2665 if (MEM_ADDR_SPACE (mem
) != MEM_ADDR_SPACE (x
))
2668 base
= find_base_term (x_addr
);
2669 if (base
&& (GET_CODE (base
) == LABEL_REF
2670 || (GET_CODE (base
) == SYMBOL_REF
2671 && CONSTANT_POOL_ADDRESS_P (base
))))
2674 rtx mem_base
= find_base_term (true_mem_addr
);
2675 if (! base_alias_check (x_addr
, base
, true_mem_addr
, mem_base
,
2676 GET_MODE (x
), mem_mode
))
2679 x_addr
= canon_rtx (x_addr
);
2680 if (!mem_canonicalized
)
2681 mem_addr
= canon_rtx (true_mem_addr
);
2683 if ((ret
= memrefs_conflict_p (GET_MODE_SIZE (mem_mode
), mem_addr
,
2684 SIZE_FOR_MODE (x
), x_addr
, 0)) != -1)
2687 if (mems_in_disjoint_alias_sets_p (x
, mem
))
2690 if (nonoverlapping_memrefs_p (mem
, x
, false))
2693 return rtx_refs_may_alias_p (x
, mem
, true);
2696 /* True dependence: X is read after store in MEM takes place. */
2699 true_dependence (const_rtx mem
, machine_mode mem_mode
, const_rtx x
)
2701 return true_dependence_1 (mem
, mem_mode
, NULL_RTX
,
2702 x
, NULL_RTX
, /*mem_canonicalized=*/false);
2705 /* Canonical true dependence: X is read after store in MEM takes place.
2706 Variant of true_dependence which assumes MEM has already been
2707 canonicalized (hence we no longer do that here).
2708 The mem_addr argument has been added, since true_dependence_1 computed
2709 this value prior to canonicalizing. */
2712 canon_true_dependence (const_rtx mem
, machine_mode mem_mode
, rtx mem_addr
,
2713 const_rtx x
, rtx x_addr
)
2715 return true_dependence_1 (mem
, mem_mode
, mem_addr
,
2716 x
, x_addr
, /*mem_canonicalized=*/true);
2719 /* Returns nonzero if a write to X might alias a previous read from
2720 (or, if WRITEP is true, a write to) MEM.
2721 If X_CANONCALIZED is true, then X_ADDR is the canonicalized address of X,
2722 and X_MODE the mode for that access.
2723 If MEM_CANONICALIZED is true, MEM is canonicalized. */
2726 write_dependence_p (const_rtx mem
,
2727 const_rtx x
, machine_mode x_mode
, rtx x_addr
,
2728 bool mem_canonicalized
, bool x_canonicalized
, bool writep
)
2731 rtx true_mem_addr
, true_x_addr
;
2735 gcc_checking_assert (x_canonicalized
2736 ? (x_addr
!= NULL_RTX
&& x_mode
!= VOIDmode
)
2737 : (x_addr
== NULL_RTX
&& x_mode
== VOIDmode
));
2739 if (MEM_VOLATILE_P (x
) && MEM_VOLATILE_P (mem
))
2742 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
2743 This is used in epilogue deallocation functions. */
2744 if (GET_MODE (x
) == BLKmode
&& GET_CODE (XEXP (x
, 0)) == SCRATCH
)
2746 if (GET_MODE (mem
) == BLKmode
&& GET_CODE (XEXP (mem
, 0)) == SCRATCH
)
2748 if (MEM_ALIAS_SET (x
) == ALIAS_SET_MEMORY_BARRIER
2749 || MEM_ALIAS_SET (mem
) == ALIAS_SET_MEMORY_BARRIER
)
2753 x_addr
= XEXP (x
, 0);
2754 true_x_addr
= get_addr (x_addr
);
2756 mem_addr
= XEXP (mem
, 0);
2757 true_mem_addr
= get_addr (mem_addr
);
2759 /* A read from read-only memory can't conflict with read-write memory.
2760 Don't assume anything when AND addresses are involved and leave to
2761 the code below to determine dependence. */
2763 && MEM_READONLY_P (mem
)
2764 && GET_CODE (true_x_addr
) != AND
2765 && GET_CODE (true_mem_addr
) != AND
)
2768 /* If we have MEMs referring to different address spaces (which can
2769 potentially overlap), we cannot easily tell from the addresses
2770 whether the references overlap. */
2771 if (MEM_ADDR_SPACE (mem
) != MEM_ADDR_SPACE (x
))
2774 base
= find_base_term (true_mem_addr
);
2777 && (GET_CODE (base
) == LABEL_REF
2778 || (GET_CODE (base
) == SYMBOL_REF
2779 && CONSTANT_POOL_ADDRESS_P (base
))))
2782 rtx x_base
= find_base_term (true_x_addr
);
2783 if (! base_alias_check (true_x_addr
, x_base
, true_mem_addr
, base
,
2784 GET_MODE (x
), GET_MODE (mem
)))
2787 if (!x_canonicalized
)
2789 x_addr
= canon_rtx (true_x_addr
);
2790 x_mode
= GET_MODE (x
);
2792 if (!mem_canonicalized
)
2793 mem_addr
= canon_rtx (true_mem_addr
);
2795 if ((ret
= memrefs_conflict_p (SIZE_FOR_MODE (mem
), mem_addr
,
2796 GET_MODE_SIZE (x_mode
), x_addr
, 0)) != -1)
2799 if (nonoverlapping_memrefs_p (x
, mem
, false))
2802 return rtx_refs_may_alias_p (x
, mem
, false);
2805 /* Anti dependence: X is written after read in MEM takes place. */
2808 anti_dependence (const_rtx mem
, const_rtx x
)
2810 return write_dependence_p (mem
, x
, VOIDmode
, NULL_RTX
,
2811 /*mem_canonicalized=*/false,
2812 /*x_canonicalized*/false, /*writep=*/false);
2815 /* Likewise, but we already have a canonicalized MEM, and X_ADDR for X.
2816 Also, consider X in X_MODE (which might be from an enclosing
2817 STRICT_LOW_PART / ZERO_EXTRACT).
2818 If MEM_CANONICALIZED is true, MEM is canonicalized. */
2821 canon_anti_dependence (const_rtx mem
, bool mem_canonicalized
,
2822 const_rtx x
, machine_mode x_mode
, rtx x_addr
)
2824 return write_dependence_p (mem
, x
, x_mode
, x_addr
,
2825 mem_canonicalized
, /*x_canonicalized=*/true,
2829 /* Output dependence: X is written after store in MEM takes place. */
2832 output_dependence (const_rtx mem
, const_rtx x
)
2834 return write_dependence_p (mem
, x
, VOIDmode
, NULL_RTX
,
2835 /*mem_canonicalized=*/false,
2836 /*x_canonicalized*/false, /*writep=*/true);
2841 /* Check whether X may be aliased with MEM. Don't do offset-based
2842 memory disambiguation & TBAA. */
2844 may_alias_p (const_rtx mem
, const_rtx x
)
2846 rtx x_addr
, mem_addr
;
2848 if (MEM_VOLATILE_P (x
) && MEM_VOLATILE_P (mem
))
2851 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
2852 This is used in epilogue deallocation functions. */
2853 if (GET_MODE (x
) == BLKmode
&& GET_CODE (XEXP (x
, 0)) == SCRATCH
)
2855 if (GET_MODE (mem
) == BLKmode
&& GET_CODE (XEXP (mem
, 0)) == SCRATCH
)
2857 if (MEM_ALIAS_SET (x
) == ALIAS_SET_MEMORY_BARRIER
2858 || MEM_ALIAS_SET (mem
) == ALIAS_SET_MEMORY_BARRIER
)
2861 x_addr
= XEXP (x
, 0);
2862 x_addr
= get_addr (x_addr
);
2864 mem_addr
= XEXP (mem
, 0);
2865 mem_addr
= get_addr (mem_addr
);
2867 /* Read-only memory is by definition never modified, and therefore can't
2868 conflict with anything. However, don't assume anything when AND
2869 addresses are involved and leave to the code below to determine
2870 dependence. We don't expect to find read-only set on MEM, but
2871 stupid user tricks can produce them, so don't die. */
2872 if (MEM_READONLY_P (x
)
2873 && GET_CODE (x_addr
) != AND
2874 && GET_CODE (mem_addr
) != AND
)
2877 /* If we have MEMs referring to different address spaces (which can
2878 potentially overlap), we cannot easily tell from the addresses
2879 whether the references overlap. */
2880 if (MEM_ADDR_SPACE (mem
) != MEM_ADDR_SPACE (x
))
2883 rtx x_base
= find_base_term (x_addr
);
2884 rtx mem_base
= find_base_term (mem_addr
);
2885 if (! base_alias_check (x_addr
, x_base
, mem_addr
, mem_base
,
2886 GET_MODE (x
), GET_MODE (mem_addr
)))
2889 if (nonoverlapping_memrefs_p (mem
, x
, true))
2892 /* TBAA not valid for loop_invarint */
2893 return rtx_refs_may_alias_p (x
, mem
, false);
2897 init_alias_target (void)
2901 if (!arg_base_value
)
2902 arg_base_value
= gen_rtx_ADDRESS (VOIDmode
, 0);
2904 memset (static_reg_base_value
, 0, sizeof static_reg_base_value
);
2906 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2907 /* Check whether this register can hold an incoming pointer
2908 argument. FUNCTION_ARG_REGNO_P tests outgoing register
2909 numbers, so translate if necessary due to register windows. */
2910 if (FUNCTION_ARG_REGNO_P (OUTGOING_REGNO (i
))
2911 && HARD_REGNO_MODE_OK (i
, Pmode
))
2912 static_reg_base_value
[i
] = arg_base_value
;
2914 static_reg_base_value
[STACK_POINTER_REGNUM
]
2915 = unique_base_value (UNIQUE_BASE_VALUE_SP
);
2916 static_reg_base_value
[ARG_POINTER_REGNUM
]
2917 = unique_base_value (UNIQUE_BASE_VALUE_ARGP
);
2918 static_reg_base_value
[FRAME_POINTER_REGNUM
]
2919 = unique_base_value (UNIQUE_BASE_VALUE_FP
);
2920 if (!HARD_FRAME_POINTER_IS_FRAME_POINTER
)
2921 static_reg_base_value
[HARD_FRAME_POINTER_REGNUM
]
2922 = unique_base_value (UNIQUE_BASE_VALUE_HFP
);
2925 /* Set MEMORY_MODIFIED when X modifies DATA (that is assumed
2926 to be memory reference. */
2927 static bool memory_modified
;
2929 memory_modified_1 (rtx x
, const_rtx pat ATTRIBUTE_UNUSED
, void *data
)
2933 if (anti_dependence (x
, (const_rtx
)data
) || output_dependence (x
, (const_rtx
)data
))
2934 memory_modified
= true;
2939 /* Return true when INSN possibly modify memory contents of MEM
2940 (i.e. address can be modified). */
2942 memory_modified_in_insn_p (const_rtx mem
, const_rtx insn
)
2946 memory_modified
= false;
2947 note_stores (PATTERN (insn
), memory_modified_1
, CONST_CAST_RTX(mem
));
2948 return memory_modified
;
2951 /* Return TRUE if the destination of a set is rtx identical to
2954 set_dest_equal_p (const_rtx set
, const_rtx item
)
2956 rtx dest
= SET_DEST (set
);
2957 return rtx_equal_p (dest
, item
);
2960 /* Like memory_modified_in_insn_p, but return TRUE if INSN will
2961 *DEFINITELY* modify the memory contents of MEM. */
2963 memory_must_be_modified_in_insn_p (const_rtx mem
, const_rtx insn
)
2967 insn
= PATTERN (insn
);
2968 if (GET_CODE (insn
) == SET
)
2969 return set_dest_equal_p (insn
, mem
);
2970 else if (GET_CODE (insn
) == PARALLEL
)
2973 for (i
= 0; i
< XVECLEN (insn
, 0); i
++)
2975 rtx sub
= XVECEXP (insn
, 0, i
);
2976 if (GET_CODE (sub
) == SET
2977 && set_dest_equal_p (sub
, mem
))
2984 /* Initialize the aliasing machinery. Initialize the REG_KNOWN_VALUE
2988 init_alias_analysis (void)
2990 unsigned int maxreg
= max_reg_num ();
2999 timevar_push (TV_ALIAS_ANALYSIS
);
3001 vec_safe_grow_cleared (reg_known_value
, maxreg
- FIRST_PSEUDO_REGISTER
);
3002 reg_known_equiv_p
= sbitmap_alloc (maxreg
- FIRST_PSEUDO_REGISTER
);
3003 bitmap_clear (reg_known_equiv_p
);
3005 /* If we have memory allocated from the previous run, use it. */
3006 if (old_reg_base_value
)
3007 reg_base_value
= old_reg_base_value
;
3010 reg_base_value
->truncate (0);
3012 vec_safe_grow_cleared (reg_base_value
, maxreg
);
3014 new_reg_base_value
= XNEWVEC (rtx
, maxreg
);
3015 reg_seen
= sbitmap_alloc (maxreg
);
3017 /* The basic idea is that each pass through this loop will use the
3018 "constant" information from the previous pass to propagate alias
3019 information through another level of assignments.
3021 The propagation is done on the CFG in reverse post-order, to propagate
3022 things forward as far as possible in each iteration.
3024 This could get expensive if the assignment chains are long. Maybe
3025 we should throttle the number of iterations, possibly based on
3026 the optimization level or flag_expensive_optimizations.
3028 We could propagate more information in the first pass by making use
3029 of DF_REG_DEF_COUNT to determine immediately that the alias information
3030 for a pseudo is "constant".
3032 A program with an uninitialized variable can cause an infinite loop
3033 here. Instead of doing a full dataflow analysis to detect such problems
3034 we just cap the number of iterations for the loop.
3036 The state of the arrays for the set chain in question does not matter
3037 since the program has undefined behavior. */
3039 rpo
= XNEWVEC (int, n_basic_blocks_for_fn (cfun
));
3040 rpo_cnt
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
3045 /* Assume nothing will change this iteration of the loop. */
3048 /* We want to assign the same IDs each iteration of this loop, so
3049 start counting from one each iteration of the loop. */
3052 /* We're at the start of the function each iteration through the
3053 loop, so we're copying arguments. */
3054 copying_arguments
= true;
3056 /* Wipe the potential alias information clean for this pass. */
3057 memset (new_reg_base_value
, 0, maxreg
* sizeof (rtx
));
3059 /* Wipe the reg_seen array clean. */
3060 bitmap_clear (reg_seen
);
3062 /* Initialize the alias information for this pass. */
3063 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3064 if (static_reg_base_value
[i
])
3066 new_reg_base_value
[i
] = static_reg_base_value
[i
];
3067 bitmap_set_bit (reg_seen
, i
);
3070 /* Walk the insns adding values to the new_reg_base_value array. */
3071 for (i
= 0; i
< rpo_cnt
; i
++)
3073 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
3074 FOR_BB_INSNS (bb
, insn
)
3076 if (NONDEBUG_INSN_P (insn
))
3080 #if defined (HAVE_prologue)
3081 static const bool prologue
= true;
3083 static const bool prologue
= false;
3086 /* The prologue/epilogue insns are not threaded onto the
3087 insn chain until after reload has completed. Thus,
3088 there is no sense wasting time checking if INSN is in
3089 the prologue/epilogue until after reload has completed. */
3090 if ((prologue
|| HAVE_epilogue
) && reload_completed
3091 && prologue_epilogue_contains (insn
))
3094 /* If this insn has a noalias note, process it, Otherwise,
3095 scan for sets. A simple set will have no side effects
3096 which could change the base value of any other register. */
3098 if (GET_CODE (PATTERN (insn
)) == SET
3099 && REG_NOTES (insn
) != 0
3100 && find_reg_note (insn
, REG_NOALIAS
, NULL_RTX
))
3101 record_set (SET_DEST (PATTERN (insn
)), NULL_RTX
, NULL
);
3103 note_stores (PATTERN (insn
), record_set
, NULL
);
3105 set
= single_set (insn
);
3108 && REG_P (SET_DEST (set
))
3109 && REGNO (SET_DEST (set
)) >= FIRST_PSEUDO_REGISTER
)
3111 unsigned int regno
= REGNO (SET_DEST (set
));
3112 rtx src
= SET_SRC (set
);
3115 note
= find_reg_equal_equiv_note (insn
);
3116 if (note
&& REG_NOTE_KIND (note
) == REG_EQUAL
3117 && DF_REG_DEF_COUNT (regno
) != 1)
3120 if (note
!= NULL_RTX
3121 && GET_CODE (XEXP (note
, 0)) != EXPR_LIST
3122 && ! rtx_varies_p (XEXP (note
, 0), 1)
3123 && ! reg_overlap_mentioned_p (SET_DEST (set
),
3126 set_reg_known_value (regno
, XEXP (note
, 0));
3127 set_reg_known_equiv_p (regno
,
3128 REG_NOTE_KIND (note
) == REG_EQUIV
);
3130 else if (DF_REG_DEF_COUNT (regno
) == 1
3131 && GET_CODE (src
) == PLUS
3132 && REG_P (XEXP (src
, 0))
3133 && (t
= get_reg_known_value (REGNO (XEXP (src
, 0))))
3134 && CONST_INT_P (XEXP (src
, 1)))
3136 t
= plus_constant (GET_MODE (src
), t
,
3137 INTVAL (XEXP (src
, 1)));
3138 set_reg_known_value (regno
, t
);
3139 set_reg_known_equiv_p (regno
, false);
3141 else if (DF_REG_DEF_COUNT (regno
) == 1
3142 && ! rtx_varies_p (src
, 1))
3144 set_reg_known_value (regno
, src
);
3145 set_reg_known_equiv_p (regno
, false);
3149 else if (NOTE_P (insn
)
3150 && NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
)
3151 copying_arguments
= false;
3155 /* Now propagate values from new_reg_base_value to reg_base_value. */
3156 gcc_assert (maxreg
== (unsigned int) max_reg_num ());
3158 for (ui
= 0; ui
< maxreg
; ui
++)
3160 if (new_reg_base_value
[ui
]
3161 && new_reg_base_value
[ui
] != (*reg_base_value
)[ui
]
3162 && ! rtx_equal_p (new_reg_base_value
[ui
], (*reg_base_value
)[ui
]))
3164 (*reg_base_value
)[ui
] = new_reg_base_value
[ui
];
3169 while (changed
&& ++pass
< MAX_ALIAS_LOOP_PASSES
);
3172 /* Fill in the remaining entries. */
3173 FOR_EACH_VEC_ELT (*reg_known_value
, i
, val
)
3175 int regno
= i
+ FIRST_PSEUDO_REGISTER
;
3177 set_reg_known_value (regno
, regno_reg_rtx
[regno
]);
3181 free (new_reg_base_value
);
3182 new_reg_base_value
= 0;
3183 sbitmap_free (reg_seen
);
3185 timevar_pop (TV_ALIAS_ANALYSIS
);
3188 /* Equate REG_BASE_VALUE (reg1) to REG_BASE_VALUE (reg2).
3189 Special API for var-tracking pass purposes. */
3192 vt_equate_reg_base_value (const_rtx reg1
, const_rtx reg2
)
3194 (*reg_base_value
)[REGNO (reg1
)] = REG_BASE_VALUE (reg2
);
3198 end_alias_analysis (void)
3200 old_reg_base_value
= reg_base_value
;
3201 vec_free (reg_known_value
);
3202 sbitmap_free (reg_known_equiv_p
);
3206 dump_alias_stats_in_alias_c (FILE *s
)
3208 fprintf (s
, " TBAA oracle: %llu disambiguations %llu queries\n"
3209 " %llu are in alias set 0\n"
3210 " %llu queries asked about the same object\n"
3211 " %llu queries asked about the same alias set\n"
3212 " %llu access volatile\n"
3213 " %llu are dependent in the DAG\n"
3214 " %llu are aritificially in conflict with void *\n",
3215 alias_stats
.num_disambiguated
,
3216 alias_stats
.num_alias_zero
+ alias_stats
.num_same_alias_set
3217 + alias_stats
.num_same_objects
+ alias_stats
.num_volatile
3218 + alias_stats
.num_dag
+ alias_stats
.num_disambiguated
3219 + alias_stats
.num_universal
,
3220 alias_stats
.num_alias_zero
, alias_stats
.num_same_alias_set
,
3221 alias_stats
.num_same_objects
, alias_stats
.num_volatile
,
3222 alias_stats
.num_dag
, alias_stats
.num_universal
);
3224 #include "gt-alias.h"