OSDN Git Service

2005-10-28 Andrew Pinski <pinskia@physics.uc.edu>
[pf3gnuchains/gcc-fork.git] / gcc / convert.c
index 5441bf1..5680c39 100644 (file)
@@ -1,6 +1,6 @@
 /* Utility routines for data type conversion for GCC.
    Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1997, 1998,
-   2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+   2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -16,8 +16,8 @@ for more details.
 
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
 
 
 /* These routines are somewhat language-independent utility function
@@ -42,11 +42,7 @@ tree
 convert_to_pointer (tree type, tree expr)
 {
   if (integer_zerop (expr))
-    {
-      expr = build_int_2 (0, 0);
-      TREE_TYPE (expr) = type;
-      return expr;
-    }
+    return build_int_cst (type, 0);
 
   switch (TREE_CODE (TREE_TYPE (expr)))
     {
@@ -58,13 +54,12 @@ convert_to_pointer (tree type, tree expr)
     case ENUMERAL_TYPE:
     case BOOLEAN_TYPE:
     case CHAR_TYPE:
-      if (TYPE_PRECISION (TREE_TYPE (expr)) == POINTER_SIZE)
-       return build1 (CONVERT_EXPR, type, expr);
+      if (TYPE_PRECISION (TREE_TYPE (expr)) != POINTER_SIZE)
+       expr = fold_build1 (NOP_EXPR,
+                            lang_hooks.types.type_for_size (POINTER_SIZE, 0),
+                           expr);
+      return fold_build1 (CONVERT_EXPR, type, expr);
 
-      return
-       convert_to_pointer (type,
-                           convert (lang_hooks.types.type_for_size
-                                    (POINTER_SIZE, 0), expr));
 
     default:
       error ("cannot convert to a pointer type");
@@ -226,12 +221,18 @@ convert_to_real (tree type, tree expr)
 
       if (fn)
        {
-         tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr,
-                                                                       1)));
-         tree arglist = build_tree_list (NULL_TREE,
-                                         fold (convert_to_real (type, arg0)));
-
-         return build_function_call_expr (fn, arglist);
+         tree arg
+           = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
+
+         /* Make sure (type)arg0 is an extension, otherwise we could end up
+            changing (float)floor(double d) into floorf((float)d), which is
+            incorrect because (float)d uses round-to-nearest and can round
+            up to the next integer.  */
+         if (TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (arg)))
+           return
+             build_function_call_expr (fn,
+                                       build_tree_list (NULL_TREE,
+                                         fold (convert_to_real (type, arg))));
        }
     }
 
@@ -268,9 +269,9 @@ convert_to_real (tree type, tree expr)
                    newtype = TREE_TYPE (arg1);
                  if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype))
                    {
-                     expr = build (TREE_CODE (expr), newtype,
-                                   fold (convert_to_real (newtype, arg0)),
-                                   fold (convert_to_real (newtype, arg1)));
+                     expr = build2 (TREE_CODE (expr), newtype,
+                                    fold (convert_to_real (newtype, arg0)),
+                                    fold (convert_to_real (newtype, arg1)));
                      if (newtype == type)
                        return expr;
                    }
@@ -295,8 +296,8 @@ convert_to_real (tree type, tree expr)
 
     case COMPLEX_TYPE:
       return convert (type,
-                     fold (build1 (REALPART_EXPR,
-                                   TREE_TYPE (TREE_TYPE (expr)), expr)));
+                     fold_build1 (REALPART_EXPR,
+                                  TREE_TYPE (TREE_TYPE (expr)), expr));
 
     case POINTER_TYPE:
     case REFERENCE_TYPE:
@@ -350,6 +351,26 @@ convert_to_integer (tree type, tree expr)
       
       switch (fcode)
         {
+       case BUILT_IN_CEIL: case BUILT_IN_CEILF: case BUILT_IN_CEILL:
+         /* Only convert in ISO C99 mode.  */
+         if (!TARGET_C99_FUNCTIONS)
+           break;
+         if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
+           fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL);
+         else
+           fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
+         break;
+
+       case BUILT_IN_FLOOR: case BUILT_IN_FLOORF: case BUILT_IN_FLOORL:
+         /* Only convert in ISO C99 mode.  */
+         if (!TARGET_C99_FUNCTIONS)
+           break;
+         if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
+           fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR);
+         else
+           fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
+         break;
+
        case BUILT_IN_ROUND: case BUILT_IN_ROUNDF: case BUILT_IN_ROUNDL:
          if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
            fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
@@ -368,6 +389,13 @@ convert_to_integer (tree type, tree expr)
          else
             fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
          break;
+
+       case BUILT_IN_TRUNC: case BUILT_IN_TRUNCF: case BUILT_IN_TRUNCL:
+         {
+           tree arglist = TREE_OPERAND (s_expr, 1);
+           return convert_to_integer (type, TREE_VALUE (arglist));
+         }
+
        default:
          break;
        }
@@ -385,49 +413,29 @@ convert_to_integer (tree type, tree expr)
     case POINTER_TYPE:
     case REFERENCE_TYPE:
       if (integer_zerop (expr))
-       expr = integer_zero_node;
-      else
-       expr = fold (build1 (CONVERT_EXPR,
-                            lang_hooks.types.type_for_size (POINTER_SIZE, 0),
-                            expr));
+       return build_int_cst (type, 0);
 
-      return convert_to_integer (type, expr);
+      /* Convert to an unsigned integer of the correct width first,
+        and from there widen/truncate to the required type.  */
+      expr = fold_build1 (CONVERT_EXPR,
+                         lang_hooks.types.type_for_size (POINTER_SIZE, 0),
+                         expr);
+      return fold_build1 (NOP_EXPR, type, expr);
 
     case INTEGER_TYPE:
     case ENUMERAL_TYPE:
     case BOOLEAN_TYPE:
     case CHAR_TYPE:
       /* If this is a logical operation, which just returns 0 or 1, we can
-        change the type of the expression.  For some logical operations,
-        we must also change the types of the operands to maintain type
-        correctness.  */
+        change the type of the expression.  */
 
-      if (TREE_CODE_CLASS (ex_form) == '<')
+      if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
        {
          expr = copy_node (expr);
          TREE_TYPE (expr) = type;
          return expr;
        }
 
-      else if (ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
-              || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
-              || ex_form == TRUTH_XOR_EXPR)
-       {
-         expr = copy_node (expr);
-         TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
-         TREE_OPERAND (expr, 1) = convert (type, TREE_OPERAND (expr, 1));
-         TREE_TYPE (expr) = type;
-         return expr;
-       }
-
-      else if (ex_form == TRUTH_NOT_EXPR)
-       {
-         expr = copy_node (expr);
-         TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
-         TREE_TYPE (expr) = type;
-         return expr;
-       }
-
       /* If we are widening the type, put in an explicit conversion.
         Similarly if we are not changing the width.  After this, we know
         we are truncating EXPR.  */
@@ -452,7 +460,7 @@ convert_to_integer (tree type, tree expr)
          else
            code = NOP_EXPR;
 
-         return build1 (code, type, expr);
+         return fold_build1 (code, type, expr);
        }
 
       /* If TYPE is an enumeral type or a type with a precision less
@@ -525,7 +533,7 @@ convert_to_integer (tree type, tree expr)
                  /* If the original expression had side-effects, we must
                     preserve it.  */
                  if (TREE_SIDE_EFFECTS (expr))
-                   return build (COMPOUND_EXPR, type, expr, t);
+                   return build2 (COMPOUND_EXPR, type, expr, t);
                  else
                    return t;
                }
@@ -605,9 +613,9 @@ convert_to_integer (tree type, tree expr)
                    else
                      typex = lang_hooks.types.signed_type (typex);
                    return convert (type,
-                                   fold (build (ex_form, typex,
+                                   fold_build2 (ex_form, typex,
                                                 convert (typex, arg0),
-                                                convert (typex, arg1))));
+                                                convert (typex, arg1)));
                  }
              }
          }
@@ -618,30 +626,18 @@ convert_to_integer (tree type, tree expr)
          /* This is not correct for ABS_EXPR,
             since we must test the sign before truncation.  */
          {
-           tree typex = type;
-
-           /* Can't do arithmetic in enumeral types
-              so use an integer type that will hold the values.  */
-           if (TREE_CODE (typex) == ENUMERAL_TYPE)
-             typex = lang_hooks.types.type_for_size
-               (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
-
-           /* But now perhaps TYPEX is as wide as INPREC.
-              In that case, do nothing special here.
-              (Otherwise would recurse infinitely in convert.  */
-           if (TYPE_PRECISION (typex) != inprec)
-             {
-               /* Don't do unsigned arithmetic where signed was wanted,
-                  or vice versa.  */
-               if (TYPE_UNSIGNED (TREE_TYPE (expr)))
-                 typex = lang_hooks.types.unsigned_type (typex);
-               else
-                 typex = lang_hooks.types.signed_type (typex);
-               return convert (type,
-                               fold (build1 (ex_form, typex,
-                                             convert (typex,
-                                                      TREE_OPERAND (expr, 0)))));
-             }
+           tree typex;
+
+           /* Don't do unsigned arithmetic where signed was wanted,
+              or vice versa.  */
+           if (TYPE_UNSIGNED (TREE_TYPE (expr)))
+             typex = lang_hooks.types.unsigned_type (type);
+           else
+             typex = lang_hooks.types.signed_type (type);
+           return convert (type,
+                           fold_build1 (ex_form, typex,
+                                        convert (typex,
+                                                 TREE_OPERAND (expr, 0))));
          }
 
        case NOP_EXPR:
@@ -658,9 +654,9 @@ convert_to_integer (tree type, tree expr)
        case COND_EXPR:
          /* It is sometimes worthwhile to push the narrowing down through
             the conditional and never loses.  */
-         return fold (build (COND_EXPR, type, TREE_OPERAND (expr, 0),
+         return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
                              convert (type, TREE_OPERAND (expr, 1)),
-                             convert (type, TREE_OPERAND (expr, 2))));
+                             convert (type, TREE_OPERAND (expr, 2)));
 
        default:
          break;
@@ -673,17 +669,16 @@ convert_to_integer (tree type, tree expr)
 
     case COMPLEX_TYPE:
       return convert (type,
-                     fold (build1 (REALPART_EXPR,
-                                   TREE_TYPE (TREE_TYPE (expr)), expr)));
+                     fold_build1 (REALPART_EXPR,
+                                  TREE_TYPE (TREE_TYPE (expr)), expr));
 
     case VECTOR_TYPE:
-      if (GET_MODE_SIZE (TYPE_MODE (type))
-         != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
+      if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
        {
          error ("can't convert between vector values of different size");
          return error_mark_node;
        }
-      return build1 (NOP_EXPR, type, expr);
+      return build1 (VIEW_CONVERT_EXPR, type, expr);
 
     default:
       error ("aggregate value used where an integer was expected");
@@ -705,8 +700,8 @@ convert_to_complex (tree type, tree expr)
     case ENUMERAL_TYPE:
     case BOOLEAN_TYPE:
     case CHAR_TYPE:
-      return build (COMPLEX_EXPR, type, convert (subtype, expr),
-                   convert (subtype, integer_zero_node));
+      return build2 (COMPLEX_EXPR, type, convert (subtype, expr),
+                    convert (subtype, integer_zero_node));
 
     case COMPLEX_TYPE:
       {
@@ -715,23 +710,22 @@ convert_to_complex (tree type, tree expr)
        if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
          return expr;
        else if (TREE_CODE (expr) == COMPLEX_EXPR)
-         return fold (build (COMPLEX_EXPR,
-                             type,
+         return fold_build2 (COMPLEX_EXPR, type,
                              convert (subtype, TREE_OPERAND (expr, 0)),
-                             convert (subtype, TREE_OPERAND (expr, 1))));
+                             convert (subtype, TREE_OPERAND (expr, 1)));
        else
          {
            expr = save_expr (expr);
            return
-             fold (build (COMPLEX_EXPR,
-                          type, convert (subtype,
-                                         fold (build1 (REALPART_EXPR,
-                                                       TREE_TYPE (TREE_TYPE (expr)),
-                                                       expr))),
+             fold_build2 (COMPLEX_EXPR, type,
+                          convert (subtype,
+                                   fold_build1 (REALPART_EXPR,
+                                                TREE_TYPE (TREE_TYPE (expr)),
+                                                expr)),
                           convert (subtype,
-                                   fold (build1 (IMAGPART_EXPR,
-                                                 TREE_TYPE (TREE_TYPE (expr)),
-                                                 expr)))));
+                                   fold_build1 (IMAGPART_EXPR,
+                                                TREE_TYPE (TREE_TYPE (expr)),
+                                                expr)));
          }
       }
 
@@ -755,16 +749,15 @@ convert_to_vector (tree type, tree expr)
     {
     case INTEGER_TYPE:
     case VECTOR_TYPE:
-      if (GET_MODE_SIZE (TYPE_MODE (type))
-         != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
+      if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
        {
          error ("can't convert between vector values of different size");
          return error_mark_node;
        }
-      return build1 (NOP_EXPR, type, expr);
+      return build1 (VIEW_CONVERT_EXPR, type, expr);
 
     default:
       error ("can't convert value to a vector");
-      return convert_to_vector (type, integer_zero_node);
+      return error_mark_node;
     }
 }