gcc/convert.cc

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