contrib/gcc-4.1/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     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 safe for
 244            round-to-nearest rounding mode.  */
 245         case ABS_EXPR:
 246         case NEGATE_EXPR:
 247           if (!flag_rounding_math
 248               && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
 249             return build1 (TREE_CODE (expr), type,
 250                            fold (convert_to_real (type,
 251                                                   TREE_OPERAND (expr, 0))));
 252           break;
 253         /* Convert (outertype)((innertype0)a+(innertype1)b)
 254            into ((newtype)a+(newtype)b) where newtype
 255            is the widest mode from all of these.  */
 256         case PLUS_EXPR:
 257         case MINUS_EXPR:
 258         case MULT_EXPR:
 259         case RDIV_EXPR:
 260            {
 261              tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
 262              tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
 263
 264              if (FLOAT_TYPE_P (TREE_TYPE (arg0))
 265                  && FLOAT_TYPE_P (TREE_TYPE (arg1)))
 266                {
 267                   tree newtype = type;
 268                   if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
 269                     newtype = TREE_TYPE (arg0);
 270                   if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
 271                     newtype = TREE_TYPE (arg1);
 272                   if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype))
 273                     {
 274                       expr = build2 (TREE_CODE (expr), newtype,
 275                                      fold (convert_to_real (newtype, arg0)),
 276                                      fold (convert_to_real (newtype, arg1)));
 277                       if (newtype == type)
 278                         return expr;
 279                     }
 280                }
 281            }
 282           break;
 283         default:
 284           break;
 285       }
 286
 287   switch (TREE_CODE (TREE_TYPE (expr)))
 288     {
 289     case REAL_TYPE:
 290       return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
 291                      type, expr);
 292
 293     case INTEGER_TYPE:
 294     case ENUMERAL_TYPE:
 295     case BOOLEAN_TYPE:
 296     case CHAR_TYPE:
 297       return build1 (FLOAT_EXPR, type, expr);
 298
 299     case COMPLEX_TYPE:
 300       return convert (type,
 301                       fold_build1 (REALPART_EXPR,
 302                                    TREE_TYPE (TREE_TYPE (expr)), expr));
 303
 304     case POINTER_TYPE:
 305     case REFERENCE_TYPE:
 306       error ("pointer value used where a floating point value was expected");
 307       return convert_to_real (type, integer_zero_node);
 308
 309     default:
 310       error ("aggregate value used where a float was expected");
 311       return convert_to_real (type, integer_zero_node);
 312     }
 313 }
 314
 315 /* Convert EXPR to some integer (or enum) type TYPE.
 316
 317    EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
 318    vector; in other cases error is called.
 319
 320    The result of this is always supposed to be a newly created tree node
 321    not in use in any existing structure.  */
 322
 323 tree
 324 convert_to_integer (tree type, tree expr)
 325 {
 326   enum tree_code ex_form = TREE_CODE (expr);
 327   tree intype = TREE_TYPE (expr);
 328   unsigned int inprec = TYPE_PRECISION (intype);
 329   unsigned int outprec = TYPE_PRECISION (type);
 330
 331   /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
 332      be.  Consider `enum E = { a, b = (enum E) 3 };'.  */
 333   if (!COMPLETE_TYPE_P (type))
 334     {
 335       error ("conversion to incomplete type");
 336       return error_mark_node;
 337     }
 338
 339   /* Convert e.g. (long)round(d) -> lround(d).  */
 340   /* If we're converting to char, we may encounter differing behavior
 341      between converting from double->char vs double->long->char.
 342      We're in "undefined" territory but we prefer to be conservative,
 343      so only proceed in "unsafe" math mode.  */
 344   if (optimize
 345       && (flag_unsafe_math_optimizations
 346           || (long_integer_type_node
 347               && outprec >= TYPE_PRECISION (long_integer_type_node))))
 348     {
 349       tree s_expr = strip_float_extensions (expr);
 350       tree s_intype = TREE_TYPE (s_expr);
 351       const enum built_in_function fcode = builtin_mathfn_code (s_expr);
 352       tree fn = 0;
 353
 354       switch (fcode)
 355         {
 356         case BUILT_IN_CEIL: case BUILT_IN_CEILF: case BUILT_IN_CEILL:
 357           /* Only convert in ISO C99 mode.  */
 358           if (!TARGET_C99_FUNCTIONS)
 359             break;
 360           if (outprec < TYPE_PRECISION (long_integer_type_node)
 361               || (outprec == TYPE_PRECISION (long_integer_type_node)
 362                   && !TYPE_UNSIGNED (type)))
 363             fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
 364           else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
 365                    && !TYPE_UNSIGNED (type))
 366             fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL);
 367           break;
 368
 369         case BUILT_IN_FLOOR: case BUILT_IN_FLOORF: case BUILT_IN_FLOORL:
 370           /* Only convert in ISO C99 mode.  */
 371           if (!TARGET_C99_FUNCTIONS)
 372             break;
 373           if (outprec < TYPE_PRECISION (long_integer_type_node)
 374               || (outprec == TYPE_PRECISION (long_integer_type_node)
 375                   && !TYPE_UNSIGNED (type)))
 376             fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
 377           else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
 378                    && !TYPE_UNSIGNED (type))
 379             fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR);
 380           break;
 381
 382         case BUILT_IN_ROUND: case BUILT_IN_ROUNDF: case BUILT_IN_ROUNDL:
 383           if (outprec < TYPE_PRECISION (long_integer_type_node)
 384               || (outprec == TYPE_PRECISION (long_integer_type_node)
 385                   && !TYPE_UNSIGNED (type)))
 386             fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
 387           else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
 388                    && !TYPE_UNSIGNED (type))
 389             fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
 390           break;
 391
 392         case BUILT_IN_RINT: case BUILT_IN_RINTF: case BUILT_IN_RINTL:
 393           /* Only convert rint* if we can ignore math exceptions.  */
 394           if (flag_trapping_math)
 395             break;
 396           /* ... Fall through ...  */
 397         case BUILT_IN_NEARBYINT:
 398         case BUILT_IN_NEARBYINTF:
 399         case BUILT_IN_NEARBYINTL:
 400           if (outprec < TYPE_PRECISION (long_integer_type_node)
 401               || (outprec == TYPE_PRECISION (long_integer_type_node)
 402                   && !TYPE_UNSIGNED (type)))
 403             fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
 404           else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
 405                    && !TYPE_UNSIGNED (type))
 406             fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT);
 407           break;
 408
 409         case BUILT_IN_TRUNC: case BUILT_IN_TRUNCF: case BUILT_IN_TRUNCL:
 410           {
 411             tree arglist = TREE_OPERAND (s_expr, 1);
 412             return convert_to_integer (type, TREE_VALUE (arglist));
 413           }
 414
 415         default:
 416           break;
 417         }
 418
 419       if (fn)
 420         {
 421           tree arglist = TREE_OPERAND (s_expr, 1);
 422           tree newexpr = build_function_call_expr (fn, arglist);
 423           return convert_to_integer (type, newexpr);
 424         }
 425     }
 426
 427   switch (TREE_CODE (intype))
 428     {
 429     case POINTER_TYPE:
 430     case REFERENCE_TYPE:
 431       if (integer_zerop (expr))
 432         return build_int_cst (type, 0);
 433
 434       /* Convert to an unsigned integer of the correct width first,
 435          and from there widen/truncate to the required type.  */
 436       expr = fold_build1 (CONVERT_EXPR,
 437                           lang_hooks.types.type_for_size (POINTER_SIZE, 0),
 438                           expr);
 439       return fold_build1 (NOP_EXPR, type, expr);
 440
 441     case INTEGER_TYPE:
 442     case ENUMERAL_TYPE:
 443     case BOOLEAN_TYPE:
 444     case CHAR_TYPE:
 445       /* If this is a logical operation, which just returns 0 or 1, we can
 446          change the type of the expression.  */
 447
 448       if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
 449         {
 450           expr = copy_node (expr);
 451           TREE_TYPE (expr) = type;
 452           return expr;
 453         }
 454
 455       /* If we are widening the type, put in an explicit conversion.
 456          Similarly if we are not changing the width.  After this, we know
 457          we are truncating EXPR.  */
 458
 459       else if (outprec >= inprec)
 460         {
 461           enum tree_code code;
 462
 463           /* If the precision of the EXPR's type is K bits and the
 464              destination mode has more bits, and the sign is changing,
 465              it is not safe to use a NOP_EXPR.  For example, suppose
 466              that EXPR's type is a 3-bit unsigned integer type, the
 467              TYPE is a 3-bit signed integer type, and the machine mode
 468              for the types is 8-bit QImode.  In that case, the
 469              conversion necessitates an explicit sign-extension.  In
 470              the signed-to-unsigned case the high-order bits have to
 471              be cleared.  */
 472           if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
 473               && (TYPE_PRECISION (TREE_TYPE (expr))
 474                   != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
 475             code = CONVERT_EXPR;
 476           else
 477             code = NOP_EXPR;
 478
 479           return fold_build1 (code, type, expr);
 480         }
 481
 482       /* If TYPE is an enumeral type or a type with a precision less
 483          than the number of bits in its mode, do the conversion to the
 484          type corresponding to its mode, then do a nop conversion
 485          to TYPE.  */
 486       else if (TREE_CODE (type) == ENUMERAL_TYPE
 487                || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
 488         return build1 (NOP_EXPR, type,
 489                        convert (lang_hooks.types.type_for_mode
 490                                 (TYPE_MODE (type), TYPE_UNSIGNED (type)),
 491                                 expr));
 492
 493       /* Here detect when we can distribute the truncation down past some
 494          arithmetic.  For example, if adding two longs and converting to an
 495          int, we can equally well convert both to ints and then add.
 496          For the operations handled here, such truncation distribution
 497          is always safe.
 498          It is desirable in these cases:
 499          1) when truncating down to full-word from a larger size
 500          2) when truncating takes no work.
 501          3) when at least one operand of the arithmetic has been extended
 502          (as by C's default conversions).  In this case we need two conversions
 503          if we do the arithmetic as already requested, so we might as well
 504          truncate both and then combine.  Perhaps that way we need only one.
 505
 506          Note that in general we cannot do the arithmetic in a type
 507          shorter than the desired result of conversion, even if the operands
 508          are both extended from a shorter type, because they might overflow
 509          if combined in that type.  The exceptions to this--the times when
 510          two narrow values can be combined in their narrow type even to
 511          make a wider result--are handled by "shorten" in build_binary_op.  */
 512
 513       switch (ex_form)
 514         {
 515         case RSHIFT_EXPR:
 516           /* We can pass truncation down through right shifting
 517              when the shift count is a nonpositive constant.  */
 518           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 519               && tree_int_cst_lt (TREE_OPERAND (expr, 1),
 520                                   convert (TREE_TYPE (TREE_OPERAND (expr, 1)),
 521                                            integer_one_node)))
 522             goto trunc1;
 523           break;
 524
 525         case LSHIFT_EXPR:
 526           /* We can pass truncation down through left shifting
 527              when the shift count is a nonnegative constant and
 528              the target type is unsigned.  */
 529           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 530               && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
 531               && TYPE_UNSIGNED (type)
 532               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 533             {
 534               /* If shift count is less than the width of the truncated type,
 535                  really shift.  */
 536               if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
 537                 /* In this case, shifting is like multiplication.  */
 538                 goto trunc1;
 539               else
 540                 {
 541                   /* If it is >= that width, result is zero.
 542                      Handling this with trunc1 would give the wrong result:
 543                      (int) ((long long) a << 32) is well defined (as 0)
 544                      but (int) a << 32 is undefined and would get a
 545                      warning.  */
 546
 547                   tree t = convert_to_integer (type, integer_zero_node);
 548
 549                   /* If the original expression had side-effects, we must
 550                      preserve it.  */
 551                   if (TREE_SIDE_EFFECTS (expr))
 552                     return build2 (COMPOUND_EXPR, type, expr, t);
 553                   else
 554                     return t;
 555                 }
 556             }
 557           break;
 558
 559         case MAX_EXPR:
 560         case MIN_EXPR:
 561         case MULT_EXPR:
 562           {
 563             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 564             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 565
 566             /* Don't distribute unless the output precision is at least as big
 567                as the actual inputs.  Otherwise, the comparison of the
 568                truncated values will be wrong.  */
 569             if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
 570                 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
 571                 /* If signedness of arg0 and arg1 don't match,
 572                    we can't necessarily find a type to compare them in.  */
 573                 && (TYPE_UNSIGNED (TREE_TYPE (arg0))
 574                     == TYPE_UNSIGNED (TREE_TYPE (arg1))))
 575               goto trunc1;
 576             break;
 577           }
 578
 579         case PLUS_EXPR:
 580         case MINUS_EXPR:
 581         case BIT_AND_EXPR:
 582         case BIT_IOR_EXPR:
 583         case BIT_XOR_EXPR:
 584         trunc1:
 585           {
 586             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 587             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 588
 589             if (outprec >= BITS_PER_WORD
 590                 || TRULY_NOOP_TRUNCATION (outprec, inprec)
 591                 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
 592                 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
 593               {
 594                 /* Do the arithmetic in type TYPEX,
 595                    then convert result to TYPE.  */
 596                 tree typex = type;
 597
 598                 /* Can't do arithmetic in enumeral types
 599                    so use an integer type that will hold the values.  */
 600                 if (TREE_CODE (typex) == ENUMERAL_TYPE)
 601                   typex = lang_hooks.types.type_for_size
 602                     (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
 603
 604                 /* But now perhaps TYPEX is as wide as INPREC.
 605                    In that case, do nothing special here.
 606                    (Otherwise would recurse infinitely in convert.  */
 607                 if (TYPE_PRECISION (typex) != inprec)
 608                   {
 609                     /* Don't do unsigned arithmetic where signed was wanted,
 610                        or vice versa.
 611                        Exception: if both of the original operands were
 612                        unsigned then we can safely do the work as unsigned.
 613                        Exception: shift operations take their type solely
 614                        from the first argument.
 615                        Exception: the LSHIFT_EXPR case above requires that
 616                        we perform this operation unsigned lest we produce
 617                        signed-overflow undefinedness.
 618                        And we may need to do it as unsigned
 619                        if we truncate to the original size.  */
 620                     if (TYPE_UNSIGNED (TREE_TYPE (expr))
 621                         || (TYPE_UNSIGNED (TREE_TYPE (arg0))
 622                             && (TYPE_UNSIGNED (TREE_TYPE (arg1))
 623                                 || ex_form == LSHIFT_EXPR
 624                                 || ex_form == RSHIFT_EXPR
 625                                 || ex_form == LROTATE_EXPR
 626                                 || ex_form == RROTATE_EXPR))
 627                         || ex_form == LSHIFT_EXPR
 628                         /* If we have !flag_wrapv, and either ARG0 or
 629                            ARG1 is of a signed type, we have to do
 630                            PLUS_EXPR or MINUS_EXPR in an unsigned
 631                            type.  Otherwise, we would introduce
 632                            signed-overflow undefinedness.  */
 633                         || (!flag_wrapv
 634                             && (ex_form == PLUS_EXPR
 635                                 || ex_form == MINUS_EXPR)
 636                             && (!TYPE_UNSIGNED (TREE_TYPE (arg0))
 637                                 || !TYPE_UNSIGNED (TREE_TYPE (arg1)))))
 638                       typex = lang_hooks.types.unsigned_type (typex);
 639                     else
 640                       typex = lang_hooks.types.signed_type (typex);
 641                     return convert (type,
 642                                     fold_build2 (ex_form, typex,
 643                                                  convert (typex, arg0),
 644                                                  convert (typex, arg1)));
 645                   }
 646               }
 647           }
 648           break;
 649
 650         case NEGATE_EXPR:
 651         case BIT_NOT_EXPR:
 652           /* This is not correct for ABS_EXPR,
 653              since we must test the sign before truncation.  */
 654           {
 655             tree typex;
 656
 657             /* Don't do unsigned arithmetic where signed was wanted,
 658                or vice versa.  */
 659             if (TYPE_UNSIGNED (TREE_TYPE (expr)))
 660               typex = lang_hooks.types.unsigned_type (type);
 661             else
 662               typex = lang_hooks.types.signed_type (type);
 663             return convert (type,
 664                             fold_build1 (ex_form, typex,
 665                                          convert (typex,
 666                                                   TREE_OPERAND (expr, 0))));
 667           }
 668
 669         case NOP_EXPR:
 670           /* Don't introduce a
 671              "can't convert between vector values of different size" error.  */
 672           if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
 673               && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
 674                   != GET_MODE_SIZE (TYPE_MODE (type))))
 675             break;
 676           /* If truncating after truncating, might as well do all at once.
 677              If truncating after extending, we may get rid of wasted work.  */
 678           return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
 679
 680         case COND_EXPR:
 681           /* It is sometimes worthwhile to push the narrowing down through
 682              the conditional and never loses.  */
 683           return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
 684                               convert (type, TREE_OPERAND (expr, 1)),
 685                               convert (type, TREE_OPERAND (expr, 2)));
 686
 687         default:
 688           break;
 689         }
 690
 691       return build1 (CONVERT_EXPR, type, expr);
 692
 693     case REAL_TYPE:
 694       return build1 (FIX_TRUNC_EXPR, type, expr);
 695
 696     case COMPLEX_TYPE:
 697       return convert (type,
 698                       fold_build1 (REALPART_EXPR,
 699                                    TREE_TYPE (TREE_TYPE (expr)), expr));
 700
 701     case VECTOR_TYPE:
 702       if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
 703         {
 704           error ("can't convert between vector values of different size");
 705           return error_mark_node;
 706         }
 707       return build1 (VIEW_CONVERT_EXPR, type, expr);
 708
 709     default:
 710       error ("aggregate value used where an integer was expected");
 711       return convert (type, integer_zero_node);
 712     }
 713 }
 714
 715 /* Convert EXPR to the complex type TYPE in the usual ways.  */
 716
 717 tree
 718 convert_to_complex (tree type, tree expr)
 719 {
 720   tree subtype = TREE_TYPE (type);
 721
 722   switch (TREE_CODE (TREE_TYPE (expr)))
 723     {
 724     case REAL_TYPE:
 725     case INTEGER_TYPE:
 726     case ENUMERAL_TYPE:
 727     case BOOLEAN_TYPE:
 728     case CHAR_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 }