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