gcc/convert.c

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