gcc/convert.c

   1 /* Utility routines for data type conversion for GCC.
   2    Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1997, 1998,
   3    2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  21
  22
  23 /* These routines are somewhat language-independent utility function
  24    intended to be called by the language-specific convert () functions.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "tree.h"
  31 #include "flags.h"
  32 #include "convert.h"
  33 #include "toplev.h"
  34 #include "langhooks.h"
  35 #include "real.h"
  36 /* Convert EXPR to some pointer or reference type TYPE.
  37
  38    EXPR must be pointer, reference, integer, enumeral, or literal zero;
  39    in other cases error is called.  */
  40
  41 tree
  42 convert_to_pointer (tree type, tree expr)
  43 {
  44   if (integer_zerop (expr))
  45     return build_int_cst (type, 0);
  46
  47   switch (TREE_CODE (TREE_TYPE (expr)))
  48     {
  49     case POINTER_TYPE:
  50     case REFERENCE_TYPE:
  51       return build1 (NOP_EXPR, type, expr);
  52
  53     case INTEGER_TYPE:
  54     case ENUMERAL_TYPE:
  55     case BOOLEAN_TYPE:
  56     case CHAR_TYPE:
  57       if (TYPE_PRECISION (TREE_TYPE (expr)) != POINTER_SIZE)
  58         expr = fold_build1 (NOP_EXPR,
  59                             lang_hooks.types.type_for_size (POINTER_SIZE, 0),
  60                             expr);
  61       return fold_build1 (CONVERT_EXPR, type, expr);
  62
  63
  64     default:
  65       error ("cannot convert to a pointer type");
  66       return convert_to_pointer (type, integer_zero_node);
  67     }
  68 }
  69
  70 /* Avoid any floating point extensions from EXP.  */
  71 tree
  72 strip_float_extensions (tree exp)
  73 {
  74   tree sub, expt, subt;
  75
  76   /*  For floating point constant look up the narrowest type that can hold
  77       it properly and handle it like (type)(narrowest_type)constant.
  78       This way we can optimize for instance a=a*2.0 where "a" is float
  79       but 2.0 is double constant.  */
  80   if (TREE_CODE (exp) == REAL_CST)
  81     {
  82       REAL_VALUE_TYPE orig;
  83       tree type = NULL;
  84
  85       orig = TREE_REAL_CST (exp);
  86       if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
  87           && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
  88         type = float_type_node;
  89       else if (TYPE_PRECISION (TREE_TYPE (exp))
  90                > TYPE_PRECISION (double_type_node)
  91                && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
  92         type = double_type_node;
  93       if (type)
  94         return build_real (type, real_value_truncate (TYPE_MODE (type), orig));
  95     }
  96
  97   if (TREE_CODE (exp) != NOP_EXPR
  98       && TREE_CODE (exp) != CONVERT_EXPR)
  99     return exp;
 100
 101   sub = TREE_OPERAND (exp, 0);
 102   subt = TREE_TYPE (sub);
 103   expt = TREE_TYPE (exp);
 104
 105   if (!FLOAT_TYPE_P (subt))
 106     return exp;
 107
 108   if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
 109     return exp;
 110
 111   return strip_float_extensions (sub);
 112 }
 113
 114
 115 /* Convert EXPR to some floating-point type TYPE.
 116
 117    EXPR must be float, integer, or enumeral;
 118    in other cases error is called.  */
 119
 120 tree
 121 convert_to_real (tree type, tree expr)
 122 {
 123   enum built_in_function fcode = builtin_mathfn_code (expr);
 124   tree itype = TREE_TYPE (expr);
 125
 126   /* Disable until we figure out how to decide whether the functions are
 127      present in runtime.  */
 128   /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
 129   if (optimize
 130       && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
 131           || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
 132     {
 133       switch (fcode)
 134         {
 135 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
 136           CASE_MATHFN (ACOS)
 137           CASE_MATHFN (ACOSH)
 138           CASE_MATHFN (ASIN)
 139           CASE_MATHFN (ASINH)
 140           CASE_MATHFN (ATAN)
 141           CASE_MATHFN (ATANH)
 142           CASE_MATHFN (CBRT)
 143           CASE_MATHFN (COS)
 144           CASE_MATHFN (COSH)
 145           CASE_MATHFN (ERF)
 146           CASE_MATHFN (ERFC)
 147           CASE_MATHFN (EXP)
 148           CASE_MATHFN (EXP10)
 149           CASE_MATHFN (EXP2)
 150           CASE_MATHFN (EXPM1)
 151           CASE_MATHFN (FABS)
 152           CASE_MATHFN (GAMMA)
 153           CASE_MATHFN (J0)
 154           CASE_MATHFN (J1)
 155           CASE_MATHFN (LGAMMA)
 156           CASE_MATHFN (LOG)
 157           CASE_MATHFN (LOG10)
 158           CASE_MATHFN (LOG1P)
 159           CASE_MATHFN (LOG2)
 160           CASE_MATHFN (LOGB)
 161           CASE_MATHFN (POW10)
 162           CASE_MATHFN (SIN)
 163           CASE_MATHFN (SINH)
 164           CASE_MATHFN (SQRT)
 165           CASE_MATHFN (TAN)
 166           CASE_MATHFN (TANH)
 167           CASE_MATHFN (TGAMMA)
 168           CASE_MATHFN (Y0)
 169           CASE_MATHFN (Y1)
 170 #undef CASE_MATHFN
 171             {
 172               tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
 173               tree newtype = type;
 174
 175               /* We have (outertype)sqrt((innertype)x).  Choose the wider mode from
 176                  the both as the safe type for operation.  */
 177               if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
 178                 newtype = TREE_TYPE (arg0);
 179
 180               /* Be careful about integer to fp conversions.
 181                  These may overflow still.  */
 182               if (FLOAT_TYPE_P (TREE_TYPE (arg0))
 183                   && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
 184                   && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
 185                       || TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
 186                 {
 187                   tree arglist;
 188                   tree fn = mathfn_built_in (newtype, fcode);
 189
 190                   if (fn)
 191                   {
 192                     arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
 193                     expr = build_function_call_expr (fn, arglist);
 194                     if (newtype == type)
 195                       return expr;
 196                   }
 197                 }
 198             }
 199         default:
 200           break;
 201         }
 202     }
 203   /* This code formerly changed (float)floor(double d) to
 204      floorf((float)d).  This is incorrect, because (float)d uses
 205      round-to-nearest and can round up to the next integer. */
 206
 207   /* Propagate the cast into the operation.  */
 208   if (itype != type && FLOAT_TYPE_P (type))
 209     switch (TREE_CODE (expr))
 210       {
 211         /* Convert (float)-x into -(float)x.  This is always safe.  */
 212         case ABS_EXPR:
 213         case NEGATE_EXPR:
 214           if (TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
 215             return build1 (TREE_CODE (expr), type,
 216                            fold (convert_to_real (type,
 217                                                   TREE_OPERAND (expr, 0))));
 218           break;
 219         /* Convert (outertype)((innertype0)a+(innertype1)b)
 220            into ((newtype)a+(newtype)b) where newtype
 221            is the widest mode from all of these.  */
 222         case PLUS_EXPR:
 223         case MINUS_EXPR:
 224         case MULT_EXPR:
 225         case RDIV_EXPR:
 226            {
 227              tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
 228              tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
 229
 230              if (FLOAT_TYPE_P (TREE_TYPE (arg0))
 231                  && FLOAT_TYPE_P (TREE_TYPE (arg1)))
 232                {
 233                   tree newtype = type;
 234                   if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
 235                     newtype = TREE_TYPE (arg0);
 236                   if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
 237                     newtype = TREE_TYPE (arg1);
 238                   if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype))
 239                     {
 240                       expr = build2 (TREE_CODE (expr), newtype,
 241                                      fold (convert_to_real (newtype, arg0)),
 242                                      fold (convert_to_real (newtype, arg1)));
 243                       if (newtype == type)
 244                         return expr;
 245                     }
 246                }
 247            }
 248           break;
 249         default:
 250           break;
 251       }
 252
 253   switch (TREE_CODE (TREE_TYPE (expr)))
 254     {
 255     case REAL_TYPE:
 256       return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
 257                      type, expr);
 258
 259     case INTEGER_TYPE:
 260     case ENUMERAL_TYPE:
 261     case BOOLEAN_TYPE:
 262     case CHAR_TYPE:
 263       return build1 (FLOAT_EXPR, type, expr);
 264
 265     case COMPLEX_TYPE:
 266       return convert (type,
 267                       fold_build1 (REALPART_EXPR,
 268                                    TREE_TYPE (TREE_TYPE (expr)), expr));
 269
 270     case POINTER_TYPE:
 271     case REFERENCE_TYPE:
 272       error ("pointer value used where a floating point value was expected");
 273       return convert_to_real (type, integer_zero_node);
 274
 275     default:
 276       error ("aggregate value used where a float was expected");
 277       return convert_to_real (type, integer_zero_node);
 278     }
 279 }
 280
 281 /* Convert EXPR to some integer (or enum) type TYPE.
 282
 283    EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
 284    vector; in other cases error is called.
 285
 286    The result of this is always supposed to be a newly created tree node
 287    not in use in any existing structure.  */
 288
 289 tree
 290 convert_to_integer (tree type, tree expr)
 291 {
 292   enum tree_code ex_form = TREE_CODE (expr);
 293   tree intype = TREE_TYPE (expr);
 294   unsigned int inprec = TYPE_PRECISION (intype);
 295   unsigned int outprec = TYPE_PRECISION (type);
 296
 297   /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
 298      be.  Consider `enum E = { a, b = (enum E) 3 };'.  */
 299   if (!COMPLETE_TYPE_P (type))
 300     {
 301       error ("conversion to incomplete type");
 302       return error_mark_node;
 303     }
 304
 305   /* Convert e.g. (long)round(d) -> lround(d).  */
 306   /* If we're converting to char, we may encounter differing behavior
 307      between converting from double->char vs double->long->char.
 308      We're in "undefined" territory but we prefer to be conservative,
 309      so only proceed in "unsafe" math mode.  */
 310   if (optimize
 311       && (flag_unsafe_math_optimizations
 312           || (long_integer_type_node
 313               && outprec >= TYPE_PRECISION (long_integer_type_node))))
 314     {
 315       tree s_expr = strip_float_extensions (expr);
 316       tree s_intype = TREE_TYPE (s_expr);
 317       const enum built_in_function fcode = builtin_mathfn_code (s_expr);
 318       tree fn = 0;
 319
 320       switch (fcode)
 321         {
 322         case BUILT_IN_CEIL: case BUILT_IN_CEILF: case BUILT_IN_CEILL:
 323           /* Only convert in ISO C99 mode.  */
 324           if (!TARGET_C99_FUNCTIONS)
 325             break;
 326           if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
 327             fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL);
 328           else
 329             fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
 330           break;
 331
 332         case BUILT_IN_FLOOR: case BUILT_IN_FLOORF: case BUILT_IN_FLOORL:
 333           /* Only convert in ISO C99 mode.  */
 334           if (!TARGET_C99_FUNCTIONS)
 335             break;
 336           if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
 337             fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR);
 338           else
 339             fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
 340           break;
 341
 342         case BUILT_IN_ROUND: case BUILT_IN_ROUNDF: case BUILT_IN_ROUNDL:
 343           if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
 344             fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
 345           else
 346             fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
 347           break;
 348
 349         case BUILT_IN_RINT: case BUILT_IN_RINTF: case BUILT_IN_RINTL:
 350           /* Only convert rint* if we can ignore math exceptions.  */
 351           if (flag_trapping_math)
 352             break;
 353           /* ... Fall through ...  */
 354         case BUILT_IN_NEARBYINT: case BUILT_IN_NEARBYINTF: case BUILT_IN_NEARBYINTL:
 355           if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
 356             fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT);
 357           else
 358             fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
 359           break;
 360
 361         case BUILT_IN_TRUNC: case BUILT_IN_TRUNCF: case BUILT_IN_TRUNCL:
 362           {
 363             tree arglist = TREE_OPERAND (s_expr, 1);
 364             return convert_to_integer (type, TREE_VALUE (arglist));
 365           }
 366
 367         default:
 368           break;
 369         }
 370
 371       if (fn)
 372         {
 373           tree arglist = TREE_OPERAND (s_expr, 1);
 374           tree newexpr = build_function_call_expr (fn, arglist);
 375           return convert_to_integer (type, newexpr);
 376         }
 377     }
 378
 379   switch (TREE_CODE (intype))
 380     {
 381     case POINTER_TYPE:
 382     case REFERENCE_TYPE:
 383       if (integer_zerop (expr))
 384         return build_int_cst (type, 0);
 385
 386       /* Convert to an unsigned integer of the correct width first,
 387          and from there widen/truncate to the required type.  */
 388       expr = fold_build1 (CONVERT_EXPR,
 389                           lang_hooks.types.type_for_size (POINTER_SIZE, 0),
 390                           expr);
 391       return fold_build1 (NOP_EXPR, type, expr);
 392
 393     case INTEGER_TYPE:
 394     case ENUMERAL_TYPE:
 395     case BOOLEAN_TYPE:
 396     case CHAR_TYPE:
 397       /* If this is a logical operation, which just returns 0 or 1, we can
 398          change the type of the expression.  */
 399
 400       if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
 401         {
 402           expr = copy_node (expr);
 403           TREE_TYPE (expr) = type;
 404           return expr;
 405         }
 406
 407       /* If we are widening the type, put in an explicit conversion.
 408          Similarly if we are not changing the width.  After this, we know
 409          we are truncating EXPR.  */
 410
 411       else if (outprec >= inprec)
 412         {
 413           enum tree_code code;
 414
 415           /* If the precision of the EXPR's type is K bits and the
 416              destination mode has more bits, and the sign is changing,
 417              it is not safe to use a NOP_EXPR.  For example, suppose
 418              that EXPR's type is a 3-bit unsigned integer type, the
 419              TYPE is a 3-bit signed integer type, and the machine mode
 420              for the types is 8-bit QImode.  In that case, the
 421              conversion necessitates an explicit sign-extension.  In
 422              the signed-to-unsigned case the high-order bits have to
 423              be cleared.  */
 424           if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
 425               && (TYPE_PRECISION (TREE_TYPE (expr))
 426                   != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
 427             code = CONVERT_EXPR;
 428           else
 429             code = NOP_EXPR;
 430
 431           return fold_build1 (code, type, expr);
 432         }
 433
 434       /* If TYPE is an enumeral type or a type with a precision less
 435          than the number of bits in its mode, do the conversion to the
 436          type corresponding to its mode, then do a nop conversion
 437          to TYPE.  */
 438       else if (TREE_CODE (type) == ENUMERAL_TYPE
 439                || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
 440         return build1 (NOP_EXPR, type,
 441                        convert (lang_hooks.types.type_for_mode
 442                                 (TYPE_MODE (type), TYPE_UNSIGNED (type)),
 443                                 expr));
 444
 445       /* Here detect when we can distribute the truncation down past some
 446          arithmetic.  For example, if adding two longs and converting to an
 447          int, we can equally well convert both to ints and then add.
 448          For the operations handled here, such truncation distribution
 449          is always safe.
 450          It is desirable in these cases:
 451          1) when truncating down to full-word from a larger size
 452          2) when truncating takes no work.
 453          3) when at least one operand of the arithmetic has been extended
 454          (as by C's default conversions).  In this case we need two conversions
 455          if we do the arithmetic as already requested, so we might as well
 456          truncate both and then combine.  Perhaps that way we need only one.
 457
 458          Note that in general we cannot do the arithmetic in a type
 459          shorter than the desired result of conversion, even if the operands
 460          are both extended from a shorter type, because they might overflow
 461          if combined in that type.  The exceptions to this--the times when
 462          two narrow values can be combined in their narrow type even to
 463          make a wider result--are handled by "shorten" in build_binary_op.  */
 464
 465       switch (ex_form)
 466         {
 467         case RSHIFT_EXPR:
 468           /* We can pass truncation down through right shifting
 469              when the shift count is a nonpositive constant.  */
 470           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 471               && tree_int_cst_lt (TREE_OPERAND (expr, 1),
 472                                   convert (TREE_TYPE (TREE_OPERAND (expr, 1)),
 473                                            integer_one_node)))
 474             goto trunc1;
 475           break;
 476
 477         case LSHIFT_EXPR:
 478           /* We can pass truncation down through left shifting
 479              when the shift count is a nonnegative constant and
 480              the target type is unsigned.  */
 481           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 482               && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
 483               && TYPE_UNSIGNED (type)
 484               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 485             {
 486               /* If shift count is less than the width of the truncated type,
 487                  really shift.  */
 488               if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
 489                 /* In this case, shifting is like multiplication.  */
 490                 goto trunc1;
 491               else
 492                 {
 493                   /* If it is >= that width, result is zero.
 494                      Handling this with trunc1 would give the wrong result:
 495                      (int) ((long long) a << 32) is well defined (as 0)
 496                      but (int) a << 32 is undefined and would get a
 497                      warning.  */
 498
 499                   tree t = convert_to_integer (type, integer_zero_node);
 500
 501                   /* If the original expression had side-effects, we must
 502                      preserve it.  */
 503                   if (TREE_SIDE_EFFECTS (expr))
 504                     return build2 (COMPOUND_EXPR, type, expr, t);
 505                   else
 506                     return t;
 507                 }
 508             }
 509           break;
 510
 511         case MAX_EXPR:
 512         case MIN_EXPR:
 513         case MULT_EXPR:
 514           {
 515             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 516             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 517
 518             /* Don't distribute unless the output precision is at least as big
 519                as the actual inputs.  Otherwise, the comparison of the
 520                truncated values will be wrong.  */
 521             if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
 522                 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
 523                 /* If signedness of arg0 and arg1 don't match,
 524                    we can't necessarily find a type to compare them in.  */
 525                 && (TYPE_UNSIGNED (TREE_TYPE (arg0))
 526                     == TYPE_UNSIGNED (TREE_TYPE (arg1))))
 527               goto trunc1;
 528             break;
 529           }
 530
 531         case PLUS_EXPR:
 532         case MINUS_EXPR:
 533         case BIT_AND_EXPR:
 534         case BIT_IOR_EXPR:
 535         case BIT_XOR_EXPR:
 536         trunc1:
 537           {
 538             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 539             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 540
 541             if (outprec >= BITS_PER_WORD
 542                 || TRULY_NOOP_TRUNCATION (outprec, inprec)
 543                 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
 544                 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
 545               {
 546                 /* Do the arithmetic in type TYPEX,
 547                    then convert result to TYPE.  */
 548                 tree typex = type;
 549
 550                 /* Can't do arithmetic in enumeral types
 551                    so use an integer type that will hold the values.  */
 552                 if (TREE_CODE (typex) == ENUMERAL_TYPE)
 553                   typex = lang_hooks.types.type_for_size
 554                     (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
 555
 556                 /* But now perhaps TYPEX is as wide as INPREC.
 557                    In that case, do nothing special here.
 558                    (Otherwise would recurse infinitely in convert.  */
 559                 if (TYPE_PRECISION (typex) != inprec)
 560                   {
 561                     /* Don't do unsigned arithmetic where signed was wanted,
 562                        or vice versa.
 563                        Exception: if both of the original operands were
 564                        unsigned then we can safely do the work as unsigned.
 565                        Exception: shift operations take their type solely
 566                        from the first argument.
 567                        Exception: the LSHIFT_EXPR case above requires that
 568                        we perform this operation unsigned lest we produce
 569                        signed-overflow undefinedness.
 570                        And we may need to do it as unsigned
 571                        if we truncate to the original size.  */
 572                     if (TYPE_UNSIGNED (TREE_TYPE (expr))
 573                         || (TYPE_UNSIGNED (TREE_TYPE (arg0))
 574                             && (TYPE_UNSIGNED (TREE_TYPE (arg1))
 575                                 || ex_form == LSHIFT_EXPR
 576                                 || ex_form == RSHIFT_EXPR
 577                                 || ex_form == LROTATE_EXPR
 578                                 || ex_form == RROTATE_EXPR))
 579                         || ex_form == LSHIFT_EXPR)
 580                       typex = lang_hooks.types.unsigned_type (typex);
 581                     else
 582                       typex = lang_hooks.types.signed_type (typex);
 583                     return convert (type,
 584                                     fold_build2 (ex_form, typex,
 585                                                  convert (typex, arg0),
 586                                                  convert (typex, arg1)));
 587                   }
 588               }
 589           }
 590           break;
 591
 592         case NEGATE_EXPR:
 593         case BIT_NOT_EXPR:
 594           /* This is not correct for ABS_EXPR,
 595              since we must test the sign before truncation.  */
 596           {
 597             tree typex;
 598
 599             /* Don't do unsigned arithmetic where signed was wanted,
 600                or vice versa.  */
 601             if (TYPE_UNSIGNED (TREE_TYPE (expr)))
 602               typex = lang_hooks.types.unsigned_type (type);
 603             else
 604               typex = lang_hooks.types.signed_type (type);
 605             return convert (type,
 606                             fold_build1 (ex_form, typex,
 607                                          convert (typex,
 608                                                   TREE_OPERAND (expr, 0))));
 609           }
 610
 611         case NOP_EXPR:
 612           /* Don't introduce a
 613              "can't convert between vector values of different size" error.  */
 614           if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
 615               && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
 616                   != GET_MODE_SIZE (TYPE_MODE (type))))
 617             break;
 618           /* If truncating after truncating, might as well do all at once.
 619              If truncating after extending, we may get rid of wasted work.  */
 620           return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
 621
 622         case COND_EXPR:
 623           /* It is sometimes worthwhile to push the narrowing down through
 624              the conditional and never loses.  */
 625           return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
 626                               convert (type, TREE_OPERAND (expr, 1)),
 627                               convert (type, TREE_OPERAND (expr, 2)));
 628
 629         default:
 630           break;
 631         }
 632
 633       return build1 (CONVERT_EXPR, type, expr);
 634
 635     case REAL_TYPE:
 636       return build1 (FIX_TRUNC_EXPR, type, expr);
 637
 638     case COMPLEX_TYPE:
 639       return convert (type,
 640                       fold_build1 (REALPART_EXPR,
 641                                    TREE_TYPE (TREE_TYPE (expr)), expr));
 642
 643     case VECTOR_TYPE:
 644       if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
 645         {
 646           error ("can't convert between vector values of different size");
 647           return error_mark_node;
 648         }
 649       return build1 (VIEW_CONVERT_EXPR, type, expr);
 650
 651     default:
 652       error ("aggregate value used where an integer was expected");
 653       return convert (type, integer_zero_node);
 654     }
 655 }
 656
 657 /* Convert EXPR to the complex type TYPE in the usual ways.  */
 658
 659 tree
 660 convert_to_complex (tree type, tree expr)
 661 {
 662   tree subtype = TREE_TYPE (type);
 663
 664   switch (TREE_CODE (TREE_TYPE (expr)))
 665     {
 666     case REAL_TYPE:
 667     case INTEGER_TYPE:
 668     case ENUMERAL_TYPE:
 669     case BOOLEAN_TYPE:
 670     case CHAR_TYPE:
 671       return build2 (COMPLEX_EXPR, type, convert (subtype, expr),
 672                      convert (subtype, integer_zero_node));
 673
 674     case COMPLEX_TYPE:
 675       {
 676         tree elt_type = TREE_TYPE (TREE_TYPE (expr));
 677
 678         if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
 679           return expr;
 680         else if (TREE_CODE (expr) == COMPLEX_EXPR)
 681           return fold_build2 (COMPLEX_EXPR, type,
 682                               convert (subtype, TREE_OPERAND (expr, 0)),
 683                               convert (subtype, TREE_OPERAND (expr, 1)));
 684         else
 685           {
 686             expr = save_expr (expr);
 687             return
 688               fold_build2 (COMPLEX_EXPR, type,
 689                            convert (subtype,
 690                                     fold_build1 (REALPART_EXPR,
 691                                                  TREE_TYPE (TREE_TYPE (expr)),
 692                                                  expr)),
 693                            convert (subtype,
 694                                     fold_build1 (IMAGPART_EXPR,
 695                                                  TREE_TYPE (TREE_TYPE (expr)),
 696                                                  expr)));
 697           }
 698       }
 699
 700     case POINTER_TYPE:
 701     case REFERENCE_TYPE:
 702       error ("pointer value used where a complex was expected");
 703       return convert_to_complex (type, integer_zero_node);
 704
 705     default:
 706       error ("aggregate value used where a complex was expected");
 707       return convert_to_complex (type, integer_zero_node);
 708     }
 709 }
 710
 711 /* Convert EXPR to the vector type TYPE in the usual ways.  */
 712
 713 tree
 714 convert_to_vector (tree type, tree expr)
 715 {
 716   switch (TREE_CODE (TREE_TYPE (expr)))
 717     {
 718     case INTEGER_TYPE:
 719     case VECTOR_TYPE:
 720       if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
 721         {
 722           error ("can't convert between vector values of different size");
 723           return error_mark_node;
 724         }
 725       return build1 (VIEW_CONVERT_EXPR, type, expr);
 726
 727     default:
 728       error ("can't convert value to a vector");
 729       return error_mark_node;
 730     }
 731 }