Daily bump.

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

diff --git a/gcc/convert.c b/gcc/convert.c
index 48f3f94..1a6159e 100644 (file)
--- a/gcc/convert.c
+++ b/gcc/convert.c
@@ -31,7 +31,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "flags.h"
 #include "convert.h"
 #include "diagnostic-core.h"
-#include "toplev.h"
 #include "langhooks.h"
 
 /* Convert EXPR to some pointer or reference type TYPE.
@@ -45,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:
@@ -441,9 +435,12 @@ convert_to_integer (tree type, tree expr)
          /* Only convert in ISO C99 mode.  */
          if (!TARGET_C99_FUNCTIONS)
            break;
-         if (outprec < TYPE_PRECISION (long_integer_type_node)
-             || (outprec == TYPE_PRECISION (long_integer_type_node)
+         if (outprec < TYPE_PRECISION (integer_type_node)
+             || (outprec == TYPE_PRECISION (integer_type_node)
                  && !TYPE_UNSIGNED (type)))
+           fn = mathfn_built_in (s_intype, BUILT_IN_ICEIL);
+         else if (outprec == TYPE_PRECISION (long_integer_type_node)
+                  && !TYPE_UNSIGNED (type))
            fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
          else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
                   && !TYPE_UNSIGNED (type))
@@ -454,9 +451,12 @@ convert_to_integer (tree type, tree expr)
          /* Only convert in ISO C99 mode.  */
          if (!TARGET_C99_FUNCTIONS)
            break;
-         if (outprec < TYPE_PRECISION (long_integer_type_node)
-             || (outprec == TYPE_PRECISION (long_integer_type_node)
+         if (outprec < TYPE_PRECISION (integer_type_node)
+             || (outprec == TYPE_PRECISION (integer_type_node)
                  && !TYPE_UNSIGNED (type)))
+           fn = mathfn_built_in (s_intype, BUILT_IN_IFLOOR);
+         else if (outprec == TYPE_PRECISION (long_integer_type_node)
+                  && !TYPE_UNSIGNED (type))
            fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
          else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
                   && !TYPE_UNSIGNED (type))
@@ -464,9 +464,15 @@ convert_to_integer (tree type, tree expr)
          break;
 
        CASE_FLT_FN (BUILT_IN_ROUND):
-         if (outprec < TYPE_PRECISION (long_integer_type_node)
-             || (outprec == TYPE_PRECISION (long_integer_type_node)
+         /* 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_IROUND);
+         else if (outprec == TYPE_PRECISION (long_integer_type_node)
+                  && !TYPE_UNSIGNED (type))
            fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
          else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
                   && !TYPE_UNSIGNED (type))
@@ -479,9 +485,15 @@ convert_to_integer (tree type, tree expr)
            break;
          /* ... Fall through ...  */
        CASE_FLT_FN (BUILT_IN_RINT):
-         if (outprec < TYPE_PRECISION (long_integer_type_node)
-             || (outprec == TYPE_PRECISION (long_integer_type_node)
+         /* 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)
+                  && !TYPE_UNSIGNED (type))
            fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
          else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
                   && !TYPE_UNSIGNED (type))
@@ -584,7 +596,7 @@ convert_to_integer (tree type, tree expr)
             be cleared.  */
          if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
              && (TYPE_PRECISION (TREE_TYPE (expr))
-                 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
+                 != GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (expr)))))
            code = CONVERT_EXPR;
          else
            code = NOP_EXPR;
@@ -603,7 +615,7 @@ convert_to_integer (tree type, tree expr)
         type corresponding to its mode, then do a nop conversion
         to TYPE.  */
       else if (TREE_CODE (type) == ENUMERAL_TYPE
-              || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
+              || outprec != GET_MODE_PRECISION (TYPE_MODE (type)))
        return build1 (NOP_EXPR, type,
                       convert (lang_hooks.types.type_for_mode
                                (TYPE_MODE (type), TYPE_UNSIGNED (type)),
@@ -728,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))
@@ -748,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
@@ -785,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)));
                  }
              }
          }
@@ -799,14 +823,7 @@ convert_to_integer (tree type, tree expr)
          /* This is not correct for ABS_EXPR,
             since we must test the sign before truncation.  */
          {
-           tree typex;
-
-           /* Don't do unsigned arithmetic where signed was wanted,
-              or vice versa.  */
-           if (TYPE_UNSIGNED (TREE_TYPE (expr)))
-             typex = unsigned_type_for (type);
-           else
-             typex = signed_type_for (type);
+           tree typex = unsigned_type_for (type);
            return convert (type,
                            fold_build1 (ex_form, typex,
                                         convert (typex,
@@ -841,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:
@@ -857,7 +878,7 @@ convert_to_integer (tree type, tree expr)
     case VECTOR_TYPE:
       if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
        {
-         error ("can't convert between vector values of different size");
+         error ("can%'t convert between vector values of different size");
          return error_mark_node;
        }
       return build1 (VIEW_CONVERT_EXPR, type, expr);
@@ -933,13 +954,13 @@ convert_to_vector (tree type, tree expr)
     case VECTOR_TYPE:
       if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
        {
-         error ("can't convert between vector values of different size");
+         error ("can%'t convert between vector values of different size");
          return error_mark_node;
        }
       return build1 (VIEW_CONVERT_EXPR, type, expr);
 
     default:
-      error ("can't convert value to a vector");
+      error ("can%'t convert value to a vector");
       return error_mark_node;
     }
 }