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