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 } 1174