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