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, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* These routines are somewhat language-independent utility function
24 intended to be called by the language-specific convert () functions. */
28 #include "coretypes.h"
34 #include "langhooks.h"
36 #include "fixed-value.h"
38 /* Convert EXPR to some pointer or reference type TYPE.
39 EXPR must be pointer, reference, integer, enumeral, or literal zero;
40 in other cases error is called. */
43 convert_to_pointer (tree type, tree expr)
45 location_t loc = EXPR_LOCATION (expr);
46 if (TREE_TYPE (expr) == type)
49 /* Propagate overflow to the NULL pointer. */
50 if (integer_zerop (expr))
51 return force_fit_type_double (type, 0, 0, 0, TREE_OVERFLOW (expr));
53 switch (TREE_CODE (TREE_TYPE (expr)))
58 /* If the pointers point to different address spaces, conversion needs
59 to be done via a ADDR_SPACE_CONVERT_EXPR instead of a NOP_EXPR. */
60 addr_space_t to_as = TYPE_ADDR_SPACE (TREE_TYPE (type));
61 addr_space_t from_as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (expr)));
64 return fold_build1_loc (loc, NOP_EXPR, type, expr);
66 return fold_build1_loc (loc, ADDR_SPACE_CONVERT_EXPR, type, expr);
73 /* If the input precision differs from the target pointer type
74 precision, first convert the input expression to an integer type of
75 the target precision. Some targets, e.g. VMS, need several pointer
76 sizes to coexist so the latter isn't necessarily POINTER_SIZE. */
77 unsigned int pprec = TYPE_PRECISION (type);
78 unsigned int eprec = TYPE_PRECISION (TREE_TYPE (expr));
81 expr = fold_build1_loc (loc, NOP_EXPR,
82 lang_hooks.types.type_for_size (pprec, 0),
86 return fold_build1_loc (loc, CONVERT_EXPR, type, expr);
89 error ("cannot convert to a pointer type");
90 return convert_to_pointer (type, integer_zero_node);
94 /* Avoid any floating point extensions from EXP. */
96 strip_float_extensions (tree exp)
100 /* For floating point constant look up the narrowest type that can hold
101 it properly and handle it like (type)(narrowest_type)constant.
102 This way we can optimize for instance a=a*2.0 where "a" is float
103 but 2.0 is double constant. */
104 if (TREE_CODE (exp) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp)))
106 REAL_VALUE_TYPE orig;
109 orig = TREE_REAL_CST (exp);
110 if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
111 && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
112 type = float_type_node;
113 else if (TYPE_PRECISION (TREE_TYPE (exp))
114 > TYPE_PRECISION (double_type_node)
115 && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
116 type = double_type_node;
118 return build_real (type, real_value_truncate (TYPE_MODE (type), orig));
121 if (!CONVERT_EXPR_P (exp))
124 sub = TREE_OPERAND (exp, 0);
125 subt = TREE_TYPE (sub);
126 expt = TREE_TYPE (exp);
128 if (!FLOAT_TYPE_P (subt))
131 if (DECIMAL_FLOAT_TYPE_P (expt) != DECIMAL_FLOAT_TYPE_P (subt))
134 if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
137 return strip_float_extensions (sub);
141 /* Convert EXPR to some floating-point type TYPE.
143 EXPR must be float, fixed-point, integer, or enumeral;
144 in other cases error is called. */
147 convert_to_real (tree type, tree expr)
149 enum built_in_function fcode = builtin_mathfn_code (expr);
150 tree itype = TREE_TYPE (expr);
152 /* Disable until we figure out how to decide whether the functions are
153 present in runtime. */
154 /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
156 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
157 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
161 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
176 /* The above functions may set errno differently with float
177 input or output so this transformation is not safe with
203 tree arg0 = strip_float_extensions (CALL_EXPR_ARG (expr, 0));
206 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
207 the both as the safe type for operation. */
208 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
209 newtype = TREE_TYPE (arg0);
211 /* Be careful about integer to fp conversions.
212 These may overflow still. */
213 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
214 && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
215 && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
216 || TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
218 tree fn = mathfn_built_in (newtype, fcode);
222 tree arg = fold (convert_to_real (newtype, arg0));
223 expr = build_call_expr (fn, 1, arg);
234 && (((fcode == BUILT_IN_FLOORL
235 || fcode == BUILT_IN_CEILL
236 || fcode == BUILT_IN_ROUNDL
237 || fcode == BUILT_IN_RINTL
238 || fcode == BUILT_IN_TRUNCL
239 || fcode == BUILT_IN_NEARBYINTL)
240 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
241 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
242 || ((fcode == BUILT_IN_FLOOR
243 || fcode == BUILT_IN_CEIL
244 || fcode == BUILT_IN_ROUND
245 || fcode == BUILT_IN_RINT
246 || fcode == BUILT_IN_TRUNC
247 || fcode == BUILT_IN_NEARBYINT)
248 && (TYPE_MODE (type) == TYPE_MODE (float_type_node)))))
250 tree fn = mathfn_built_in (type, fcode);
254 tree arg = strip_float_extensions (CALL_EXPR_ARG (expr, 0));
256 /* Make sure (type)arg0 is an extension, otherwise we could end up
257 changing (float)floor(double d) into floorf((float)d), which is
258 incorrect because (float)d uses round-to-nearest and can round
259 up to the next integer. */
260 if (TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (arg)))
261 return build_call_expr (fn, 1, fold (convert_to_real (type, arg)));
265 /* Propagate the cast into the operation. */
266 if (itype != type && FLOAT_TYPE_P (type))
267 switch (TREE_CODE (expr))
269 /* Convert (float)-x into -(float)x. This is safe for
270 round-to-nearest rounding mode. */
273 if (!flag_rounding_math
274 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
275 return build1 (TREE_CODE (expr), type,
276 fold (convert_to_real (type,
277 TREE_OPERAND (expr, 0))));
279 /* Convert (outertype)((innertype0)a+(innertype1)b)
280 into ((newtype)a+(newtype)b) where newtype
281 is the widest mode from all of these. */
287 tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
288 tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
290 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
291 && FLOAT_TYPE_P (TREE_TYPE (arg1))
292 && DECIMAL_FLOAT_TYPE_P (itype) == DECIMAL_FLOAT_TYPE_P (type))
296 if (TYPE_MODE (TREE_TYPE (arg0)) == SDmode
297 || TYPE_MODE (TREE_TYPE (arg1)) == SDmode
298 || TYPE_MODE (type) == SDmode)
299 newtype = dfloat32_type_node;
300 if (TYPE_MODE (TREE_TYPE (arg0)) == DDmode
301 || TYPE_MODE (TREE_TYPE (arg1)) == DDmode
302 || TYPE_MODE (type) == DDmode)
303 newtype = dfloat64_type_node;
304 if (TYPE_MODE (TREE_TYPE (arg0)) == TDmode
305 || TYPE_MODE (TREE_TYPE (arg1)) == TDmode
306 || TYPE_MODE (type) == TDmode)
307 newtype = dfloat128_type_node;
308 if (newtype == dfloat32_type_node
309 || newtype == dfloat64_type_node
310 || newtype == dfloat128_type_node)
312 expr = build2 (TREE_CODE (expr), newtype,
313 fold (convert_to_real (newtype, arg0)),
314 fold (convert_to_real (newtype, arg1)));
320 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
321 newtype = TREE_TYPE (arg0);
322 if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
323 newtype = TREE_TYPE (arg1);
324 /* Sometimes this transformation is safe (cannot
325 change results through affecting double rounding
326 cases) and sometimes it is not. If NEWTYPE is
327 wider than TYPE, e.g. (float)((long double)double
328 + (long double)double) converted to
329 (float)(double + double), the transformation is
330 unsafe regardless of the details of the types
331 involved; double rounding can arise if the result
332 of NEWTYPE arithmetic is a NEWTYPE value half way
333 between two representable TYPE values but the
334 exact value is sufficiently different (in the
335 right direction) for this difference to be
336 visible in ITYPE arithmetic. If NEWTYPE is the
337 same as TYPE, however, the transformation may be
338 safe depending on the types involved: it is safe
339 if the ITYPE has strictly more than twice as many
340 mantissa bits as TYPE, can represent infinities
341 and NaNs if the TYPE can, and has sufficient
342 exponent range for the product or ratio of two
343 values representable in the TYPE to be within the
344 range of normal values of ITYPE. */
345 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
346 && (flag_unsafe_math_optimizations
347 || (TYPE_PRECISION (newtype) == TYPE_PRECISION (type)
348 && real_can_shorten_arithmetic (TYPE_MODE (itype),
350 && !excess_precision_type (newtype))))
352 expr = build2 (TREE_CODE (expr), newtype,
353 fold (convert_to_real (newtype, arg0)),
354 fold (convert_to_real (newtype, arg1)));
365 switch (TREE_CODE (TREE_TYPE (expr)))
368 /* Ignore the conversion if we don't need to store intermediate
369 results and neither type is a decimal float. */
370 return build1 ((flag_float_store
371 || DECIMAL_FLOAT_TYPE_P (type)
372 || DECIMAL_FLOAT_TYPE_P (itype))
373 ? CONVERT_EXPR : NOP_EXPR, type, expr);
378 return build1 (FLOAT_EXPR, type, expr);
380 case FIXED_POINT_TYPE:
381 return build1 (FIXED_CONVERT_EXPR, type, expr);
384 return convert (type,
385 fold_build1 (REALPART_EXPR,
386 TREE_TYPE (TREE_TYPE (expr)), expr));
390 error ("pointer value used where a floating point value was expected");
391 return convert_to_real (type, integer_zero_node);
394 error ("aggregate value used where a float was expected");
395 return convert_to_real (type, integer_zero_node);
399 /* Convert EXPR to some integer (or enum) type TYPE.
401 EXPR must be pointer, integer, discrete (enum, char, or bool), float,
402 fixed-point or vector; in other cases error is called.
404 The result of this is always supposed to be a newly created tree node
405 not in use in any existing structure. */
408 convert_to_integer (tree type, tree expr)
410 enum tree_code ex_form = TREE_CODE (expr);
411 tree intype = TREE_TYPE (expr);
412 unsigned int inprec = TYPE_PRECISION (intype);
413 unsigned int outprec = TYPE_PRECISION (type);
415 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
416 be. Consider `enum E = { a, b = (enum E) 3 };'. */
417 if (!COMPLETE_TYPE_P (type))
419 error ("conversion to incomplete type");
420 return error_mark_node;
423 /* Convert e.g. (long)round(d) -> lround(d). */
424 /* If we're converting to char, we may encounter differing behavior
425 between converting from double->char vs double->long->char.
426 We're in "undefined" territory but we prefer to be conservative,
427 so only proceed in "unsafe" math mode. */
429 && (flag_unsafe_math_optimizations
430 || (long_integer_type_node
431 && outprec >= TYPE_PRECISION (long_integer_type_node))))
433 tree s_expr = strip_float_extensions (expr);
434 tree s_intype = TREE_TYPE (s_expr);
435 const enum built_in_function fcode = builtin_mathfn_code (s_expr);
440 CASE_FLT_FN (BUILT_IN_CEIL):
441 /* Only convert in ISO C99 mode. */
442 if (!TARGET_C99_FUNCTIONS)
444 if (outprec < TYPE_PRECISION (long_integer_type_node)
445 || (outprec == TYPE_PRECISION (long_integer_type_node)
446 && !TYPE_UNSIGNED (type)))
447 fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
448 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
449 && !TYPE_UNSIGNED (type))
450 fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL);
453 CASE_FLT_FN (BUILT_IN_FLOOR):
454 /* Only convert in ISO C99 mode. */
455 if (!TARGET_C99_FUNCTIONS)
457 if (outprec < TYPE_PRECISION (long_integer_type_node)
458 || (outprec == TYPE_PRECISION (long_integer_type_node)
459 && !TYPE_UNSIGNED (type)))
460 fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
461 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
462 && !TYPE_UNSIGNED (type))
463 fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR);
466 CASE_FLT_FN (BUILT_IN_ROUND):
467 if (outprec < TYPE_PRECISION (long_integer_type_node)
468 || (outprec == TYPE_PRECISION (long_integer_type_node)
469 && !TYPE_UNSIGNED (type)))
470 fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
471 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
472 && !TYPE_UNSIGNED (type))
473 fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
476 CASE_FLT_FN (BUILT_IN_NEARBYINT):
477 /* Only convert nearbyint* if we can ignore math exceptions. */
478 if (flag_trapping_math)
480 /* ... Fall through ... */
481 CASE_FLT_FN (BUILT_IN_RINT):
482 if (outprec < TYPE_PRECISION (long_integer_type_node)
483 || (outprec == TYPE_PRECISION (long_integer_type_node)
484 && !TYPE_UNSIGNED (type)))
485 fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
486 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
487 && !TYPE_UNSIGNED (type))
488 fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT);
491 CASE_FLT_FN (BUILT_IN_TRUNC):
492 return convert_to_integer (type, CALL_EXPR_ARG (s_expr, 0));
500 tree newexpr = build_call_expr (fn, 1, CALL_EXPR_ARG (s_expr, 0));
501 return convert_to_integer (type, newexpr);
505 /* Convert (int)logb(d) -> ilogb(d). */
507 && flag_unsafe_math_optimizations
508 && !flag_trapping_math && !flag_errno_math && flag_finite_math_only
510 && (outprec > TYPE_PRECISION (integer_type_node)
511 || (outprec == TYPE_PRECISION (integer_type_node)
512 && !TYPE_UNSIGNED (type))))
514 tree s_expr = strip_float_extensions (expr);
515 tree s_intype = TREE_TYPE (s_expr);
516 const enum built_in_function fcode = builtin_mathfn_code (s_expr);
521 CASE_FLT_FN (BUILT_IN_LOGB):
522 fn = mathfn_built_in (s_intype, BUILT_IN_ILOGB);
531 tree newexpr = build_call_expr (fn, 1, CALL_EXPR_ARG (s_expr, 0));
532 return convert_to_integer (type, newexpr);
536 switch (TREE_CODE (intype))
540 if (integer_zerop (expr))
541 return build_int_cst (type, 0);
543 /* Convert to an unsigned integer of the correct width first, and from
544 there widen/truncate to the required type. Some targets support the
545 coexistence of multiple valid pointer sizes, so fetch the one we need
547 expr = fold_build1 (CONVERT_EXPR,
548 lang_hooks.types.type_for_size
549 (TYPE_PRECISION (intype), 0),
551 return fold_convert (type, expr);
557 /* If this is a logical operation, which just returns 0 or 1, we can
558 change the type of the expression. */
560 if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
562 expr = copy_node (expr);
563 TREE_TYPE (expr) = type;
567 /* If we are widening the type, put in an explicit conversion.
568 Similarly if we are not changing the width. After this, we know
569 we are truncating EXPR. */
571 else if (outprec >= inprec)
576 /* If the precision of the EXPR's type is K bits and the
577 destination mode has more bits, and the sign is changing,
578 it is not safe to use a NOP_EXPR. For example, suppose
579 that EXPR's type is a 3-bit unsigned integer type, the
580 TYPE is a 3-bit signed integer type, and the machine mode
581 for the types is 8-bit QImode. In that case, the
582 conversion necessitates an explicit sign-extension. In
583 the signed-to-unsigned case the high-order bits have to
585 if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
586 && (TYPE_PRECISION (TREE_TYPE (expr))
587 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
592 tem = fold_unary (code, type, expr);
596 tem = build1 (code, type, expr);
597 TREE_NO_WARNING (tem) = 1;
601 /* If TYPE is an enumeral type or a type with a precision less
602 than the number of bits in its mode, do the conversion to the
603 type corresponding to its mode, then do a nop conversion
605 else if (TREE_CODE (type) == ENUMERAL_TYPE
606 || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
607 return build1 (NOP_EXPR, type,
608 convert (lang_hooks.types.type_for_mode
609 (TYPE_MODE (type), TYPE_UNSIGNED (type)),
612 /* Here detect when we can distribute the truncation down past some
613 arithmetic. For example, if adding two longs and converting to an
614 int, we can equally well convert both to ints and then add.
615 For the operations handled here, such truncation distribution
617 It is desirable in these cases:
618 1) when truncating down to full-word from a larger size
619 2) when truncating takes no work.
620 3) when at least one operand of the arithmetic has been extended
621 (as by C's default conversions). In this case we need two conversions
622 if we do the arithmetic as already requested, so we might as well
623 truncate both and then combine. Perhaps that way we need only one.
625 Note that in general we cannot do the arithmetic in a type
626 shorter than the desired result of conversion, even if the operands
627 are both extended from a shorter type, because they might overflow
628 if combined in that type. The exceptions to this--the times when
629 two narrow values can be combined in their narrow type even to
630 make a wider result--are handled by "shorten" in build_binary_op. */
635 /* We can pass truncation down through right shifting
636 when the shift count is a nonpositive constant. */
637 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
638 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) <= 0)
643 /* We can pass truncation down through left shifting
644 when the shift count is a nonnegative constant and
645 the target type is unsigned. */
646 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
647 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
648 && TYPE_UNSIGNED (type)
649 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
651 /* If shift count is less than the width of the truncated type,
653 if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
654 /* In this case, shifting is like multiplication. */
658 /* If it is >= that width, result is zero.
659 Handling this with trunc1 would give the wrong result:
660 (int) ((long long) a << 32) is well defined (as 0)
661 but (int) a << 32 is undefined and would get a
664 tree t = build_int_cst (type, 0);
666 /* If the original expression had side-effects, we must
668 if (TREE_SIDE_EFFECTS (expr))
669 return build2 (COMPOUND_EXPR, type, expr, t);
680 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
681 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
683 /* Don't distribute unless the output precision is at least as big
684 as the actual inputs. Otherwise, the comparison of the
685 truncated values will be wrong. */
686 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
687 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
688 /* If signedness of arg0 and arg1 don't match,
689 we can't necessarily find a type to compare them in. */
690 && (TYPE_UNSIGNED (TREE_TYPE (arg0))
691 == TYPE_UNSIGNED (TREE_TYPE (arg1))))
703 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
704 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
706 if (outprec >= BITS_PER_WORD
707 || TRULY_NOOP_TRUNCATION (outprec, inprec)
708 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
709 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
711 /* Do the arithmetic in type TYPEX,
712 then convert result to TYPE. */
715 /* Can't do arithmetic in enumeral types
716 so use an integer type that will hold the values. */
717 if (TREE_CODE (typex) == ENUMERAL_TYPE)
718 typex = lang_hooks.types.type_for_size
719 (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
721 /* But now perhaps TYPEX is as wide as INPREC.
722 In that case, do nothing special here.
723 (Otherwise would recurse infinitely in convert. */
724 if (TYPE_PRECISION (typex) != inprec)
726 /* Don't do unsigned arithmetic where signed was wanted,
728 Exception: if both of the original operands were
729 unsigned then we can safely do the work as unsigned.
730 Exception: shift operations take their type solely
731 from the first argument.
732 Exception: the LSHIFT_EXPR case above requires that
733 we perform this operation unsigned lest we produce
734 signed-overflow undefinedness.
735 And we may need to do it as unsigned
736 if we truncate to the original size. */
737 if (TYPE_UNSIGNED (TREE_TYPE (expr))
738 || (TYPE_UNSIGNED (TREE_TYPE (arg0))
739 && (TYPE_UNSIGNED (TREE_TYPE (arg1))
740 || ex_form == LSHIFT_EXPR
741 || ex_form == RSHIFT_EXPR
742 || ex_form == LROTATE_EXPR
743 || ex_form == RROTATE_EXPR))
744 || ex_form == LSHIFT_EXPR
745 /* If we have !flag_wrapv, and either ARG0 or
746 ARG1 is of a signed type, we have to do
747 PLUS_EXPR or MINUS_EXPR in an unsigned
748 type. Otherwise, we would introduce
749 signed-overflow undefinedness. */
750 || ((!TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
751 || !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1)))
752 && (ex_form == PLUS_EXPR
753 || ex_form == MINUS_EXPR)))
754 typex = unsigned_type_for (typex);
756 typex = signed_type_for (typex);
757 return convert (type,
758 fold_build2 (ex_form, typex,
759 convert (typex, arg0),
760 convert (typex, arg1)));
768 /* This is not correct for ABS_EXPR,
769 since we must test the sign before truncation. */
773 /* Don't do unsigned arithmetic where signed was wanted,
775 if (TYPE_UNSIGNED (TREE_TYPE (expr)))
776 typex = unsigned_type_for (type);
778 typex = signed_type_for (type);
779 return convert (type,
780 fold_build1 (ex_form, typex,
782 TREE_OPERAND (expr, 0))));
787 "can't convert between vector values of different size" error. */
788 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
789 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
790 != GET_MODE_SIZE (TYPE_MODE (type))))
792 /* If truncating after truncating, might as well do all at once.
793 If truncating after extending, we may get rid of wasted work. */
794 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
797 /* It is sometimes worthwhile to push the narrowing down through
798 the conditional and never loses. A COND_EXPR may have a throw
799 as one operand, which then has void type. Just leave void
800 operands as they are. */
801 return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
802 VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1)))
803 ? TREE_OPERAND (expr, 1)
804 : convert (type, TREE_OPERAND (expr, 1)),
805 VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 2)))
806 ? TREE_OPERAND (expr, 2)
807 : convert (type, TREE_OPERAND (expr, 2)));
813 return build1 (CONVERT_EXPR, type, expr);
816 return build1 (FIX_TRUNC_EXPR, type, expr);
818 case FIXED_POINT_TYPE:
819 return build1 (FIXED_CONVERT_EXPR, type, expr);
822 return convert (type,
823 fold_build1 (REALPART_EXPR,
824 TREE_TYPE (TREE_TYPE (expr)), expr));
827 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
829 error ("can't convert between vector values of different size");
830 return error_mark_node;
832 return build1 (VIEW_CONVERT_EXPR, type, expr);
835 error ("aggregate value used where an integer was expected");
836 return convert (type, integer_zero_node);
840 /* Convert EXPR to the complex type TYPE in the usual ways. */
843 convert_to_complex (tree type, tree expr)
845 tree subtype = TREE_TYPE (type);
847 switch (TREE_CODE (TREE_TYPE (expr)))
850 case FIXED_POINT_TYPE:
854 return build2 (COMPLEX_EXPR, type, convert (subtype, expr),
855 convert (subtype, integer_zero_node));
859 tree elt_type = TREE_TYPE (TREE_TYPE (expr));
861 if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
863 else if (TREE_CODE (expr) == COMPLEX_EXPR)
864 return fold_build2 (COMPLEX_EXPR, type,
865 convert (subtype, TREE_OPERAND (expr, 0)),
866 convert (subtype, TREE_OPERAND (expr, 1)));
869 expr = save_expr (expr);
871 fold_build2 (COMPLEX_EXPR, type,
873 fold_build1 (REALPART_EXPR,
874 TREE_TYPE (TREE_TYPE (expr)),
877 fold_build1 (IMAGPART_EXPR,
878 TREE_TYPE (TREE_TYPE (expr)),
885 error ("pointer value used where a complex was expected");
886 return convert_to_complex (type, integer_zero_node);
889 error ("aggregate value used where a complex was expected");
890 return convert_to_complex (type, integer_zero_node);
894 /* Convert EXPR to the vector type TYPE in the usual ways. */
897 convert_to_vector (tree type, tree expr)
899 switch (TREE_CODE (TREE_TYPE (expr)))
903 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
905 error ("can't convert between vector values of different size");
906 return error_mark_node;
908 return build1 (VIEW_CONVERT_EXPR, type, expr);
911 error ("can't convert value to a vector");
912 return error_mark_node;
916 /* Convert EXPR to some fixed-point type TYPE.
918 EXPR must be fixed-point, float, integer, or enumeral;
919 in other cases error is called. */
922 convert_to_fixed (tree type, tree expr)
924 if (integer_zerop (expr))
926 tree fixed_zero_node = build_fixed (type, FCONST0 (TYPE_MODE (type)));
927 return fixed_zero_node;
929 else if (integer_onep (expr) && ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)))
931 tree fixed_one_node = build_fixed (type, FCONST1 (TYPE_MODE (type)));
932 return fixed_one_node;
935 switch (TREE_CODE (TREE_TYPE (expr)))
937 case FIXED_POINT_TYPE:
942 return build1 (FIXED_CONVERT_EXPR, type, expr);
945 return convert (type,
946 fold_build1 (REALPART_EXPR,
947 TREE_TYPE (TREE_TYPE (expr)), expr));
950 error ("aggregate value used where a fixed-point was expected");
951 return error_mark_node;