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