Daily bump.

[pf3gnuchains/gcc-fork.git] / gcc / convert.c

diff --git a/gcc/convert.c b/gcc/convert.c
index d72dda8..1a6159e 100644 (file)
--- a/gcc/convert.c
+++ b/gcc/convert.c
@@ -44,11 +44,6 @@ convert_to_pointer (tree type, tree expr)
   if (TREE_TYPE (expr) == type)
     return expr;
 
-  /* Propagate overflow to the NULL pointer.  */
-  if (integer_zerop (expr))
-    return force_fit_type_double (type, double_int_zero, 0,
-                                 TREE_OVERFLOW (expr));
-
   switch (TREE_CODE (TREE_TYPE (expr)))
     {
     case POINTER_TYPE:
@@ -469,6 +464,9 @@ convert_to_integer (tree type, tree expr)
          break;
 
        CASE_FLT_FN (BUILT_IN_ROUND):
+         /* Only convert in ISO C99 mode.  */
+         if (!TARGET_C99_FUNCTIONS)
+           break;
          if (outprec < TYPE_PRECISION (integer_type_node)
              || (outprec == TYPE_PRECISION (integer_type_node)
                  && !TYPE_UNSIGNED (type)))
@@ -487,11 +485,14 @@ convert_to_integer (tree type, tree expr)
            break;
          /* ... Fall through ...  */
        CASE_FLT_FN (BUILT_IN_RINT):
+         /* Only convert in ISO C99 mode.  */
+         if (!TARGET_C99_FUNCTIONS)
+           break;
          if (outprec < TYPE_PRECISION (integer_type_node)
              || (outprec == TYPE_PRECISION (integer_type_node)
                  && !TYPE_UNSIGNED (type)))
            fn = mathfn_built_in (s_intype, BUILT_IN_IRINT);
-         else if (outprec < TYPE_PRECISION (long_integer_type_node)
+         else if (outprec == TYPE_PRECISION (long_integer_type_node)
                   && !TYPE_UNSIGNED (type))
            fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
          else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
@@ -739,6 +740,15 @@ convert_to_integer (tree type, tree expr)
            tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
            tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 
+           /* Do not try to narrow operands of pointer subtraction;
+              that will interfere with other folding.  */
+           if (ex_form == MINUS_EXPR
+               && CONVERT_EXPR_P (arg0)
+               && CONVERT_EXPR_P (arg1)
+               && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
+               && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg1, 0))))
+             break;
+
            if (outprec >= BITS_PER_WORD
                || TRULY_NOOP_TRUNCATION (outprec, inprec)
                || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
@@ -759,6 +769,7 @@ convert_to_integer (tree type, tree expr)
                   (Otherwise would recurse infinitely in convert.  */
                if (TYPE_PRECISION (typex) != inprec)
                  {
+                   tree otypex = typex;
                    /* Don't do unsigned arithmetic where signed was wanted,
                       or vice versa.
                       Exception: if both of the original operands were
@@ -796,10 +807,12 @@ convert_to_integer (tree type, tree expr)
                      typex = unsigned_type_for (typex);
                    else
                      typex = signed_type_for (typex);
-                   return convert (type,
-                                   fold_build2 (ex_form, typex,
-                                                convert (typex, arg0),
-                                                convert (typex, arg1)));
+
+                   if (TYPE_PRECISION (otypex) == TYPE_PRECISION (typex))
+                     return convert (type,
+                                     fold_build2 (ex_form, typex,
+                                                  convert (typex, arg0),
+                                                  convert (typex, arg1)));
                  }
              }
          }
@@ -845,6 +858,10 @@ convert_to_integer (tree type, tree expr)
          break;
        }
 
+      /* When parsing long initializers, we might end up with a lot of casts.
+        Shortcut this.  */
+      if (TREE_CODE (expr) == INTEGER_CST)
+       return fold_convert (type, expr);
       return build1 (CONVERT_EXPR, type, expr);
 
     case REAL_TYPE: