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