* final.c (FIRST_INSN_ADDRESS): Remove.

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

diff --git a/gcc/convert.c b/gcc/convert.c
index a268f3e..9096541 100644 (file)
--- a/gcc/convert.c
+++ b/gcc/convert.c
@@ -152,7 +152,7 @@ convert_to_real (tree type, tree expr)
       if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
        newtype = TREE_TYPE (arg0);
 
-      /* Be curefull about integer to fp conversions.
+      /* Be careful about integer to fp conversions.
         These may overflow still.  */
       if (FLOAT_TYPE_P (TREE_TYPE (arg0))
          && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
@@ -203,7 +203,7 @@ convert_to_real (tree type, tree expr)
   if (itype != type && FLOAT_TYPE_P (type))
     switch (TREE_CODE (expr))
       {
-       /* convert (float)-x into -(float)x.  This is always safe.  */
+       /* Convert (float)-x into -(float)x.  This is always safe.  */
        case ABS_EXPR:
        case NEGATE_EXPR:
          if (TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
@@ -211,7 +211,7 @@ convert_to_real (tree type, tree expr)
                           fold (convert_to_real (type,
                                                  TREE_OPERAND (expr, 0))));
          break;
-       /* convert (outertype)((innertype0)a+(innertype1)b)
+       /* Convert (outertype)((innertype0)a+(innertype1)b)
           into ((newtype)a+(newtype)b) where newtype
           is the widest mode from all of these.  */
        case PLUS_EXPR:
@@ -320,6 +320,7 @@ convert_to_integer (tree type, tree expr)
 
       if (TREE_CODE_CLASS (ex_form) == '<')
        {
+         expr = copy_node (expr);
          TREE_TYPE (expr) = type;
          return expr;
        }
@@ -328,6 +329,7 @@ convert_to_integer (tree type, tree 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;
@@ -336,6 +338,7 @@ convert_to_integer (tree type, tree 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;
@@ -346,7 +349,27 @@ convert_to_integer (tree type, tree expr)
         we are truncating EXPR.  */
 
       else if (outprec >= inprec)
-       return build1 (NOP_EXPR, type, expr);
+       {
+         enum tree_code code;
+
+         /* If the precision of the EXPR's type is K bits and the
+            destination mode has more bits, and the sign is changing,
+            it is not safe to use a NOP_EXPR.  For example, suppose
+            that EXPR's type is a 3-bit unsigned integer type, the
+            TYPE is a 3-bit signed integer type, and the machine mode
+            for the types is 8-bit QImode.  In that case, the
+            conversion necessitates an explicit sign-extension.  In
+            the signed-to-unsigned case the high-order bits have to
+            be cleared.  */
+         if (TREE_UNSIGNED (type) != TREE_UNSIGNED (TREE_TYPE (expr))
+             && (TYPE_PRECISION (TREE_TYPE (expr))
+                 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
+           code = CONVERT_EXPR;
+         else
+           code = NOP_EXPR;
+
+         return build1 (code, type, expr);
+       }
 
       /* If TYPE is an enumeral type or a type with a precision less
         than the number of bits in its mode, do the conversion to the
@@ -450,7 +473,6 @@ convert_to_integer (tree type, tree expr)
        case BIT_AND_EXPR:
        case BIT_IOR_EXPR:
        case BIT_XOR_EXPR:
-       case BIT_ANDTC_EXPR:
        trunc1:
          {
            tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);