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
)))
57 return fold_build1_loc (loc
, NOP_EXPR
, type
, expr
);
63 /* If the input precision differs from the target pointer type
64 precision, first convert the input expression to an integer type of
65 the target precision. Some targets, e.g. VMS, need several pointer
66 sizes to coexist so the latter isn't necessarily POINTER_SIZE. */
67 unsigned int pprec
= TYPE_PRECISION (type
);
68 unsigned int eprec
= TYPE_PRECISION (TREE_TYPE (expr
));
71 expr
= fold_build1_loc (loc
, NOP_EXPR
,
72 lang_hooks
.types
.type_for_size (pprec
, 0),
76 return fold_build1_loc (loc
, CONVERT_EXPR
, type
, expr
);
79 error ("cannot convert to a pointer type");
80 return convert_to_pointer (type
, integer_zero_node
);
84 /* Avoid any floating point extensions from EXP. */
86 strip_float_extensions (tree exp
)
90 /* For floating point constant look up the narrowest type that can hold
91 it properly and handle it like (type)(narrowest_type)constant.
92 This way we can optimize for instance a=a*2.0 where "a" is float
93 but 2.0 is double constant. */
94 if (TREE_CODE (exp
) == REAL_CST
&& !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp
)))
99 orig
= TREE_REAL_CST (exp
);
100 if (TYPE_PRECISION (TREE_TYPE (exp
)) > TYPE_PRECISION (float_type_node
)
101 && exact_real_truncate (TYPE_MODE (float_type_node
), &orig
))
102 type
= float_type_node
;
103 else if (TYPE_PRECISION (TREE_TYPE (exp
))
104 > TYPE_PRECISION (double_type_node
)
105 && exact_real_truncate (TYPE_MODE (double_type_node
), &orig
))
106 type
= double_type_node
;
108 return build_real (type
, real_value_truncate (TYPE_MODE (type
), orig
));
111 if (!CONVERT_EXPR_P (exp
))
114 sub
= TREE_OPERAND (exp
, 0);
115 subt
= TREE_TYPE (sub
);
116 expt
= TREE_TYPE (exp
);
118 if (!FLOAT_TYPE_P (subt
))
121 if (DECIMAL_FLOAT_TYPE_P (expt
) != DECIMAL_FLOAT_TYPE_P (subt
))
124 if (TYPE_PRECISION (subt
) > TYPE_PRECISION (expt
))
127 return strip_float_extensions (sub
);
131 /* Convert EXPR to some floating-point type TYPE.
133 EXPR must be float, fixed-point, integer, or enumeral;
134 in other cases error is called. */
137 convert_to_real (tree type
, tree expr
)
139 enum built_in_function fcode
= builtin_mathfn_code (expr
);
140 tree itype
= TREE_TYPE (expr
);
142 /* Disable until we figure out how to decide whether the functions are
143 present in runtime. */
144 /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
146 && (TYPE_MODE (type
) == TYPE_MODE (double_type_node
)
147 || TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))
151 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
166 /* The above functions may set errno differently with float
167 input or output so this transformation is not safe with
193 tree arg0
= strip_float_extensions (CALL_EXPR_ARG (expr
, 0));
196 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
197 the both as the safe type for operation. */
198 if (TYPE_PRECISION (TREE_TYPE (arg0
)) > TYPE_PRECISION (type
))
199 newtype
= TREE_TYPE (arg0
);
201 /* Be careful about integer to fp conversions.
202 These may overflow still. */
203 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
204 && TYPE_PRECISION (newtype
) < TYPE_PRECISION (itype
)
205 && (TYPE_MODE (newtype
) == TYPE_MODE (double_type_node
)
206 || TYPE_MODE (newtype
) == TYPE_MODE (float_type_node
)))
208 tree fn
= mathfn_built_in (newtype
, fcode
);
212 tree arg
= fold (convert_to_real (newtype
, arg0
));
213 expr
= build_call_expr (fn
, 1, arg
);
224 && (((fcode
== BUILT_IN_FLOORL
225 || fcode
== BUILT_IN_CEILL
226 || fcode
== BUILT_IN_ROUNDL
227 || fcode
== BUILT_IN_RINTL
228 || fcode
== BUILT_IN_TRUNCL
229 || fcode
== BUILT_IN_NEARBYINTL
)
230 && (TYPE_MODE (type
) == TYPE_MODE (double_type_node
)
231 || TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))
232 || ((fcode
== BUILT_IN_FLOOR
233 || fcode
== BUILT_IN_CEIL
234 || fcode
== BUILT_IN_ROUND
235 || fcode
== BUILT_IN_RINT
236 || fcode
== BUILT_IN_TRUNC
237 || fcode
== BUILT_IN_NEARBYINT
)
238 && (TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))))
240 tree fn
= mathfn_built_in (type
, fcode
);
244 tree arg
= strip_float_extensions (CALL_EXPR_ARG (expr
, 0));
246 /* Make sure (type)arg0 is an extension, otherwise we could end up
247 changing (float)floor(double d) into floorf((float)d), which is
248 incorrect because (float)d uses round-to-nearest and can round
249 up to the next integer. */
250 if (TYPE_PRECISION (type
) >= TYPE_PRECISION (TREE_TYPE (arg
)))
251 return build_call_expr (fn
, 1, fold (convert_to_real (type
, arg
)));
255 /* Propagate the cast into the operation. */
256 if (itype
!= type
&& FLOAT_TYPE_P (type
))
257 switch (TREE_CODE (expr
))
259 /* Convert (float)-x into -(float)x. This is safe for
260 round-to-nearest rounding mode. */
263 if (!flag_rounding_math
264 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (expr
)))
265 return build1 (TREE_CODE (expr
), type
,
266 fold (convert_to_real (type
,
267 TREE_OPERAND (expr
, 0))));
269 /* Convert (outertype)((innertype0)a+(innertype1)b)
270 into ((newtype)a+(newtype)b) where newtype
271 is the widest mode from all of these. */
277 tree arg0
= strip_float_extensions (TREE_OPERAND (expr
, 0));
278 tree arg1
= strip_float_extensions (TREE_OPERAND (expr
, 1));
280 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
281 && FLOAT_TYPE_P (TREE_TYPE (arg1
))
282 && DECIMAL_FLOAT_TYPE_P (itype
) == DECIMAL_FLOAT_TYPE_P (type
))
286 if (TYPE_MODE (TREE_TYPE (arg0
)) == SDmode
287 || TYPE_MODE (TREE_TYPE (arg1
)) == SDmode
288 || TYPE_MODE (type
) == SDmode
)
289 newtype
= dfloat32_type_node
;
290 if (TYPE_MODE (TREE_TYPE (arg0
)) == DDmode
291 || TYPE_MODE (TREE_TYPE (arg1
)) == DDmode
292 || TYPE_MODE (type
) == DDmode
)
293 newtype
= dfloat64_type_node
;
294 if (TYPE_MODE (TREE_TYPE (arg0
)) == TDmode
295 || TYPE_MODE (TREE_TYPE (arg1
)) == TDmode
296 || TYPE_MODE (type
) == TDmode
)
297 newtype
= dfloat128_type_node
;
298 if (newtype
== dfloat32_type_node
299 || newtype
== dfloat64_type_node
300 || newtype
== dfloat128_type_node
)
302 expr
= build2 (TREE_CODE (expr
), newtype
,
303 fold (convert_to_real (newtype
, arg0
)),
304 fold (convert_to_real (newtype
, arg1
)));
310 if (TYPE_PRECISION (TREE_TYPE (arg0
)) > TYPE_PRECISION (newtype
))
311 newtype
= TREE_TYPE (arg0
);
312 if (TYPE_PRECISION (TREE_TYPE (arg1
)) > TYPE_PRECISION (newtype
))
313 newtype
= TREE_TYPE (arg1
);
314 /* Sometimes this transformation is safe (cannot
315 change results through affecting double rounding
316 cases) and sometimes it is not. If NEWTYPE is
317 wider than TYPE, e.g. (float)((long double)double
318 + (long double)double) converted to
319 (float)(double + double), the transformation is
320 unsafe regardless of the details of the types
321 involved; double rounding can arise if the result
322 of NEWTYPE arithmetic is a NEWTYPE value half way
323 between two representable TYPE values but the
324 exact value is sufficiently different (in the
325 right direction) for this difference to be
326 visible in ITYPE arithmetic. If NEWTYPE is the
327 same as TYPE, however, the transformation may be
328 safe depending on the types involved: it is safe
329 if the ITYPE has strictly more than twice as many
330 mantissa bits as TYPE, can represent infinities
331 and NaNs if the TYPE can, and has sufficient
332 exponent range for the product or ratio of two
333 values representable in the TYPE to be within the
334 range of normal values of ITYPE. */
335 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (itype
)
336 && (flag_unsafe_math_optimizations
337 || (TYPE_PRECISION (newtype
) == TYPE_PRECISION (type
)
338 && real_can_shorten_arithmetic (TYPE_MODE (itype
),
340 && !excess_precision_type (newtype
))))
342 expr
= build2 (TREE_CODE (expr
), newtype
,
343 fold (convert_to_real (newtype
, arg0
)),
344 fold (convert_to_real (newtype
, arg1
)));
355 switch (TREE_CODE (TREE_TYPE (expr
)))
358 /* Ignore the conversion if we don't need to store intermediate
359 results and neither type is a decimal float. */
360 return build1 ((flag_float_store
361 || DECIMAL_FLOAT_TYPE_P (type
)
362 || DECIMAL_FLOAT_TYPE_P (itype
))
363 ? CONVERT_EXPR
: NOP_EXPR
, type
, expr
);
368 return build1 (FLOAT_EXPR
, type
, expr
);
370 case FIXED_POINT_TYPE
:
371 return build1 (FIXED_CONVERT_EXPR
, type
, expr
);
374 return convert (type
,
375 fold_build1 (REALPART_EXPR
,
376 TREE_TYPE (TREE_TYPE (expr
)), expr
));
380 error ("pointer value used where a floating point value was expected");
381 return convert_to_real (type
, integer_zero_node
);
384 error ("aggregate value used where a float was expected");
385 return convert_to_real (type
, integer_zero_node
);
389 /* Convert EXPR to some integer (or enum) type TYPE.
391 EXPR must be pointer, integer, discrete (enum, char, or bool), float,
392 fixed-point or vector; in other cases error is called.
394 The result of this is always supposed to be a newly created tree node
395 not in use in any existing structure. */
398 convert_to_integer (tree type
, tree expr
)
400 enum tree_code ex_form
= TREE_CODE (expr
);
401 tree intype
= TREE_TYPE (expr
);
402 unsigned int inprec
= TYPE_PRECISION (intype
);
403 unsigned int outprec
= TYPE_PRECISION (type
);
405 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
406 be. Consider `enum E = { a, b = (enum E) 3 };'. */
407 if (!COMPLETE_TYPE_P (type
))
409 error ("conversion to incomplete type");
410 return error_mark_node
;
413 /* Convert e.g. (long)round(d) -> lround(d). */
414 /* If we're converting to char, we may encounter differing behavior
415 between converting from double->char vs double->long->char.
416 We're in "undefined" territory but we prefer to be conservative,
417 so only proceed in "unsafe" math mode. */
419 && (flag_unsafe_math_optimizations
420 || (long_integer_type_node
421 && outprec
>= TYPE_PRECISION (long_integer_type_node
))))
423 tree s_expr
= strip_float_extensions (expr
);
424 tree s_intype
= TREE_TYPE (s_expr
);
425 const enum built_in_function fcode
= builtin_mathfn_code (s_expr
);
430 CASE_FLT_FN (BUILT_IN_CEIL
):
431 /* Only convert in ISO C99 mode. */
432 if (!TARGET_C99_FUNCTIONS
)
434 if (outprec
< TYPE_PRECISION (long_integer_type_node
)
435 || (outprec
== TYPE_PRECISION (long_integer_type_node
)
436 && !TYPE_UNSIGNED (type
)))
437 fn
= mathfn_built_in (s_intype
, BUILT_IN_LCEIL
);
438 else if (outprec
== TYPE_PRECISION (long_long_integer_type_node
)
439 && !TYPE_UNSIGNED (type
))
440 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLCEIL
);
443 CASE_FLT_FN (BUILT_IN_FLOOR
):
444 /* Only convert in ISO C99 mode. */
445 if (!TARGET_C99_FUNCTIONS
)
447 if (outprec
< TYPE_PRECISION (long_integer_type_node
)
448 || (outprec
== TYPE_PRECISION (long_integer_type_node
)
449 && !TYPE_UNSIGNED (type
)))
450 fn
= mathfn_built_in (s_intype
, BUILT_IN_LFLOOR
);
451 else if (outprec
== TYPE_PRECISION (long_long_integer_type_node
)
452 && !TYPE_UNSIGNED (type
))
453 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLFLOOR
);
456 CASE_FLT_FN (BUILT_IN_ROUND
):
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_LROUND
);
461 else if (outprec
== TYPE_PRECISION (long_long_integer_type_node
)
462 && !TYPE_UNSIGNED (type
))
463 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLROUND
);
466 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
467 /* Only convert nearbyint* if we can ignore math exceptions. */
468 if (flag_trapping_math
)
470 /* ... Fall through ... */
471 CASE_FLT_FN (BUILT_IN_RINT
):
472 if (outprec
< TYPE_PRECISION (long_integer_type_node
)
473 || (outprec
== TYPE_PRECISION (long_integer_type_node
)
474 && !TYPE_UNSIGNED (type
)))
475 fn
= mathfn_built_in (s_intype
, BUILT_IN_LRINT
);
476 else if (outprec
== TYPE_PRECISION (long_long_integer_type_node
)
477 && !TYPE_UNSIGNED (type
))
478 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLRINT
);
481 CASE_FLT_FN (BUILT_IN_TRUNC
):
482 return convert_to_integer (type
, CALL_EXPR_ARG (s_expr
, 0));
490 tree newexpr
= build_call_expr (fn
, 1, CALL_EXPR_ARG (s_expr
, 0));
491 return convert_to_integer (type
, newexpr
);
495 /* Convert (int)logb(d) -> ilogb(d). */
497 && flag_unsafe_math_optimizations
498 && !flag_trapping_math
&& !flag_errno_math
&& flag_finite_math_only
500 && (outprec
> TYPE_PRECISION (integer_type_node
)
501 || (outprec
== TYPE_PRECISION (integer_type_node
)
502 && !TYPE_UNSIGNED (type
))))
504 tree s_expr
= strip_float_extensions (expr
);
505 tree s_intype
= TREE_TYPE (s_expr
);
506 const enum built_in_function fcode
= builtin_mathfn_code (s_expr
);
511 CASE_FLT_FN (BUILT_IN_LOGB
):
512 fn
= mathfn_built_in (s_intype
, BUILT_IN_ILOGB
);
521 tree newexpr
= build_call_expr (fn
, 1, CALL_EXPR_ARG (s_expr
, 0));
522 return convert_to_integer (type
, newexpr
);
526 switch (TREE_CODE (intype
))
530 if (integer_zerop (expr
))
531 return build_int_cst (type
, 0);
533 /* Convert to an unsigned integer of the correct width first, and from
534 there widen/truncate to the required type. Some targets support the
535 coexistence of multiple valid pointer sizes, so fetch the one we need
537 expr
= fold_build1 (CONVERT_EXPR
,
538 lang_hooks
.types
.type_for_size
539 (TYPE_PRECISION (intype
), 0),
541 return fold_convert (type
, expr
);
547 /* If this is a logical operation, which just returns 0 or 1, we can
548 change the type of the expression. */
550 if (TREE_CODE_CLASS (ex_form
) == tcc_comparison
)
552 expr
= copy_node (expr
);
553 TREE_TYPE (expr
) = type
;
557 /* If we are widening the type, put in an explicit conversion.
558 Similarly if we are not changing the width. After this, we know
559 we are truncating EXPR. */
561 else if (outprec
>= inprec
)
566 /* If the precision of the EXPR's type is K bits and the
567 destination mode has more bits, and the sign is changing,
568 it is not safe to use a NOP_EXPR. For example, suppose
569 that EXPR's type is a 3-bit unsigned integer type, the
570 TYPE is a 3-bit signed integer type, and the machine mode
571 for the types is 8-bit QImode. In that case, the
572 conversion necessitates an explicit sign-extension. In
573 the signed-to-unsigned case the high-order bits have to
575 if (TYPE_UNSIGNED (type
) != TYPE_UNSIGNED (TREE_TYPE (expr
))
576 && (TYPE_PRECISION (TREE_TYPE (expr
))
577 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)))))
582 tem
= fold_unary (code
, type
, expr
);
586 tem
= build1 (code
, type
, expr
);
587 TREE_NO_WARNING (tem
) = 1;
591 /* If TYPE is an enumeral type or a type with a precision less
592 than the number of bits in its mode, do the conversion to the
593 type corresponding to its mode, then do a nop conversion
595 else if (TREE_CODE (type
) == ENUMERAL_TYPE
596 || outprec
!= GET_MODE_BITSIZE (TYPE_MODE (type
)))
597 return build1 (NOP_EXPR
, type
,
598 convert (lang_hooks
.types
.type_for_mode
599 (TYPE_MODE (type
), TYPE_UNSIGNED (type
)),
602 /* Here detect when we can distribute the truncation down past some
603 arithmetic. For example, if adding two longs and converting to an
604 int, we can equally well convert both to ints and then add.
605 For the operations handled here, such truncation distribution
607 It is desirable in these cases:
608 1) when truncating down to full-word from a larger size
609 2) when truncating takes no work.
610 3) when at least one operand of the arithmetic has been extended
611 (as by C's default conversions). In this case we need two conversions
612 if we do the arithmetic as already requested, so we might as well
613 truncate both and then combine. Perhaps that way we need only one.
615 Note that in general we cannot do the arithmetic in a type
616 shorter than the desired result of conversion, even if the operands
617 are both extended from a shorter type, because they might overflow
618 if combined in that type. The exceptions to this--the times when
619 two narrow values can be combined in their narrow type even to
620 make a wider result--are handled by "shorten" in build_binary_op. */
625 /* We can pass truncation down through right shifting
626 when the shift count is a nonpositive constant. */
627 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
628 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) <= 0)
633 /* We can pass truncation down through left shifting
634 when the shift count is a nonnegative constant and
635 the target type is unsigned. */
636 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
637 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) >= 0
638 && TYPE_UNSIGNED (type
)
639 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
641 /* If shift count is less than the width of the truncated type,
643 if (tree_int_cst_lt (TREE_OPERAND (expr
, 1), TYPE_SIZE (type
)))
644 /* In this case, shifting is like multiplication. */
648 /* If it is >= that width, result is zero.
649 Handling this with trunc1 would give the wrong result:
650 (int) ((long long) a << 32) is well defined (as 0)
651 but (int) a << 32 is undefined and would get a
654 tree t
= build_int_cst (type
, 0);
656 /* If the original expression had side-effects, we must
658 if (TREE_SIDE_EFFECTS (expr
))
659 return build2 (COMPOUND_EXPR
, type
, expr
, t
);
670 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
671 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
673 /* Don't distribute unless the output precision is at least as big
674 as the actual inputs. Otherwise, the comparison of the
675 truncated values will be wrong. */
676 if (outprec
>= TYPE_PRECISION (TREE_TYPE (arg0
))
677 && outprec
>= TYPE_PRECISION (TREE_TYPE (arg1
))
678 /* If signedness of arg0 and arg1 don't match,
679 we can't necessarily find a type to compare them in. */
680 && (TYPE_UNSIGNED (TREE_TYPE (arg0
))
681 == TYPE_UNSIGNED (TREE_TYPE (arg1
))))
693 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
694 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
696 if (outprec
>= BITS_PER_WORD
697 || TRULY_NOOP_TRUNCATION (outprec
, inprec
)
698 || inprec
> TYPE_PRECISION (TREE_TYPE (arg0
))
699 || inprec
> TYPE_PRECISION (TREE_TYPE (arg1
)))
701 /* Do the arithmetic in type TYPEX,
702 then convert result to TYPE. */
705 /* Can't do arithmetic in enumeral types
706 so use an integer type that will hold the values. */
707 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
708 typex
= lang_hooks
.types
.type_for_size
709 (TYPE_PRECISION (typex
), TYPE_UNSIGNED (typex
));
711 /* But now perhaps TYPEX is as wide as INPREC.
712 In that case, do nothing special here.
713 (Otherwise would recurse infinitely in convert. */
714 if (TYPE_PRECISION (typex
) != inprec
)
716 /* Don't do unsigned arithmetic where signed was wanted,
718 Exception: if both of the original operands were
719 unsigned then we can safely do the work as unsigned.
720 Exception: shift operations take their type solely
721 from the first argument.
722 Exception: the LSHIFT_EXPR case above requires that
723 we perform this operation unsigned lest we produce
724 signed-overflow undefinedness.
725 And we may need to do it as unsigned
726 if we truncate to the original size. */
727 if (TYPE_UNSIGNED (TREE_TYPE (expr
))
728 || (TYPE_UNSIGNED (TREE_TYPE (arg0
))
729 && (TYPE_UNSIGNED (TREE_TYPE (arg1
))
730 || ex_form
== LSHIFT_EXPR
731 || ex_form
== RSHIFT_EXPR
732 || ex_form
== LROTATE_EXPR
733 || ex_form
== RROTATE_EXPR
))
734 || ex_form
== LSHIFT_EXPR
735 /* If we have !flag_wrapv, and either ARG0 or
736 ARG1 is of a signed type, we have to do
737 PLUS_EXPR or MINUS_EXPR in an unsigned
738 type. Otherwise, we would introduce
739 signed-overflow undefinedness. */
740 || ((!TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
741 || !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1
)))
742 && (ex_form
== PLUS_EXPR
743 || ex_form
== MINUS_EXPR
)))
744 typex
= unsigned_type_for (typex
);
746 typex
= signed_type_for (typex
);
747 return convert (type
,
748 fold_build2 (ex_form
, typex
,
749 convert (typex
, arg0
),
750 convert (typex
, arg1
)));
758 /* This is not correct for ABS_EXPR,
759 since we must test the sign before truncation. */
763 /* Don't do unsigned arithmetic where signed was wanted,
765 if (TYPE_UNSIGNED (TREE_TYPE (expr
)))
766 typex
= unsigned_type_for (type
);
768 typex
= signed_type_for (type
);
769 return convert (type
,
770 fold_build1 (ex_form
, typex
,
772 TREE_OPERAND (expr
, 0))));
777 "can't convert between vector values of different size" error. */
778 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == VECTOR_TYPE
779 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0))))
780 != GET_MODE_SIZE (TYPE_MODE (type
))))
782 /* If truncating after truncating, might as well do all at once.
783 If truncating after extending, we may get rid of wasted work. */
784 return convert (type
, get_unwidened (TREE_OPERAND (expr
, 0), type
));
787 /* It is sometimes worthwhile to push the narrowing down through
788 the conditional and never loses. A COND_EXPR may have a throw
789 as one operand, which then has void type. Just leave void
790 operands as they are. */
791 return fold_build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0),
792 VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 1)))
793 ? TREE_OPERAND (expr
, 1)
794 : convert (type
, TREE_OPERAND (expr
, 1)),
795 VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 2)))
796 ? TREE_OPERAND (expr
, 2)
797 : convert (type
, TREE_OPERAND (expr
, 2)));
803 return build1 (CONVERT_EXPR
, type
, expr
);
806 return build1 (FIX_TRUNC_EXPR
, type
, expr
);
808 case FIXED_POINT_TYPE
:
809 return build1 (FIXED_CONVERT_EXPR
, type
, expr
);
812 return convert (type
,
813 fold_build1 (REALPART_EXPR
,
814 TREE_TYPE (TREE_TYPE (expr
)), expr
));
817 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
819 error ("can't convert between vector values of different size");
820 return error_mark_node
;
822 return build1 (VIEW_CONVERT_EXPR
, type
, expr
);
825 error ("aggregate value used where an integer was expected");
826 return convert (type
, integer_zero_node
);
830 /* Convert EXPR to the complex type TYPE in the usual ways. */
833 convert_to_complex (tree type
, tree expr
)
835 tree subtype
= TREE_TYPE (type
);
837 switch (TREE_CODE (TREE_TYPE (expr
)))
840 case FIXED_POINT_TYPE
:
844 return build2 (COMPLEX_EXPR
, type
, convert (subtype
, expr
),
845 convert (subtype
, integer_zero_node
));
849 tree elt_type
= TREE_TYPE (TREE_TYPE (expr
));
851 if (TYPE_MAIN_VARIANT (elt_type
) == TYPE_MAIN_VARIANT (subtype
))
853 else if (TREE_CODE (expr
) == COMPLEX_EXPR
)
854 return fold_build2 (COMPLEX_EXPR
, type
,
855 convert (subtype
, TREE_OPERAND (expr
, 0)),
856 convert (subtype
, TREE_OPERAND (expr
, 1)));
859 expr
= save_expr (expr
);
861 fold_build2 (COMPLEX_EXPR
, type
,
863 fold_build1 (REALPART_EXPR
,
864 TREE_TYPE (TREE_TYPE (expr
)),
867 fold_build1 (IMAGPART_EXPR
,
868 TREE_TYPE (TREE_TYPE (expr
)),
875 error ("pointer value used where a complex was expected");
876 return convert_to_complex (type
, integer_zero_node
);
879 error ("aggregate value used where a complex was expected");
880 return convert_to_complex (type
, integer_zero_node
);
884 /* Convert EXPR to the vector type TYPE in the usual ways. */
887 convert_to_vector (tree type
, tree expr
)
889 switch (TREE_CODE (TREE_TYPE (expr
)))
893 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
895 error ("can't convert between vector values of different size");
896 return error_mark_node
;
898 return build1 (VIEW_CONVERT_EXPR
, type
, expr
);
901 error ("can't convert value to a vector");
902 return error_mark_node
;
906 /* Convert EXPR to some fixed-point type TYPE.
908 EXPR must be fixed-point, float, integer, or enumeral;
909 in other cases error is called. */
912 convert_to_fixed (tree type
, tree expr
)
914 if (integer_zerop (expr
))
916 tree fixed_zero_node
= build_fixed (type
, FCONST0 (TYPE_MODE (type
)));
917 return fixed_zero_node
;
919 else if (integer_onep (expr
) && ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type
)))
921 tree fixed_one_node
= build_fixed (type
, FCONST1 (TYPE_MODE (type
)));
922 return fixed_one_node
;
925 switch (TREE_CODE (TREE_TYPE (expr
)))
927 case FIXED_POINT_TYPE
:
932 return build1 (FIXED_CONVERT_EXPR
, type
, expr
);
935 return convert (type
,
936 fold_build1 (REALPART_EXPR
,
937 TREE_TYPE (TREE_TYPE (expr
)), expr
));
940 error ("aggregate value used where a fixed-point was expected");
941 return error_mark_node
;