1/* Utility routines for data type conversion for GCC. 2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1997, 1998, 3 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-1301, USA. */ 21 22 23/* These routines are somewhat language-independent utility function 24 intended to be called by the language-specific convert () functions. */ 25 26#include "config.h" 27#include "system.h" 28#include "coretypes.h" 29#include "tm.h" 30#include "tree.h" 31#include "flags.h" 32#include "convert.h" 33#include "toplev.h" 34#include "langhooks.h" 35#include "real.h" 36 37/* Convert EXPR to some pointer or reference type TYPE. 38 EXPR must be pointer, reference, integer, enumeral, or literal zero; 39 in other cases error is called. */ 40 41tree 42convert_to_pointer (tree type, tree expr) 43{ 44 if (TREE_TYPE (expr) == type) 45 return expr; 46 47 if (integer_zerop (expr)) 48 { 49 tree t = build_int_cst (type, 0); 50 if (TREE_OVERFLOW (expr) || TREE_CONSTANT_OVERFLOW (expr)) 51 t = force_fit_type (t, 0, TREE_OVERFLOW (expr), 52 TREE_CONSTANT_OVERFLOW (expr)); 53 return t; 54 } 55 56 switch (TREE_CODE (TREE_TYPE (expr))) 57 { 58 case POINTER_TYPE: 59 case REFERENCE_TYPE: 60 return fold_build1 (NOP_EXPR, type, expr); 61 62 case INTEGER_TYPE: 63 case ENUMERAL_TYPE: 64 case BOOLEAN_TYPE: 65 if (TYPE_PRECISION (TREE_TYPE (expr)) != POINTER_SIZE) 66 expr = fold_build1 (NOP_EXPR, 67 lang_hooks.types.type_for_size (POINTER_SIZE, 0), 68 expr); 69 return fold_build1 (CONVERT_EXPR, type, expr); 70 71 /* APPLE LOCAL begin blocks (C++ ck) */ 72 case BLOCK_POINTER_TYPE: 73 /* APPLE LOCAL begin radar 5809099 */ 74 if (objc_is_id (type) 75 || (TREE_CODE (type) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))) 76 /* APPLE LOCAL end radar 5809099 */ 77 return fold_build1 (NOP_EXPR, type, expr); 78 /* APPLE LOCAL end blocks (C++ ck) */ 79 default: 80 error ("cannot convert to a pointer type"); 81 return convert_to_pointer (type, integer_zero_node); 82 } 83} 84 85/* APPLE LOCAL begin blocks (C++ ck) */ 86tree 87convert_to_block_pointer (tree type, tree expr) 88{ 89 if (TREE_TYPE (expr) == type) 90 return expr; 91 92 if (integer_zerop (expr)) 93 { 94 tree t = build_int_cst (type, 0); 95 if (TREE_OVERFLOW (expr) || TREE_CONSTANT_OVERFLOW (expr)) 96 t = force_fit_type (t, 0, TREE_OVERFLOW (expr), 97 TREE_CONSTANT_OVERFLOW (expr)); 98 return t; 99 } 100 101 switch (TREE_CODE (TREE_TYPE (expr))) 102 { 103 case BLOCK_POINTER_TYPE: 104 return fold_build1 (NOP_EXPR, type, expr); 105 106 case INTEGER_TYPE: 107 if (TYPE_PRECISION (TREE_TYPE (expr)) != POINTER_SIZE) 108 expr = fold_build1 (NOP_EXPR, 109 lang_hooks.types.type_for_size (POINTER_SIZE, 0), 110 expr); 111 return fold_build1 (CONVERT_EXPR, type, expr); 112 113 case POINTER_TYPE: 114 /* APPLE LOCAL radar 5809099 */ 115 if (objc_is_id (TREE_TYPE (expr)) || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (expr)))) 116 return build1 (NOP_EXPR, type, expr); 117 /* fall thru */ 118 119 default: 120 error ("cannot convert to a block pointer type"); 121 return convert_to_block_pointer (type, integer_zero_node); 122 } 123} 124 125/* APPLE LOCAL end blocks (C++ ck) */ 126 127/* Avoid any floating point extensions from EXP. */ 128tree 129strip_float_extensions (tree exp) 130{ 131 tree sub, expt, subt; 132 133 /* For floating point constant look up the narrowest type that can hold 134 it properly and handle it like (type)(narrowest_type)constant. 135 This way we can optimize for instance a=a*2.0 where "a" is float 136 but 2.0 is double constant. */ 137 if (TREE_CODE (exp) == REAL_CST) 138 { 139 REAL_VALUE_TYPE orig; 140 tree type = NULL; 141 142 orig = TREE_REAL_CST (exp); 143 if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node) 144 && exact_real_truncate (TYPE_MODE (float_type_node), &orig)) 145 type = float_type_node; 146 else if (TYPE_PRECISION (TREE_TYPE (exp)) 147 > TYPE_PRECISION (double_type_node) 148 && exact_real_truncate (TYPE_MODE (double_type_node), &orig)) 149 type = double_type_node; 150 if (type) 151 return build_real (type, real_value_truncate (TYPE_MODE (type), orig)); 152 } 153 154 if (TREE_CODE (exp) != NOP_EXPR 155 && TREE_CODE (exp) != CONVERT_EXPR) 156 return exp; 157 158 sub = TREE_OPERAND (exp, 0); 159 subt = TREE_TYPE (sub); 160 expt = TREE_TYPE (exp); 161 162 if (!FLOAT_TYPE_P (subt)) 163 return exp; 164 165 if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt)) 166 return exp; 167 168 return strip_float_extensions (sub); 169} 170 171 172/* Convert EXPR to some floating-point type TYPE. 173 174 EXPR must be float, integer, or enumeral; 175 in other cases error is called. */ 176 177tree 178convert_to_real (tree type, tree expr) 179{ 180 enum built_in_function fcode = builtin_mathfn_code (expr); 181 tree itype = TREE_TYPE (expr); 182 183 /* Disable until we figure out how to decide whether the functions are 184 present in runtime. */ 185 /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */ 186 if (optimize 187 && (TYPE_MODE (type) == TYPE_MODE (double_type_node) 188 || TYPE_MODE (type) == TYPE_MODE (float_type_node))) 189 { 190 switch (fcode) 191 { 192#define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L: 193 CASE_MATHFN (ACOS) 194 CASE_MATHFN (ACOSH) 195 CASE_MATHFN (ASIN) 196 CASE_MATHFN (ASINH) 197 CASE_MATHFN (ATAN) 198 CASE_MATHFN (ATANH) 199 CASE_MATHFN (CBRT) 200 CASE_MATHFN (COS) 201 CASE_MATHFN (COSH) 202 CASE_MATHFN (ERF) 203 CASE_MATHFN (ERFC) 204 CASE_MATHFN (EXP) 205 CASE_MATHFN (EXP10) 206 CASE_MATHFN (EXP2) 207 CASE_MATHFN (EXPM1) 208 CASE_MATHFN (FABS) 209 CASE_MATHFN (GAMMA) 210 CASE_MATHFN (J0) 211 CASE_MATHFN (J1) 212 CASE_MATHFN (LGAMMA) 213 CASE_MATHFN (LOG) 214 CASE_MATHFN (LOG10) 215 CASE_MATHFN (LOG1P) 216 CASE_MATHFN (LOG2) 217 CASE_MATHFN (LOGB) 218 CASE_MATHFN (POW10) 219 CASE_MATHFN (SIN) 220 CASE_MATHFN (SINH) 221 CASE_MATHFN (SQRT) 222 CASE_MATHFN (TAN) 223 CASE_MATHFN (TANH) 224 CASE_MATHFN (TGAMMA) 225 CASE_MATHFN (Y0) 226 CASE_MATHFN (Y1) 227#undef CASE_MATHFN 228 { 229 tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1))); 230 tree newtype = type; 231 232 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from 233 the both as the safe type for operation. */ 234 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type)) 235 newtype = TREE_TYPE (arg0); 236 237 /* Be careful about integer to fp conversions. 238 These may overflow still. */ 239 if (FLOAT_TYPE_P (TREE_TYPE (arg0)) 240 && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype) 241 && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node) 242 || TYPE_MODE (newtype) == TYPE_MODE (float_type_node))) 243 { 244 tree arglist; 245 tree fn = mathfn_built_in (newtype, fcode); 246 247 if (fn) 248 { 249 arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0))); 250 expr = build_function_call_expr (fn, arglist); 251 if (newtype == type) 252 return expr; 253 } 254 } 255 } 256 default: 257 break; 258 } 259 } 260 if (optimize 261 && (((fcode == BUILT_IN_FLOORL 262 || fcode == BUILT_IN_CEILL 263 || fcode == BUILT_IN_ROUNDL 264 || fcode == BUILT_IN_RINTL 265 || fcode == BUILT_IN_TRUNCL 266 || fcode == BUILT_IN_NEARBYINTL) 267 && (TYPE_MODE (type) == TYPE_MODE (double_type_node) 268 || TYPE_MODE (type) == TYPE_MODE (float_type_node))) 269 || ((fcode == BUILT_IN_FLOOR 270 || fcode == BUILT_IN_CEIL 271 || fcode == BUILT_IN_ROUND 272 || fcode == BUILT_IN_RINT 273 || fcode == BUILT_IN_TRUNC 274 || fcode == BUILT_IN_NEARBYINT) 275 && (TYPE_MODE (type) == TYPE_MODE (float_type_node))))) 276 { 277 tree fn = mathfn_built_in (type, fcode); 278 279 if (fn) 280 { 281 tree arg 282 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1))); 283 284 /* Make sure (type)arg0 is an extension, otherwise we could end up 285 changing (float)floor(double d) into floorf((float)d), which is 286 incorrect because (float)d uses round-to-nearest and can round 287 up to the next integer. */ 288 if (TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (arg))) 289 return 290 build_function_call_expr (fn, 291 build_tree_list (NULL_TREE, 292 fold (convert_to_real (type, arg)))); 293 } 294 } 295 296 /* Propagate the cast into the operation. */ 297 if (itype != type && FLOAT_TYPE_P (type)) 298 switch (TREE_CODE (expr)) 299 { 300 /* Convert (float)-x into -(float)x. This is safe for 301 round-to-nearest rounding mode. */ 302 case ABS_EXPR: 303 case NEGATE_EXPR: 304 if (!flag_rounding_math 305 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr))) 306 return build1 (TREE_CODE (expr), type, 307 fold (convert_to_real (type, 308 TREE_OPERAND (expr, 0)))); 309 break; 310 /* Convert (outertype)((innertype0)a+(innertype1)b) 311 into ((newtype)a+(newtype)b) where newtype 312 is the widest mode from all of these. */ 313 case PLUS_EXPR: 314 case MINUS_EXPR: 315 case MULT_EXPR: 316 case RDIV_EXPR: 317 { 318 tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0)); 319 tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1)); 320 321 if (FLOAT_TYPE_P (TREE_TYPE (arg0)) 322 && FLOAT_TYPE_P (TREE_TYPE (arg1))) 323 { 324 tree newtype = type; 325 326 if (TYPE_MODE (TREE_TYPE (arg0)) == SDmode 327 || TYPE_MODE (TREE_TYPE (arg1)) == SDmode) 328 newtype = dfloat32_type_node; 329 if (TYPE_MODE (TREE_TYPE (arg0)) == DDmode 330 || TYPE_MODE (TREE_TYPE (arg1)) == DDmode) 331 newtype = dfloat64_type_node; 332 if (TYPE_MODE (TREE_TYPE (arg0)) == TDmode 333 || TYPE_MODE (TREE_TYPE (arg1)) == TDmode) 334 newtype = dfloat128_type_node; 335 if (newtype == dfloat32_type_node 336 || newtype == dfloat64_type_node 337 || newtype == dfloat128_type_node) 338 { 339 expr = build2 (TREE_CODE (expr), newtype, 340 fold (convert_to_real (newtype, arg0)), 341 fold (convert_to_real (newtype, arg1))); 342 if (newtype == type) 343 return expr; 344 break; 345 } 346 347 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype)) 348 newtype = TREE_TYPE (arg0); 349 if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype)) 350 newtype = TREE_TYPE (arg1); 351 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)) 352 { 353 expr = build2 (TREE_CODE (expr), newtype, 354 fold (convert_to_real (newtype, arg0)), 355 fold (convert_to_real (newtype, arg1))); 356 if (newtype == type) 357 return expr; 358 } 359 } 360 } 361 break; 362 default: 363 break; 364 } 365 366 switch (TREE_CODE (TREE_TYPE (expr))) 367 { 368 case REAL_TYPE: 369 /* Ignore the conversion if we don't need to store intermediate 370 results and neither type is a decimal float. */ 371 return build1 ((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 COMPLEX_TYPE: 382 return convert (type, 383 fold_build1 (REALPART_EXPR, 384 TREE_TYPE (TREE_TYPE (expr)), expr)); 385 386 case POINTER_TYPE: 387 case REFERENCE_TYPE: 388 error ("pointer value used where a floating point value was expected"); 389 return convert_to_real (type, integer_zero_node); 390 391 default: 392 error ("aggregate value used where a float was expected"); 393 return convert_to_real (type, integer_zero_node); 394 } 395} 396 397/* Convert EXPR to some integer (or enum) type TYPE. 398 399 EXPR must be pointer, integer, discrete (enum, char, or bool), float, or 400 vector; in other cases error is called. 401 402 The result of this is always supposed to be a newly created tree node 403 not in use in any existing structure. */ 404 405tree 406convert_to_integer (tree type, tree expr) 407{ 408 enum tree_code ex_form = TREE_CODE (expr); 409 tree intype = TREE_TYPE (expr); 410 unsigned int inprec = TYPE_PRECISION (intype); 411 unsigned int outprec = TYPE_PRECISION (type); 412 413 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can 414 be. Consider `enum E = { a, b = (enum E) 3 };'. */ 415 if (!COMPLETE_TYPE_P (type)) 416 { 417 error ("conversion to incomplete type"); 418 return error_mark_node; 419 } 420 421 /* Convert e.g. (long)round(d) -> lround(d). */ 422 /* If we're converting to char, we may encounter differing behavior 423 between converting from double->char vs double->long->char. 424 We're in "undefined" territory but we prefer to be conservative, 425 so only proceed in "unsafe" math mode. */ 426 if (optimize 427 && (flag_unsafe_math_optimizations 428 || (long_integer_type_node 429 && outprec >= TYPE_PRECISION (long_integer_type_node)))) 430 { 431 tree s_expr = strip_float_extensions (expr); 432 tree s_intype = TREE_TYPE (s_expr); 433 const enum built_in_function fcode = builtin_mathfn_code (s_expr); 434 tree fn = 0; 435 436 switch (fcode) 437 { 438 CASE_FLT_FN (BUILT_IN_CEIL): 439 /* Only convert in ISO C99 mode. */ 440 if (!TARGET_C99_FUNCTIONS) 441 break; 442 if (outprec < TYPE_PRECISION (long_integer_type_node) 443 || (outprec == TYPE_PRECISION (long_integer_type_node) 444 && !TYPE_UNSIGNED (type))) 445 fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL); 446 else if (outprec == TYPE_PRECISION (long_long_integer_type_node) 447 && !TYPE_UNSIGNED (type)) 448 fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL); 449 break; 450 451 CASE_FLT_FN (BUILT_IN_FLOOR): 452 /* Only convert in ISO C99 mode. */ 453 if (!TARGET_C99_FUNCTIONS) 454 break; 455 if (outprec < TYPE_PRECISION (long_integer_type_node) 456 || (outprec == TYPE_PRECISION (long_integer_type_node) 457 && !TYPE_UNSIGNED (type))) 458 fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR); 459 else if (outprec == TYPE_PRECISION (long_long_integer_type_node) 460 && !TYPE_UNSIGNED (type)) 461 fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR); 462 break; 463 464 CASE_FLT_FN (BUILT_IN_ROUND): 465 if (outprec < TYPE_PRECISION (long_integer_type_node) 466 || (outprec == TYPE_PRECISION (long_integer_type_node) 467 && !TYPE_UNSIGNED (type))) 468 fn = mathfn_built_in (s_intype, BUILT_IN_LROUND); 469 else if (outprec == TYPE_PRECISION (long_long_integer_type_node) 470 && !TYPE_UNSIGNED (type)) 471 fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND); 472 break; 473 474 CASE_FLT_FN (BUILT_IN_NEARBYINT): 475 /* Only convert nearbyint* if we can ignore math exceptions. */ 476 if (flag_trapping_math) 477 break; 478 /* ... Fall through ... */ 479 CASE_FLT_FN (BUILT_IN_RINT): 480 if (outprec < TYPE_PRECISION (long_integer_type_node) 481 || (outprec == TYPE_PRECISION (long_integer_type_node) 482 && !TYPE_UNSIGNED (type))) 483 fn = mathfn_built_in (s_intype, BUILT_IN_LRINT); 484 else if (outprec == TYPE_PRECISION (long_long_integer_type_node) 485 && !TYPE_UNSIGNED (type)) 486 fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT); 487 break; 488 489 CASE_FLT_FN (BUILT_IN_TRUNC): 490 { 491 tree arglist = TREE_OPERAND (s_expr, 1); 492 return convert_to_integer (type, TREE_VALUE (arglist)); 493 } 494 495 default: 496 break; 497 } 498 499 if (fn) 500 { 501 tree arglist = TREE_OPERAND (s_expr, 1); 502 tree newexpr = build_function_call_expr (fn, arglist); 503 return convert_to_integer (type, newexpr); 504 } 505 } 506 507 switch (TREE_CODE (intype)) 508 { 509 case POINTER_TYPE: 510 case REFERENCE_TYPE: 511 /* APPLE LOCAL radar 6035389 */ 512 case BLOCK_POINTER_TYPE: 513 if (integer_zerop (expr)) 514 return build_int_cst (type, 0); 515 516 /* Convert to an unsigned integer of the correct width first, 517 and from there widen/truncate to the required type. */ 518 expr = fold_build1 (CONVERT_EXPR, 519 lang_hooks.types.type_for_size (POINTER_SIZE, 0), 520 expr); 521 return fold_convert (type, expr); 522 523 case INTEGER_TYPE: 524 case ENUMERAL_TYPE: 525 case BOOLEAN_TYPE: 526 /* If this is a logical operation, which just returns 0 or 1, we can 527 change the type of the expression. */ 528 529 if (TREE_CODE_CLASS (ex_form) == tcc_comparison) 530 { 531 expr = copy_node (expr); 532 TREE_TYPE (expr) = type; 533 return expr; 534 } 535 536 /* If we are widening the type, put in an explicit conversion. 537 Similarly if we are not changing the width. After this, we know 538 we are truncating EXPR. */ 539 540 else if (outprec >= inprec) 541 { 542 enum tree_code code; 543 tree tem; 544 545 /* If the precision of the EXPR's type is K bits and the 546 destination mode has more bits, and the sign is changing, 547 it is not safe to use a NOP_EXPR. For example, suppose 548 that EXPR's type is a 3-bit unsigned integer type, the 549 TYPE is a 3-bit signed integer type, and the machine mode 550 for the types is 8-bit QImode. In that case, the 551 conversion necessitates an explicit sign-extension. In 552 the signed-to-unsigned case the high-order bits have to 553 be cleared. */ 554 if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr)) 555 && (TYPE_PRECISION (TREE_TYPE (expr)) 556 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr))))) 557 code = CONVERT_EXPR; 558 else 559 code = NOP_EXPR; 560 561 tem = fold_unary (code, type, expr); 562 if (tem) 563 return tem; 564 565 tem = build1 (code, type, expr); 566 TREE_NO_WARNING (tem) = 1; 567 return tem; 568 } 569 570 /* If TYPE is an enumeral type or a type with a precision less 571 than the number of bits in its mode, do the conversion to the 572 type corresponding to its mode, then do a nop conversion 573 to TYPE. */ 574 else if (TREE_CODE (type) == ENUMERAL_TYPE 575 || outprec != GET_MODE_BITSIZE (TYPE_MODE (type))) 576 return build1 (NOP_EXPR, type, 577 convert (lang_hooks.types.type_for_mode 578 (TYPE_MODE (type), TYPE_UNSIGNED (type)), 579 expr)); 580 581 /* Here detect when we can distribute the truncation down past some 582 arithmetic. For example, if adding two longs and converting to an 583 int, we can equally well convert both to ints and then add. 584 For the operations handled here, such truncation distribution 585 is always safe. 586 It is desirable in these cases: 587 1) when truncating down to full-word from a larger size 588 2) when truncating takes no work. 589 3) when at least one operand of the arithmetic has been extended 590 (as by C's default conversions). In this case we need two conversions 591 if we do the arithmetic as already requested, so we might as well 592 truncate both and then combine. Perhaps that way we need only one. 593 594 Note that in general we cannot do the arithmetic in a type 595 shorter than the desired result of conversion, even if the operands 596 are both extended from a shorter type, because they might overflow 597 if combined in that type. The exceptions to this--the times when 598 two narrow values can be combined in their narrow type even to 599 make a wider result--are handled by "shorten" in build_binary_op. */ 600 601 switch (ex_form) 602 { 603 case RSHIFT_EXPR: 604 /* We can pass truncation down through right shifting 605 when the shift count is a nonpositive constant. */ 606 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST 607 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) <= 0) 608 goto trunc1; 609 break; 610 611 case LSHIFT_EXPR: 612 /* We can pass truncation down through left shifting 613 when the shift count is a nonnegative constant and 614 the target type is unsigned. */ 615 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST 616 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0 617 && TYPE_UNSIGNED (type) 618 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST) 619 { 620 /* If shift count is less than the width of the truncated type, 621 really shift. */ 622 if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type))) 623 /* In this case, shifting is like multiplication. */ 624 goto trunc1; 625 else 626 { 627 /* If it is >= that width, result is zero. 628 Handling this with trunc1 would give the wrong result: 629 (int) ((long long) a << 32) is well defined (as 0) 630 but (int) a << 32 is undefined and would get a 631 warning. */ 632 633 tree t = build_int_cst (type, 0); 634 635 /* If the original expression had side-effects, we must 636 preserve it. */ 637 if (TREE_SIDE_EFFECTS (expr)) 638 return build2 (COMPOUND_EXPR, type, expr, t); 639 else 640 return t; 641 } 642 } 643 break; 644 645 case MAX_EXPR: 646 case MIN_EXPR: 647 case MULT_EXPR: 648 { 649 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type); 650 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type); 651 652 /* Don't distribute unless the output precision is at least as big 653 as the actual inputs. Otherwise, the comparison of the 654 truncated values will be wrong. */ 655 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0)) 656 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1)) 657 /* If signedness of arg0 and arg1 don't match, 658 we can't necessarily find a type to compare them in. */ 659 && (TYPE_UNSIGNED (TREE_TYPE (arg0)) 660 == TYPE_UNSIGNED (TREE_TYPE (arg1)))) 661 goto trunc1; 662 break; 663 } 664 665 case PLUS_EXPR: 666 case MINUS_EXPR: 667 case BIT_AND_EXPR: 668 case BIT_IOR_EXPR: 669 case BIT_XOR_EXPR: 670 trunc1: 671 { 672 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type); 673 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type); 674 675 if (outprec >= BITS_PER_WORD 676 || TRULY_NOOP_TRUNCATION (outprec, inprec) 677 || inprec > TYPE_PRECISION (TREE_TYPE (arg0)) 678 || inprec > TYPE_PRECISION (TREE_TYPE (arg1))) 679 { 680 /* Do the arithmetic in type TYPEX, 681 then convert result to TYPE. */ 682 tree typex = type; 683 684 /* Can't do arithmetic in enumeral types 685 so use an integer type that will hold the values. */ 686 if (TREE_CODE (typex) == ENUMERAL_TYPE) 687 typex = lang_hooks.types.type_for_size 688 (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex)); 689 690 /* But now perhaps TYPEX is as wide as INPREC. 691 In that case, do nothing special here. 692 (Otherwise would recurse infinitely in convert. */ 693 if (TYPE_PRECISION (typex) != inprec) 694 { 695 /* Don't do unsigned arithmetic where signed was wanted, 696 or vice versa. 697 Exception: if both of the original operands were 698 unsigned then we can safely do the work as unsigned. 699 Exception: shift operations take their type solely 700 from the first argument. 701 Exception: the LSHIFT_EXPR case above requires that 702 we perform this operation unsigned lest we produce 703 signed-overflow undefinedness. 704 And we may need to do it as unsigned 705 if we truncate to the original size. */ 706 if (TYPE_UNSIGNED (TREE_TYPE (expr)) 707 || (TYPE_UNSIGNED (TREE_TYPE (arg0)) 708 && (TYPE_UNSIGNED (TREE_TYPE (arg1)) 709 || ex_form == LSHIFT_EXPR 710 || ex_form == RSHIFT_EXPR 711 || ex_form == LROTATE_EXPR 712 || ex_form == RROTATE_EXPR)) 713 || ex_form == LSHIFT_EXPR 714 /* If we have !flag_wrapv, and either ARG0 or 715 ARG1 is of a signed type, we have to do 716 PLUS_EXPR or MINUS_EXPR in an unsigned 717 type. Otherwise, we would introduce 718 signed-overflow undefinedness. */ 719 || ((!TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)) 720 || !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1))) 721 && (ex_form == PLUS_EXPR 722 || ex_form == MINUS_EXPR))) 723 typex = lang_hooks.types.unsigned_type (typex); 724 else 725 typex = lang_hooks.types.signed_type (typex); 726 return convert (type, 727 fold_build2 (ex_form, typex, 728 convert (typex, arg0), 729 convert (typex, arg1))); 730 } 731 } 732 } 733 break; 734 735 case NEGATE_EXPR: 736 case BIT_NOT_EXPR: 737 /* This is not correct for ABS_EXPR, 738 since we must test the sign before truncation. */ 739 { 740 tree typex; 741 742 /* Don't do unsigned arithmetic where signed was wanted, 743 or vice versa. */ 744 if (TYPE_UNSIGNED (TREE_TYPE (expr))) 745 typex = lang_hooks.types.unsigned_type (type); 746 else 747 typex = lang_hooks.types.signed_type (type); 748 return convert (type, 749 fold_build1 (ex_form, typex, 750 convert (typex, 751 TREE_OPERAND (expr, 0)))); 752 } 753 754 case NOP_EXPR: 755 /* Don't introduce a 756 "can't convert between vector values of different size" error. */ 757 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE 758 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))) 759 != GET_MODE_SIZE (TYPE_MODE (type)))) 760 break; 761 /* If truncating after truncating, might as well do all at once. 762 If truncating after extending, we may get rid of wasted work. */ 763 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type)); 764 765 case COND_EXPR: 766 /* It is sometimes worthwhile to push the narrowing down through 767 the conditional and never loses. */ 768 return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), 769 convert (type, TREE_OPERAND (expr, 1)), 770 convert (type, TREE_OPERAND (expr, 2))); 771 772 default: 773 break; 774 } 775 776 return build1 (CONVERT_EXPR, type, expr); 777 778 case REAL_TYPE: 779 return build1 (FIX_TRUNC_EXPR, type, expr); 780 781 case COMPLEX_TYPE: 782 return convert (type, 783 fold_build1 (REALPART_EXPR, 784 TREE_TYPE (TREE_TYPE (expr)), expr)); 785 786 case VECTOR_TYPE: 787 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr)))) 788 { 789 error ("can't convert between vector values of different size"); 790 return error_mark_node; 791 } 792 return build1 (VIEW_CONVERT_EXPR, type, expr); 793 794 default: 795 error ("aggregate value used where an integer was expected"); 796 return convert (type, integer_zero_node); 797 } 798} 799 800/* Convert EXPR to the complex type TYPE in the usual ways. */ 801 802tree 803convert_to_complex (tree type, tree expr) 804{ 805 tree subtype = TREE_TYPE (type); 806 807 switch (TREE_CODE (TREE_TYPE (expr))) 808 { 809 case REAL_TYPE: 810 case INTEGER_TYPE: 811 case ENUMERAL_TYPE: 812 case BOOLEAN_TYPE: 813 return build2 (COMPLEX_EXPR, type, convert (subtype, expr), 814 convert (subtype, integer_zero_node)); 815 816 case COMPLEX_TYPE: 817 { 818 tree elt_type = TREE_TYPE (TREE_TYPE (expr)); 819 820 if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype)) 821 return expr; 822 else if (TREE_CODE (expr) == COMPLEX_EXPR) 823 return fold_build2 (COMPLEX_EXPR, type, 824 convert (subtype, TREE_OPERAND (expr, 0)), 825 convert (subtype, TREE_OPERAND (expr, 1))); 826 else 827 { 828 expr = save_expr (expr); 829 return 830 fold_build2 (COMPLEX_EXPR, type, 831 convert (subtype, 832 fold_build1 (REALPART_EXPR, 833 TREE_TYPE (TREE_TYPE (expr)), 834 expr)), 835 convert (subtype, 836 fold_build1 (IMAGPART_EXPR, 837 TREE_TYPE (TREE_TYPE (expr)), 838 expr))); 839 } 840 } 841 842 case POINTER_TYPE: 843 case REFERENCE_TYPE: 844 error ("pointer value used where a complex was expected"); 845 return convert_to_complex (type, integer_zero_node); 846 847 default: 848 error ("aggregate value used where a complex was expected"); 849 return convert_to_complex (type, integer_zero_node); 850 } 851} 852 853/* Convert EXPR to the vector type TYPE in the usual ways. */ 854 855tree 856convert_to_vector (tree type, tree expr) 857{ 858 switch (TREE_CODE (TREE_TYPE (expr))) 859 { 860 case INTEGER_TYPE: 861 case VECTOR_TYPE: 862 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr)))) 863 { 864 error ("can't convert between vector values of different size"); 865 return error_mark_node; 866 } 867 return build1 (VIEW_CONVERT_EXPR, type, expr); 868 869 default: 870 error ("can't convert value to a vector"); 871 return error_mark_node; 872 } 873} 874