tree.h (get_object_or_type_alignment): Remove.

2012-07-18  Richard Guenther  <rguenther@suse.de>

	* tree.h (get_object_or_type_alignment): Remove.
	* builtins.c (get_object_alignment_2): New function copied from
	get_object_alignment_1.  Take extra argument to indicate whether
	we take the address of EXP.  Rework to use type alignment information
	if not, and return whether the result is an approximation or not.
	(get_object_alignment_1): Wrap around get_object_alignment_2.
	(get_pointer_alignment_1): Call get_object_alignment_2 indicating
	we take the address.
	(get_object_or_type_alignment): Remove.
	* expr.c (expand_assignment): Call get_object_alignment.
	(expand_expr_real_1): Likewise.

From-SVN: r189607

1 files changed, 86 insertions, 119 deletions

diff --git a/gcc/builtins.c b/gcc/builtins.c
index 040f352..4fb3d53 100644
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -273,11 +273,14 @@ called_as_built_in (tree node)
    on the address at which an object is actually located.  These two
    addresses are not always the same.  For example, on ARM targets,
    the address &foo of a Thumb function foo() has the lowest bit set,
-   whereas foo() itself starts on an even address.  */
+   whereas foo() itself starts on an even address.
 
-bool
-get_object_alignment_1 (tree exp, unsigned int *alignp,
-			unsigned HOST_WIDE_INT *bitposp)
+   If ADDR_P is true we are taking the address of the memory reference EXP
+   and thus cannot rely on the access taking place.  */
+
+static bool
+get_object_alignment_2 (tree exp, unsigned int *alignp,
+			unsigned HOST_WIDE_INT *bitposp, bool addr_p)
 {
   HOST_WIDE_INT bitsize, bitpos;
   tree offset;
@@ -293,48 +296,40 @@ get_object_alignment_1 (tree exp, unsigned int *alignp,
 
   /* Extract alignment information from the innermost object and
      possibly adjust bitpos and offset.  */
-  if (TREE_CODE (exp) == CONST_DECL)
-    exp = DECL_INITIAL (exp);
-  if (DECL_P (exp)
-      && TREE_CODE (exp) != LABEL_DECL)
-    {
-      if (TREE_CODE (exp) == FUNCTION_DECL)
-	{
-	  /* Function addresses can encode extra information besides their
-	     alignment.  However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
-	     allows the low bit to be used as a virtual bit, we know
-	     that the address itself must be 2-byte aligned.  */
-	  if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn)
-	    {
-	      known_alignment = true;
-	      align = 2 * BITS_PER_UNIT;
-	    }
-	}
-      else
-	{
-	  known_alignment = true;
-	  align = DECL_ALIGN (exp);
-	}
+  if (TREE_CODE (exp) == FUNCTION_DECL)
+    {
+      /* Function addresses can encode extra information besides their
+	 alignment.  However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
+	 allows the low bit to be used as a virtual bit, we know
+	 that the address itself must be at least 2-byte aligned.  */
+      if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn)
+	align = 2 * BITS_PER_UNIT;
     }
-  else if (CONSTANT_CLASS_P (exp))
+  else if (TREE_CODE (exp) == LABEL_DECL)
+    ;
+  else if (TREE_CODE (exp) == CONST_DECL)
     {
-      known_alignment = true;
+      /* The alignment of a CONST_DECL is determined by its initializer.  */
+      exp = DECL_INITIAL (exp);
       align = TYPE_ALIGN (TREE_TYPE (exp));
 #ifdef CONSTANT_ALIGNMENT
-      align = (unsigned)CONSTANT_ALIGNMENT (exp, align);
+      if (CONSTANT_CLASS_P (exp))
+	align = (unsigned) CONSTANT_ALIGNMENT (exp, align);
 #endif
+      known_alignment = true;
     }
-  else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
+  else if (DECL_P (exp))
     {
+      align = DECL_ALIGN (exp);
       known_alignment = true;
-      align = TYPE_ALIGN (TREE_TYPE (exp));
     }
-  else if (TREE_CODE (exp) == INDIRECT_REF)
+  else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
     {
-      known_alignment = true;
       align = TYPE_ALIGN (TREE_TYPE (exp));
     }
-  else if (TREE_CODE (exp) == MEM_REF)
+  else if (TREE_CODE (exp) == INDIRECT_REF
+	   || TREE_CODE (exp) == MEM_REF
+	   || TREE_CODE (exp) == TARGET_MEM_REF)
     {
       tree addr = TREE_OPERAND (exp, 0);
       unsigned ptr_align;
@@ -343,58 +338,51 @@ get_object_alignment_1 (tree exp, unsigned int *alignp,
       if (TREE_CODE (addr) == BIT_AND_EXPR
 	  && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 	{
-	  known_alignment = true;
 	  align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 		    & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 	  align *= BITS_PER_UNIT;
 	  addr = TREE_OPERAND (addr, 0);
 	}
 
-      if (get_pointer_alignment_1 (addr, &ptr_align, &ptr_bitpos))
+      known_alignment
+	= get_pointer_alignment_1 (addr, &ptr_align, &ptr_bitpos);
+      bitpos += ptr_bitpos;
+      align = MAX (ptr_align, align);
+
+      if (TREE_CODE (exp) == MEM_REF
+	  || TREE_CODE (exp) == TARGET_MEM_REF)
+	bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;
+      if (TREE_CODE (exp) == TARGET_MEM_REF)
 	{
-	  known_alignment = true;
-	  bitpos += ptr_bitpos & ~(align - 1);
-	  align = MAX (ptr_align, align);
+	  if (TMR_INDEX (exp))
+	    {
+	      unsigned HOST_WIDE_INT step = 1;
+	      if (TMR_STEP (exp))
+		step = TREE_INT_CST_LOW (TMR_STEP (exp));
+	      align = MIN (align, (step & -step) * BITS_PER_UNIT);
+	    }
+	  if (TMR_INDEX2 (exp))
+	    align = BITS_PER_UNIT;
+	  known_alignment = false;
 	}
 
-      bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;
+      /* When EXP is an actual memory reference then we can use
+	 TYPE_ALIGN of a pointer indirection to derive alignment.
+	 Do so only if get_pointer_alignment_1 did not reveal absolute
+	 alignment knowledge.  */
+      if (!addr_p && !known_alignment)
+	align = MAX (TYPE_ALIGN (TREE_TYPE (exp)), align);
     }
-  else if (TREE_CODE (exp) == TARGET_MEM_REF)
+  else if (TREE_CODE (exp) == STRING_CST)
     {
-      unsigned ptr_align;
-      unsigned HOST_WIDE_INT ptr_bitpos;
-      tree addr = TMR_BASE (exp);
-
-      if (TREE_CODE (addr) == BIT_AND_EXPR
-	  && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
-	{
-	  known_alignment = true;
-	  align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
-		   & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
-	  align *= BITS_PER_UNIT;
-	  addr = TREE_OPERAND (addr, 0);
-	}
-
-      if (get_pointer_alignment_1 (addr, &ptr_align, &ptr_bitpos))
-	{
-	  known_alignment = true;
-	  bitpos += ptr_bitpos & ~(align - 1);
-	  align = MAX (ptr_align, align);
-	}
-
-      if (TMR_OFFSET (exp))
-	bitpos += TREE_INT_CST_LOW (TMR_OFFSET (exp)) * BITS_PER_UNIT;
-      if (TMR_INDEX (exp) && TMR_STEP (exp))
-	{
-	  unsigned HOST_WIDE_INT step = TREE_INT_CST_LOW (TMR_STEP (exp));
-	  align = MIN (align, (step & -step) * BITS_PER_UNIT);
-	  known_alignment = true;
-	}
-      else if (TMR_INDEX (exp))
-	known_alignment = false;
-
-      if (TMR_INDEX2 (exp))
-	known_alignment = false;
+      /* STRING_CST are the only constant objects we allow to be not
+         wrapped inside a CONST_DECL.  */
+      align = TYPE_ALIGN (TREE_TYPE (exp));
+#ifdef CONSTANT_ALIGNMENT
+      if (CONSTANT_CLASS_P (exp))
+	align = (unsigned) CONSTANT_ALIGNMENT (exp, align);
+#endif
+      known_alignment = true;
     }
 
   /* If there is a non-constant offset part extract the maximum
@@ -435,29 +423,32 @@ get_object_alignment_1 (tree exp, unsigned int *alignp,
 	}
       else
 	{
-	  known_alignment = false;
+	  inner = MIN (inner, BITS_PER_UNIT);
 	  break;
 	}
       offset = next_offset;
     }
+  /* Alignment is innermost object alignment adjusted by the constant
+     and non-constant offset parts.  */
+  align = MIN (align, inner);
 
-  if (known_alignment)
-    {
-      /* Alignment is innermost object alignment adjusted by the constant
-	 and non-constant offset parts.  */
-      align = MIN (align, inner);
-      bitpos = bitpos & (align - 1);
-      *alignp = align;
-    }
-  else
-    {
-      bitpos = bitpos & (BITS_PER_UNIT - 1);
-      *alignp = BITS_PER_UNIT;
-    }
-  *bitposp = bitpos;
+  *alignp = align;
+  *bitposp = bitpos & (*alignp - 1);
   return known_alignment;
 }
 
+/* For a memory reference expression EXP compute values M and N such that M
+   divides (&EXP - N) and such that N < M.  If these numbers can be determined,
+   store M in alignp and N in *BITPOSP and return true.  Otherwise return false
+   and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp.  */
+
+bool
+get_object_alignment_1 (tree exp, unsigned int *alignp,
+			unsigned HOST_WIDE_INT *bitposp)
+{
+  return get_object_alignment_2 (exp, alignp, bitposp, false);
+}
+
 /* Return the alignment in bits of EXP, an object.  */
 
 unsigned int
@@ -476,36 +467,10 @@ get_object_alignment (tree exp)
   return align;
 }
 
-/* Return the alignment of object EXP, also considering its type when we do
-   not know of explicit misalignment.  Only handle MEM_REF and TARGET_MEM_REF.
-
-   ??? Note that, in the general case, the type of an expression is not kept
-   consistent with misalignment information by the front-end, for example when
-   taking the address of a member of a packed structure.  However, in most of
-   the cases, expressions have the alignment of their type so we optimistically
-   fall back to this alignment when we cannot compute a misalignment.  */
-
-unsigned int
-get_object_or_type_alignment (tree exp)
-{
-  unsigned HOST_WIDE_INT misalign;
-  unsigned int align;
-  bool known_alignment;
-
-  gcc_assert (TREE_CODE (exp) == MEM_REF || TREE_CODE (exp) == TARGET_MEM_REF);
-  known_alignment = get_object_alignment_1 (exp, &align, &misalign);
-  if (misalign != 0)
-    align = (misalign & -misalign);
-  else if (!known_alignment)
-    align = TYPE_ALIGN (TREE_TYPE (exp));
-
-  return align;
-}
-
 /* For a pointer valued expression EXP compute values M and N such that M
    divides (EXP - N) and such that N < M.  If these numbers can be determined,
-   store M in alignp and N in *BITPOSP and return true.  Otherwise return false
-   and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp.
+   store M in alignp and N in *BITPOSP and return true.  Return false if
+   the results are just a conservative approximation.
 
    If EXP is not a pointer, false is returned too.  */
 
@@ -516,7 +481,8 @@ get_pointer_alignment_1 (tree exp, unsigned int *alignp,
   STRIP_NOPS (exp);
 
   if (TREE_CODE (exp) == ADDR_EXPR)
-    return get_object_alignment_1 (TREE_OPERAND (exp, 0), alignp, bitposp);
+    return get_object_alignment_2 (TREE_OPERAND (exp, 0),
+				   alignp, bitposp, true);
   else if (TREE_CODE (exp) == SSA_NAME
 	   && POINTER_TYPE_P (TREE_TYPE (exp)))
     {
@@ -527,6 +493,7 @@ get_pointer_alignment_1 (tree exp, unsigned int *alignp,
 	{
 	  *bitposp = ptr_misalign * BITS_PER_UNIT;
 	  *alignp = ptr_align * BITS_PER_UNIT;
+	  /* We cannot really tell whether this result is an approximation.  */
 	  return true;
 	}
       else