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