gcc/convert.c

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