c-common.c (pointer_int_sum): Do the negation in sizetype.

	* c-common.c (pointer_int_sum): Do the negation in sizetype.

From-SVN: r126108

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 669640aae50506e5451fa84aa461581e84bf0fa7..082b207bc0e7c3d602de20748be380ac66e2ebc7 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,7 @@
+2007-06-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * c-common.c (pointer_int_sum): Do the negation in sizetype.
+
 2007-06-28  DJ Delorie  <dj@redhat.com>
 
        * config/m32c/m32c.h (OVERRIDE_OPTIONS): Omit unneeded semicolon.

diff --git a/gcc/c-common.c b/gcc/c-common.c
index e1c387502040f60ba67bd12b459f8db745aaf9b7..5243dd749f9ebb818a1d6f04fcb10bae0578eddc 100644 (file)
--- a/gcc/c-common.c
+++ b/gcc/c-common.c
@@ -2627,7 +2627,6 @@ pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
   tree size_exp, ret;
 
   /* The result is a pointer of the same type that is being added.  */
-
   tree result_type = TREE_TYPE (ptrop);
 
   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
@@ -2661,7 +2660,6 @@ pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
      contains a constant term, apply distributive law
      and multiply that constant term separately.
      This helps produce common subexpressions.  */
-
   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
       && !TREE_CONSTANT (intop)
       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
@@ -2690,7 +2688,6 @@ pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
 
   /* Convert the integer argument to a type the same size as sizetype
      so the multiply won't overflow spuriously.  */
-
   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
@@ -2698,17 +2695,15 @@ pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
 
   /* Replace the integer argument with a suitable product by the object size.
      Do this multiplication as signed, then convert to the appropriate
-     pointer type (actually unsigned integral).  */
-
-  intop = build_binary_op (MULT_EXPR, intop,
-                          convert (TREE_TYPE (intop), size_exp), 1);
+     type for the pointer operation.  */
+  intop = convert (sizetype,
+                  build_binary_op (MULT_EXPR, intop,
+                                   convert (TREE_TYPE (intop), size_exp), 1));
 
+  /* Create the sum or difference.  */
   if (resultcode == MINUS_EXPR)
-    intop = fold_build1 (NEGATE_EXPR, TREE_TYPE (intop), intop);
-
-  intop = convert (sizetype, intop);
+    intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
 
-  /* Create the sum or difference.  */
   ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
 
   fold_undefer_and_ignore_overflow_warnings ();

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 7552ef4304b2aaa9c863b51f8bc2467c351483ea..d023d472c9821e505731b84cc92641db4b9fb03f 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2007-06-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gcc.dg/pointer-arith-9.c: New test.
+
 2007-06-29  Tobias Burnus  <burnus@net-b.de>
 
        PR fortran/32483

diff --git a/gcc/testsuite/gcc.dg/pointer-arith-9.c b/gcc/testsuite/gcc.dg/pointer-arith-9.c
new file mode 100644 (file)
index 0000000..2d26112
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pointer-arith-9.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "" } */
+
+void *foo(void)
+{
+  return (void *)0 - 1;
+}