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