gcc/convert.c

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