CbC/CbC_gcc: gcc/alias.c comparison

comparison gcc/alias.c @ 132:d34655255c78

update gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 10:21:07 +0900
parents	84e7813d76e9
children	1830386684a0

comparison

equal deleted inserted replaced

-:e108057fa461
+:d34655255c78
 /* Alias analysis for GNU C
-Copyright (C) 1997-2017 Free Software Foundation, Inc.
+Copyright (C) 1997-2018 Free Software Foundation, Inc.
 Contributed by John Carr (jfc@mit.edu).
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 `int', `double', `float', and `struct S'.  */
 hash_map<alias_set_hash, int> *children;
 };
 static int rtx_equal_for_memref_p (const_rtx, const_rtx);
-static int memrefs_conflict_p (int, rtx, int, rtx, HOST_WIDE_INT);
 static void record_set (rtx, const_rtx, void *);
 static int base_alias_check (rtx, rtx, rtx, rtx, machine_mode,
 			     machine_mode);
 static rtx find_base_value (rtx);
 static int mems_in_disjoint_alias_sets_p (const_rtx, const_rtx);
 || !MEM_SIZE_KNOWN_P (mem))
 return true;
 /* If MEM_OFFSET/MEM_SIZE get us outside of ref->offset/ref->max_size
 drop ref->ref.  */
-if (MEM_OFFSET (mem) < 0
+if (maybe_lt (MEM_OFFSET (mem), 0)
-|| (ref->max_size != -1
+|| (ref->max_size_known_p ()
-	  && ((MEM_OFFSET (mem) + MEM_SIZE (mem)) * BITS_PER_UNIT
+	  && maybe_gt ((MEM_OFFSET (mem) + MEM_SIZE (mem)) * BITS_PER_UNIT,
-	      > ref->max_size)))
+		       ref->max_size)))
 ref->ref = NULL_TREE;
 /* Refine size and offset we got from analyzing MEM_EXPR by using
 MEM_SIZE and MEM_OFFSET.  */
 ref->offset += MEM_OFFSET (mem) * BITS_PER_UNIT;
 ref->size = MEM_SIZE (mem) * BITS_PER_UNIT;
 /* The MEM may extend into adjacent fields, so adjust max_size if
 necessary.  */
-if (ref->max_size != -1
+if (ref->max_size_known_p ())
-&& ref->size > ref->max_size)
+ref->max_size = upper_bound (ref->max_size, ref->size);
-ref->max_size = ref->size;
+/* If MEM_OFFSET and MEM_SIZE might get us outside of the base object of
-/* If MEM_OFFSET and MEM_SIZE get us outside of the base object of
 the MEM_EXPR punt.  This happens for STRICT_ALIGNMENT targets a lot.  */
 if (MEM_EXPR (mem) != get_spill_slot_decl (false)
-&& (ref->offset < 0
+&& (maybe_lt (ref->offset, 0)
 	  || (DECL_P (ref->base)
 	      && (DECL_SIZE (ref->base) == NULL_TREE
-		  || TREE_CODE (DECL_SIZE (ref->base)) != INTEGER_CST
+		  || !poly_int_tree_p (DECL_SIZE (ref->base))
-		  || wi::ltu_p (wi::to_offset (DECL_SIZE (ref->base)),
+		  || maybe_lt (wi::to_poly_offset (DECL_SIZE (ref->base)),
-				ref->offset + ref->size)))))
+			       ref->offset + ref->size)))))
 return false;
 return true;
 }
 static rtx
 find_base_value (rtx src)
 {
 unsigned int regno;
+scalar_int_mode int_mode;
 #if defined (FIND_BASE_TERM)
 /* Try machine-dependent ways to find the base term.  */
 src = FIND_BASE_TERM (src);
 #endif
 /* As we do not know which address space the pointer is referring to, we can
 	 handle this only if the target does not support different pointer or
 	 address modes depending on the address space.  */
 if (!target_default_pointer_address_modes_p ())
 	break;
-if (GET_MODE_SIZE (GET_MODE (src)) < GET_MODE_SIZE (Pmode))
+if (!is_a <scalar_int_mode> (GET_MODE (src), &int_mode)
+	  || GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (Pmode))
 	break;
 /* Fall through.  */
 case HIGH:
 case PRE_INC:
 case PRE_DEC:
 if (GET_CODE (set) == CLOBBER)
 	{
 	  new_reg_base_value[regno] = 0;
 	  return;
 	}
+/* A CLOBBER_HIGH only wipes out the old value if the mode of the old
+	 value is greater than that of the clobber.  */
+else if (GET_CODE (set) == CLOBBER_HIGH)
+	{
+	  if (new_reg_base_value[regno] != 0
+	      && reg_is_clobbered_by_clobber_high (
+		   regno, GET_MODE (new_reg_base_value[regno]), XEXP (set, 0)))
+	    new_reg_base_value[regno] = 0;
+	  return;
+	}
 src = SET_SRC (set);
 }
 else
 {
 /* There's a REG_NOALIAS note against DEST.  */
 	case 'i':
 	  if (XINT (x, i) != XINT (y, i))
 	    return 0;
 	  break;
+	case 'p':
+	  if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
+	    return 0;
+	  break;
 	case 'E':
 	  /* Two vectors must have the same length.  */
 	  if (XVECLEN (x, i) != XVECLEN (y, i))
 	    return 0;
 }
 return 1;
 }
 static rtx
-find_base_term (rtx x)
+find_base_term (rtx x, vec<std::pair<cselib_val *,
+				     struct elt_loc_list *> > &visited_vals)
 {
 cselib_val *val;
 struct elt_loc_list *l, *f;
 rtx ret;
+scalar_int_mode int_mode;
 #if defined (FIND_BASE_TERM)
 /* Try machine-dependent ways to find the base term.  */
 x = FIND_BASE_TERM (x);
 #endif
 /* As we do not know which address space the pointer is referring to, we can
 	 handle this only if the target does not support different pointer or
 	 address modes depending on the address space.  */
 if (!target_default_pointer_address_modes_p ())
 	return 0;
-if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (Pmode))
+if (!is_a <scalar_int_mode> (GET_MODE (x), &int_mode)
+	  || GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (Pmode))
 	return 0;
 /* Fall through.  */
 case HIGH:
 case PRE_INC:
 case PRE_DEC:
 case POST_INC:
 case POST_DEC:
 case PRE_MODIFY:
 case POST_MODIFY:
-return find_base_term (XEXP (x, 0));
+return find_base_term (XEXP (x, 0), visited_vals);
 case ZERO_EXTEND:
 case SIGN_EXTEND:	/* Used for Alpha/NT pointers */
 /* As we do not know which address space the pointer is referring to, we can
 	 handle this only if the target does not support different pointer or
 	 address modes depending on the address space.  */
 if (!target_default_pointer_address_modes_p ())
 	return 0;
 {
-	rtx temp = find_base_term (XEXP (x, 0));
+	rtx temp = find_base_term (XEXP (x, 0), visited_vals);
 	if (temp != 0 && CONSTANT_P (temp))
 	  temp = convert_memory_address (Pmode, temp);
 	return temp;
 if (cselib_sp_based_value_p (val))
 	return static_reg_base_value[STACK_POINTER_REGNUM];
 f = val->locs;
-/* Temporarily reset val->locs to avoid infinite recursion.  */
+/* Reset val->locs to avoid infinite recursion.  */
+if (f)
+	visited_vals.safe_push (std::make_pair (val, f));
 val->locs = NULL;
 for (l = f; l; l = l->next)
 	if (GET_CODE (l->loc) == VALUE
 	    && CSELIB_VAL_PTR (l->loc)->locs
 	    && !CSELIB_VAL_PTR (l->loc)->locs->next
 	    && CSELIB_VAL_PTR (l->loc)->locs->loc == x)
 	  continue;
-	else if ((ret = find_base_term (l->loc)) != 0)
+	else if ((ret = find_base_term (l->loc, visited_vals)) != 0)
 	  break;
-val->locs = f;
 return ret;
 case LO_SUM:
 /* The standard form is (lo_sum reg sym) so look only at the
 second operand.  */
-return find_base_term (XEXP (x, 1));
+return find_base_term (XEXP (x, 1), visited_vals);
 case CONST:
 x = XEXP (x, 0);
 if (GET_CODE (x) != PLUS && GET_CODE (x) != MINUS)
 	return 0;
 	   tests can certainly be added.  For example, if one of the operands
 	   is a shift or multiply, then it must be the index register and the
 	   other operand is the base register.  */
 	if (tmp1 == pic_offset_table_rtx && CONSTANT_P (tmp2))
-	  return find_base_term (tmp2);
+	  return find_base_term (tmp2, visited_vals);
 	/* If either operand is known to be a pointer, then prefer it
 	   to determine the base term.  */
 	if (REG_P (tmp1) && REG_POINTER (tmp1))
 	  ;
 	/* Go ahead and find the base term for both operands.  If either base
 	   term is from a pointer or is a named object or a special address
 	   (like an argument or stack reference), then use it for the
 	   base term.  */
-	rtx base = find_base_term (tmp1);
+	rtx base = find_base_term (tmp1, visited_vals);
 	if (base != NULL_RTX
 	    && ((REG_P (tmp1) && REG_POINTER (tmp1))
 		 || known_base_value_p (base)))
 	  return base;
-	base = find_base_term (tmp2);
+	base = find_base_term (tmp2, visited_vals);
 	if (base != NULL_RTX
 	    && ((REG_P (tmp2) && REG_POINTER (tmp2))
 		 || known_base_value_p (base)))
 	  return base;
 	return 0;
 }
 case AND:
 if (CONST_INT_P (XEXP (x, 1)) && INTVAL (XEXP (x, 1)) != 0)
-	return find_base_term (XEXP (x, 0));
+	return find_base_term (XEXP (x, 0), visited_vals);
 return 0;
 case SYMBOL_REF:
 case LABEL_REF:
 return x;
 default:
 return 0;
 }
+}
+/* Wrapper around the worker above which removes locs from visited VALUEs
+to avoid visiting them multiple times.  We unwind that changes here.  */
+static rtx
+find_base_term (rtx x)
+{
+auto_vec<std::pair<cselib_val *, struct elt_loc_list *>, 32> visited_vals;
+rtx res = find_base_term (x, visited_vals);
+for (unsigned i = 0; i < visited_vals.length (); ++i)
+visited_vals[i].first->locs = visited_vals[i].second;
+return res;
 }
 /* Return true if accesses to address X may alias accesses based
 on the stack pointer.  */
 	  && CONST_SCALAR_INT_P (XEXP (x, 1)))
 	{
 	  rtx op0 = get_addr (XEXP (x, 0));
 	  if (op0 != XEXP (x, 0))
 	    {
+	      poly_int64 c;
 	      if (GET_CODE (x) == PLUS
-		  && GET_CODE (XEXP (x, 1)) == CONST_INT)
+		  && poly_int_rtx_p (XEXP (x, 1), &c))
-		return plus_constant (GET_MODE (x), op0, INTVAL (XEXP (x, 1)));
+		return plus_constant (GET_MODE (x), op0, c);
 	      return simplify_gen_binary (GET_CODE (x), GET_MODE (x),
 					  op0, XEXP (x, 1));
 	    }
 	}
 return x;
 /*  Return the address of the (N_REFS + 1)th memory reference to ADDR
 where SIZE is the size in bytes of the memory reference.  If ADDR
 is not modified by the memory reference then ADDR is returned.  */
 static rtx
-addr_side_effect_eval (rtx addr, int size, int n_refs)
+addr_side_effect_eval (rtx addr, poly_int64 size, int n_refs)
 {
-int offset = 0;
+poly_int64 offset = 0;
 switch (GET_CODE (addr))
 {
 case PRE_INC:
 offset = (n_refs + 1) * size;
 default:
 return addr;
 }
-if (offset)
+addr = plus_constant (GET_MODE (addr), XEXP (addr, 0), offset);
-addr = gen_rtx_PLUS (GET_MODE (addr), XEXP (addr, 0),
-			 gen_int_mode (offset, GET_MODE (addr)));
-else
-addr = XEXP (addr, 0);
 addr = canon_rtx (addr);
 return addr;
 }
 Y sized at YSIZE bytes, starting C bytes after X, may overlap.  If
 any of the sizes is zero, assume an overlap, otherwise use the
 absolute value of the sizes as the actual sizes.  */
 static inline bool
-offset_overlap_p (HOST_WIDE_INT c, int xsize, int ysize)
+offset_overlap_p (poly_int64 c, poly_int64 xsize, poly_int64 ysize)
 {
-return (xsize == 0 || ysize == 0
+if (known_eq (xsize, 0) || known_eq (ysize, 0))
-	  || (c >= 0
+return true;
-	      ? (abs (xsize) > c)
-	      : (abs (ysize) > -c)));
+if (maybe_ge (c, 0))
+return maybe_gt (maybe_lt (xsize, 0) ? -xsize : xsize, c);
+else
+return maybe_gt (maybe_lt (ysize, 0) ? -ysize : ysize, -c);
 }
 /* Return one if X and Y (memory addresses) reference the
 same location in memory or if the references overlap.
 Return zero if they do not overlap, else return
 ???  Contrary to the tree alias oracle this does not return
 one for X + non-constant and Y + non-constant when X and Y are equal.
 If that is fixed the TBAA hack for union type-punning can be removed.  */
 static int
-memrefs_conflict_p (int xsize, rtx x, int ysize, rtx y, HOST_WIDE_INT c)
+memrefs_conflict_p (poly_int64 xsize, rtx x, poly_int64 ysize, rtx y,
+		    poly_int64 c)
 {
 if (GET_CODE (x) == VALUE)
 {
 if (REG_P (y))
 	{
 if (GET_CODE (x) == HIGH)
 x = XEXP (x, 0);
 else if (GET_CODE (x) == LO_SUM)
 x = XEXP (x, 1);
 else
-x = addr_side_effect_eval (x, abs (xsize), 0);
+x = addr_side_effect_eval (x, maybe_lt (xsize, 0) ? -xsize : xsize, 0);
 if (GET_CODE (y) == HIGH)
 y = XEXP (y, 0);
 else if (GET_CODE (y) == LO_SUM)
 y = XEXP (y, 1);
 else
-y = addr_side_effect_eval (y, abs (ysize), 0);
+y = addr_side_effect_eval (y, maybe_lt (ysize, 0) ? -ysize : ysize, 0);
 if (GET_CODE (x) == SYMBOL_REF && GET_CODE (y) == SYMBOL_REF)
 {
 int cmp = compare_base_symbol_refs (x,y);
 return offset_overlap_p (c, xsize, ysize);
 /* Assume a potential overlap for symbolic addresses that went
 	 through alignment adjustments (i.e., that have negative
 	 sizes), because we can't know how far they are from each
 	 other.  */
-if (xsize < 0 || ysize < 0)
+if (maybe_lt (xsize, 0) || maybe_lt (ysize, 0))
 	return -1;
 /* If decls are different or we know by offsets that there is no overlap,
 	 we win.  */
 if (!cmp || !offset_overlap_p (c, xsize, ysize))
 	return 0;
 if (x0 == y)
 	return memrefs_conflict_p (xsize, x1, ysize, const0_rtx, c);
 else if (x1 == y)
 	return memrefs_conflict_p (xsize, x0, ysize, const0_rtx, c);
+poly_int64 cx1, cy1;
 if (GET_CODE (y) == PLUS)
 	{
 	  /* The fact that Y is canonicalized means that this
 	     PLUS rtx is canonicalized.  */
 	  rtx y0 = XEXP (y, 0);
 	  if (rtx_equal_for_memref_p (x1, y1))
 	    return memrefs_conflict_p (xsize, x0, ysize, y0, c);
 	  if (rtx_equal_for_memref_p (x0, y0))
 	    return memrefs_conflict_p (xsize, x1, ysize, y1, c);
-	  if (CONST_INT_P (x1))
+	  if (poly_int_rtx_p (x1, &cx1))
 	    {
-	      if (CONST_INT_P (y1))
+	      if (poly_int_rtx_p (y1, &cy1))
 		return memrefs_conflict_p (xsize, x0, ysize, y0,
-					   c - INTVAL (x1) + INTVAL (y1));
+					   c - cx1 + cy1);
 	      else
-		return memrefs_conflict_p (xsize, x0, ysize, y,
+		return memrefs_conflict_p (xsize, x0, ysize, y, c - cx1);
-					   c - INTVAL (x1));
 	    }
-	  else if (CONST_INT_P (y1))
+	  else if (poly_int_rtx_p (y1, &cy1))
-	    return memrefs_conflict_p (xsize, x, ysize, y0, c + INTVAL (y1));
+	    return memrefs_conflict_p (xsize, x, ysize, y0, c + cy1);
 	  return -1;
 	}
-else if (CONST_INT_P (x1))
+else if (poly_int_rtx_p (x1, &cx1))
-	return memrefs_conflict_p (xsize, x0, ysize, y, c - INTVAL (x1));
+	return memrefs_conflict_p (xsize, x0, ysize, y, c - cx1);
 }
 else if (GET_CODE (y) == PLUS)
 {
 /* The fact that Y is canonicalized means that this
 	 PLUS rtx is canonicalized.  */
 if (x == y0)
 	return memrefs_conflict_p (xsize, const0_rtx, ysize, y1, c);
 if (x == y1)
 	return memrefs_conflict_p (xsize, const0_rtx, ysize, y0, c);
-if (CONST_INT_P (y1))
+poly_int64 cy1;
-	return memrefs_conflict_p (xsize, x, ysize, y0, c + INTVAL (y1));
+if (poly_int_rtx_p (y1, &cy1))
+	return memrefs_conflict_p (xsize, x, ysize, y0, c + cy1);
 else
 	return -1;
 }
 if (GET_CODE (x) == GET_CODE (y))
 	  y0 = canon_rtx (XEXP (y, 0));
 	  if (rtx_equal_for_memref_p (x0, y0))
 	    return offset_overlap_p (c, xsize, ysize);
 	  /* Can't properly adjust our sizes.  */
-	  if (!CONST_INT_P (x1))
+	  poly_int64 c1;
+	  if (!poly_int_rtx_p (x1, &c1)
+	      || !can_div_trunc_p (xsize, c1, &xsize)
+	      || !can_div_trunc_p (ysize, c1, &ysize)
+	      || !can_div_trunc_p (c, c1, &c))
 	    return -1;
-	  xsize /= INTVAL (x1);
-	  ysize /= INTVAL (x1);
-	  c /= INTVAL (x1);
 	  return memrefs_conflict_p (xsize, x0, ysize, y0, c);
 	}
 default:
 	break;
 {
 HOST_WIDE_INT sc = INTVAL (XEXP (x, 1));
 unsigned HOST_WIDE_INT uc = sc;
 if (sc < 0 && pow2_or_zerop (-uc))
 	{
-	  if (xsize > 0)
+	  if (maybe_gt (xsize, 0))
 	    xsize = -xsize;
-	  if (xsize)
+	  if (maybe_ne (xsize, 0))
 	    xsize += sc + 1;
 	  c -= sc + 1;
 	  return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)),
 				     ysize, y, c);
 	}
 {
 HOST_WIDE_INT sc = INTVAL (XEXP (y, 1));
 unsigned HOST_WIDE_INT uc = sc;
 if (sc < 0 && pow2_or_zerop (-uc))
 	{
-	  if (ysize > 0)
+	  if (maybe_gt (ysize, 0))
 	    ysize = -ysize;
-	  if (ysize)
+	  if (maybe_ne (ysize, 0))
 	    ysize += sc + 1;
 	  c += sc + 1;
 	  return memrefs_conflict_p (xsize, x,
 				     ysize, canon_rtx (XEXP (y, 0)), c);
 	}
 }
 if (CONSTANT_P (x))
 {
-if (CONST_INT_P (x) && CONST_INT_P (y))
+poly_int64 cx, cy;
+if (poly_int_rtx_p (x, &cx) && poly_int_rtx_p (y, &cy))
 	{
-	  c += (INTVAL (y) - INTVAL (x));
+	  c += cy - cx;
 	  return offset_overlap_p (c, xsize, ysize);
 	}
 if (GET_CODE (x) == CONST)
 	{
 /* Assume a potential overlap for symbolic addresses that went
 	 through alignment adjustments (i.e., that have negative
 	 sizes), because we can't know how far they are from each
 	 other.  */
 if (CONSTANT_P (y))
-	return (xsize < 0 || ysize < 0 || offset_overlap_p (c, xsize, ysize));
+	return (maybe_lt (xsize, 0)
+		|| maybe_lt (ysize, 0)
+		|| offset_overlap_p (c, xsize, ysize));
 return -1;
 }
 return -1;
 for the offset of the field reference.  *KNOWN_P says whether the
 offset is known.  */
 static void
 adjust_offset_for_component_ref (tree x, bool *known_p,
-				 HOST_WIDE_INT *offset)
+				 poly_int64 *offset)
 {
 if (!*known_p)
 return;
 do
 {
 tree xoffset = component_ref_field_offset (x);
 tree field = TREE_OPERAND (x, 1);
-if (TREE_CODE (xoffset) != INTEGER_CST)
+if (!poly_int_tree_p (xoffset))
 	{
 	  *known_p = false;
 	  return;
 	}
-offset_int woffset
+poly_offset_int woffset
-	= (wi::to_offset (xoffset)
+	= (wi::to_poly_offset (xoffset)
 	   + (wi::to_offset (DECL_FIELD_BIT_OFFSET (field))
-	      >> LOG2_BITS_PER_UNIT));
+	      >> LOG2_BITS_PER_UNIT)
-if (!wi::fits_uhwi_p (woffset))
+	   + *offset);
+if (!woffset.to_shwi (offset))
 	{
 	  *known_p = false;
 	  return;
 	}
-*offset += woffset.to_uhwi ();
 x = TREE_OPERAND (x, 0);
 }
 while (x && TREE_CODE (x) == COMPONENT_REF);
 }
 {
 tree exprx = MEM_EXPR (x), expry = MEM_EXPR (y);
 rtx rtlx, rtly;
 rtx basex, basey;
 bool moffsetx_known_p, moffsety_known_p;
-HOST_WIDE_INT moffsetx = 0, moffsety = 0;
+poly_int64 moffsetx = 0, moffsety = 0;
-HOST_WIDE_INT offsetx = 0, offsety = 0, sizex, sizey;
+poly_int64 offsetx = 0, offsety = 0, sizex, sizey;
 /* Unless both have exprs, we can't tell anything.  */
 if (exprx == 0 || expry == 0)
 return 0;
 /* Get the base and offsets of both decls.  If either is a register, we
 know both are and are the same, so use that as the base.  The only
 we can avoid overlap is if we can deduce that they are nonoverlapping
 pieces of that decl, which is very rare.  */
 basex = MEM_P (rtlx) ? XEXP (rtlx, 0) : rtlx;
-if (GET_CODE (basex) == PLUS && CONST_INT_P (XEXP (basex, 1)))
+basex = strip_offset_and_add (basex, &offsetx);
-offsetx = INTVAL (XEXP (basex, 1)), basex = XEXP (basex, 0);
 basey = MEM_P (rtly) ? XEXP (rtly, 0) : rtly;
-if (GET_CODE (basey) == PLUS && CONST_INT_P (XEXP (basey, 1)))
+basey = strip_offset_and_add (basey, &offsety);
-offsety = INTVAL (XEXP (basey, 1)), basey = XEXP (basey, 0);
 /* If the bases are different, we know they do not overlap if both
 are constants or if one is a constant and the other a pointer into the
 stack frame.  Otherwise a different base means we can't tell if they
 overlap or not.  */
 /* Offset based disambiguation is OK even if we do not know that the
 declarations are necessarily different
 (i.e. compare_base_decls (exprx, expry) == -1)  */
-sizex = (!MEM_P (rtlx) ? (int) GET_MODE_SIZE (GET_MODE (rtlx))
+sizex = (!MEM_P (rtlx) ? poly_int64 (GET_MODE_SIZE (GET_MODE (rtlx)))
 	   : MEM_SIZE_KNOWN_P (rtlx) ? MEM_SIZE (rtlx)
 	   : -1);
-sizey = (!MEM_P (rtly) ? (int) GET_MODE_SIZE (GET_MODE (rtly))
+sizey = (!MEM_P (rtly) ? poly_int64 (GET_MODE_SIZE (GET_MODE (rtly)))
 	   : MEM_SIZE_KNOWN_P (rtly) ? MEM_SIZE (rtly)
 	   : -1);
 /* If we have an offset for either memref, it can update the values computed
 above.  */
 if (MEM_SIZE_KNOWN_P (x) && moffsetx_known_p)
 sizex = MEM_SIZE (x);
 if (MEM_SIZE_KNOWN_P (y) && moffsety_known_p)
 sizey = MEM_SIZE (y);
-/* Put the values of the memref with the lower offset in X's values.  */
+return !ranges_maybe_overlap_p (offsetx, sizex, offsety, sizey);
-if (offsetx > offsety)
-{
-std::swap (offsetx, offsety);
-std::swap (sizex, sizey);
-}
-/* If we don't know the size of the lower-offset value, we can't tell
-if they conflict.  Otherwise, we do the test.  */
-return sizex >= 0 && offsety >= offsetx + sizex;
 }
 /* Helper for true_dependence and canon_true_dependence.
 Checks for true dependence: X is read after store in MEM takes place.
 rtx true_mem_addr, true_x_addr;
 rtx base;
 int ret;
 gcc_checking_assert (x_canonicalized
-		       ? (x_addr != NULL_RTX && x_mode != VOIDmode)
+		       ? (x_addr != NULL_RTX
+			  && (x_mode != VOIDmode || GET_MODE (x) == VOIDmode))
 		       : (x_addr == NULL_RTX && x_mode == VOIDmode));
 if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
 return 1;
 numbers, so translate if necessary due to register windows.  */
 if (FUNCTION_ARG_REGNO_P (OUTGOING_REGNO (i))
 	&& targetm.hard_regno_mode_ok (i, Pmode))
 static_reg_base_value[i] = arg_base_value;
+/* RTL code is required to be consistent about whether it uses the
+stack pointer, the frame pointer or the argument pointer to
+access a given area of the frame.  We can therefore use the
+base address to distinguish between the different areas.  */
 static_reg_base_value[STACK_POINTER_REGNUM]
 = unique_base_value (UNIQUE_BASE_VALUE_SP);
 static_reg_base_value[ARG_POINTER_REGNUM]
 = unique_base_value (UNIQUE_BASE_VALUE_ARGP);
 static_reg_base_value[FRAME_POINTER_REGNUM]
 = unique_base_value (UNIQUE_BASE_VALUE_FP);
+/* The above rules extend post-reload, with eliminations applying
+consistently to each of the three pointers.  Cope with cases in
+which the frame pointer is eliminated to the hard frame pointer
+rather than the stack pointer.  */
 if (!HARD_FRAME_POINTER_IS_FRAME_POINTER)
 static_reg_base_value[HARD_FRAME_POINTER_REGNUM]
 = unique_base_value (UNIQUE_BASE_VALUE_HFP);
 }
 memory_modified = false;
 note_stores (PATTERN (insn), memory_modified_1, CONST_CAST_RTX(mem));
 return memory_modified;
 }
-/* Return TRUE if the destination of a set is rtx identical to
-ITEM.  */
-static inline bool
-set_dest_equal_p (const_rtx set, const_rtx item)
-{
-rtx dest = SET_DEST (set);
-return rtx_equal_p (dest, item);
-}
 /* Initialize the aliasing machinery.  Initialize the REG_KNOWN_VALUE
 array.  */
 void
 init_alias_analysis (void)
 /* Wipe the reg_seen array clean.  */
 bitmap_clear (reg_seen);
 /* Initialize the alias information for this pass.  */
 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
-	if (static_reg_base_value[i])
+	if (static_reg_base_value[i]
+	    /* Don't treat the hard frame pointer as special if we
+	       eliminated the frame pointer to the stack pointer instead.  */
+	    && !(i == HARD_FRAME_POINTER_REGNUM
+		 && reload_completed
+		 && !frame_pointer_needed
+		 && targetm.can_eliminate (FRAME_POINTER_REGNUM,
+					   STACK_POINTER_REGNUM)))
 	  {
 	    new_reg_base_value[i] = static_reg_base_value[i];
 	    bitmap_set_bit (reg_seen, i);
 	  }
 		      note = find_reg_equal_equiv_note (insn);
 		      if (note && REG_NOTE_KIND (note) == REG_EQUAL
 			  && DF_REG_DEF_COUNT (regno) != 1)
 			note = NULL_RTX;
+		      poly_int64 offset;
 		      if (note != NULL_RTX
 			  && GET_CODE (XEXP (note, 0)) != EXPR_LIST
 			  && ! rtx_varies_p (XEXP (note, 0), 1)
 			  && ! reg_overlap_mentioned_p (SET_DEST (set),
 							XEXP (note, 0)))
 			}
 		      else if (DF_REG_DEF_COUNT (regno) == 1
 			       && GET_CODE (src) == PLUS
 			       && REG_P (XEXP (src, 0))
 			       && (t = get_reg_known_value (REGNO (XEXP (src, 0))))
-			       && CONST_INT_P (XEXP (src, 1)))
+			       && poly_int_rtx_p (XEXP (src, 1), &offset))
 			{
-			  t = plus_constant (GET_MODE (src), t,
+			  t = plus_constant (GET_MODE (src), t, offset);
-					     INTVAL (XEXP (src, 1)));
 			  set_reg_known_value (regno, t);
 			  set_reg_known_equiv_p (regno, false);
 			}
 		      else if (DF_REG_DEF_COUNT (regno) == 1
 			       && ! rtx_varies_p (src, 1))

Mercurial > hg > CbC > CbC_gcc

comparison gcc/alias.c @ 132:d34655255c78