gcc/convert.c

   1 /* Utility routines for data type conversion for GCC.
   2    Copyright (C) 1987-2018 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20
  21 /* These routines are somewhat language-independent utility function
  22    intended to be called by the language-specific convert () functions.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "target.h"
  28 #include "tree.h"
  29 #include "diagnostic-core.h"
  30 #include "fold-const.h"
  31 #include "stor-layout.h"
  32 #include "convert.h"
  33 #include "langhooks.h"
  34 #include "builtins.h"
  35 #include "ubsan.h"
  36 #include "stringpool.h"
  37 #include "attribs.h"
  38 #include "asan.h"
  39
  40 #define maybe_fold_build1_loc(FOLD_P, LOC, CODE, TYPE, EXPR) \
  41   ((FOLD_P) ? fold_build1_loc (LOC, CODE, TYPE, EXPR)        \
  42    : build1_loc (LOC, CODE, TYPE, EXPR))
  43 #define maybe_fold_build2_loc(FOLD_P, LOC, CODE, TYPE, EXPR1, EXPR2) \
  44   ((FOLD_P) ? fold_build2_loc (LOC, CODE, TYPE, EXPR1, EXPR2)        \
  45    : build2_loc (LOC, CODE, TYPE, EXPR1, EXPR2))
  46
  47 /* Convert EXPR to some pointer or reference type TYPE.
  48    EXPR must be pointer, reference, integer, enumeral, or literal zero;
  49    in other cases error is called.  If FOLD_P is true, try to fold the
  50    expression.  */
  51
  52 static tree
  53 convert_to_pointer_1 (tree type, tree expr, bool fold_p)
  54 {
  55   location_t loc = EXPR_LOCATION (expr);
  56   if (TREE_TYPE (expr) == type)
  57     return expr;
  58
  59   switch (TREE_CODE (TREE_TYPE (expr)))
  60     {
  61     case POINTER_TYPE:
  62     case REFERENCE_TYPE:
  63       {
  64         /* If the pointers point to different address spaces, conversion needs
  65            to be done via a ADDR_SPACE_CONVERT_EXPR instead of a NOP_EXPR.  */
  66         addr_space_t to_as = TYPE_ADDR_SPACE (TREE_TYPE (type));
  67         addr_space_t from_as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (expr)));
  68
  69         if (to_as == from_as)
  70           return maybe_fold_build1_loc (fold_p, loc, NOP_EXPR, type, expr);
  71         else
  72           return maybe_fold_build1_loc (fold_p, loc, ADDR_SPACE_CONVERT_EXPR,
  73                                         type, expr);
  74       }
  75
  76     case INTEGER_TYPE:
  77     case ENUMERAL_TYPE:
  78     case BOOLEAN_TYPE:
  79       {
  80         /* If the input precision differs from the target pointer type
  81            precision, first convert the input expression to an integer type of
  82            the target precision.  Some targets, e.g. VMS, need several pointer
  83            sizes to coexist so the latter isn't necessarily POINTER_SIZE.  */
  84         unsigned int pprec = TYPE_PRECISION (type);
  85         unsigned int eprec = TYPE_PRECISION (TREE_TYPE (expr));
  86
  87         if (eprec != pprec)
  88           expr
  89             = maybe_fold_build1_loc (fold_p, loc, NOP_EXPR,
  90                                      lang_hooks.types.type_for_size (pprec, 0),
  91                                      expr);
  92       }
  93       return maybe_fold_build1_loc (fold_p, loc, CONVERT_EXPR, type, expr);
  94
  95     default:
  96       error ("cannot convert to a pointer type");
  97       return convert_to_pointer_1 (type, integer_zero_node, fold_p);
  98     }
  99 }
 100
 101 /* A wrapper around convert_to_pointer_1 that always folds the
 102    expression.  */
 103
 104 tree
 105 convert_to_pointer (tree type, tree expr)
 106 {
 107   return convert_to_pointer_1 (type, expr, true);
 108 }
 109
 110 /* A wrapper around convert_to_pointer_1 that only folds the
 111    expression if DOFOLD, or if it is CONSTANT_CLASS_P.  */
 112
 113 tree
 114 convert_to_pointer_maybe_fold (tree type, tree expr, bool dofold)
 115 {
 116   return convert_to_pointer_1 (type, expr, dofold || CONSTANT_CLASS_P (expr));
 117 }
 118
 119 /* Convert EXPR to some floating-point type TYPE.
 120
 121    EXPR must be float, fixed-point, integer, or enumeral;
 122    in other cases error is called.  If FOLD_P is true, try to fold
 123    the expression.  */
 124
 125 static tree
 126 convert_to_real_1 (tree type, tree expr, bool fold_p)
 127 {
 128   enum built_in_function fcode = builtin_mathfn_code (expr);
 129   tree itype = TREE_TYPE (expr);
 130   location_t loc = EXPR_LOCATION (expr);
 131
 132   if (TREE_CODE (expr) == COMPOUND_EXPR)
 133     {
 134       tree t = convert_to_real_1 (type, TREE_OPERAND (expr, 1), fold_p);
 135       if (t == TREE_OPERAND (expr, 1))
 136         return expr;
 137       return build2_loc (EXPR_LOCATION (expr), COMPOUND_EXPR, TREE_TYPE (t),
 138                          TREE_OPERAND (expr, 0), t);
 139     }
 140
 141   /* Disable until we figure out how to decide whether the functions are
 142      present in runtime.  */
 143   /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
 144   if (optimize
 145       && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
 146           || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
 147     {
 148       switch (fcode)
 149         {
 150 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
 151           CASE_MATHFN (COSH)
 152           CASE_MATHFN (EXP)
 153           CASE_MATHFN (EXP10)
 154           CASE_MATHFN (EXP2)
 155           CASE_MATHFN (EXPM1)
 156           CASE_MATHFN (GAMMA)
 157           CASE_MATHFN (J0)
 158           CASE_MATHFN (J1)
 159           CASE_MATHFN (LGAMMA)
 160           CASE_MATHFN (POW10)
 161           CASE_MATHFN (SINH)
 162           CASE_MATHFN (TGAMMA)
 163           CASE_MATHFN (Y0)
 164           CASE_MATHFN (Y1)
 165             /* The above functions may set errno differently with float
 166                input or output so this transformation is not safe with
 167                -fmath-errno.  */
 168             if (flag_errno_math)
 169               break;
 170             gcc_fallthrough ();
 171           CASE_MATHFN (ACOS)
 172           CASE_MATHFN (ACOSH)
 173           CASE_MATHFN (ASIN)
 174           CASE_MATHFN (ASINH)
 175           CASE_MATHFN (ATAN)
 176           CASE_MATHFN (ATANH)
 177           CASE_MATHFN (CBRT)
 178           CASE_MATHFN (COS)
 179           CASE_MATHFN (ERF)
 180           CASE_MATHFN (ERFC)
 181           CASE_MATHFN (LOG)
 182           CASE_MATHFN (LOG10)
 183           CASE_MATHFN (LOG2)
 184           CASE_MATHFN (LOG1P)
 185           CASE_MATHFN (SIN)
 186           CASE_MATHFN (TAN)
 187           CASE_MATHFN (TANH)
 188             /* The above functions are not safe to do this conversion.  */
 189             if (!flag_unsafe_math_optimizations)
 190               break;
 191             gcc_fallthrough ();
 192           CASE_MATHFN (SQRT)
 193           CASE_MATHFN (FABS)
 194           CASE_MATHFN (LOGB)
 195 #undef CASE_MATHFN
 196             {
 197               tree arg0 = strip_float_extensions (CALL_EXPR_ARG (expr, 0));
 198               tree newtype = type;
 199
 200               /* We have (outertype)sqrt((innertype)x).  Choose the wider mode from
 201                  the both as the safe type for operation.  */
 202               if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
 203                 newtype = TREE_TYPE (arg0);
 204
 205               /* We consider to convert
 206
 207                      (T1) sqrtT2 ((T2) exprT3)
 208                  to
 209                      (T1) sqrtT4 ((T4) exprT3)
 210
 211                   , where T1 is TYPE, T2 is ITYPE, T3 is TREE_TYPE (ARG0),
 212                  and T4 is NEWTYPE.  All those types are of floating point types.
 213                  T4 (NEWTYPE) should be narrower than T2 (ITYPE). This conversion
 214                  is safe only if P1 >= P2*2+2, where P1 and P2 are precisions of
 215                  T2 and T4.  See the following URL for a reference:
 216                  http://stackoverflow.com/questions/9235456/determining-
 217                  floating-point-square-root
 218                  */
 219               if ((fcode == BUILT_IN_SQRT || fcode == BUILT_IN_SQRTL)
 220                   && !flag_unsafe_math_optimizations)
 221                 {
 222                   /* The following conversion is unsafe even the precision condition
 223                      below is satisfied:
 224
 225                      (float) sqrtl ((long double) double_val) -> (float) sqrt (double_val)
 226                     */
 227                   if (TYPE_MODE (type) != TYPE_MODE (newtype))
 228                     break;
 229
 230                   int p1 = REAL_MODE_FORMAT (TYPE_MODE (itype))->p;
 231                   int p2 = REAL_MODE_FORMAT (TYPE_MODE (newtype))->p;
 232                   if (p1 < p2 * 2 + 2)
 233                     break;
 234                 }
 235
 236               /* Be careful about integer to fp conversions.
 237                  These may overflow still.  */
 238               if (FLOAT_TYPE_P (TREE_TYPE (arg0))
 239                   && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
 240                   && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
 241                       || TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
 242                 {
 243                   tree fn = mathfn_built_in (newtype, fcode);
 244                   if (fn)
 245                     {
 246                       tree arg = convert_to_real_1 (newtype, arg0, fold_p);
 247                       expr = build_call_expr (fn, 1, arg);
 248                       if (newtype == type)
 249                         return expr;
 250                     }
 251                 }
 252             }
 253         default:
 254           break;
 255         }
 256     }
 257
 258   /* Propagate the cast into the operation.  */
 259   if (itype != type && FLOAT_TYPE_P (type))
 260     switch (TREE_CODE (expr))
 261       {
 262         /* Convert (float)-x into -(float)x.  This is safe for
 263            round-to-nearest rounding mode when the inner type is float.  */
 264         case ABS_EXPR:
 265         case NEGATE_EXPR:
 266           if (!flag_rounding_math
 267               && FLOAT_TYPE_P (itype)
 268               && TYPE_PRECISION (type) < TYPE_PRECISION (itype))
 269             {
 270               tree arg = convert_to_real_1 (type, TREE_OPERAND (expr, 0),
 271                                             fold_p);
 272               return build1 (TREE_CODE (expr), type, arg);
 273             }
 274           break;
 275         /* Convert (outertype)((innertype0)a+(innertype1)b)
 276            into ((newtype)a+(newtype)b) where newtype
 277            is the widest mode from all of these.  */
 278         case PLUS_EXPR:
 279         case MINUS_EXPR:
 280         case MULT_EXPR:
 281         case RDIV_EXPR:
 282            {
 283              tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
 284              tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
 285
 286              if (FLOAT_TYPE_P (TREE_TYPE (arg0))
 287                  && FLOAT_TYPE_P (TREE_TYPE (arg1))
 288                  && DECIMAL_FLOAT_TYPE_P (itype) == DECIMAL_FLOAT_TYPE_P (type))
 289                {
 290                   tree newtype = type;
 291
 292                   if (TYPE_MODE (TREE_TYPE (arg0)) == SDmode
 293                       || TYPE_MODE (TREE_TYPE (arg1)) == SDmode
 294                       || TYPE_MODE (type) == SDmode)
 295                     newtype = dfloat32_type_node;
 296                   if (TYPE_MODE (TREE_TYPE (arg0)) == DDmode
 297                       || TYPE_MODE (TREE_TYPE (arg1)) == DDmode
 298                       || TYPE_MODE (type) == DDmode)
 299                     newtype = dfloat64_type_node;
 300                   if (TYPE_MODE (TREE_TYPE (arg0)) == TDmode
 301                       || TYPE_MODE (TREE_TYPE (arg1)) == TDmode
 302                       || TYPE_MODE (type) == TDmode)
 303                     newtype = dfloat128_type_node;
 304                   if (newtype == dfloat32_type_node
 305                       || newtype == dfloat64_type_node
 306                       || newtype == dfloat128_type_node)
 307                     {
 308                       expr = build2 (TREE_CODE (expr), newtype,
 309                                      convert_to_real_1 (newtype, arg0,
 310                                                         fold_p),
 311                                      convert_to_real_1 (newtype, arg1,
 312                                                         fold_p));
 313                       if (newtype == type)
 314                         return expr;
 315                       break;
 316                     }
 317
 318                   if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
 319                     newtype = TREE_TYPE (arg0);
 320                   if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
 321                     newtype = TREE_TYPE (arg1);
 322                   /* Sometimes this transformation is safe (cannot
 323                      change results through affecting double rounding
 324                      cases) and sometimes it is not.  If NEWTYPE is
 325                      wider than TYPE, e.g. (float)((long double)double
 326                      + (long double)double) converted to
 327                      (float)(double + double), the transformation is
 328                      unsafe regardless of the details of the types
 329                      involved; double rounding can arise if the result
 330                      of NEWTYPE arithmetic is a NEWTYPE value half way
 331                      between two representable TYPE values but the
 332                      exact value is sufficiently different (in the
 333                      right direction) for this difference to be
 334                      visible in ITYPE arithmetic.  If NEWTYPE is the
 335                      same as TYPE, however, the transformation may be
 336                      safe depending on the types involved: it is safe
 337                      if the ITYPE has strictly more than twice as many
 338                      mantissa bits as TYPE, can represent infinities
 339                      and NaNs if the TYPE can, and has sufficient
 340                      exponent range for the product or ratio of two
 341                      values representable in the TYPE to be within the
 342                      range of normal values of ITYPE.  */
 343                   if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
 344                       && (flag_unsafe_math_optimizations
 345                           || (TYPE_PRECISION (newtype) == TYPE_PRECISION (type)
 346                               && real_can_shorten_arithmetic (TYPE_MODE (itype),
 347                                                               TYPE_MODE (type))
 348                               && !excess_precision_type (newtype))))
 349                     {
 350                       expr = build2 (TREE_CODE (expr), newtype,
 351                                      convert_to_real_1 (newtype, arg0,
 352                                                         fold_p),
 353                                      convert_to_real_1 (newtype, arg1,
 354                                                         fold_p));
 355                       if (newtype == type)
 356                         return expr;
 357                     }
 358                }
 359            }
 360           break;
 361         default:
 362           break;
 363       }
 364
 365   switch (TREE_CODE (TREE_TYPE (expr)))
 366     {
 367     case REAL_TYPE:
 368       /* Ignore the conversion if we don't need to store intermediate
 369          results and neither type is a decimal float.  */
 370       return build1_loc (loc,
 371                          (flag_float_store
 372                           || DECIMAL_FLOAT_TYPE_P (type)
 373                           || DECIMAL_FLOAT_TYPE_P (itype))
 374                          ? CONVERT_EXPR : NOP_EXPR, type, expr);
 375
 376     case INTEGER_TYPE:
 377     case ENUMERAL_TYPE:
 378     case BOOLEAN_TYPE:
 379       return build1 (FLOAT_EXPR, type, expr);
 380
 381     case FIXED_POINT_TYPE:
 382       return build1 (FIXED_CONVERT_EXPR, type, expr);
 383
 384     case COMPLEX_TYPE:
 385       return convert (type,
 386                       maybe_fold_build1_loc (fold_p, loc, REALPART_EXPR,
 387                                              TREE_TYPE (TREE_TYPE (expr)),
 388                                              expr));
 389
 390     case POINTER_TYPE:
 391     case REFERENCE_TYPE:
 392       error ("pointer value used where a floating point value was expected");
 393       return convert_to_real_1 (type, integer_zero_node, fold_p);
 394
 395     default:
 396       error ("aggregate value used where a float was expected");
 397       return convert_to_real_1 (type, integer_zero_node, fold_p);
 398     }
 399 }
 400
 401 /* A wrapper around convert_to_real_1 that always folds the
 402    expression.  */
 403
 404 tree
 405 convert_to_real (tree type, tree expr)
 406 {
 407   return convert_to_real_1 (type, expr, true);
 408 }
 409
 410 /* A wrapper around convert_to_real_1 that only folds the
 411    expression if DOFOLD, or if it is CONSTANT_CLASS_P.  */
 412
 413 tree
 414 convert_to_real_maybe_fold (tree type, tree expr, bool dofold)
 415 {
 416   return convert_to_real_1 (type, expr, dofold || CONSTANT_CLASS_P (expr));
 417 }
 418
 419 /* Try to narrow EX_FORM ARG0 ARG1 in narrowed arg types producing a
 420    result in TYPE.  */
 421
 422 static tree
 423 do_narrow (location_t loc,
 424            enum tree_code ex_form, tree type, tree arg0, tree arg1,
 425            tree expr, unsigned inprec, unsigned outprec, bool dofold)
 426 {
 427   /* Do the arithmetic in type TYPEX,
 428      then convert result to TYPE.  */
 429   tree typex = type;
 430
 431   /* Can't do arithmetic in enumeral types
 432      so use an integer type that will hold the values.  */
 433   if (TREE_CODE (typex) == ENUMERAL_TYPE)
 434     typex = lang_hooks.types.type_for_size (TYPE_PRECISION (typex),
 435                                             TYPE_UNSIGNED (typex));
 436
 437   /* The type demotion below might cause doing unsigned arithmetic
 438      instead of signed, and thus hide overflow bugs.  */
 439   if ((ex_form == PLUS_EXPR || ex_form == MINUS_EXPR)
 440       && !TYPE_UNSIGNED (typex)
 441       && sanitize_flags_p (SANITIZE_SI_OVERFLOW))
 442     return NULL_TREE;
 443
 444   /* But now perhaps TYPEX is as wide as INPREC.
 445      In that case, do nothing special here.
 446      (Otherwise would recurse infinitely in convert.  */
 447   if (TYPE_PRECISION (typex) != inprec)
 448     {
 449       /* Don't do unsigned arithmetic where signed was wanted,
 450          or vice versa.
 451          Exception: if both of the original operands were
 452          unsigned then we can safely do the work as unsigned.
 453          Exception: shift operations take their type solely
 454          from the first argument.
 455          Exception: the LSHIFT_EXPR case above requires that
 456          we perform this operation unsigned lest we produce
 457          signed-overflow undefinedness.
 458          And we may need to do it as unsigned
 459          if we truncate to the original size.  */
 460       if (TYPE_UNSIGNED (TREE_TYPE (expr))
 461           || (TYPE_UNSIGNED (TREE_TYPE (arg0))
 462               && (TYPE_UNSIGNED (TREE_TYPE (arg1))
 463                   || ex_form == LSHIFT_EXPR
 464                   || ex_form == RSHIFT_EXPR
 465                   || ex_form == LROTATE_EXPR
 466                   || ex_form == RROTATE_EXPR))
 467           || ex_form == LSHIFT_EXPR
 468           /* If we have !flag_wrapv, and either ARG0 or
 469              ARG1 is of a signed type, we have to do
 470              PLUS_EXPR, MINUS_EXPR or MULT_EXPR in an unsigned
 471              type in case the operation in outprec precision
 472              could overflow.  Otherwise, we would introduce
 473              signed-overflow undefinedness.  */
 474           || ((!(INTEGRAL_TYPE_P (TREE_TYPE (arg0))
 475                  && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
 476                || !(INTEGRAL_TYPE_P (TREE_TYPE (arg1))
 477                     && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1))))
 478               && ((TYPE_PRECISION (TREE_TYPE (arg0)) * 2u
 479                    > outprec)
 480                   || (TYPE_PRECISION (TREE_TYPE (arg1)) * 2u
 481                       > outprec))
 482               && (ex_form == PLUS_EXPR
 483                   || ex_form == MINUS_EXPR
 484                   || ex_form == MULT_EXPR)))
 485         {
 486           if (!TYPE_UNSIGNED (typex))
 487             typex = unsigned_type_for (typex);
 488         }
 489       else
 490         {
 491           if (TYPE_UNSIGNED (typex))
 492             typex = signed_type_for (typex);
 493         }
 494       /* We should do away with all this once we have a proper
 495          type promotion/demotion pass, see PR45397.  */
 496       expr = maybe_fold_build2_loc (dofold, loc, ex_form, typex,
 497                                     convert (typex, arg0),
 498                                     convert (typex, arg1));
 499       return convert (type, expr);
 500     }
 501
 502   return NULL_TREE;
 503 }
 504
 505 /* Convert EXPR to some integer (or enum) type TYPE.
 506
 507    EXPR must be pointer, integer, discrete (enum, char, or bool), float,
 508    fixed-point or vector; in other cases error is called.
 509
 510    If DOFOLD is TRUE, we try to simplify newly-created patterns by folding.
 511
 512    The result of this is always supposed to be a newly created tree node
 513    not in use in any existing structure.  */
 514
 515 static tree
 516 convert_to_integer_1 (tree type, tree expr, bool dofold)
 517 {
 518   enum tree_code ex_form = TREE_CODE (expr);
 519   tree intype = TREE_TYPE (expr);
 520   unsigned int inprec = element_precision (intype);
 521   unsigned int outprec = element_precision (type);
 522   location_t loc = EXPR_LOCATION (expr);
 523
 524   /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
 525      be.  Consider `enum E = { a, b = (enum E) 3 };'.  */
 526   if (!COMPLETE_TYPE_P (type))
 527     {
 528       error ("conversion to incomplete type");
 529       return error_mark_node;
 530     }
 531
 532   if (ex_form == COMPOUND_EXPR)
 533     {
 534       tree t = convert_to_integer_1 (type, TREE_OPERAND (expr, 1), dofold);
 535       if (t == TREE_OPERAND (expr, 1))
 536         return expr;
 537       return build2_loc (EXPR_LOCATION (expr), COMPOUND_EXPR, TREE_TYPE (t),
 538                          TREE_OPERAND (expr, 0), t);
 539     }
 540
 541   /* Convert e.g. (long)round(d) -> lround(d).  */
 542   /* If we're converting to char, we may encounter differing behavior
 543      between converting from double->char vs double->long->char.
 544      We're in "undefined" territory but we prefer to be conservative,
 545      so only proceed in "unsafe" math mode.  */
 546   if (optimize
 547       && (flag_unsafe_math_optimizations
 548           || (long_integer_type_node
 549               && outprec >= TYPE_PRECISION (long_integer_type_node))))
 550     {
 551       tree s_expr = strip_float_extensions (expr);
 552       tree s_intype = TREE_TYPE (s_expr);
 553       const enum built_in_function fcode = builtin_mathfn_code (s_expr);
 554       tree fn = 0;
 555
 556       switch (fcode)
 557         {
 558         CASE_FLT_FN (BUILT_IN_CEIL):
 559         CASE_FLT_FN_FLOATN_NX (BUILT_IN_CEIL):
 560           /* Only convert in ISO C99 mode.  */
 561           if (!targetm.libc_has_function (function_c99_misc))
 562             break;
 563           if (outprec < TYPE_PRECISION (integer_type_node)
 564               || (outprec == TYPE_PRECISION (integer_type_node)
 565                   && !TYPE_UNSIGNED (type)))
 566             fn = mathfn_built_in (s_intype, BUILT_IN_ICEIL);
 567           else if (outprec == TYPE_PRECISION (long_integer_type_node)
 568                    && !TYPE_UNSIGNED (type))
 569             fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
 570           else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
 571                    && !TYPE_UNSIGNED (type))
 572             fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL);
 573           break;
 574
 575         CASE_FLT_FN (BUILT_IN_FLOOR):
 576         CASE_FLT_FN_FLOATN_NX (BUILT_IN_FLOOR):
 577           /* Only convert in ISO C99 mode.  */
 578           if (!targetm.libc_has_function (function_c99_misc))
 579             break;
 580           if (outprec < TYPE_PRECISION (integer_type_node)
 581               || (outprec == TYPE_PRECISION (integer_type_node)
 582                   && !TYPE_UNSIGNED (type)))
 583             fn = mathfn_built_in (s_intype, BUILT_IN_IFLOOR);
 584           else if (outprec == TYPE_PRECISION (long_integer_type_node)
 585                    && !TYPE_UNSIGNED (type))
 586             fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
 587           else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
 588                    && !TYPE_UNSIGNED (type))
 589             fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR);
 590           break;
 591
 592         CASE_FLT_FN (BUILT_IN_ROUND):
 593         CASE_FLT_FN_FLOATN_NX (BUILT_IN_ROUND):
 594           /* Only convert in ISO C99 mode and with -fno-math-errno.  */
 595           if (!targetm.libc_has_function (function_c99_misc) || flag_errno_math)
 596             break;
 597           if (outprec < TYPE_PRECISION (integer_type_node)
 598               || (outprec == TYPE_PRECISION (integer_type_node)
 599                   && !TYPE_UNSIGNED (type)))
 600             fn = mathfn_built_in (s_intype, BUILT_IN_IROUND);
 601           else if (outprec == TYPE_PRECISION (long_integer_type_node)
 602                    && !TYPE_UNSIGNED (type))
 603             fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
 604           else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
 605                    && !TYPE_UNSIGNED (type))
 606             fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
 607           break;
 608
 609         CASE_FLT_FN (BUILT_IN_NEARBYINT):
 610         CASE_FLT_FN_FLOATN_NX (BUILT_IN_NEARBYINT):
 611           /* Only convert nearbyint* if we can ignore math exceptions.  */
 612           if (flag_trapping_math)
 613             break;
 614           gcc_fallthrough ();
 615         CASE_FLT_FN (BUILT_IN_RINT):
 616         CASE_FLT_FN_FLOATN_NX (BUILT_IN_RINT):
 617           /* Only convert in ISO C99 mode and with -fno-math-errno.  */
 618           if (!targetm.libc_has_function (function_c99_misc) || flag_errno_math)
 619             break;
 620           if (outprec < TYPE_PRECISION (integer_type_node)
 621               || (outprec == TYPE_PRECISION (integer_type_node)
 622                   && !TYPE_UNSIGNED (type)))
 623             fn = mathfn_built_in (s_intype, BUILT_IN_IRINT);
 624           else if (outprec == TYPE_PRECISION (long_integer_type_node)
 625                    && !TYPE_UNSIGNED (type))
 626             fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
 627           else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
 628                    && !TYPE_UNSIGNED (type))
 629             fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT);
 630           break;
 631
 632         CASE_FLT_FN (BUILT_IN_TRUNC):
 633         CASE_FLT_FN_FLOATN_NX (BUILT_IN_TRUNC):
 634           return convert_to_integer_1 (type, CALL_EXPR_ARG (s_expr, 0), dofold);
 635
 636         default:
 637           break;
 638         }
 639
 640       if (fn)
 641         {
 642           tree newexpr = build_call_expr (fn, 1, CALL_EXPR_ARG (s_expr, 0));
 643           return convert_to_integer_1 (type, newexpr, dofold);
 644         }
 645     }
 646
 647   /* Convert (int)logb(d) -> ilogb(d).  */
 648   if (optimize
 649       && flag_unsafe_math_optimizations
 650       && !flag_trapping_math && !flag_errno_math && flag_finite_math_only
 651       && integer_type_node
 652       && (outprec > TYPE_PRECISION (integer_type_node)
 653           || (outprec == TYPE_PRECISION (integer_type_node)
 654               && !TYPE_UNSIGNED (type))))
 655     {
 656       tree s_expr = strip_float_extensions (expr);
 657       tree s_intype = TREE_TYPE (s_expr);
 658       const enum built_in_function fcode = builtin_mathfn_code (s_expr);
 659       tree fn = 0;
 660
 661       switch (fcode)
 662         {
 663         CASE_FLT_FN (BUILT_IN_LOGB):
 664           fn = mathfn_built_in (s_intype, BUILT_IN_ILOGB);
 665           break;
 666
 667         default:
 668           break;
 669         }
 670
 671       if (fn)
 672         {
 673           tree newexpr = build_call_expr (fn, 1, CALL_EXPR_ARG (s_expr, 0));
 674           return convert_to_integer_1 (type, newexpr, dofold);
 675         }
 676     }
 677
 678   switch (TREE_CODE (intype))
 679     {
 680     case POINTER_TYPE:
 681     case REFERENCE_TYPE:
 682       if (integer_zerop (expr) && !TREE_OVERFLOW (expr))
 683         return build_int_cst (type, 0);
 684
 685       /* Convert to an unsigned integer of the correct width first, and from
 686          there widen/truncate to the required type.  Some targets support the
 687          coexistence of multiple valid pointer sizes, so fetch the one we need
 688          from the type.  */
 689       if (!dofold)
 690         return build1 (CONVERT_EXPR, type, expr);
 691       expr = fold_build1 (CONVERT_EXPR,
 692                           lang_hooks.types.type_for_size
 693                             (TYPE_PRECISION (intype), 0),
 694                           expr);
 695       return fold_convert (type, expr);
 696
 697     case INTEGER_TYPE:
 698     case ENUMERAL_TYPE:
 699     case BOOLEAN_TYPE:
 700     case OFFSET_TYPE:
 701       /* If this is a logical operation, which just returns 0 or 1, we can
 702          change the type of the expression.  */
 703
 704       if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
 705         {
 706           expr = copy_node (expr);
 707           TREE_TYPE (expr) = type;
 708           return expr;
 709         }
 710
 711       /* If we are widening the type, put in an explicit conversion.
 712          Similarly if we are not changing the width.  After this, we know
 713          we are truncating EXPR.  */
 714
 715       else if (outprec >= inprec)
 716         {
 717           enum tree_code code;
 718
 719           /* If the precision of the EXPR's type is K bits and the
 720              destination mode has more bits, and the sign is changing,
 721              it is not safe to use a NOP_EXPR.  For example, suppose
 722              that EXPR's type is a 3-bit unsigned integer type, the
 723              TYPE is a 3-bit signed integer type, and the machine mode
 724              for the types is 8-bit QImode.  In that case, the
 725              conversion necessitates an explicit sign-extension.  In
 726              the signed-to-unsigned case the high-order bits have to
 727              be cleared.  */
 728           if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
 729               && !type_has_mode_precision_p (TREE_TYPE (expr)))
 730             code = CONVERT_EXPR;
 731           else
 732             code = NOP_EXPR;
 733
 734           return maybe_fold_build1_loc (dofold, loc, code, type, expr);
 735         }
 736
 737       /* If TYPE is an enumeral type or a type with a precision less
 738          than the number of bits in its mode, do the conversion to the
 739          type corresponding to its mode, then do a nop conversion
 740          to TYPE.  */
 741       else if (TREE_CODE (type) == ENUMERAL_TYPE
 742                || maybe_ne (outprec, GET_MODE_PRECISION (TYPE_MODE (type))))
 743         {
 744           expr
 745             = convert_to_integer_1 (lang_hooks.types.type_for_mode
 746                                     (TYPE_MODE (type), TYPE_UNSIGNED (type)),
 747                                     expr, dofold);
 748           return maybe_fold_build1_loc (dofold, loc, NOP_EXPR, type, expr);
 749         }
 750
 751       /* Here detect when we can distribute the truncation down past some
 752          arithmetic.  For example, if adding two longs and converting to an
 753          int, we can equally well convert both to ints and then add.
 754          For the operations handled here, such truncation distribution
 755          is always safe.
 756          It is desirable in these cases:
 757          1) when truncating down to full-word from a larger size
 758          2) when truncating takes no work.
 759          3) when at least one operand of the arithmetic has been extended
 760          (as by C's default conversions).  In this case we need two conversions
 761          if we do the arithmetic as already requested, so we might as well
 762          truncate both and then combine.  Perhaps that way we need only one.
 763
 764          Note that in general we cannot do the arithmetic in a type
 765          shorter than the desired result of conversion, even if the operands
 766          are both extended from a shorter type, because they might overflow
 767          if combined in that type.  The exceptions to this--the times when
 768          two narrow values can be combined in their narrow type even to
 769          make a wider result--are handled by "shorten" in build_binary_op.  */
 770
 771       if (dofold)
 772         switch (ex_form)
 773           {
 774           case RSHIFT_EXPR:
 775             /* We can pass truncation down through right shifting
 776                when the shift count is a nonpositive constant.  */
 777             if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 778                 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) <= 0)
 779               goto trunc1;
 780             break;
 781
 782           case LSHIFT_EXPR:
 783             /* We can pass truncation down through left shifting
 784                when the shift count is a nonnegative constant and
 785                the target type is unsigned.  */
 786             if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 787                 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
 788                 && TYPE_UNSIGNED (type)
 789                 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 790               {
 791                 /* If shift count is less than the width of the truncated type,
 792                    really shift.  */
 793                 if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
 794                   /* In this case, shifting is like multiplication.  */
 795                   goto trunc1;
 796                 else
 797                   {
 798                     /* If it is >= that width, result is zero.
 799                        Handling this with trunc1 would give the wrong result:
 800                        (int) ((long long) a << 32) is well defined (as 0)
 801                        but (int) a << 32 is undefined and would get a
 802                        warning.  */
 803
 804                     tree t = build_int_cst (type, 0);
 805
 806                     /* If the original expression had side-effects, we must
 807                        preserve it.  */
 808                     if (TREE_SIDE_EFFECTS (expr))
 809                       return build2 (COMPOUND_EXPR, type, expr, t);
 810                     else
 811                       return t;
 812                   }
 813               }
 814             break;
 815
 816           case TRUNC_DIV_EXPR:
 817             {
 818               tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), NULL_TREE);
 819               tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), NULL_TREE);
 820
 821               /* Don't distribute unless the output precision is at least as
 822                  big as the actual inputs and it has the same signedness.  */
 823               if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
 824                   && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
 825                   /* If signedness of arg0 and arg1 don't match,
 826                      we can't necessarily find a type to compare them in.  */
 827                   && (TYPE_UNSIGNED (TREE_TYPE (arg0))
 828                       == TYPE_UNSIGNED (TREE_TYPE (arg1)))
 829                   /* Do not change the sign of the division.  */
 830                   && (TYPE_UNSIGNED (TREE_TYPE (expr))
 831                       == TYPE_UNSIGNED (TREE_TYPE (arg0)))
 832                   /* Either require unsigned division or a division by
 833                      a constant that is not -1.  */
 834                   && (TYPE_UNSIGNED (TREE_TYPE (arg0))
 835                       || (TREE_CODE (arg1) == INTEGER_CST
 836                           && !integer_all_onesp (arg1))))
 837                 {
 838                   tree tem = do_narrow (loc, ex_form, type, arg0, arg1,
 839                                         expr, inprec, outprec, dofold);
 840                   if (tem)
 841                     return tem;
 842                 }
 843               break;
 844             }
 845
 846           case MAX_EXPR:
 847           case MIN_EXPR:
 848           case MULT_EXPR:
 849             {
 850               tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 851               tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 852
 853               /* Don't distribute unless the output precision is at least as
 854                  big as the actual inputs.  Otherwise, the comparison of the
 855                  truncated values will be wrong.  */
 856               if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
 857                   && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
 858                   /* If signedness of arg0 and arg1 don't match,
 859                      we can't necessarily find a type to compare them in.  */
 860                   && (TYPE_UNSIGNED (TREE_TYPE (arg0))
 861                       == TYPE_UNSIGNED (TREE_TYPE (arg1))))
 862                 goto trunc1;
 863               break;
 864             }
 865
 866           case PLUS_EXPR:
 867           case MINUS_EXPR:
 868           case BIT_AND_EXPR:
 869           case BIT_IOR_EXPR:
 870           case BIT_XOR_EXPR:
 871           trunc1:
 872             {
 873               tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 874               tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 875
 876               /* Do not try to narrow operands of pointer subtraction;
 877                  that will interfere with other folding.  */
 878               if (ex_form == MINUS_EXPR
 879                   && CONVERT_EXPR_P (arg0)
 880                   && CONVERT_EXPR_P (arg1)
 881                   && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
 882                   && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg1, 0))))
 883                 break;
 884
 885               if (outprec >= BITS_PER_WORD
 886                   || targetm.truly_noop_truncation (outprec, inprec)
 887                   || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
 888                   || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
 889                 {
 890                   tree tem = do_narrow (loc, ex_form, type, arg0, arg1,
 891                                         expr, inprec, outprec, dofold);
 892                   if (tem)
 893                     return tem;
 894                 }
 895             }
 896             break;
 897
 898           case NEGATE_EXPR:
 899             /* Using unsigned arithmetic for signed types may hide overflow
 900                bugs.  */
 901             if (!TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (expr, 0)))
 902                 && sanitize_flags_p (SANITIZE_SI_OVERFLOW))
 903               break;
 904             /* Fall through.  */
 905           case BIT_NOT_EXPR:
 906             /* This is not correct for ABS_EXPR,
 907                since we must test the sign before truncation.  */
 908             {
 909               /* Do the arithmetic in type TYPEX,
 910                  then convert result to TYPE.  */
 911               tree typex = type;
 912
 913               /* Can't do arithmetic in enumeral types
 914                  so use an integer type that will hold the values.  */
 915               if (TREE_CODE (typex) == ENUMERAL_TYPE)
 916                 typex
 917                   = lang_hooks.types.type_for_size (TYPE_PRECISION (typex),
 918                                                     TYPE_UNSIGNED (typex));
 919
 920               if (!TYPE_UNSIGNED (typex))
 921                 typex = unsigned_type_for (typex);
 922               return convert (type,
 923                               fold_build1 (ex_form, typex,
 924                                            convert (typex,
 925                                                     TREE_OPERAND (expr, 0))));
 926             }
 927
 928           CASE_CONVERT:
 929             {
 930               tree argtype = TREE_TYPE (TREE_OPERAND (expr, 0));
 931               /* Don't introduce a "can't convert between vector values
 932                  of different size" error.  */
 933               if (TREE_CODE (argtype) == VECTOR_TYPE
 934                   && maybe_ne (GET_MODE_SIZE (TYPE_MODE (argtype)),
 935                                GET_MODE_SIZE (TYPE_MODE (type))))
 936                 break;
 937             }
 938             /* If truncating after truncating, might as well do all at once.
 939                If truncating after extending, we may get rid of wasted work.  */
 940             return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
 941
 942           case COND_EXPR:
 943             /* It is sometimes worthwhile to push the narrowing down through
 944                the conditional and never loses.  A COND_EXPR may have a throw
 945                as one operand, which then has void type.  Just leave void
 946                operands as they are.  */
 947             return
 948               fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
 949                            VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1)))
 950                            ? TREE_OPERAND (expr, 1)
 951                            : convert (type, TREE_OPERAND (expr, 1)),
 952                            VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 2)))
 953                            ? TREE_OPERAND (expr, 2)
 954                            : convert (type, TREE_OPERAND (expr, 2)));
 955
 956           default:
 957             break;
 958           }
 959
 960       /* When parsing long initializers, we might end up with a lot of casts.
 961          Shortcut this.  */
 962       if (TREE_CODE (expr) == INTEGER_CST)
 963         return fold_convert (type, expr);
 964       return build1 (CONVERT_EXPR, type, expr);
 965
 966     case REAL_TYPE:
 967       if (sanitize_flags_p (SANITIZE_FLOAT_CAST)
 968           && current_function_decl != NULL_TREE)
 969         {
 970           expr = save_expr (expr);
 971           tree check = ubsan_instrument_float_cast (loc, type, expr);
 972           expr = build1 (FIX_TRUNC_EXPR, type, expr);
 973           if (check == NULL_TREE)
 974             return expr;
 975           return maybe_fold_build2_loc (dofold, loc, COMPOUND_EXPR,
 976                                         TREE_TYPE (expr), check, expr);
 977         }
 978       else
 979         return build1 (FIX_TRUNC_EXPR, type, expr);
 980
 981     case FIXED_POINT_TYPE:
 982       return build1 (FIXED_CONVERT_EXPR, type, expr);
 983
 984     case COMPLEX_TYPE:
 985       expr = maybe_fold_build1_loc (dofold, loc, REALPART_EXPR,
 986                                     TREE_TYPE (TREE_TYPE (expr)), expr);
 987       return convert (type, expr);
 988
 989     case VECTOR_TYPE:
 990       if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
 991         {
 992           error ("can%'t convert a vector of type %qT"
 993                  " to type %qT which has different size",
 994                  TREE_TYPE (expr), type);
 995           return error_mark_node;
 996         }
 997       return build1 (VIEW_CONVERT_EXPR, type, expr);
 998
 999     default:
1000       error ("aggregate value used where an integer was expected");
1001       return convert (type, integer_zero_node);
1002     }
1003 }
1004
1005 /* Convert EXPR to some integer (or enum) type TYPE.
1006
1007    EXPR must be pointer, integer, discrete (enum, char, or bool), float,
1008    fixed-point or vector; in other cases error is called.
1009
1010    The result of this is always supposed to be a newly created tree node
1011    not in use in any existing structure.  */
1012
1013 tree
1014 convert_to_integer (tree type, tree expr)
1015 {
1016   return convert_to_integer_1 (type, expr, true);
1017 }
1018
1019 /* A wrapper around convert_to_complex_1 that only folds the
1020    expression if DOFOLD, or if it is CONSTANT_CLASS_P.  */
1021
1022 tree
1023 convert_to_integer_maybe_fold (tree type, tree expr, bool dofold)
1024 {
1025   return convert_to_integer_1 (type, expr, dofold || CONSTANT_CLASS_P (expr));
1026 }
1027
1028 /* Convert EXPR to the complex type TYPE in the usual ways.  If FOLD_P is
1029    true, try to fold the expression.  */
1030
1031 static tree
1032 convert_to_complex_1 (tree type, tree expr, bool fold_p)
1033 {
1034   location_t loc = EXPR_LOCATION (expr);
1035   tree subtype = TREE_TYPE (type);
1036
1037   switch (TREE_CODE (TREE_TYPE (expr)))
1038     {
1039     case REAL_TYPE:
1040     case FIXED_POINT_TYPE:
1041     case INTEGER_TYPE:
1042     case ENUMERAL_TYPE:
1043     case BOOLEAN_TYPE:
1044       return build2 (COMPLEX_EXPR, type, convert (subtype, expr),
1045                      convert (subtype, integer_zero_node));
1046
1047     case COMPLEX_TYPE:
1048       {
1049         tree elt_type = TREE_TYPE (TREE_TYPE (expr));
1050
1051         if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
1052           return expr;
1053         else if (TREE_CODE (expr) == COMPOUND_EXPR)
1054           {
1055             tree t = convert_to_complex_1 (type, TREE_OPERAND (expr, 1),
1056                                            fold_p);
1057             if (t == TREE_OPERAND (expr, 1))
1058               return expr;
1059             return build2_loc (EXPR_LOCATION (expr), COMPOUND_EXPR,
1060                                TREE_TYPE (t), TREE_OPERAND (expr, 0), t);
1061           }
1062         else if (TREE_CODE (expr) == COMPLEX_EXPR)
1063           return maybe_fold_build2_loc (fold_p, loc, COMPLEX_EXPR, type,
1064                                         convert (subtype,
1065                                                  TREE_OPERAND (expr, 0)),
1066                                         convert (subtype,
1067                                                  TREE_OPERAND (expr, 1)));
1068         else
1069           {
1070             expr = save_expr (expr);
1071             tree realp = maybe_fold_build1_loc (fold_p, loc, REALPART_EXPR,
1072                                                 TREE_TYPE (TREE_TYPE (expr)),
1073                                                 expr);
1074             tree imagp = maybe_fold_build1_loc (fold_p, loc, IMAGPART_EXPR,
1075                                                 TREE_TYPE (TREE_TYPE (expr)),
1076                                                 expr);
1077             return maybe_fold_build2_loc (fold_p, loc, COMPLEX_EXPR, type,
1078                                           convert (subtype, realp),
1079                                           convert (subtype, imagp));
1080           }
1081       }
1082
1083     case POINTER_TYPE:
1084     case REFERENCE_TYPE:
1085       error ("pointer value used where a complex was expected");
1086       return convert_to_complex_1 (type, integer_zero_node, fold_p);
1087
1088     default:
1089       error ("aggregate value used where a complex was expected");
1090       return convert_to_complex_1 (type, integer_zero_node, fold_p);
1091     }
1092 }
1093
1094 /* A wrapper around convert_to_complex_1 that always folds the
1095    expression.  */
1096
1097 tree
1098 convert_to_complex (tree type, tree expr)
1099 {
1100   return convert_to_complex_1 (type, expr, true);
1101 }
1102
1103 /* A wrapper around convert_to_complex_1 that only folds the
1104    expression if DOFOLD, or if it is CONSTANT_CLASS_P.  */
1105
1106 tree
1107 convert_to_complex_maybe_fold (tree type, tree expr, bool dofold)
1108 {
1109   return convert_to_complex_1 (type, expr, dofold || CONSTANT_CLASS_P (expr));
1110 }
1111
1112 /* Convert EXPR to the vector type TYPE in the usual ways.  */
1113
1114 tree
1115 convert_to_vector (tree type, tree expr)
1116 {
1117   switch (TREE_CODE (TREE_TYPE (expr)))
1118     {
1119     case INTEGER_TYPE:
1120     case VECTOR_TYPE:
1121       if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
1122         {
1123           error ("can%'t convert a value of type %qT"
1124                  " to vector type %qT which has different size",
1125                  TREE_TYPE (expr), type);
1126           return error_mark_node;
1127         }
1128       return build1 (VIEW_CONVERT_EXPR, type, expr);
1129
1130     default:
1131       error ("can%'t convert value to a vector");
1132       return error_mark_node;
1133     }
1134 }
1135
1136 /* Convert EXPR to some fixed-point type TYPE.
1137
1138    EXPR must be fixed-point, float, integer, or enumeral;
1139    in other cases error is called.  */
1140
1141 tree
1142 convert_to_fixed (tree type, tree expr)
1143 {
1144   if (integer_zerop (expr))
1145     {
1146       tree fixed_zero_node = build_fixed (type, FCONST0 (TYPE_MODE (type)));
1147       return fixed_zero_node;
1148     }
1149   else if (integer_onep (expr) && ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)))
1150     {
1151       tree fixed_one_node = build_fixed (type, FCONST1 (TYPE_MODE (type)));
1152       return fixed_one_node;
1153     }
1154
1155   switch (TREE_CODE (TREE_TYPE (expr)))
1156     {
1157     case FIXED_POINT_TYPE:
1158     case INTEGER_TYPE:
1159     case ENUMERAL_TYPE:
1160     case BOOLEAN_TYPE:
1161     case REAL_TYPE:
1162       return build1 (FIXED_CONVERT_EXPR, type, expr);
1163
1164     case COMPLEX_TYPE:
1165       return convert (type,
1166                       fold_build1 (REALPART_EXPR,
1167                                    TREE_TYPE (TREE_TYPE (expr)), expr));
1168
1169     default:
1170       error ("aggregate value used where a fixed-point was expected");
1171       return error_mark_node;
1172     }
1173 }