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 "double-int.h"
36 #include "fold-const.h"
39 #include "hard-reg-set.h"
42 #include "statistics.h"
44 #include "fixed-value.h"
45 #include "insn-config.h"
55 #include "diagnostic-core.h"
58 #include "langhooks.h"
62 #include "dominance.h"
66 #include "basic-block.h"
68 #include "tree-ssa-alias.h"
69 #include "internal-fn.h"
70 #include "gimple-expr.h"
73 #include "gimple-ssa.h"
76 /* The aliasing API provided here solves related but different problems:
78 Say there exists (in c)
92 Consider the four questions:
94 Can a store to x1 interfere with px2->y1?
95 Can a store to x1 interfere with px2->z2?
96 Can a store to x1 change the value pointed to by with py?
97 Can a store to x1 change the value pointed to by with pz?
99 The answer to these questions can be yes, yes, yes, and maybe.
101 The first two questions can be answered with a simple examination
102 of the type system. If structure X contains a field of type Y then
103 a store through a pointer to an X can overwrite any field that is
104 contained (recursively) in an X (unless we know that px1 != px2).
106 The last two questions can be solved in the same way as the first
107 two questions but this is too conservative. The observation is
108 that in some cases we can know which (if any) fields are addressed
109 and if those addresses are used in bad ways. This analysis may be
110 language specific. In C, arbitrary operations may be applied to
111 pointers. However, there is some indication that this may be too
112 conservative for some C++ types.
114 The pass ipa-type-escape does this analysis for the types whose
115 instances do not escape across the compilation boundary.
117 Historically in GCC, these two problems were combined and a single
118 data structure that was used to represent the solution to these
119 problems. We now have two similar but different data structures,
120 The data structure to solve the last two questions is similar to
121 the first, but does not contain the fields whose address are never
122 taken. For types that do escape the compilation unit, the data
123 structures will have identical information.
126 /* The alias sets assigned to MEMs assist the back-end in determining
127 which MEMs can alias which other MEMs. In general, two MEMs in
128 different alias sets cannot alias each other, with one important
129 exception. Consider something like:
131 struct S { int i; double d; };
133 a store to an `S' can alias something of either type `int' or type
134 `double'. (However, a store to an `int' cannot alias a `double'
135 and vice versa.) We indicate this via a tree structure that looks
143 (The arrows are directed and point downwards.)
144 In this situation we say the alias set for `struct S' is the
145 `superset' and that those for `int' and `double' are `subsets'.
147 To see whether two alias sets can point to the same memory, we must
148 see if either alias set is a subset of the other. We need not trace
149 past immediate descendants, however, since we propagate all
150 grandchildren up one level.
152 Alias set zero is implicitly a superset of all other alias sets.
153 However, this is no actual entry for alias set zero. It is an
154 error to attempt to explicitly construct a subset of zero. */
156 struct alias_set_traits
: default_hashmap_traits
162 return e
.m_key
== INT_MIN
;
169 return e
.m_key
== (INT_MIN
+ 1);
172 template<typename T
> static void mark_empty (T
&e
) { e
.m_key
= INT_MIN
; }
178 e
.m_key
= INT_MIN
+ 1;
182 struct GTY(()) alias_set_entry_d
{
183 /* The alias set number, as stored in MEM_ALIAS_SET. */
184 alias_set_type alias_set
;
186 /* The children of the alias set. These are not just the immediate
187 children, but, in fact, all descendants. So, if we have:
189 struct T { struct S s; float f; }
191 continuing our example above, the children here will be all of
192 `int', `double', `float', and `struct S'. */
193 hash_map
<int, int, alias_set_traits
> *children
;
195 /* Nonzero if would have a child of zero: this effectively makes this
196 alias set the same as alias set zero. */
198 /* Nonzero if alias set corresponds to pointer type itself (i.e. not to
199 aggregate contaiing pointer.
200 This is used for a special case where we need an universal pointer type
201 compatible with all other pointer types. */
203 /* Nonzero if is_pointer or if one of childs have has_pointer set. */
206 typedef struct alias_set_entry_d
*alias_set_entry
;
208 static int rtx_equal_for_memref_p (const_rtx
, const_rtx
);
209 static int memrefs_conflict_p (int, rtx
, int, rtx
, HOST_WIDE_INT
);
210 static void record_set (rtx
, const_rtx
, void *);
211 static int base_alias_check (rtx
, rtx
, rtx
, rtx
, machine_mode
,
213 static rtx
find_base_value (rtx
);
214 static int mems_in_disjoint_alias_sets_p (const_rtx
, const_rtx
);
215 static alias_set_entry
get_alias_set_entry (alias_set_type
);
216 static tree
decl_for_component_ref (tree
);
217 static int write_dependence_p (const_rtx
,
218 const_rtx
, machine_mode
, rtx
,
221 static void memory_modified_1 (rtx
, const_rtx
, void *);
223 /* Query statistics for the different low-level disambiguators.
224 A high-level query may trigger multiple of them. */
227 unsigned long long num_alias_zero
;
228 unsigned long long num_same_alias_set
;
229 unsigned long long num_same_objects
;
230 unsigned long long num_volatile
;
231 unsigned long long num_dag
;
232 unsigned long long num_universal
;
233 unsigned long long num_disambiguated
;
237 /* Set up all info needed to perform alias analysis on memory references. */
239 /* Returns the size in bytes of the mode of X. */
240 #define SIZE_FOR_MODE(X) (GET_MODE_SIZE (GET_MODE (X)))
242 /* Cap the number of passes we make over the insns propagating alias
243 information through set chains.
244 ??? 10 is a completely arbitrary choice. This should be based on the
245 maximum loop depth in the CFG, but we do not have this information
246 available (even if current_loops _is_ available). */
247 #define MAX_ALIAS_LOOP_PASSES 10
249 /* reg_base_value[N] gives an address to which register N is related.
250 If all sets after the first add or subtract to the current value
251 or otherwise modify it so it does not point to a different top level
252 object, reg_base_value[N] is equal to the address part of the source
255 A base address can be an ADDRESS, SYMBOL_REF, or LABEL_REF. ADDRESS
256 expressions represent three types of base:
258 1. incoming arguments. There is just one ADDRESS to represent all
259 arguments, since we do not know at this level whether accesses
260 based on different arguments can alias. The ADDRESS has id 0.
262 2. stack_pointer_rtx, frame_pointer_rtx, hard_frame_pointer_rtx
263 (if distinct from frame_pointer_rtx) and arg_pointer_rtx.
264 Each of these rtxes has a separate ADDRESS associated with it,
265 each with a negative id.
267 GCC is (and is required to be) precise in which register it
268 chooses to access a particular region of stack. We can therefore
269 assume that accesses based on one of these rtxes do not alias
270 accesses based on another of these rtxes.
272 3. bases that are derived from malloc()ed memory (REG_NOALIAS).
273 Each such piece of memory has a separate ADDRESS associated
274 with it, each with an id greater than 0.
276 Accesses based on one ADDRESS do not alias accesses based on other
277 ADDRESSes. Accesses based on ADDRESSes in groups (2) and (3) do not
278 alias globals either; the ADDRESSes have Pmode to indicate this.
279 The ADDRESS in group (1) _may_ alias globals; it has VOIDmode to
282 static GTY(()) vec
<rtx
, va_gc
> *reg_base_value
;
283 static rtx
*new_reg_base_value
;
285 /* The single VOIDmode ADDRESS that represents all argument bases.
287 static GTY(()) rtx arg_base_value
;
289 /* Used to allocate unique ids to each REG_NOALIAS ADDRESS. */
290 static int unique_id
;
292 /* We preserve the copy of old array around to avoid amount of garbage
293 produced. About 8% of garbage produced were attributed to this
295 static GTY((deletable
)) vec
<rtx
, va_gc
> *old_reg_base_value
;
297 /* Values of XINT (address, 0) of Pmode ADDRESS rtxes for special
299 #define UNIQUE_BASE_VALUE_SP -1
300 #define UNIQUE_BASE_VALUE_ARGP -2
301 #define UNIQUE_BASE_VALUE_FP -3
302 #define UNIQUE_BASE_VALUE_HFP -4
304 #define static_reg_base_value \
305 (this_target_rtl->x_static_reg_base_value)
307 #define REG_BASE_VALUE(X) \
308 (REGNO (X) < vec_safe_length (reg_base_value) \
309 ? (*reg_base_value)[REGNO (X)] : 0)
311 /* Vector indexed by N giving the initial (unchanging) value known for
312 pseudo-register N. This vector is initialized in init_alias_analysis,
313 and does not change until end_alias_analysis is called. */
314 static GTY(()) vec
<rtx
, va_gc
> *reg_known_value
;
316 /* Vector recording for each reg_known_value whether it is due to a
317 REG_EQUIV note. Future passes (viz., reload) may replace the
318 pseudo with the equivalent expression and so we account for the
319 dependences that would be introduced if that happens.
321 The REG_EQUIV notes created in assign_parms may mention the arg
322 pointer, and there are explicit insns in the RTL that modify the
323 arg pointer. Thus we must ensure that such insns don't get
324 scheduled across each other because that would invalidate the
325 REG_EQUIV notes. One could argue that the REG_EQUIV notes are
326 wrong, but solving the problem in the scheduler will likely give
327 better code, so we do it here. */
328 static sbitmap reg_known_equiv_p
;
330 /* True when scanning insns from the start of the rtl to the
331 NOTE_INSN_FUNCTION_BEG note. */
332 static bool copying_arguments
;
335 /* The splay-tree used to store the various alias set entries. */
336 static GTY (()) vec
<alias_set_entry
, va_gc
> *alias_sets
;
338 /* Build a decomposed reference object for querying the alias-oracle
339 from the MEM rtx and store it in *REF.
340 Returns false if MEM is not suitable for the alias-oracle. */
343 ao_ref_from_mem (ao_ref
*ref
, const_rtx mem
)
345 tree expr
= MEM_EXPR (mem
);
351 ao_ref_init (ref
, expr
);
353 /* Get the base of the reference and see if we have to reject or
355 base
= ao_ref_base (ref
);
356 if (base
== NULL_TREE
)
359 /* The tree oracle doesn't like bases that are neither decls
360 nor indirect references of SSA names. */
362 || (TREE_CODE (base
) == MEM_REF
363 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
)
364 || (TREE_CODE (base
) == TARGET_MEM_REF
365 && TREE_CODE (TMR_BASE (base
)) == SSA_NAME
)))
368 /* If this is a reference based on a partitioned decl replace the
369 base with a MEM_REF of the pointer representative we
370 created during stack slot partitioning. */
371 if (TREE_CODE (base
) == VAR_DECL
372 && ! is_global_var (base
)
373 && cfun
->gimple_df
->decls_to_pointers
!= NULL
)
375 tree
*namep
= cfun
->gimple_df
->decls_to_pointers
->get (base
);
377 ref
->base
= build_simple_mem_ref (*namep
);
380 ref
->ref_alias_set
= MEM_ALIAS_SET (mem
);
382 /* If MEM_OFFSET or MEM_SIZE are unknown what we got from MEM_EXPR
383 is conservative, so trust it. */
384 if (!MEM_OFFSET_KNOWN_P (mem
)
385 || !MEM_SIZE_KNOWN_P (mem
))
388 /* If the base decl is a parameter we can have negative MEM_OFFSET in
389 case of promoted subregs on bigendian targets. Trust the MEM_EXPR
391 if (MEM_OFFSET (mem
) < 0
392 && (MEM_SIZE (mem
) + MEM_OFFSET (mem
)) * BITS_PER_UNIT
== ref
->size
)
395 /* Otherwise continue and refine size and offset we got from analyzing
396 MEM_EXPR by using MEM_SIZE and MEM_OFFSET. */
398 ref
->offset
+= MEM_OFFSET (mem
) * BITS_PER_UNIT
;
399 ref
->size
= MEM_SIZE (mem
) * BITS_PER_UNIT
;
401 /* The MEM may extend into adjacent fields, so adjust max_size if
403 if (ref
->max_size
!= -1
404 && ref
->size
> ref
->max_size
)
405 ref
->max_size
= ref
->size
;
407 /* If MEM_OFFSET and MEM_SIZE get us outside of the base object of
408 the MEM_EXPR punt. This happens for STRICT_ALIGNMENT targets a lot. */
409 if (MEM_EXPR (mem
) != get_spill_slot_decl (false)
411 || (DECL_P (ref
->base
)
412 && (DECL_SIZE (ref
->base
) == NULL_TREE
413 || TREE_CODE (DECL_SIZE (ref
->base
)) != INTEGER_CST
414 || wi::ltu_p (wi::to_offset (DECL_SIZE (ref
->base
)),
415 ref
->offset
+ ref
->size
)))))
421 /* Query the alias-oracle on whether the two memory rtx X and MEM may
422 alias. If TBAA_P is set also apply TBAA. Returns true if the
423 two rtxen may alias, false otherwise. */
426 rtx_refs_may_alias_p (const_rtx x
, const_rtx mem
, bool tbaa_p
)
430 if (!ao_ref_from_mem (&ref1
, x
)
431 || !ao_ref_from_mem (&ref2
, mem
))
434 return refs_may_alias_p_1 (&ref1
, &ref2
,
436 && MEM_ALIAS_SET (x
) != 0
437 && MEM_ALIAS_SET (mem
) != 0);
440 /* Returns a pointer to the alias set entry for ALIAS_SET, if there is
441 such an entry, or NULL otherwise. */
443 static inline alias_set_entry
444 get_alias_set_entry (alias_set_type alias_set
)
446 return (*alias_sets
)[alias_set
];
449 /* Returns nonzero if the alias sets for MEM1 and MEM2 are such that
450 the two MEMs cannot alias each other. */
453 mems_in_disjoint_alias_sets_p (const_rtx mem1
, const_rtx mem2
)
455 return (flag_strict_aliasing
456 && ! alias_sets_conflict_p (MEM_ALIAS_SET (mem1
),
457 MEM_ALIAS_SET (mem2
)));
460 /* Return true if the first alias set is a subset of the second. */
463 alias_set_subset_of (alias_set_type set1
, alias_set_type set2
)
465 alias_set_entry ase2
;
467 /* Everything is a subset of the "aliases everything" set. */
471 /* Check if set1 is a subset of set2. */
472 ase2
= get_alias_set_entry (set2
);
474 && (ase2
->has_zero_child
475 || (ase2
->children
&& ase2
->children
->get (set1
))))
478 /* As a special case we consider alias set of "void *" to be both subset
479 and superset of every alias set of a pointer. This extra symmetry does
480 not matter for alias_sets_conflict_p but it makes aliasing_component_refs_p
481 to return true on the following testcase:
484 char **ptr2=(char **)&ptr;
487 Additionally if a set contains universal pointer, we consider every pointer
488 to be a subset of it, but we do not represent this explicitely - doing so
489 would require us to update transitive closure each time we introduce new
490 pointer type. This makes aliasing_component_refs_p to return true
491 on the following testcase:
493 struct a {void *ptr;}
494 char **ptr = (char **)&a.ptr;
497 This makes void * truly universal pointer type. See pointer handling in
498 get_alias_set for more details. */
499 if (ase2
&& ase2
->has_pointer
)
501 alias_set_entry ase1
= get_alias_set_entry (set1
);
503 if (ase1
&& ase1
->is_pointer
)
505 alias_set_type voidptr_set
= TYPE_ALIAS_SET (ptr_type_node
);
506 /* If one is ptr_type_node and other is pointer, then we consider
507 them subset of each other. */
508 if (set1
== voidptr_set
|| set2
== voidptr_set
)
510 /* If SET2 contains universal pointer's alias set, then we consdier
511 every (non-universal) pointer. */
512 if (ase2
->children
&& set1
!= voidptr_set
513 && ase2
->children
->get (voidptr_set
))
520 /* Return 1 if the two specified alias sets may conflict. */
523 alias_sets_conflict_p (alias_set_type set1
, alias_set_type set2
)
525 alias_set_entry ase1
;
526 alias_set_entry ase2
;
529 if (alias_sets_must_conflict_p (set1
, set2
))
532 /* See if the first alias set is a subset of the second. */
533 ase1
= get_alias_set_entry (set1
);
535 && ase1
->children
&& ase1
->children
->get (set2
))
537 ++alias_stats
.num_dag
;
541 /* Now do the same, but with the alias sets reversed. */
542 ase2
= get_alias_set_entry (set2
);
544 && ase2
->children
&& ase2
->children
->get (set1
))
546 ++alias_stats
.num_dag
;
550 /* We want void * to be compatible with any other pointer without
551 really dropping it to alias set 0. Doing so would make it
552 compatible with all non-pointer types too.
554 This is not strictly necessary by the C/C++ language
555 standards, but avoids common type punning mistakes. In
556 addition to that, we need the existence of such universal
557 pointer to implement Fortran's C_PTR type (which is defined as
558 type compatible with all C pointers). */
559 if (ase1
&& ase2
&& ase1
->has_pointer
&& ase2
->has_pointer
)
561 alias_set_type voidptr_set
= TYPE_ALIAS_SET (ptr_type_node
);
563 /* If one of the sets corresponds to universal pointer,
564 we consider it to conflict with anything that is
565 or contains pointer. */
566 if (set1
== voidptr_set
|| set2
== voidptr_set
)
568 ++alias_stats
.num_universal
;
571 /* If one of sets is (non-universal) pointer and the other
572 contains universal pointer, we also get conflict. */
573 if (ase1
->is_pointer
&& set2
!= voidptr_set
574 && ase2
->children
&& ase2
->children
->get (voidptr_set
))
576 ++alias_stats
.num_universal
;
579 if (ase2
->is_pointer
&& set1
!= voidptr_set
580 && ase1
->children
&& ase1
->children
->get (voidptr_set
))
582 ++alias_stats
.num_universal
;
587 ++alias_stats
.num_disambiguated
;
589 /* The two alias sets are distinct and neither one is the
590 child of the other. Therefore, they cannot conflict. */
594 /* Return 1 if the two specified alias sets will always conflict. */
597 alias_sets_must_conflict_p (alias_set_type set1
, alias_set_type set2
)
599 if (set1
== 0 || set2
== 0)
601 ++alias_stats
.num_alias_zero
;
606 ++alias_stats
.num_same_alias_set
;
613 /* Return 1 if any MEM object of type T1 will always conflict (using the
614 dependency routines in this file) with any MEM object of type T2.
615 This is used when allocating temporary storage. If T1 and/or T2 are
616 NULL_TREE, it means we know nothing about the storage. */
619 objects_must_conflict_p (tree t1
, tree t2
)
621 alias_set_type set1
, set2
;
623 /* If neither has a type specified, we don't know if they'll conflict
624 because we may be using them to store objects of various types, for
625 example the argument and local variables areas of inlined functions. */
626 if (t1
== 0 && t2
== 0)
629 /* If they are the same type, they must conflict. */
632 ++alias_stats
.num_same_objects
;
635 /* Likewise if both are volatile. */
636 if (t1
!= 0 && TYPE_VOLATILE (t1
) && t2
!= 0 && TYPE_VOLATILE (t2
))
638 ++alias_stats
.num_volatile
;
642 set1
= t1
? get_alias_set (t1
) : 0;
643 set2
= t2
? get_alias_set (t2
) : 0;
645 /* We can't use alias_sets_conflict_p because we must make sure
646 that every subtype of t1 will conflict with every subtype of
647 t2 for which a pair of subobjects of these respective subtypes
648 overlaps on the stack. */
649 return alias_sets_must_conflict_p (set1
, set2
);
652 /* Return the outermost parent of component present in the chain of
653 component references handled by get_inner_reference in T with the
655 - the component is non-addressable, or
656 - the parent has alias set zero,
657 or NULL_TREE if no such parent exists. In the former cases, the alias
658 set of this parent is the alias set that must be used for T itself. */
661 component_uses_parent_alias_set_from (const_tree t
)
663 const_tree found
= NULL_TREE
;
665 while (handled_component_p (t
))
667 switch (TREE_CODE (t
))
670 if (DECL_NONADDRESSABLE_P (TREE_OPERAND (t
, 1)))
675 case ARRAY_RANGE_REF
:
676 if (TYPE_NONALIASED_COMPONENT (TREE_TYPE (TREE_OPERAND (t
, 0))))
685 case VIEW_CONVERT_EXPR
:
686 /* Bitfields and casts are never addressable. */
694 if (get_alias_set (TREE_TYPE (TREE_OPERAND (t
, 0))) == 0)
697 t
= TREE_OPERAND (t
, 0);
701 return TREE_OPERAND (found
, 0);
707 /* Return whether the pointer-type T effective for aliasing may
708 access everything and thus the reference has to be assigned
712 ref_all_alias_ptr_type_p (const_tree t
)
714 return (TREE_CODE (TREE_TYPE (t
)) == VOID_TYPE
715 || TYPE_REF_CAN_ALIAS_ALL (t
));
718 /* Return the alias set for the memory pointed to by T, which may be
719 either a type or an expression. Return -1 if there is nothing
720 special about dereferencing T. */
722 static alias_set_type
723 get_deref_alias_set_1 (tree t
)
725 /* All we care about is the type. */
729 /* If we have an INDIRECT_REF via a void pointer, we don't
730 know anything about what that might alias. Likewise if the
731 pointer is marked that way. */
732 if (ref_all_alias_ptr_type_p (t
))
738 /* Return the alias set for the memory pointed to by T, which may be
739 either a type or an expression. */
742 get_deref_alias_set (tree t
)
744 /* If we're not doing any alias analysis, just assume everything
745 aliases everything else. */
746 if (!flag_strict_aliasing
)
749 alias_set_type set
= get_deref_alias_set_1 (t
);
751 /* Fall back to the alias-set of the pointed-to type. */
756 set
= get_alias_set (TREE_TYPE (t
));
762 /* Return the pointer-type relevant for TBAA purposes from the
763 memory reference tree *T or NULL_TREE in which case *T is
764 adjusted to point to the outermost component reference that
765 can be used for assigning an alias set. */
768 reference_alias_ptr_type_1 (tree
*t
)
772 /* Get the base object of the reference. */
774 while (handled_component_p (inner
))
776 /* If there is a VIEW_CONVERT_EXPR in the chain we cannot use
777 the type of any component references that wrap it to
778 determine the alias-set. */
779 if (TREE_CODE (inner
) == VIEW_CONVERT_EXPR
)
780 *t
= TREE_OPERAND (inner
, 0);
781 inner
= TREE_OPERAND (inner
, 0);
784 /* Handle pointer dereferences here, they can override the
786 if (INDIRECT_REF_P (inner
)
787 && ref_all_alias_ptr_type_p (TREE_TYPE (TREE_OPERAND (inner
, 0))))
788 return TREE_TYPE (TREE_OPERAND (inner
, 0));
789 else if (TREE_CODE (inner
) == TARGET_MEM_REF
)
790 return TREE_TYPE (TMR_OFFSET (inner
));
791 else if (TREE_CODE (inner
) == MEM_REF
792 && ref_all_alias_ptr_type_p (TREE_TYPE (TREE_OPERAND (inner
, 1))))
793 return TREE_TYPE (TREE_OPERAND (inner
, 1));
795 /* If the innermost reference is a MEM_REF that has a
796 conversion embedded treat it like a VIEW_CONVERT_EXPR above,
797 using the memory access type for determining the alias-set. */
798 if (TREE_CODE (inner
) == MEM_REF
799 && (TYPE_MAIN_VARIANT (TREE_TYPE (inner
))
801 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (inner
, 1))))))
802 return TREE_TYPE (TREE_OPERAND (inner
, 1));
804 /* Otherwise, pick up the outermost object that we could have
806 tree tem
= component_uses_parent_alias_set_from (*t
);
813 /* Return the pointer-type relevant for TBAA purposes from the
814 gimple memory reference tree T. This is the type to be used for
815 the offset operand of MEM_REF or TARGET_MEM_REF replacements of T
816 and guarantees that get_alias_set will return the same alias
817 set for T and the replacement. */
820 reference_alias_ptr_type (tree t
)
822 tree ptype
= reference_alias_ptr_type_1 (&t
);
823 /* If there is a given pointer type for aliasing purposes, return it. */
824 if (ptype
!= NULL_TREE
)
827 /* Otherwise build one from the outermost component reference we
829 if (TREE_CODE (t
) == MEM_REF
830 || TREE_CODE (t
) == TARGET_MEM_REF
)
831 return TREE_TYPE (TREE_OPERAND (t
, 1));
833 return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (t
)));
836 /* Return whether the pointer-types T1 and T2 used to determine
837 two alias sets of two references will yield the same answer
838 from get_deref_alias_set. */
841 alias_ptr_types_compatible_p (tree t1
, tree t2
)
843 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
846 if (ref_all_alias_ptr_type_p (t1
)
847 || ref_all_alias_ptr_type_p (t2
))
850 return (TYPE_MAIN_VARIANT (TREE_TYPE (t1
))
851 == TYPE_MAIN_VARIANT (TREE_TYPE (t2
)));
854 /* Create emptry alias set entry. */
857 init_alias_set_entry (alias_set_type set
)
859 alias_set_entry ase
= ggc_alloc
<alias_set_entry_d
> ();
860 ase
->alias_set
= set
;
861 ase
->children
= NULL
;
862 ase
->has_zero_child
= false;
863 ase
->is_pointer
= false;
864 ase
->has_pointer
= false;
865 gcc_checking_assert (!get_alias_set_entry (set
));
866 (*alias_sets
)[set
] = ase
;
870 /* Return the alias set for T, which may be either a type or an
871 expression. Call language-specific routine for help, if needed. */
874 get_alias_set (tree t
)
878 /* If we're not doing any alias analysis, just assume everything
879 aliases everything else. Also return 0 if this or its type is
881 if (! flag_strict_aliasing
|| t
== error_mark_node
883 && (TREE_TYPE (t
) == 0 || TREE_TYPE (t
) == error_mark_node
)))
886 /* We can be passed either an expression or a type. This and the
887 language-specific routine may make mutually-recursive calls to each other
888 to figure out what to do. At each juncture, we see if this is a tree
889 that the language may need to handle specially. First handle things that
893 /* Give the language a chance to do something with this tree
894 before we look at it. */
896 set
= lang_hooks
.get_alias_set (t
);
900 /* Get the alias pointer-type to use or the outermost object
901 that we could have a pointer to. */
902 tree ptype
= reference_alias_ptr_type_1 (&t
);
904 return get_deref_alias_set (ptype
);
906 /* If we've already determined the alias set for a decl, just return
907 it. This is necessary for C++ anonymous unions, whose component
908 variables don't look like union members (boo!). */
909 if (TREE_CODE (t
) == VAR_DECL
910 && DECL_RTL_SET_P (t
) && MEM_P (DECL_RTL (t
)))
911 return MEM_ALIAS_SET (DECL_RTL (t
));
913 /* Now all we care about is the type. */
917 /* Variant qualifiers don't affect the alias set, so get the main
919 t
= TYPE_MAIN_VARIANT (t
);
921 /* Always use the canonical type as well. If this is a type that
922 requires structural comparisons to identify compatible types
923 use alias set zero. */
924 if (TYPE_STRUCTURAL_EQUALITY_P (t
))
926 /* Allow the language to specify another alias set for this
928 set
= lang_hooks
.get_alias_set (t
);
934 t
= TYPE_CANONICAL (t
);
936 /* The canonical type should not require structural equality checks. */
937 gcc_checking_assert (!TYPE_STRUCTURAL_EQUALITY_P (t
));
939 /* If this is a type with a known alias set, return it. */
940 if (TYPE_ALIAS_SET_KNOWN_P (t
))
941 return TYPE_ALIAS_SET (t
);
943 /* We don't want to set TYPE_ALIAS_SET for incomplete types. */
944 if (!COMPLETE_TYPE_P (t
))
946 /* For arrays with unknown size the conservative answer is the
947 alias set of the element type. */
948 if (TREE_CODE (t
) == ARRAY_TYPE
)
949 return get_alias_set (TREE_TYPE (t
));
951 /* But return zero as a conservative answer for incomplete types. */
955 /* See if the language has special handling for this type. */
956 set
= lang_hooks
.get_alias_set (t
);
960 /* There are no objects of FUNCTION_TYPE, so there's no point in
961 using up an alias set for them. (There are, of course, pointers
962 and references to functions, but that's different.) */
963 else if (TREE_CODE (t
) == FUNCTION_TYPE
|| TREE_CODE (t
) == METHOD_TYPE
)
966 /* Unless the language specifies otherwise, let vector types alias
967 their components. This avoids some nasty type punning issues in
968 normal usage. And indeed lets vectors be treated more like an
970 else if (TREE_CODE (t
) == VECTOR_TYPE
)
971 set
= get_alias_set (TREE_TYPE (t
));
973 /* Unless the language specifies otherwise, treat array types the
974 same as their components. This avoids the asymmetry we get
975 through recording the components. Consider accessing a
976 character(kind=1) through a reference to a character(kind=1)[1:1].
977 Or consider if we want to assign integer(kind=4)[0:D.1387] and
978 integer(kind=4)[4] the same alias set or not.
979 Just be pragmatic here and make sure the array and its element
980 type get the same alias set assigned. */
981 else if (TREE_CODE (t
) == ARRAY_TYPE
&& !TYPE_NONALIASED_COMPONENT (t
))
982 set
= get_alias_set (TREE_TYPE (t
));
984 /* From the former common C and C++ langhook implementation:
986 Unfortunately, there is no canonical form of a pointer type.
987 In particular, if we have `typedef int I', then `int *', and
988 `I *' are different types. So, we have to pick a canonical
989 representative. We do this below.
991 Technically, this approach is actually more conservative that
992 it needs to be. In particular, `const int *' and `int *'
993 should be in different alias sets, according to the C and C++
994 standard, since their types are not the same, and so,
995 technically, an `int **' and `const int **' cannot point at
998 But, the standard is wrong. In particular, this code is
1003 const int* const* cipp = ipp;
1004 And, it doesn't make sense for that to be legal unless you
1005 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
1006 the pointed-to types. This issue has been reported to the
1009 For this reason go to canonical type of the unqalified pointer type.
1010 Until GCC 6 this code set all pointers sets to have alias set of
1011 ptr_type_node but that is a bad idea, because it prevents disabiguations
1012 in between pointers. For Firefox this accounts about 20% of all
1013 disambiguations in the program. */
1014 else if (POINTER_TYPE_P (t
) && t
!= ptr_type_node
&& !in_lto_p
)
1017 auto_vec
<bool, 8> reference
;
1019 /* Unnest all pointers and references.
1020 We also want to make pointer to array equivalent to pointer to its
1021 element. So skip all array types, too. */
1022 for (p
= t
; POINTER_TYPE_P (p
)
1023 || (TREE_CODE (p
) == ARRAY_TYPE
&& !TYPE_NONALIASED_COMPONENT (p
));
1026 if (TREE_CODE (p
) == REFERENCE_TYPE
)
1027 reference
.safe_push (true);
1028 if (TREE_CODE (p
) == POINTER_TYPE
)
1029 reference
.safe_push (false);
1031 p
= TYPE_MAIN_VARIANT (p
);
1033 /* Make void * compatible with char * and also void **.
1034 Programs are commonly violating TBAA by this.
1036 We also make void * to conflict with every pointer
1037 (see record_component_aliases) and thus it is safe it to use it for
1038 pointers to types with TYPE_STRUCTURAL_EQUALITY_P. */
1039 if (TREE_CODE (p
) == VOID_TYPE
|| TYPE_STRUCTURAL_EQUALITY_P (p
))
1040 set
= get_alias_set (ptr_type_node
);
1043 /* Rebuild pointer type from starting from canonical types using
1044 unqualified pointers and references only. This way all such
1045 pointers will have the same alias set and will conflict with
1048 Most of time we already have pointers or references of a given type.
1049 If not we build new one just to be sure that if someone later
1050 (probably only middle-end can, as we should assign all alias
1051 classes only after finishing translation unit) builds the pointer
1052 type, the canonical type will match. */
1053 p
= TYPE_CANONICAL (p
);
1054 while (!reference
.is_empty ())
1056 if (reference
.pop ())
1057 p
= build_reference_type (p
);
1059 p
= build_pointer_type (p
);
1060 p
= TYPE_CANONICAL (TYPE_MAIN_VARIANT (p
));
1062 gcc_checking_assert (TYPE_CANONICAL (p
) == p
);
1064 /* Assign the alias set to both p and t.
1065 We can not call get_alias_set (p) here as that would trigger
1066 infinite recursion when p == t. In other cases it would just
1067 trigger unnecesary legwork of rebuilding the pointer again. */
1068 if (TYPE_ALIAS_SET_KNOWN_P (p
))
1069 set
= TYPE_ALIAS_SET (p
);
1072 set
= new_alias_set ();
1073 TYPE_ALIAS_SET (p
) = set
;
1077 /* In LTO the rules above needs to be part of canonical type machinery.
1078 For now just punt. */
1079 else if (POINTER_TYPE_P (t
) && t
!= ptr_type_node
&& in_lto_p
)
1080 set
= get_alias_set (ptr_type_node
);
1082 /* Otherwise make a new alias set for this type. */
1085 /* Each canonical type gets its own alias set, so canonical types
1086 shouldn't form a tree. It doesn't really matter for types
1087 we handle specially above, so only check it where it possibly
1088 would result in a bogus alias set. */
1089 gcc_checking_assert (TYPE_CANONICAL (t
) == t
);
1091 set
= new_alias_set ();
1094 TYPE_ALIAS_SET (t
) = set
;
1096 /* If this is an aggregate type or a complex type, we must record any
1097 component aliasing information. */
1098 if (AGGREGATE_TYPE_P (t
) || TREE_CODE (t
) == COMPLEX_TYPE
)
1099 record_component_aliases (t
);
1101 /* We treat pointer types specially in alias_set_subset_of. */
1102 if (POINTER_TYPE_P (t
) && set
)
1104 alias_set_entry ase
= get_alias_set_entry (set
);
1106 ase
= init_alias_set_entry (set
);
1107 ase
->is_pointer
= true;
1108 ase
->has_pointer
= true;
1114 /* Return a brand-new alias set. */
1117 new_alias_set (void)
1119 if (flag_strict_aliasing
)
1121 if (alias_sets
== 0)
1122 vec_safe_push (alias_sets
, (alias_set_entry
) 0);
1123 vec_safe_push (alias_sets
, (alias_set_entry
) 0);
1124 return alias_sets
->length () - 1;
1130 /* Indicate that things in SUBSET can alias things in SUPERSET, but that
1131 not everything that aliases SUPERSET also aliases SUBSET. For example,
1132 in C, a store to an `int' can alias a load of a structure containing an
1133 `int', and vice versa. But it can't alias a load of a 'double' member
1134 of the same structure. Here, the structure would be the SUPERSET and
1135 `int' the SUBSET. This relationship is also described in the comment at
1136 the beginning of this file.
1138 This function should be called only once per SUPERSET/SUBSET pair.
1140 It is illegal for SUPERSET to be zero; everything is implicitly a
1141 subset of alias set zero. */
1144 record_alias_subset (alias_set_type superset
, alias_set_type subset
)
1146 alias_set_entry superset_entry
;
1147 alias_set_entry subset_entry
;
1149 /* It is possible in complex type situations for both sets to be the same,
1150 in which case we can ignore this operation. */
1151 if (superset
== subset
)
1154 gcc_assert (superset
);
1156 superset_entry
= get_alias_set_entry (superset
);
1157 if (superset_entry
== 0)
1159 /* Create an entry for the SUPERSET, so that we have a place to
1160 attach the SUBSET. */
1161 superset_entry
= init_alias_set_entry (superset
);
1165 superset_entry
->has_zero_child
= 1;
1168 subset_entry
= get_alias_set_entry (subset
);
1169 if (!superset_entry
->children
)
1170 superset_entry
->children
1171 = hash_map
<int, int, alias_set_traits
>::create_ggc (64);
1172 /* If there is an entry for the subset, enter all of its children
1173 (if they are not already present) as children of the SUPERSET. */
1176 if (subset_entry
->has_zero_child
)
1177 superset_entry
->has_zero_child
= true;
1178 if (subset_entry
->has_pointer
)
1179 superset_entry
->has_pointer
= true;
1181 if (subset_entry
->children
)
1183 hash_map
<int, int, alias_set_traits
>::iterator iter
1184 = subset_entry
->children
->begin ();
1185 for (; iter
!= subset_entry
->children
->end (); ++iter
)
1186 superset_entry
->children
->put ((*iter
).first
, (*iter
).second
);
1190 /* Enter the SUBSET itself as a child of the SUPERSET. */
1191 superset_entry
->children
->put (subset
, 0);
1195 /* Record that component types of TYPE, if any, are part of that type for
1196 aliasing purposes. For record types, we only record component types
1197 for fields that are not marked non-addressable. For array types, we
1198 only record the component type if it is not marked non-aliased. */
1201 record_component_aliases (tree type
)
1203 alias_set_type superset
= get_alias_set (type
);
1209 switch (TREE_CODE (type
))
1213 case QUAL_UNION_TYPE
:
1214 for (field
= TYPE_FIELDS (type
); field
!= 0; field
= DECL_CHAIN (field
))
1215 if (TREE_CODE (field
) == FIELD_DECL
&& !DECL_NONADDRESSABLE_P (field
))
1216 record_alias_subset (superset
, get_alias_set (TREE_TYPE (field
)));
1220 record_alias_subset (superset
, get_alias_set (TREE_TYPE (type
)));
1223 /* VECTOR_TYPE and ARRAY_TYPE share the alias set with their
1231 /* Allocate an alias set for use in storing and reading from the varargs
1234 static GTY(()) alias_set_type varargs_set
= -1;
1237 get_varargs_alias_set (void)
1240 /* We now lower VA_ARG_EXPR, and there's currently no way to attach the
1241 varargs alias set to an INDIRECT_REF (FIXME!), so we can't
1242 consistently use the varargs alias set for loads from the varargs
1243 area. So don't use it anywhere. */
1246 if (varargs_set
== -1)
1247 varargs_set
= new_alias_set ();
1253 /* Likewise, but used for the fixed portions of the frame, e.g., register
1256 static GTY(()) alias_set_type frame_set
= -1;
1259 get_frame_alias_set (void)
1261 if (frame_set
== -1)
1262 frame_set
= new_alias_set ();
1267 /* Create a new, unique base with id ID. */
1270 unique_base_value (HOST_WIDE_INT id
)
1272 return gen_rtx_ADDRESS (Pmode
, id
);
1275 /* Return true if accesses based on any other base value cannot alias
1276 those based on X. */
1279 unique_base_value_p (rtx x
)
1281 return GET_CODE (x
) == ADDRESS
&& GET_MODE (x
) == Pmode
;
1284 /* Return true if X is known to be a base value. */
1287 known_base_value_p (rtx x
)
1289 switch (GET_CODE (x
))
1296 /* Arguments may or may not be bases; we don't know for sure. */
1297 return GET_MODE (x
) != VOIDmode
;
1304 /* Inside SRC, the source of a SET, find a base address. */
1307 find_base_value (rtx src
)
1311 #if defined (FIND_BASE_TERM)
1312 /* Try machine-dependent ways to find the base term. */
1313 src
= FIND_BASE_TERM (src
);
1316 switch (GET_CODE (src
))
1323 regno
= REGNO (src
);
1324 /* At the start of a function, argument registers have known base
1325 values which may be lost later. Returning an ADDRESS
1326 expression here allows optimization based on argument values
1327 even when the argument registers are used for other purposes. */
1328 if (regno
< FIRST_PSEUDO_REGISTER
&& copying_arguments
)
1329 return new_reg_base_value
[regno
];
1331 /* If a pseudo has a known base value, return it. Do not do this
1332 for non-fixed hard regs since it can result in a circular
1333 dependency chain for registers which have values at function entry.
1335 The test above is not sufficient because the scheduler may move
1336 a copy out of an arg reg past the NOTE_INSN_FUNCTION_BEGIN. */
1337 if ((regno
>= FIRST_PSEUDO_REGISTER
|| fixed_regs
[regno
])
1338 && regno
< vec_safe_length (reg_base_value
))
1340 /* If we're inside init_alias_analysis, use new_reg_base_value
1341 to reduce the number of relaxation iterations. */
1342 if (new_reg_base_value
&& new_reg_base_value
[regno
]
1343 && DF_REG_DEF_COUNT (regno
) == 1)
1344 return new_reg_base_value
[regno
];
1346 if ((*reg_base_value
)[regno
])
1347 return (*reg_base_value
)[regno
];
1353 /* Check for an argument passed in memory. Only record in the
1354 copying-arguments block; it is too hard to track changes
1356 if (copying_arguments
1357 && (XEXP (src
, 0) == arg_pointer_rtx
1358 || (GET_CODE (XEXP (src
, 0)) == PLUS
1359 && XEXP (XEXP (src
, 0), 0) == arg_pointer_rtx
)))
1360 return arg_base_value
;
1364 src
= XEXP (src
, 0);
1365 if (GET_CODE (src
) != PLUS
&& GET_CODE (src
) != MINUS
)
1368 /* ... fall through ... */
1373 rtx temp
, src_0
= XEXP (src
, 0), src_1
= XEXP (src
, 1);
1375 /* If either operand is a REG that is a known pointer, then it
1377 if (REG_P (src_0
) && REG_POINTER (src_0
))
1378 return find_base_value (src_0
);
1379 if (REG_P (src_1
) && REG_POINTER (src_1
))
1380 return find_base_value (src_1
);
1382 /* If either operand is a REG, then see if we already have
1383 a known value for it. */
1386 temp
= find_base_value (src_0
);
1393 temp
= find_base_value (src_1
);
1398 /* If either base is named object or a special address
1399 (like an argument or stack reference), then use it for the
1401 if (src_0
!= 0 && known_base_value_p (src_0
))
1404 if (src_1
!= 0 && known_base_value_p (src_1
))
1407 /* Guess which operand is the base address:
1408 If either operand is a symbol, then it is the base. If
1409 either operand is a CONST_INT, then the other is the base. */
1410 if (CONST_INT_P (src_1
) || CONSTANT_P (src_0
))
1411 return find_base_value (src_0
);
1412 else if (CONST_INT_P (src_0
) || CONSTANT_P (src_1
))
1413 return find_base_value (src_1
);
1419 /* The standard form is (lo_sum reg sym) so look only at the
1421 return find_base_value (XEXP (src
, 1));
1424 /* If the second operand is constant set the base
1425 address to the first operand. */
1426 if (CONST_INT_P (XEXP (src
, 1)) && INTVAL (XEXP (src
, 1)) != 0)
1427 return find_base_value (XEXP (src
, 0));
1431 /* As we do not know which address space the pointer is referring to, we can
1432 handle this only if the target does not support different pointer or
1433 address modes depending on the address space. */
1434 if (!target_default_pointer_address_modes_p ())
1436 if (GET_MODE_SIZE (GET_MODE (src
)) < GET_MODE_SIZE (Pmode
))
1446 return find_base_value (XEXP (src
, 0));
1449 case SIGN_EXTEND
: /* used for NT/Alpha pointers */
1450 /* As we do not know which address space the pointer is referring to, we can
1451 handle this only if the target does not support different pointer or
1452 address modes depending on the address space. */
1453 if (!target_default_pointer_address_modes_p ())
1457 rtx temp
= find_base_value (XEXP (src
, 0));
1459 if (temp
!= 0 && CONSTANT_P (temp
))
1460 temp
= convert_memory_address (Pmode
, temp
);
1472 /* Called from init_alias_analysis indirectly through note_stores,
1473 or directly if DEST is a register with a REG_NOALIAS note attached.
1474 SET is null in the latter case. */
1476 /* While scanning insns to find base values, reg_seen[N] is nonzero if
1477 register N has been set in this function. */
1478 static sbitmap reg_seen
;
1481 record_set (rtx dest
, const_rtx set
, void *data ATTRIBUTE_UNUSED
)
1490 regno
= REGNO (dest
);
1492 gcc_checking_assert (regno
< reg_base_value
->length ());
1494 n
= REG_NREGS (dest
);
1499 bitmap_set_bit (reg_seen
, regno
+ n
);
1500 new_reg_base_value
[regno
+ n
] = 0;
1507 /* A CLOBBER wipes out any old value but does not prevent a previously
1508 unset register from acquiring a base address (i.e. reg_seen is not
1510 if (GET_CODE (set
) == CLOBBER
)
1512 new_reg_base_value
[regno
] = 0;
1515 src
= SET_SRC (set
);
1519 /* There's a REG_NOALIAS note against DEST. */
1520 if (bitmap_bit_p (reg_seen
, regno
))
1522 new_reg_base_value
[regno
] = 0;
1525 bitmap_set_bit (reg_seen
, regno
);
1526 new_reg_base_value
[regno
] = unique_base_value (unique_id
++);
1530 /* If this is not the first set of REGNO, see whether the new value
1531 is related to the old one. There are two cases of interest:
1533 (1) The register might be assigned an entirely new value
1534 that has the same base term as the original set.
1536 (2) The set might be a simple self-modification that
1537 cannot change REGNO's base value.
1539 If neither case holds, reject the original base value as invalid.
1540 Note that the following situation is not detected:
1542 extern int x, y; int *p = &x; p += (&y-&x);
1544 ANSI C does not allow computing the difference of addresses
1545 of distinct top level objects. */
1546 if (new_reg_base_value
[regno
] != 0
1547 && find_base_value (src
) != new_reg_base_value
[regno
])
1548 switch (GET_CODE (src
))
1552 if (XEXP (src
, 0) != dest
&& XEXP (src
, 1) != dest
)
1553 new_reg_base_value
[regno
] = 0;
1556 /* If the value we add in the PLUS is also a valid base value,
1557 this might be the actual base value, and the original value
1560 rtx other
= NULL_RTX
;
1562 if (XEXP (src
, 0) == dest
)
1563 other
= XEXP (src
, 1);
1564 else if (XEXP (src
, 1) == dest
)
1565 other
= XEXP (src
, 0);
1567 if (! other
|| find_base_value (other
))
1568 new_reg_base_value
[regno
] = 0;
1572 if (XEXP (src
, 0) != dest
|| !CONST_INT_P (XEXP (src
, 1)))
1573 new_reg_base_value
[regno
] = 0;
1576 new_reg_base_value
[regno
] = 0;
1579 /* If this is the first set of a register, record the value. */
1580 else if ((regno
>= FIRST_PSEUDO_REGISTER
|| ! fixed_regs
[regno
])
1581 && ! bitmap_bit_p (reg_seen
, regno
) && new_reg_base_value
[regno
] == 0)
1582 new_reg_base_value
[regno
] = find_base_value (src
);
1584 bitmap_set_bit (reg_seen
, regno
);
1587 /* Return REG_BASE_VALUE for REGNO. Selective scheduler uses this to avoid
1588 using hard registers with non-null REG_BASE_VALUE for renaming. */
1590 get_reg_base_value (unsigned int regno
)
1592 return (*reg_base_value
)[regno
];
1595 /* If a value is known for REGNO, return it. */
1598 get_reg_known_value (unsigned int regno
)
1600 if (regno
>= FIRST_PSEUDO_REGISTER
)
1602 regno
-= FIRST_PSEUDO_REGISTER
;
1603 if (regno
< vec_safe_length (reg_known_value
))
1604 return (*reg_known_value
)[regno
];
1612 set_reg_known_value (unsigned int regno
, rtx val
)
1614 if (regno
>= FIRST_PSEUDO_REGISTER
)
1616 regno
-= FIRST_PSEUDO_REGISTER
;
1617 if (regno
< vec_safe_length (reg_known_value
))
1618 (*reg_known_value
)[regno
] = val
;
1622 /* Similarly for reg_known_equiv_p. */
1625 get_reg_known_equiv_p (unsigned int regno
)
1627 if (regno
>= FIRST_PSEUDO_REGISTER
)
1629 regno
-= FIRST_PSEUDO_REGISTER
;
1630 if (regno
< vec_safe_length (reg_known_value
))
1631 return bitmap_bit_p (reg_known_equiv_p
, regno
);
1637 set_reg_known_equiv_p (unsigned int regno
, bool val
)
1639 if (regno
>= FIRST_PSEUDO_REGISTER
)
1641 regno
-= FIRST_PSEUDO_REGISTER
;
1642 if (regno
< vec_safe_length (reg_known_value
))
1645 bitmap_set_bit (reg_known_equiv_p
, regno
);
1647 bitmap_clear_bit (reg_known_equiv_p
, regno
);
1653 /* Returns a canonical version of X, from the point of view alias
1654 analysis. (For example, if X is a MEM whose address is a register,
1655 and the register has a known value (say a SYMBOL_REF), then a MEM
1656 whose address is the SYMBOL_REF is returned.) */
1661 /* Recursively look for equivalences. */
1662 if (REG_P (x
) && REGNO (x
) >= FIRST_PSEUDO_REGISTER
)
1664 rtx t
= get_reg_known_value (REGNO (x
));
1668 return canon_rtx (t
);
1671 if (GET_CODE (x
) == PLUS
)
1673 rtx x0
= canon_rtx (XEXP (x
, 0));
1674 rtx x1
= canon_rtx (XEXP (x
, 1));
1676 if (x0
!= XEXP (x
, 0) || x1
!= XEXP (x
, 1))
1678 if (CONST_INT_P (x0
))
1679 return plus_constant (GET_MODE (x
), x1
, INTVAL (x0
));
1680 else if (CONST_INT_P (x1
))
1681 return plus_constant (GET_MODE (x
), x0
, INTVAL (x1
));
1682 return gen_rtx_PLUS (GET_MODE (x
), x0
, x1
);
1686 /* This gives us much better alias analysis when called from
1687 the loop optimizer. Note we want to leave the original
1688 MEM alone, but need to return the canonicalized MEM with
1689 all the flags with their original values. */
1691 x
= replace_equiv_address_nv (x
, canon_rtx (XEXP (x
, 0)));
1696 /* Return 1 if X and Y are identical-looking rtx's.
1697 Expect that X and Y has been already canonicalized.
1699 We use the data in reg_known_value above to see if two registers with
1700 different numbers are, in fact, equivalent. */
1703 rtx_equal_for_memref_p (const_rtx x
, const_rtx y
)
1710 if (x
== 0 && y
== 0)
1712 if (x
== 0 || y
== 0)
1718 code
= GET_CODE (x
);
1719 /* Rtx's of different codes cannot be equal. */
1720 if (code
!= GET_CODE (y
))
1723 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
1724 (REG:SI x) and (REG:HI x) are NOT equivalent. */
1726 if (GET_MODE (x
) != GET_MODE (y
))
1729 /* Some RTL can be compared without a recursive examination. */
1733 return REGNO (x
) == REGNO (y
);
1736 return LABEL_REF_LABEL (x
) == LABEL_REF_LABEL (y
);
1739 return XSTR (x
, 0) == XSTR (y
, 0);
1742 /* This is magic, don't go through canonicalization et al. */
1743 return rtx_equal_p (ENTRY_VALUE_EXP (x
), ENTRY_VALUE_EXP (y
));
1747 /* Pointer equality guarantees equality for these nodes. */
1754 /* canon_rtx knows how to handle plus. No need to canonicalize. */
1756 return ((rtx_equal_for_memref_p (XEXP (x
, 0), XEXP (y
, 0))
1757 && rtx_equal_for_memref_p (XEXP (x
, 1), XEXP (y
, 1)))
1758 || (rtx_equal_for_memref_p (XEXP (x
, 0), XEXP (y
, 1))
1759 && rtx_equal_for_memref_p (XEXP (x
, 1), XEXP (y
, 0))));
1760 /* For commutative operations, the RTX match if the operand match in any
1761 order. Also handle the simple binary and unary cases without a loop. */
1762 if (COMMUTATIVE_P (x
))
1764 rtx xop0
= canon_rtx (XEXP (x
, 0));
1765 rtx yop0
= canon_rtx (XEXP (y
, 0));
1766 rtx yop1
= canon_rtx (XEXP (y
, 1));
1768 return ((rtx_equal_for_memref_p (xop0
, yop0
)
1769 && rtx_equal_for_memref_p (canon_rtx (XEXP (x
, 1)), yop1
))
1770 || (rtx_equal_for_memref_p (xop0
, yop1
)
1771 && rtx_equal_for_memref_p (canon_rtx (XEXP (x
, 1)), yop0
)));
1773 else if (NON_COMMUTATIVE_P (x
))
1775 return (rtx_equal_for_memref_p (canon_rtx (XEXP (x
, 0)),
1776 canon_rtx (XEXP (y
, 0)))
1777 && rtx_equal_for_memref_p (canon_rtx (XEXP (x
, 1)),
1778 canon_rtx (XEXP (y
, 1))));
1780 else if (UNARY_P (x
))
1781 return rtx_equal_for_memref_p (canon_rtx (XEXP (x
, 0)),
1782 canon_rtx (XEXP (y
, 0)));
1784 /* Compare the elements. If any pair of corresponding elements
1785 fail to match, return 0 for the whole things.
1787 Limit cases to types which actually appear in addresses. */
1789 fmt
= GET_RTX_FORMAT (code
);
1790 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1795 if (XINT (x
, i
) != XINT (y
, i
))
1800 /* Two vectors must have the same length. */
1801 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
1804 /* And the corresponding elements must match. */
1805 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1806 if (rtx_equal_for_memref_p (canon_rtx (XVECEXP (x
, i
, j
)),
1807 canon_rtx (XVECEXP (y
, i
, j
))) == 0)
1812 if (rtx_equal_for_memref_p (canon_rtx (XEXP (x
, i
)),
1813 canon_rtx (XEXP (y
, i
))) == 0)
1817 /* This can happen for asm operands. */
1819 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
1823 /* This can happen for an asm which clobbers memory. */
1827 /* It is believed that rtx's at this level will never
1828 contain anything but integers and other rtx's,
1829 except for within LABEL_REFs and SYMBOL_REFs. */
1838 find_base_term (rtx x
)
1841 struct elt_loc_list
*l
, *f
;
1844 #if defined (FIND_BASE_TERM)
1845 /* Try machine-dependent ways to find the base term. */
1846 x
= FIND_BASE_TERM (x
);
1849 switch (GET_CODE (x
))
1852 return REG_BASE_VALUE (x
);
1855 /* As we do not know which address space the pointer is referring to, we can
1856 handle this only if the target does not support different pointer or
1857 address modes depending on the address space. */
1858 if (!target_default_pointer_address_modes_p ())
1860 if (GET_MODE_SIZE (GET_MODE (x
)) < GET_MODE_SIZE (Pmode
))
1870 return find_base_term (XEXP (x
, 0));
1873 case SIGN_EXTEND
: /* Used for Alpha/NT pointers */
1874 /* As we do not know which address space the pointer is referring to, we can
1875 handle this only if the target does not support different pointer or
1876 address modes depending on the address space. */
1877 if (!target_default_pointer_address_modes_p ())
1881 rtx temp
= find_base_term (XEXP (x
, 0));
1883 if (temp
!= 0 && CONSTANT_P (temp
))
1884 temp
= convert_memory_address (Pmode
, temp
);
1890 val
= CSELIB_VAL_PTR (x
);
1896 if (cselib_sp_based_value_p (val
))
1897 return static_reg_base_value
[STACK_POINTER_REGNUM
];
1900 /* Temporarily reset val->locs to avoid infinite recursion. */
1903 for (l
= f
; l
; l
= l
->next
)
1904 if (GET_CODE (l
->loc
) == VALUE
1905 && CSELIB_VAL_PTR (l
->loc
)->locs
1906 && !CSELIB_VAL_PTR (l
->loc
)->locs
->next
1907 && CSELIB_VAL_PTR (l
->loc
)->locs
->loc
== x
)
1909 else if ((ret
= find_base_term (l
->loc
)) != 0)
1916 /* The standard form is (lo_sum reg sym) so look only at the
1918 return find_base_term (XEXP (x
, 1));
1922 if (GET_CODE (x
) != PLUS
&& GET_CODE (x
) != MINUS
)
1928 rtx tmp1
= XEXP (x
, 0);
1929 rtx tmp2
= XEXP (x
, 1);
1931 /* This is a little bit tricky since we have to determine which of
1932 the two operands represents the real base address. Otherwise this
1933 routine may return the index register instead of the base register.
1935 That may cause us to believe no aliasing was possible, when in
1936 fact aliasing is possible.
1938 We use a few simple tests to guess the base register. Additional
1939 tests can certainly be added. For example, if one of the operands
1940 is a shift or multiply, then it must be the index register and the
1941 other operand is the base register. */
1943 if (tmp1
== pic_offset_table_rtx
&& CONSTANT_P (tmp2
))
1944 return find_base_term (tmp2
);
1946 /* If either operand is known to be a pointer, then prefer it
1947 to determine the base term. */
1948 if (REG_P (tmp1
) && REG_POINTER (tmp1
))
1950 else if (REG_P (tmp2
) && REG_POINTER (tmp2
))
1951 std::swap (tmp1
, tmp2
);
1952 /* If second argument is constant which has base term, prefer it
1953 over variable tmp1. See PR64025. */
1954 else if (CONSTANT_P (tmp2
) && !CONST_INT_P (tmp2
))
1955 std::swap (tmp1
, tmp2
);
1957 /* Go ahead and find the base term for both operands. If either base
1958 term is from a pointer or is a named object or a special address
1959 (like an argument or stack reference), then use it for the
1961 rtx base
= find_base_term (tmp1
);
1962 if (base
!= NULL_RTX
1963 && ((REG_P (tmp1
) && REG_POINTER (tmp1
))
1964 || known_base_value_p (base
)))
1966 base
= find_base_term (tmp2
);
1967 if (base
!= NULL_RTX
1968 && ((REG_P (tmp2
) && REG_POINTER (tmp2
))
1969 || known_base_value_p (base
)))
1972 /* We could not determine which of the two operands was the
1973 base register and which was the index. So we can determine
1974 nothing from the base alias check. */
1979 if (CONST_INT_P (XEXP (x
, 1)) && INTVAL (XEXP (x
, 1)) != 0)
1980 return find_base_term (XEXP (x
, 0));
1992 /* Return true if accesses to address X may alias accesses based
1993 on the stack pointer. */
1996 may_be_sp_based_p (rtx x
)
1998 rtx base
= find_base_term (x
);
1999 return !base
|| base
== static_reg_base_value
[STACK_POINTER_REGNUM
];
2002 /* Return 0 if the addresses X and Y are known to point to different
2003 objects, 1 if they might be pointers to the same object. */
2006 base_alias_check (rtx x
, rtx x_base
, rtx y
, rtx y_base
,
2007 machine_mode x_mode
, machine_mode y_mode
)
2009 /* If the address itself has no known base see if a known equivalent
2010 value has one. If either address still has no known base, nothing
2011 is known about aliasing. */
2016 if (! flag_expensive_optimizations
|| (x_c
= canon_rtx (x
)) == x
)
2019 x_base
= find_base_term (x_c
);
2027 if (! flag_expensive_optimizations
|| (y_c
= canon_rtx (y
)) == y
)
2030 y_base
= find_base_term (y_c
);
2035 /* If the base addresses are equal nothing is known about aliasing. */
2036 if (rtx_equal_p (x_base
, y_base
))
2039 /* The base addresses are different expressions. If they are not accessed
2040 via AND, there is no conflict. We can bring knowledge of object
2041 alignment into play here. For example, on alpha, "char a, b;" can
2042 alias one another, though "char a; long b;" cannot. AND addesses may
2043 implicitly alias surrounding objects; i.e. unaligned access in DImode
2044 via AND address can alias all surrounding object types except those
2045 with aligment 8 or higher. */
2046 if (GET_CODE (x
) == AND
&& GET_CODE (y
) == AND
)
2048 if (GET_CODE (x
) == AND
2049 && (!CONST_INT_P (XEXP (x
, 1))
2050 || (int) GET_MODE_UNIT_SIZE (y_mode
) < -INTVAL (XEXP (x
, 1))))
2052 if (GET_CODE (y
) == AND
2053 && (!CONST_INT_P (XEXP (y
, 1))
2054 || (int) GET_MODE_UNIT_SIZE (x_mode
) < -INTVAL (XEXP (y
, 1))))
2057 /* Differing symbols not accessed via AND never alias. */
2058 if (GET_CODE (x_base
) != ADDRESS
&& GET_CODE (y_base
) != ADDRESS
)
2061 if (unique_base_value_p (x_base
) || unique_base_value_p (y_base
))
2067 /* Return TRUE if EXPR refers to a VALUE whose uid is greater than
2071 refs_newer_value_p (const_rtx expr
, rtx v
)
2073 int minuid
= CSELIB_VAL_PTR (v
)->uid
;
2074 subrtx_iterator::array_type array
;
2075 FOR_EACH_SUBRTX (iter
, array
, expr
, NONCONST
)
2076 if (GET_CODE (*iter
) == VALUE
&& CSELIB_VAL_PTR (*iter
)->uid
> minuid
)
2081 /* Convert the address X into something we can use. This is done by returning
2082 it unchanged unless it is a value; in the latter case we call cselib to get
2083 a more useful rtx. */
2089 struct elt_loc_list
*l
;
2091 if (GET_CODE (x
) != VALUE
)
2093 v
= CSELIB_VAL_PTR (x
);
2096 bool have_equivs
= cselib_have_permanent_equivalences ();
2098 v
= canonical_cselib_val (v
);
2099 for (l
= v
->locs
; l
; l
= l
->next
)
2100 if (CONSTANT_P (l
->loc
))
2102 for (l
= v
->locs
; l
; l
= l
->next
)
2103 if (!REG_P (l
->loc
) && !MEM_P (l
->loc
)
2104 /* Avoid infinite recursion when potentially dealing with
2105 var-tracking artificial equivalences, by skipping the
2106 equivalences themselves, and not choosing expressions
2107 that refer to newer VALUEs. */
2109 || (GET_CODE (l
->loc
) != VALUE
2110 && !refs_newer_value_p (l
->loc
, x
))))
2114 for (l
= v
->locs
; l
; l
= l
->next
)
2116 || (GET_CODE (l
->loc
) != VALUE
2117 && !refs_newer_value_p (l
->loc
, x
)))
2119 /* Return the canonical value. */
2123 return v
->locs
->loc
;
2128 /* Return the address of the (N_REFS + 1)th memory reference to ADDR
2129 where SIZE is the size in bytes of the memory reference. If ADDR
2130 is not modified by the memory reference then ADDR is returned. */
2133 addr_side_effect_eval (rtx addr
, int size
, int n_refs
)
2137 switch (GET_CODE (addr
))
2140 offset
= (n_refs
+ 1) * size
;
2143 offset
= -(n_refs
+ 1) * size
;
2146 offset
= n_refs
* size
;
2149 offset
= -n_refs
* size
;
2157 addr
= gen_rtx_PLUS (GET_MODE (addr
), XEXP (addr
, 0),
2158 gen_int_mode (offset
, GET_MODE (addr
)));
2160 addr
= XEXP (addr
, 0);
2161 addr
= canon_rtx (addr
);
2166 /* Return TRUE if an object X sized at XSIZE bytes and another object
2167 Y sized at YSIZE bytes, starting C bytes after X, may overlap. If
2168 any of the sizes is zero, assume an overlap, otherwise use the
2169 absolute value of the sizes as the actual sizes. */
2172 offset_overlap_p (HOST_WIDE_INT c
, int xsize
, int ysize
)
2174 return (xsize
== 0 || ysize
== 0
2177 : (abs (ysize
) > -c
)));
2180 /* Return one if X and Y (memory addresses) reference the
2181 same location in memory or if the references overlap.
2182 Return zero if they do not overlap, else return
2183 minus one in which case they still might reference the same location.
2185 C is an offset accumulator. When
2186 C is nonzero, we are testing aliases between X and Y + C.
2187 XSIZE is the size in bytes of the X reference,
2188 similarly YSIZE is the size in bytes for Y.
2189 Expect that canon_rtx has been already called for X and Y.
2191 If XSIZE or YSIZE is zero, we do not know the amount of memory being
2192 referenced (the reference was BLKmode), so make the most pessimistic
2195 If XSIZE or YSIZE is negative, we may access memory outside the object
2196 being referenced as a side effect. This can happen when using AND to
2197 align memory references, as is done on the Alpha.
2199 Nice to notice that varying addresses cannot conflict with fp if no
2200 local variables had their addresses taken, but that's too hard now.
2202 ??? Contrary to the tree alias oracle this does not return
2203 one for X + non-constant and Y + non-constant when X and Y are equal.
2204 If that is fixed the TBAA hack for union type-punning can be removed. */
2207 memrefs_conflict_p (int xsize
, rtx x
, int ysize
, rtx y
, HOST_WIDE_INT c
)
2209 if (GET_CODE (x
) == VALUE
)
2213 struct elt_loc_list
*l
= NULL
;
2214 if (CSELIB_VAL_PTR (x
))
2215 for (l
= canonical_cselib_val (CSELIB_VAL_PTR (x
))->locs
;
2217 if (REG_P (l
->loc
) && rtx_equal_for_memref_p (l
->loc
, y
))
2224 /* Don't call get_addr if y is the same VALUE. */
2228 if (GET_CODE (y
) == VALUE
)
2232 struct elt_loc_list
*l
= NULL
;
2233 if (CSELIB_VAL_PTR (y
))
2234 for (l
= canonical_cselib_val (CSELIB_VAL_PTR (y
))->locs
;
2236 if (REG_P (l
->loc
) && rtx_equal_for_memref_p (l
->loc
, x
))
2243 /* Don't call get_addr if x is the same VALUE. */
2247 if (GET_CODE (x
) == HIGH
)
2249 else if (GET_CODE (x
) == LO_SUM
)
2252 x
= addr_side_effect_eval (x
, abs (xsize
), 0);
2253 if (GET_CODE (y
) == HIGH
)
2255 else if (GET_CODE (y
) == LO_SUM
)
2258 y
= addr_side_effect_eval (y
, abs (ysize
), 0);
2260 if (rtx_equal_for_memref_p (x
, y
))
2262 return offset_overlap_p (c
, xsize
, ysize
);
2265 /* This code used to check for conflicts involving stack references and
2266 globals but the base address alias code now handles these cases. */
2268 if (GET_CODE (x
) == PLUS
)
2270 /* The fact that X is canonicalized means that this
2271 PLUS rtx is canonicalized. */
2272 rtx x0
= XEXP (x
, 0);
2273 rtx x1
= XEXP (x
, 1);
2275 if (GET_CODE (y
) == PLUS
)
2277 /* The fact that Y is canonicalized means that this
2278 PLUS rtx is canonicalized. */
2279 rtx y0
= XEXP (y
, 0);
2280 rtx y1
= XEXP (y
, 1);
2282 if (rtx_equal_for_memref_p (x1
, y1
))
2283 return memrefs_conflict_p (xsize
, x0
, ysize
, y0
, c
);
2284 if (rtx_equal_for_memref_p (x0
, y0
))
2285 return memrefs_conflict_p (xsize
, x1
, ysize
, y1
, c
);
2286 if (CONST_INT_P (x1
))
2288 if (CONST_INT_P (y1
))
2289 return memrefs_conflict_p (xsize
, x0
, ysize
, y0
,
2290 c
- INTVAL (x1
) + INTVAL (y1
));
2292 return memrefs_conflict_p (xsize
, x0
, ysize
, y
,
2295 else if (CONST_INT_P (y1
))
2296 return memrefs_conflict_p (xsize
, x
, ysize
, y0
, c
+ INTVAL (y1
));
2300 else if (CONST_INT_P (x1
))
2301 return memrefs_conflict_p (xsize
, x0
, ysize
, y
, c
- INTVAL (x1
));
2303 else if (GET_CODE (y
) == PLUS
)
2305 /* The fact that Y is canonicalized means that this
2306 PLUS rtx is canonicalized. */
2307 rtx y0
= XEXP (y
, 0);
2308 rtx y1
= XEXP (y
, 1);
2310 if (CONST_INT_P (y1
))
2311 return memrefs_conflict_p (xsize
, x
, ysize
, y0
, c
+ INTVAL (y1
));
2316 if (GET_CODE (x
) == GET_CODE (y
))
2317 switch (GET_CODE (x
))
2321 /* Handle cases where we expect the second operands to be the
2322 same, and check only whether the first operand would conflict
2325 rtx x1
= canon_rtx (XEXP (x
, 1));
2326 rtx y1
= canon_rtx (XEXP (y
, 1));
2327 if (! rtx_equal_for_memref_p (x1
, y1
))
2329 x0
= canon_rtx (XEXP (x
, 0));
2330 y0
= canon_rtx (XEXP (y
, 0));
2331 if (rtx_equal_for_memref_p (x0
, y0
))
2332 return offset_overlap_p (c
, xsize
, ysize
);
2334 /* Can't properly adjust our sizes. */
2335 if (!CONST_INT_P (x1
))
2337 xsize
/= INTVAL (x1
);
2338 ysize
/= INTVAL (x1
);
2340 return memrefs_conflict_p (xsize
, x0
, ysize
, y0
, c
);
2347 /* Deal with alignment ANDs by adjusting offset and size so as to
2348 cover the maximum range, without taking any previously known
2349 alignment into account. Make a size negative after such an
2350 adjustments, so that, if we end up with e.g. two SYMBOL_REFs, we
2351 assume a potential overlap, because they may end up in contiguous
2352 memory locations and the stricter-alignment access may span over
2354 if (GET_CODE (x
) == AND
&& CONST_INT_P (XEXP (x
, 1)))
2356 HOST_WIDE_INT sc
= INTVAL (XEXP (x
, 1));
2357 unsigned HOST_WIDE_INT uc
= sc
;
2358 if (sc
< 0 && -uc
== (uc
& -uc
))
2365 return memrefs_conflict_p (xsize
, canon_rtx (XEXP (x
, 0)),
2369 if (GET_CODE (y
) == AND
&& CONST_INT_P (XEXP (y
, 1)))
2371 HOST_WIDE_INT sc
= INTVAL (XEXP (y
, 1));
2372 unsigned HOST_WIDE_INT uc
= sc
;
2373 if (sc
< 0 && -uc
== (uc
& -uc
))
2380 return memrefs_conflict_p (xsize
, x
,
2381 ysize
, canon_rtx (XEXP (y
, 0)), c
);
2387 if (CONST_INT_P (x
) && CONST_INT_P (y
))
2389 c
+= (INTVAL (y
) - INTVAL (x
));
2390 return offset_overlap_p (c
, xsize
, ysize
);
2393 if (GET_CODE (x
) == CONST
)
2395 if (GET_CODE (y
) == CONST
)
2396 return memrefs_conflict_p (xsize
, canon_rtx (XEXP (x
, 0)),
2397 ysize
, canon_rtx (XEXP (y
, 0)), c
);
2399 return memrefs_conflict_p (xsize
, canon_rtx (XEXP (x
, 0)),
2402 if (GET_CODE (y
) == CONST
)
2403 return memrefs_conflict_p (xsize
, x
, ysize
,
2404 canon_rtx (XEXP (y
, 0)), c
);
2406 /* Assume a potential overlap for symbolic addresses that went
2407 through alignment adjustments (i.e., that have negative
2408 sizes), because we can't know how far they are from each
2411 return (xsize
< 0 || ysize
< 0 || offset_overlap_p (c
, xsize
, ysize
));
2419 /* Functions to compute memory dependencies.
2421 Since we process the insns in execution order, we can build tables
2422 to keep track of what registers are fixed (and not aliased), what registers
2423 are varying in known ways, and what registers are varying in unknown
2426 If both memory references are volatile, then there must always be a
2427 dependence between the two references, since their order can not be
2428 changed. A volatile and non-volatile reference can be interchanged
2431 We also must allow AND addresses, because they may generate accesses
2432 outside the object being referenced. This is used to generate aligned
2433 addresses from unaligned addresses, for instance, the alpha
2434 storeqi_unaligned pattern. */
2436 /* Read dependence: X is read after read in MEM takes place. There can
2437 only be a dependence here if both reads are volatile, or if either is
2438 an explicit barrier. */
2441 read_dependence (const_rtx mem
, const_rtx x
)
2443 if (MEM_VOLATILE_P (x
) && MEM_VOLATILE_P (mem
))
2445 if (MEM_ALIAS_SET (x
) == ALIAS_SET_MEMORY_BARRIER
2446 || MEM_ALIAS_SET (mem
) == ALIAS_SET_MEMORY_BARRIER
)
2451 /* Look at the bottom of the COMPONENT_REF list for a DECL, and return it. */
2454 decl_for_component_ref (tree x
)
2458 x
= TREE_OPERAND (x
, 0);
2460 while (x
&& TREE_CODE (x
) == COMPONENT_REF
);
2462 return x
&& DECL_P (x
) ? x
: NULL_TREE
;
2465 /* Walk up the COMPONENT_REF list in X and adjust *OFFSET to compensate
2466 for the offset of the field reference. *KNOWN_P says whether the
2470 adjust_offset_for_component_ref (tree x
, bool *known_p
,
2471 HOST_WIDE_INT
*offset
)
2477 tree xoffset
= component_ref_field_offset (x
);
2478 tree field
= TREE_OPERAND (x
, 1);
2479 if (TREE_CODE (xoffset
) != INTEGER_CST
)
2486 = (wi::to_offset (xoffset
)
2487 + wi::lrshift (wi::to_offset (DECL_FIELD_BIT_OFFSET (field
)),
2488 LOG2_BITS_PER_UNIT
));
2489 if (!wi::fits_uhwi_p (woffset
))
2494 *offset
+= woffset
.to_uhwi ();
2496 x
= TREE_OPERAND (x
, 0);
2498 while (x
&& TREE_CODE (x
) == COMPONENT_REF
);
2501 /* Return nonzero if we can determine the exprs corresponding to memrefs
2502 X and Y and they do not overlap.
2503 If LOOP_VARIANT is set, skip offset-based disambiguation */
2506 nonoverlapping_memrefs_p (const_rtx x
, const_rtx y
, bool loop_invariant
)
2508 tree exprx
= MEM_EXPR (x
), expry
= MEM_EXPR (y
);
2511 bool moffsetx_known_p
, moffsety_known_p
;
2512 HOST_WIDE_INT moffsetx
= 0, moffsety
= 0;
2513 HOST_WIDE_INT offsetx
= 0, offsety
= 0, sizex
, sizey
, tem
;
2515 /* Unless both have exprs, we can't tell anything. */
2516 if (exprx
== 0 || expry
== 0)
2519 /* For spill-slot accesses make sure we have valid offsets. */
2520 if ((exprx
== get_spill_slot_decl (false)
2521 && ! MEM_OFFSET_KNOWN_P (x
))
2522 || (expry
== get_spill_slot_decl (false)
2523 && ! MEM_OFFSET_KNOWN_P (y
)))
2526 /* If the field reference test failed, look at the DECLs involved. */
2527 moffsetx_known_p
= MEM_OFFSET_KNOWN_P (x
);
2528 if (moffsetx_known_p
)
2529 moffsetx
= MEM_OFFSET (x
);
2530 if (TREE_CODE (exprx
) == COMPONENT_REF
)
2532 tree t
= decl_for_component_ref (exprx
);
2535 adjust_offset_for_component_ref (exprx
, &moffsetx_known_p
, &moffsetx
);
2539 moffsety_known_p
= MEM_OFFSET_KNOWN_P (y
);
2540 if (moffsety_known_p
)
2541 moffsety
= MEM_OFFSET (y
);
2542 if (TREE_CODE (expry
) == COMPONENT_REF
)
2544 tree t
= decl_for_component_ref (expry
);
2547 adjust_offset_for_component_ref (expry
, &moffsety_known_p
, &moffsety
);
2551 if (! DECL_P (exprx
) || ! DECL_P (expry
))
2554 /* With invalid code we can end up storing into the constant pool.
2555 Bail out to avoid ICEing when creating RTL for this.
2556 See gfortran.dg/lto/20091028-2_0.f90. */
2557 if (TREE_CODE (exprx
) == CONST_DECL
2558 || TREE_CODE (expry
) == CONST_DECL
)
2561 rtlx
= DECL_RTL (exprx
);
2562 rtly
= DECL_RTL (expry
);
2564 /* If either RTL is not a MEM, it must be a REG or CONCAT, meaning they
2565 can't overlap unless they are the same because we never reuse that part
2566 of the stack frame used for locals for spilled pseudos. */
2567 if ((!MEM_P (rtlx
) || !MEM_P (rtly
))
2568 && ! rtx_equal_p (rtlx
, rtly
))
2571 /* If we have MEMs referring to different address spaces (which can
2572 potentially overlap), we cannot easily tell from the addresses
2573 whether the references overlap. */
2574 if (MEM_P (rtlx
) && MEM_P (rtly
)
2575 && MEM_ADDR_SPACE (rtlx
) != MEM_ADDR_SPACE (rtly
))
2578 /* Get the base and offsets of both decls. If either is a register, we
2579 know both are and are the same, so use that as the base. The only
2580 we can avoid overlap is if we can deduce that they are nonoverlapping
2581 pieces of that decl, which is very rare. */
2582 basex
= MEM_P (rtlx
) ? XEXP (rtlx
, 0) : rtlx
;
2583 if (GET_CODE (basex
) == PLUS
&& CONST_INT_P (XEXP (basex
, 1)))
2584 offsetx
= INTVAL (XEXP (basex
, 1)), basex
= XEXP (basex
, 0);
2586 basey
= MEM_P (rtly
) ? XEXP (rtly
, 0) : rtly
;
2587 if (GET_CODE (basey
) == PLUS
&& CONST_INT_P (XEXP (basey
, 1)))
2588 offsety
= INTVAL (XEXP (basey
, 1)), basey
= XEXP (basey
, 0);
2590 /* If the bases are different, we know they do not overlap if both
2591 are constants or if one is a constant and the other a pointer into the
2592 stack frame. Otherwise a different base means we can't tell if they
2594 if (! rtx_equal_p (basex
, basey
))
2595 return ((CONSTANT_P (basex
) && CONSTANT_P (basey
))
2596 || (CONSTANT_P (basex
) && REG_P (basey
)
2597 && REGNO_PTR_FRAME_P (REGNO (basey
)))
2598 || (CONSTANT_P (basey
) && REG_P (basex
)
2599 && REGNO_PTR_FRAME_P (REGNO (basex
))));
2601 /* Offset based disambiguation not appropriate for loop invariant */
2605 sizex
= (!MEM_P (rtlx
) ? (int) GET_MODE_SIZE (GET_MODE (rtlx
))
2606 : MEM_SIZE_KNOWN_P (rtlx
) ? MEM_SIZE (rtlx
)
2608 sizey
= (!MEM_P (rtly
) ? (int) GET_MODE_SIZE (GET_MODE (rtly
))
2609 : MEM_SIZE_KNOWN_P (rtly
) ? MEM_SIZE (rtly
)
2612 /* If we have an offset for either memref, it can update the values computed
2614 if (moffsetx_known_p
)
2615 offsetx
+= moffsetx
, sizex
-= moffsetx
;
2616 if (moffsety_known_p
)
2617 offsety
+= moffsety
, sizey
-= moffsety
;
2619 /* If a memref has both a size and an offset, we can use the smaller size.
2620 We can't do this if the offset isn't known because we must view this
2621 memref as being anywhere inside the DECL's MEM. */
2622 if (MEM_SIZE_KNOWN_P (x
) && moffsetx_known_p
)
2623 sizex
= MEM_SIZE (x
);
2624 if (MEM_SIZE_KNOWN_P (y
) && moffsety_known_p
)
2625 sizey
= MEM_SIZE (y
);
2627 /* Put the values of the memref with the lower offset in X's values. */
2628 if (offsetx
> offsety
)
2630 tem
= offsetx
, offsetx
= offsety
, offsety
= tem
;
2631 tem
= sizex
, sizex
= sizey
, sizey
= tem
;
2634 /* If we don't know the size of the lower-offset value, we can't tell
2635 if they conflict. Otherwise, we do the test. */
2636 return sizex
>= 0 && offsety
>= offsetx
+ sizex
;
2639 /* Helper for true_dependence and canon_true_dependence.
2640 Checks for true dependence: X is read after store in MEM takes place.
2642 If MEM_CANONICALIZED is FALSE, then X_ADDR and MEM_ADDR should be
2643 NULL_RTX, and the canonical addresses of MEM and X are both computed
2644 here. If MEM_CANONICALIZED, then MEM must be already canonicalized.
2646 If X_ADDR is non-NULL, it is used in preference of XEXP (x, 0).
2648 Returns 1 if there is a true dependence, 0 otherwise. */
2651 true_dependence_1 (const_rtx mem
, machine_mode mem_mode
, rtx mem_addr
,
2652 const_rtx x
, rtx x_addr
, bool mem_canonicalized
)
2658 gcc_checking_assert (mem_canonicalized
? (mem_addr
!= NULL_RTX
)
2659 : (mem_addr
== NULL_RTX
&& x_addr
== NULL_RTX
));
2661 if (MEM_VOLATILE_P (x
) && MEM_VOLATILE_P (mem
))
2664 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
2665 This is used in epilogue deallocation functions, and in cselib. */
2666 if (GET_MODE (x
) == BLKmode
&& GET_CODE (XEXP (x
, 0)) == SCRATCH
)
2668 if (GET_MODE (mem
) == BLKmode
&& GET_CODE (XEXP (mem
, 0)) == SCRATCH
)
2670 if (MEM_ALIAS_SET (x
) == ALIAS_SET_MEMORY_BARRIER
2671 || MEM_ALIAS_SET (mem
) == ALIAS_SET_MEMORY_BARRIER
)
2675 x_addr
= XEXP (x
, 0);
2676 x_addr
= get_addr (x_addr
);
2680 mem_addr
= XEXP (mem
, 0);
2681 if (mem_mode
== VOIDmode
)
2682 mem_mode
= GET_MODE (mem
);
2684 true_mem_addr
= get_addr (mem_addr
);
2686 /* Read-only memory is by definition never modified, and therefore can't
2687 conflict with anything. However, don't assume anything when AND
2688 addresses are involved and leave to the code below to determine
2689 dependence. We don't expect to find read-only set on MEM, but
2690 stupid user tricks can produce them, so don't die. */
2691 if (MEM_READONLY_P (x
)
2692 && GET_CODE (x_addr
) != AND
2693 && GET_CODE (true_mem_addr
) != AND
)
2696 /* If we have MEMs referring to different address spaces (which can
2697 potentially overlap), we cannot easily tell from the addresses
2698 whether the references overlap. */
2699 if (MEM_ADDR_SPACE (mem
) != MEM_ADDR_SPACE (x
))
2702 base
= find_base_term (x_addr
);
2703 if (base
&& (GET_CODE (base
) == LABEL_REF
2704 || (GET_CODE (base
) == SYMBOL_REF
2705 && CONSTANT_POOL_ADDRESS_P (base
))))
2708 rtx mem_base
= find_base_term (true_mem_addr
);
2709 if (! base_alias_check (x_addr
, base
, true_mem_addr
, mem_base
,
2710 GET_MODE (x
), mem_mode
))
2713 x_addr
= canon_rtx (x_addr
);
2714 if (!mem_canonicalized
)
2715 mem_addr
= canon_rtx (true_mem_addr
);
2717 if ((ret
= memrefs_conflict_p (GET_MODE_SIZE (mem_mode
), mem_addr
,
2718 SIZE_FOR_MODE (x
), x_addr
, 0)) != -1)
2721 if (mems_in_disjoint_alias_sets_p (x
, mem
))
2724 if (nonoverlapping_memrefs_p (mem
, x
, false))
2727 return rtx_refs_may_alias_p (x
, mem
, true);
2730 /* True dependence: X is read after store in MEM takes place. */
2733 true_dependence (const_rtx mem
, machine_mode mem_mode
, const_rtx x
)
2735 return true_dependence_1 (mem
, mem_mode
, NULL_RTX
,
2736 x
, NULL_RTX
, /*mem_canonicalized=*/false);
2739 /* Canonical true dependence: X is read after store in MEM takes place.
2740 Variant of true_dependence which assumes MEM has already been
2741 canonicalized (hence we no longer do that here).
2742 The mem_addr argument has been added, since true_dependence_1 computed
2743 this value prior to canonicalizing. */
2746 canon_true_dependence (const_rtx mem
, machine_mode mem_mode
, rtx mem_addr
,
2747 const_rtx x
, rtx x_addr
)
2749 return true_dependence_1 (mem
, mem_mode
, mem_addr
,
2750 x
, x_addr
, /*mem_canonicalized=*/true);
2753 /* Returns nonzero if a write to X might alias a previous read from
2754 (or, if WRITEP is true, a write to) MEM.
2755 If X_CANONCALIZED is true, then X_ADDR is the canonicalized address of X,
2756 and X_MODE the mode for that access.
2757 If MEM_CANONICALIZED is true, MEM is canonicalized. */
2760 write_dependence_p (const_rtx mem
,
2761 const_rtx x
, machine_mode x_mode
, rtx x_addr
,
2762 bool mem_canonicalized
, bool x_canonicalized
, bool writep
)
2765 rtx true_mem_addr
, true_x_addr
;
2769 gcc_checking_assert (x_canonicalized
2770 ? (x_addr
!= NULL_RTX
&& x_mode
!= VOIDmode
)
2771 : (x_addr
== NULL_RTX
&& x_mode
== VOIDmode
));
2773 if (MEM_VOLATILE_P (x
) && MEM_VOLATILE_P (mem
))
2776 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
2777 This is used in epilogue deallocation functions. */
2778 if (GET_MODE (x
) == BLKmode
&& GET_CODE (XEXP (x
, 0)) == SCRATCH
)
2780 if (GET_MODE (mem
) == BLKmode
&& GET_CODE (XEXP (mem
, 0)) == SCRATCH
)
2782 if (MEM_ALIAS_SET (x
) == ALIAS_SET_MEMORY_BARRIER
2783 || MEM_ALIAS_SET (mem
) == ALIAS_SET_MEMORY_BARRIER
)
2787 x_addr
= XEXP (x
, 0);
2788 true_x_addr
= get_addr (x_addr
);
2790 mem_addr
= XEXP (mem
, 0);
2791 true_mem_addr
= get_addr (mem_addr
);
2793 /* A read from read-only memory can't conflict with read-write memory.
2794 Don't assume anything when AND addresses are involved and leave to
2795 the code below to determine dependence. */
2797 && MEM_READONLY_P (mem
)
2798 && GET_CODE (true_x_addr
) != AND
2799 && GET_CODE (true_mem_addr
) != AND
)
2802 /* If we have MEMs referring to different address spaces (which can
2803 potentially overlap), we cannot easily tell from the addresses
2804 whether the references overlap. */
2805 if (MEM_ADDR_SPACE (mem
) != MEM_ADDR_SPACE (x
))
2808 base
= find_base_term (true_mem_addr
);
2811 && (GET_CODE (base
) == LABEL_REF
2812 || (GET_CODE (base
) == SYMBOL_REF
2813 && CONSTANT_POOL_ADDRESS_P (base
))))
2816 rtx x_base
= find_base_term (true_x_addr
);
2817 if (! base_alias_check (true_x_addr
, x_base
, true_mem_addr
, base
,
2818 GET_MODE (x
), GET_MODE (mem
)))
2821 if (!x_canonicalized
)
2823 x_addr
= canon_rtx (true_x_addr
);
2824 x_mode
= GET_MODE (x
);
2826 if (!mem_canonicalized
)
2827 mem_addr
= canon_rtx (true_mem_addr
);
2829 if ((ret
= memrefs_conflict_p (SIZE_FOR_MODE (mem
), mem_addr
,
2830 GET_MODE_SIZE (x_mode
), x_addr
, 0)) != -1)
2833 if (nonoverlapping_memrefs_p (x
, mem
, false))
2836 return rtx_refs_may_alias_p (x
, mem
, false);
2839 /* Anti dependence: X is written after read in MEM takes place. */
2842 anti_dependence (const_rtx mem
, const_rtx x
)
2844 return write_dependence_p (mem
, x
, VOIDmode
, NULL_RTX
,
2845 /*mem_canonicalized=*/false,
2846 /*x_canonicalized*/false, /*writep=*/false);
2849 /* Likewise, but we already have a canonicalized MEM, and X_ADDR for X.
2850 Also, consider X in X_MODE (which might be from an enclosing
2851 STRICT_LOW_PART / ZERO_EXTRACT).
2852 If MEM_CANONICALIZED is true, MEM is canonicalized. */
2855 canon_anti_dependence (const_rtx mem
, bool mem_canonicalized
,
2856 const_rtx x
, machine_mode x_mode
, rtx x_addr
)
2858 return write_dependence_p (mem
, x
, x_mode
, x_addr
,
2859 mem_canonicalized
, /*x_canonicalized=*/true,
2863 /* Output dependence: X is written after store in MEM takes place. */
2866 output_dependence (const_rtx mem
, const_rtx x
)
2868 return write_dependence_p (mem
, x
, VOIDmode
, NULL_RTX
,
2869 /*mem_canonicalized=*/false,
2870 /*x_canonicalized*/false, /*writep=*/true);
2875 /* Check whether X may be aliased with MEM. Don't do offset-based
2876 memory disambiguation & TBAA. */
2878 may_alias_p (const_rtx mem
, const_rtx x
)
2880 rtx x_addr
, mem_addr
;
2882 if (MEM_VOLATILE_P (x
) && MEM_VOLATILE_P (mem
))
2885 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
2886 This is used in epilogue deallocation functions. */
2887 if (GET_MODE (x
) == BLKmode
&& GET_CODE (XEXP (x
, 0)) == SCRATCH
)
2889 if (GET_MODE (mem
) == BLKmode
&& GET_CODE (XEXP (mem
, 0)) == SCRATCH
)
2891 if (MEM_ALIAS_SET (x
) == ALIAS_SET_MEMORY_BARRIER
2892 || MEM_ALIAS_SET (mem
) == ALIAS_SET_MEMORY_BARRIER
)
2895 x_addr
= XEXP (x
, 0);
2896 x_addr
= get_addr (x_addr
);
2898 mem_addr
= XEXP (mem
, 0);
2899 mem_addr
= get_addr (mem_addr
);
2901 /* Read-only memory is by definition never modified, and therefore can't
2902 conflict with anything. However, don't assume anything when AND
2903 addresses are involved and leave to the code below to determine
2904 dependence. We don't expect to find read-only set on MEM, but
2905 stupid user tricks can produce them, so don't die. */
2906 if (MEM_READONLY_P (x
)
2907 && GET_CODE (x_addr
) != AND
2908 && GET_CODE (mem_addr
) != AND
)
2911 /* If we have MEMs referring to different address spaces (which can
2912 potentially overlap), we cannot easily tell from the addresses
2913 whether the references overlap. */
2914 if (MEM_ADDR_SPACE (mem
) != MEM_ADDR_SPACE (x
))
2917 rtx x_base
= find_base_term (x_addr
);
2918 rtx mem_base
= find_base_term (mem_addr
);
2919 if (! base_alias_check (x_addr
, x_base
, mem_addr
, mem_base
,
2920 GET_MODE (x
), GET_MODE (mem_addr
)))
2923 if (nonoverlapping_memrefs_p (mem
, x
, true))
2926 /* TBAA not valid for loop_invarint */
2927 return rtx_refs_may_alias_p (x
, mem
, false);
2931 init_alias_target (void)
2935 if (!arg_base_value
)
2936 arg_base_value
= gen_rtx_ADDRESS (VOIDmode
, 0);
2938 memset (static_reg_base_value
, 0, sizeof static_reg_base_value
);
2940 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2941 /* Check whether this register can hold an incoming pointer
2942 argument. FUNCTION_ARG_REGNO_P tests outgoing register
2943 numbers, so translate if necessary due to register windows. */
2944 if (FUNCTION_ARG_REGNO_P (OUTGOING_REGNO (i
))
2945 && HARD_REGNO_MODE_OK (i
, Pmode
))
2946 static_reg_base_value
[i
] = arg_base_value
;
2948 static_reg_base_value
[STACK_POINTER_REGNUM
]
2949 = unique_base_value (UNIQUE_BASE_VALUE_SP
);
2950 static_reg_base_value
[ARG_POINTER_REGNUM
]
2951 = unique_base_value (UNIQUE_BASE_VALUE_ARGP
);
2952 static_reg_base_value
[FRAME_POINTER_REGNUM
]
2953 = unique_base_value (UNIQUE_BASE_VALUE_FP
);
2954 if (!HARD_FRAME_POINTER_IS_FRAME_POINTER
)
2955 static_reg_base_value
[HARD_FRAME_POINTER_REGNUM
]
2956 = unique_base_value (UNIQUE_BASE_VALUE_HFP
);
2959 /* Set MEMORY_MODIFIED when X modifies DATA (that is assumed
2960 to be memory reference. */
2961 static bool memory_modified
;
2963 memory_modified_1 (rtx x
, const_rtx pat ATTRIBUTE_UNUSED
, void *data
)
2967 if (anti_dependence (x
, (const_rtx
)data
) || output_dependence (x
, (const_rtx
)data
))
2968 memory_modified
= true;
2973 /* Return true when INSN possibly modify memory contents of MEM
2974 (i.e. address can be modified). */
2976 memory_modified_in_insn_p (const_rtx mem
, const_rtx insn
)
2980 memory_modified
= false;
2981 note_stores (PATTERN (insn
), memory_modified_1
, CONST_CAST_RTX(mem
));
2982 return memory_modified
;
2985 /* Return TRUE if the destination of a set is rtx identical to
2988 set_dest_equal_p (const_rtx set
, const_rtx item
)
2990 rtx dest
= SET_DEST (set
);
2991 return rtx_equal_p (dest
, item
);
2994 /* Like memory_modified_in_insn_p, but return TRUE if INSN will
2995 *DEFINITELY* modify the memory contents of MEM. */
2997 memory_must_be_modified_in_insn_p (const_rtx mem
, const_rtx insn
)
3001 insn
= PATTERN (insn
);
3002 if (GET_CODE (insn
) == SET
)
3003 return set_dest_equal_p (insn
, mem
);
3004 else if (GET_CODE (insn
) == PARALLEL
)
3007 for (i
= 0; i
< XVECLEN (insn
, 0); i
++)
3009 rtx sub
= XVECEXP (insn
, 0, i
);
3010 if (GET_CODE (sub
) == SET
3011 && set_dest_equal_p (sub
, mem
))
3018 /* Initialize the aliasing machinery. Initialize the REG_KNOWN_VALUE
3022 init_alias_analysis (void)
3024 unsigned int maxreg
= max_reg_num ();
3033 timevar_push (TV_ALIAS_ANALYSIS
);
3035 vec_safe_grow_cleared (reg_known_value
, maxreg
- FIRST_PSEUDO_REGISTER
);
3036 reg_known_equiv_p
= sbitmap_alloc (maxreg
- FIRST_PSEUDO_REGISTER
);
3037 bitmap_clear (reg_known_equiv_p
);
3039 /* If we have memory allocated from the previous run, use it. */
3040 if (old_reg_base_value
)
3041 reg_base_value
= old_reg_base_value
;
3044 reg_base_value
->truncate (0);
3046 vec_safe_grow_cleared (reg_base_value
, maxreg
);
3048 new_reg_base_value
= XNEWVEC (rtx
, maxreg
);
3049 reg_seen
= sbitmap_alloc (maxreg
);
3051 /* The basic idea is that each pass through this loop will use the
3052 "constant" information from the previous pass to propagate alias
3053 information through another level of assignments.
3055 The propagation is done on the CFG in reverse post-order, to propagate
3056 things forward as far as possible in each iteration.
3058 This could get expensive if the assignment chains are long. Maybe
3059 we should throttle the number of iterations, possibly based on
3060 the optimization level or flag_expensive_optimizations.
3062 We could propagate more information in the first pass by making use
3063 of DF_REG_DEF_COUNT to determine immediately that the alias information
3064 for a pseudo is "constant".
3066 A program with an uninitialized variable can cause an infinite loop
3067 here. Instead of doing a full dataflow analysis to detect such problems
3068 we just cap the number of iterations for the loop.
3070 The state of the arrays for the set chain in question does not matter
3071 since the program has undefined behavior. */
3073 rpo
= XNEWVEC (int, n_basic_blocks_for_fn (cfun
));
3074 rpo_cnt
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
3079 /* Assume nothing will change this iteration of the loop. */
3082 /* We want to assign the same IDs each iteration of this loop, so
3083 start counting from one each iteration of the loop. */
3086 /* We're at the start of the function each iteration through the
3087 loop, so we're copying arguments. */
3088 copying_arguments
= true;
3090 /* Wipe the potential alias information clean for this pass. */
3091 memset (new_reg_base_value
, 0, maxreg
* sizeof (rtx
));
3093 /* Wipe the reg_seen array clean. */
3094 bitmap_clear (reg_seen
);
3096 /* Initialize the alias information for this pass. */
3097 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3098 if (static_reg_base_value
[i
])
3100 new_reg_base_value
[i
] = static_reg_base_value
[i
];
3101 bitmap_set_bit (reg_seen
, i
);
3104 /* Walk the insns adding values to the new_reg_base_value array. */
3105 for (i
= 0; i
< rpo_cnt
; i
++)
3107 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
3108 FOR_BB_INSNS (bb
, insn
)
3110 if (NONDEBUG_INSN_P (insn
))
3114 #if defined (HAVE_prologue)
3115 static const bool prologue
= true;
3117 static const bool prologue
= false;
3120 /* The prologue/epilogue insns are not threaded onto the
3121 insn chain until after reload has completed. Thus,
3122 there is no sense wasting time checking if INSN is in
3123 the prologue/epilogue until after reload has completed. */
3124 if ((prologue
|| HAVE_epilogue
) && reload_completed
3125 && prologue_epilogue_contains (insn
))
3128 /* If this insn has a noalias note, process it, Otherwise,
3129 scan for sets. A simple set will have no side effects
3130 which could change the base value of any other register. */
3132 if (GET_CODE (PATTERN (insn
)) == SET
3133 && REG_NOTES (insn
) != 0
3134 && find_reg_note (insn
, REG_NOALIAS
, NULL_RTX
))
3135 record_set (SET_DEST (PATTERN (insn
)), NULL_RTX
, NULL
);
3137 note_stores (PATTERN (insn
), record_set
, NULL
);
3139 set
= single_set (insn
);
3142 && REG_P (SET_DEST (set
))
3143 && REGNO (SET_DEST (set
)) >= FIRST_PSEUDO_REGISTER
)
3145 unsigned int regno
= REGNO (SET_DEST (set
));
3146 rtx src
= SET_SRC (set
);
3149 note
= find_reg_equal_equiv_note (insn
);
3150 if (note
&& REG_NOTE_KIND (note
) == REG_EQUAL
3151 && DF_REG_DEF_COUNT (regno
) != 1)
3154 if (note
!= NULL_RTX
3155 && GET_CODE (XEXP (note
, 0)) != EXPR_LIST
3156 && ! rtx_varies_p (XEXP (note
, 0), 1)
3157 && ! reg_overlap_mentioned_p (SET_DEST (set
),
3160 set_reg_known_value (regno
, XEXP (note
, 0));
3161 set_reg_known_equiv_p (regno
,
3162 REG_NOTE_KIND (note
) == REG_EQUIV
);
3164 else if (DF_REG_DEF_COUNT (regno
) == 1
3165 && GET_CODE (src
) == PLUS
3166 && REG_P (XEXP (src
, 0))
3167 && (t
= get_reg_known_value (REGNO (XEXP (src
, 0))))
3168 && CONST_INT_P (XEXP (src
, 1)))
3170 t
= plus_constant (GET_MODE (src
), t
,
3171 INTVAL (XEXP (src
, 1)));
3172 set_reg_known_value (regno
, t
);
3173 set_reg_known_equiv_p (regno
, false);
3175 else if (DF_REG_DEF_COUNT (regno
) == 1
3176 && ! rtx_varies_p (src
, 1))
3178 set_reg_known_value (regno
, src
);
3179 set_reg_known_equiv_p (regno
, false);
3183 else if (NOTE_P (insn
)
3184 && NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
)
3185 copying_arguments
= false;
3189 /* Now propagate values from new_reg_base_value to reg_base_value. */
3190 gcc_assert (maxreg
== (unsigned int) max_reg_num ());
3192 for (ui
= 0; ui
< maxreg
; ui
++)
3194 if (new_reg_base_value
[ui
]
3195 && new_reg_base_value
[ui
] != (*reg_base_value
)[ui
]
3196 && ! rtx_equal_p (new_reg_base_value
[ui
], (*reg_base_value
)[ui
]))
3198 (*reg_base_value
)[ui
] = new_reg_base_value
[ui
];
3203 while (changed
&& ++pass
< MAX_ALIAS_LOOP_PASSES
);
3206 /* Fill in the remaining entries. */
3207 FOR_EACH_VEC_ELT (*reg_known_value
, i
, val
)
3209 int regno
= i
+ FIRST_PSEUDO_REGISTER
;
3211 set_reg_known_value (regno
, regno_reg_rtx
[regno
]);
3215 free (new_reg_base_value
);
3216 new_reg_base_value
= 0;
3217 sbitmap_free (reg_seen
);
3219 timevar_pop (TV_ALIAS_ANALYSIS
);
3222 /* Equate REG_BASE_VALUE (reg1) to REG_BASE_VALUE (reg2).
3223 Special API for var-tracking pass purposes. */
3226 vt_equate_reg_base_value (const_rtx reg1
, const_rtx reg2
)
3228 (*reg_base_value
)[REGNO (reg1
)] = REG_BASE_VALUE (reg2
);
3232 end_alias_analysis (void)
3234 old_reg_base_value
= reg_base_value
;
3235 vec_free (reg_known_value
);
3236 sbitmap_free (reg_known_equiv_p
);
3240 dump_alias_stats_in_alias_c (FILE *s
)
3242 fprintf (s
, " TBAA oracle: %llu disambiguations %llu queries\n"
3243 " %llu are in alias set 0\n"
3244 " %llu queries asked about the same object\n"
3245 " %llu queries asked about the same alias set\n"
3246 " %llu access volatile\n"
3247 " %llu are dependent in the DAG\n"
3248 " %llu are aritificially in conflict with void *\n",
3249 alias_stats
.num_disambiguated
,
3250 alias_stats
.num_alias_zero
+ alias_stats
.num_same_alias_set
3251 + alias_stats
.num_same_objects
+ alias_stats
.num_volatile
3252 + alias_stats
.num_dag
+ alias_stats
.num_disambiguated
3253 + alias_stats
.num_universal
,
3254 alias_stats
.num_alias_zero
, alias_stats
.num_same_alias_set
,
3255 alias_stats
.num_same_objects
, alias_stats
.num_volatile
,
3256 alias_stats
.num_dag
, alias_stats
.num_universal
);
3258 #include "gt-alias.h"