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 if (TREE_TYPE (expr) == type)
48 /* Propagate overflow to the NULL pointer. */
49 if (integer_zerop (expr))
50 return force_fit_type_double (type, 0, 0, 0, TREE_OVERFLOW (expr));
52 switch (TREE_CODE (TREE_TYPE (expr)))
56 return fold_build1 (NOP_EXPR, type, expr);
61 if (TYPE_PRECISION (TREE_TYPE (expr)) != POINTER_SIZE)
62 expr = fold_build1 (NOP_EXPR,
63 lang_hooks.types.type_for_size (POINTER_SIZE, 0),
65 return fold_build1 (CONVERT_EXPR, type, expr);
69 error ("cannot convert to a pointer type");
70 return convert_to_pointer (type, integer_zero_node);
74 /* Avoid any floating point extensions from EXP. */
76 strip_float_extensions (tree exp)
80 /* For floating point constant look up the narrowest type that can hold
81 it properly and handle it like (type)(narrowest_type)constant.
82 This way we can optimize for instance a=a*2.0 where "a" is float
83 but 2.0 is double constant. */
84 if (TREE_CODE (exp) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp)))
89 orig = TREE_REAL_CST (exp);
90 if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
91 && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
92 type = float_type_node;
93 else if (TYPE_PRECISION (TREE_TYPE (exp))
94 > TYPE_PRECISION (double_type_node)
95 && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
96 type = double_type_node;
98 return build_real (type, real_value_truncate (TYPE_MODE (type), orig));
101 if (!CONVERT_EXPR_P (exp))
104 sub = TREE_OPERAND (exp, 0);
105 subt = TREE_TYPE (sub);
106 expt = TREE_TYPE (exp);
108 if (!FLOAT_TYPE_P (subt))
111 if (DECIMAL_FLOAT_TYPE_P (expt) != DECIMAL_FLOAT_TYPE_P (subt))
114 if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
117 return strip_float_extensions (sub);
121 /* Convert EXPR to some floating-point type TYPE.
123 EXPR must be float, fixed-point, integer, or enumeral;
124 in other cases error is called. */
127 convert_to_real (tree type, tree expr)
129 enum built_in_function fcode = builtin_mathfn_code (expr);
130 tree itype = TREE_TYPE (expr);
132 /* Disable until we figure out how to decide whether the functions are
133 present in runtime. */
134 /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
136 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
137 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
141 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
156 /* The above functions may set errno differently with float
157 input or output so this transformation is not safe with
183 tree arg0 = strip_float_extensions (CALL_EXPR_ARG (expr, 0));
186 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
187 the both as the safe type for operation. */
188 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
189 newtype = TREE_TYPE (arg0);
191 /* Be careful about integer to fp conversions.
192 These may overflow still. */
193 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
194 && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
195 && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
196 || TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
198 tree fn = mathfn_built_in (newtype, fcode);
202 tree arg = fold (convert_to_real (newtype, arg0));
203 expr = build_call_expr (fn, 1, arg);
214 && (((fcode == BUILT_IN_FLOORL
215 || fcode == BUILT_IN_CEILL
216 || fcode == BUILT_IN_ROUNDL
217 || fcode == BUILT_IN_RINTL
218 || fcode == BUILT_IN_TRUNCL
219 || fcode == BUILT_IN_NEARBYINTL)
220 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
221 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
222 || ((fcode == BUILT_IN_FLOOR
223 || fcode == BUILT_IN_CEIL
224 || fcode == BUILT_IN_ROUND
225 || fcode == BUILT_IN_RINT
226 || fcode == BUILT_IN_TRUNC
227 || fcode == BUILT_IN_NEARBYINT)
228 && (TYPE_MODE (type) == TYPE_MODE (float_type_node)))))
230 tree fn = mathfn_built_in (type, fcode);
234 tree arg = strip_float_extensions (CALL_EXPR_ARG (expr, 0));
236 /* Make sure (type)arg0 is an extension, otherwise we could end up
237 changing (float)floor(double d) into floorf((float)d), which is
238 incorrect because (float)d uses round-to-nearest and can round
239 up to the next integer. */
240 if (TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (arg)))
241 return build_call_expr (fn, 1, fold (convert_to_real (type, arg)));
245 /* Propagate the cast into the operation. */
246 if (itype != type && FLOAT_TYPE_P (type))
247 switch (TREE_CODE (expr))
249 /* Convert (float)-x into -(float)x. This is safe for
250 round-to-nearest rounding mode. */
253 if (!flag_rounding_math
254 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
255 return build1 (TREE_CODE (expr), type,
256 fold (convert_to_real (type,
257 TREE_OPERAND (expr, 0))));
259 /* Convert (outertype)((innertype0)a+(innertype1)b)
260 into ((newtype)a+(newtype)b) where newtype
261 is the widest mode from all of these. */
267 tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
268 tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
270 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
271 && FLOAT_TYPE_P (TREE_TYPE (arg1))
272 && DECIMAL_FLOAT_TYPE_P (itype) == DECIMAL_FLOAT_TYPE_P (type))
276 if (TYPE_MODE (TREE_TYPE (arg0)) == SDmode
277 || TYPE_MODE (TREE_TYPE (arg1)) == SDmode
278 || TYPE_MODE (type) == SDmode)
279 newtype = dfloat32_type_node;
280 if (TYPE_MODE (TREE_TYPE (arg0)) == DDmode
281 || TYPE_MODE (TREE_TYPE (arg1)) == DDmode
282 || TYPE_MODE (type) == DDmode)
283 newtype = dfloat64_type_node;
284 if (TYPE_MODE (TREE_TYPE (arg0)) == TDmode
285 || TYPE_MODE (TREE_TYPE (arg1)) == TDmode
286 || TYPE_MODE (type) == TDmode)
287 newtype = dfloat128_type_node;
288 if (newtype == dfloat32_type_node
289 || newtype == dfloat64_type_node
290 || newtype == dfloat128_type_node)
292 expr = build2 (TREE_CODE (expr), newtype,
293 fold (convert_to_real (newtype, arg0)),
294 fold (convert_to_real (newtype, arg1)));
300 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
301 newtype = TREE_TYPE (arg0);
302 if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
303 newtype = TREE_TYPE (arg1);
304 /* Sometimes this transformation is safe (cannot
305 change results through affecting double rounding
306 cases) and sometimes it is not. If NEWTYPE is
307 wider than TYPE, e.g. (float)((long double)double
308 + (long double)double) converted to
309 (float)(double + double), the transformation is
310 unsafe regardless of the details of the types
311 involved; double rounding can arise if the result
312 of NEWTYPE arithmetic is a NEWTYPE value half way
313 between two representable TYPE values but the
314 exact value is sufficiently different (in the
315 right direction) for this difference to be
316 visible in ITYPE arithmetic. If NEWTYPE is the
317 same as TYPE, however, the transformation may be
318 safe depending on the types involved: it is safe
319 if the ITYPE has strictly more than twice as many
320 mantissa bits as TYPE, can represent infinities
321 and NaNs if the TYPE can, and has sufficient
322 exponent range for the product or ratio of two
323 values representable in the TYPE to be within the
324 range of normal values of ITYPE. */
325 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
326 && (flag_unsafe_math_optimizations
327 || (TYPE_PRECISION (newtype) == TYPE_PRECISION (type)
328 && real_can_shorten_arithmetic (TYPE_MODE (itype),
331 expr = build2 (TREE_CODE (expr), newtype,
332 fold (convert_to_real (newtype, arg0)),
333 fold (convert_to_real (newtype, arg1)));
344 switch (TREE_CODE (TREE_TYPE (expr)))
347 /* Ignore the conversion if we don't need to store intermediate
348 results and neither type is a decimal float. */
349 return build1 ((flag_float_store
350 || DECIMAL_FLOAT_TYPE_P (type)
351 || DECIMAL_FLOAT_TYPE_P (itype))
352 ? CONVERT_EXPR : NOP_EXPR, type, expr);
357 return build1 (FLOAT_EXPR, type, expr);
359 case FIXED_POINT_TYPE:
360 return build1 (FIXED_CONVERT_EXPR, type, expr);
363 return convert (type,
364 fold_build1 (REALPART_EXPR,
365 TREE_TYPE (TREE_TYPE (expr)), expr));
369 error ("pointer value used where a floating point value was expected");
370 return convert_to_real (type, integer_zero_node);
373 error ("aggregate value used where a float was expected");
374 return convert_to_real (type, integer_zero_node);
378 /* Convert EXPR to some integer (or enum) type TYPE.
380 EXPR must be pointer, integer, discrete (enum, char, or bool), float,
381 fixed-point or vector; in other cases error is called.
383 The result of this is always supposed to be a newly created tree node
384 not in use in any existing structure. */
387 convert_to_integer (tree type, tree expr)
389 enum tree_code ex_form = TREE_CODE (expr);
390 tree intype = TREE_TYPE (expr);
391 unsigned int inprec = TYPE_PRECISION (intype);
392 unsigned int outprec = TYPE_PRECISION (type);
394 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
395 be. Consider `enum E = { a, b = (enum E) 3 };'. */
396 if (!COMPLETE_TYPE_P (type))
398 error ("conversion to incomplete type");
399 return error_mark_node;
402 /* Convert e.g. (long)round(d) -> lround(d). */
403 /* If we're converting to char, we may encounter differing behavior
404 between converting from double->char vs double->long->char.
405 We're in "undefined" territory but we prefer to be conservative,
406 so only proceed in "unsafe" math mode. */
408 && (flag_unsafe_math_optimizations
409 || (long_integer_type_node
410 && outprec >= TYPE_PRECISION (long_integer_type_node))))
412 tree s_expr = strip_float_extensions (expr);
413 tree s_intype = TREE_TYPE (s_expr);
414 const enum built_in_function fcode = builtin_mathfn_code (s_expr);
419 CASE_FLT_FN (BUILT_IN_CEIL):
420 /* Only convert in ISO C99 mode. */
421 if (!TARGET_C99_FUNCTIONS)
423 if (outprec < TYPE_PRECISION (long_integer_type_node)
424 || (outprec == TYPE_PRECISION (long_integer_type_node)
425 && !TYPE_UNSIGNED (type)))
426 fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
427 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
428 && !TYPE_UNSIGNED (type))
429 fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL);
432 CASE_FLT_FN (BUILT_IN_FLOOR):
433 /* Only convert in ISO C99 mode. */
434 if (!TARGET_C99_FUNCTIONS)
436 if (outprec < TYPE_PRECISION (long_integer_type_node)
437 || (outprec == TYPE_PRECISION (long_integer_type_node)
438 && !TYPE_UNSIGNED (type)))
439 fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
440 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
441 && !TYPE_UNSIGNED (type))
442 fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR);
445 CASE_FLT_FN (BUILT_IN_ROUND):
446 if (outprec < TYPE_PRECISION (long_integer_type_node)
447 || (outprec == TYPE_PRECISION (long_integer_type_node)
448 && !TYPE_UNSIGNED (type)))
449 fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
450 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
451 && !TYPE_UNSIGNED (type))
452 fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
455 CASE_FLT_FN (BUILT_IN_NEARBYINT):
456 /* Only convert nearbyint* if we can ignore math exceptions. */
457 if (flag_trapping_math)
459 /* ... Fall through ... */
460 CASE_FLT_FN (BUILT_IN_RINT):
461 if (outprec < TYPE_PRECISION (long_integer_type_node)
462 || (outprec == TYPE_PRECISION (long_integer_type_node)
463 && !TYPE_UNSIGNED (type)))
464 fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
465 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
466 && !TYPE_UNSIGNED (type))
467 fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT);
470 CASE_FLT_FN (BUILT_IN_TRUNC):
471 return convert_to_integer (type, CALL_EXPR_ARG (s_expr, 0));
479 tree newexpr = build_call_expr (fn, 1, CALL_EXPR_ARG (s_expr, 0));
480 return convert_to_integer (type, newexpr);
484 switch (TREE_CODE (intype))
488 if (integer_zerop (expr))
489 return build_int_cst (type, 0);
491 /* Convert to an unsigned integer of the correct width first,
492 and from there widen/truncate to the required type. */
493 expr = fold_build1 (CONVERT_EXPR,
494 lang_hooks.types.type_for_size (POINTER_SIZE, 0),
496 return fold_convert (type, expr);
502 /* If this is a logical operation, which just returns 0 or 1, we can
503 change the type of the expression. */
505 if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
507 expr = copy_node (expr);
508 TREE_TYPE (expr) = type;
512 /* If we are widening the type, put in an explicit conversion.
513 Similarly if we are not changing the width. After this, we know
514 we are truncating EXPR. */
516 else if (outprec >= inprec)
521 /* If the precision of the EXPR's type is K bits and the
522 destination mode has more bits, and the sign is changing,
523 it is not safe to use a NOP_EXPR. For example, suppose
524 that EXPR's type is a 3-bit unsigned integer type, the
525 TYPE is a 3-bit signed integer type, and the machine mode
526 for the types is 8-bit QImode. In that case, the
527 conversion necessitates an explicit sign-extension. In
528 the signed-to-unsigned case the high-order bits have to
530 if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
531 && (TYPE_PRECISION (TREE_TYPE (expr))
532 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
537 tem = fold_unary (code, type, expr);
541 tem = build1 (code, type, expr);
542 TREE_NO_WARNING (tem) = 1;
546 /* If TYPE is an enumeral type or a type with a precision less
547 than the number of bits in its mode, do the conversion to the
548 type corresponding to its mode, then do a nop conversion
550 else if (TREE_CODE (type) == ENUMERAL_TYPE
551 || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
552 return build1 (NOP_EXPR, type,
553 convert (lang_hooks.types.type_for_mode
554 (TYPE_MODE (type), TYPE_UNSIGNED (type)),
557 /* Here detect when we can distribute the truncation down past some
558 arithmetic. For example, if adding two longs and converting to an
559 int, we can equally well convert both to ints and then add.
560 For the operations handled here, such truncation distribution
562 It is desirable in these cases:
563 1) when truncating down to full-word from a larger size
564 2) when truncating takes no work.
565 3) when at least one operand of the arithmetic has been extended
566 (as by C's default conversions). In this case we need two conversions
567 if we do the arithmetic as already requested, so we might as well
568 truncate both and then combine. Perhaps that way we need only one.
570 Note that in general we cannot do the arithmetic in a type
571 shorter than the desired result of conversion, even if the operands
572 are both extended from a shorter type, because they might overflow
573 if combined in that type. The exceptions to this--the times when
574 two narrow values can be combined in their narrow type even to
575 make a wider result--are handled by "shorten" in build_binary_op. */
580 /* We can pass truncation down through right shifting
581 when the shift count is a nonpositive constant. */
582 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
583 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) <= 0)
588 /* We can pass truncation down through left shifting
589 when the shift count is a nonnegative constant and
590 the target type is unsigned. */
591 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
592 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
593 && TYPE_UNSIGNED (type)
594 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
596 /* If shift count is less than the width of the truncated type,
598 if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
599 /* In this case, shifting is like multiplication. */
603 /* If it is >= that width, result is zero.
604 Handling this with trunc1 would give the wrong result:
605 (int) ((long long) a << 32) is well defined (as 0)
606 but (int) a << 32 is undefined and would get a
609 tree t = build_int_cst (type, 0);
611 /* If the original expression had side-effects, we must
613 if (TREE_SIDE_EFFECTS (expr))
614 return build2 (COMPOUND_EXPR, type, expr, t);
625 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
626 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
628 /* Don't distribute unless the output precision is at least as big
629 as the actual inputs. Otherwise, the comparison of the
630 truncated values will be wrong. */
631 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
632 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
633 /* If signedness of arg0 and arg1 don't match,
634 we can't necessarily find a type to compare them in. */
635 && (TYPE_UNSIGNED (TREE_TYPE (arg0))
636 == TYPE_UNSIGNED (TREE_TYPE (arg1))))
648 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
649 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
651 if (outprec >= BITS_PER_WORD
652 || TRULY_NOOP_TRUNCATION (outprec, inprec)
653 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
654 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
656 /* Do the arithmetic in type TYPEX,
657 then convert result to TYPE. */
660 /* Can't do arithmetic in enumeral types
661 so use an integer type that will hold the values. */
662 if (TREE_CODE (typex) == ENUMERAL_TYPE)
663 typex = lang_hooks.types.type_for_size
664 (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
666 /* But now perhaps TYPEX is as wide as INPREC.
667 In that case, do nothing special here.
668 (Otherwise would recurse infinitely in convert. */
669 if (TYPE_PRECISION (typex) != inprec)
671 /* Don't do unsigned arithmetic where signed was wanted,
673 Exception: if both of the original operands were
674 unsigned then we can safely do the work as unsigned.
675 Exception: shift operations take their type solely
676 from the first argument.
677 Exception: the LSHIFT_EXPR case above requires that
678 we perform this operation unsigned lest we produce
679 signed-overflow undefinedness.
680 And we may need to do it as unsigned
681 if we truncate to the original size. */
682 if (TYPE_UNSIGNED (TREE_TYPE (expr))
683 || (TYPE_UNSIGNED (TREE_TYPE (arg0))
684 && (TYPE_UNSIGNED (TREE_TYPE (arg1))
685 || ex_form == LSHIFT_EXPR
686 || ex_form == RSHIFT_EXPR
687 || ex_form == LROTATE_EXPR
688 || ex_form == RROTATE_EXPR))
689 || ex_form == LSHIFT_EXPR
690 /* If we have !flag_wrapv, and either ARG0 or
691 ARG1 is of a signed type, we have to do
692 PLUS_EXPR or MINUS_EXPR in an unsigned
693 type. Otherwise, we would introduce
694 signed-overflow undefinedness. */
695 || ((!TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
696 || !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1)))
697 && (ex_form == PLUS_EXPR
698 || ex_form == MINUS_EXPR)))
699 typex = unsigned_type_for (typex);
701 typex = signed_type_for (typex);
702 return convert (type,
703 fold_build2 (ex_form, typex,
704 convert (typex, arg0),
705 convert (typex, arg1)));
713 /* This is not correct for ABS_EXPR,
714 since we must test the sign before truncation. */
718 /* Don't do unsigned arithmetic where signed was wanted,
720 if (TYPE_UNSIGNED (TREE_TYPE (expr)))
721 typex = unsigned_type_for (type);
723 typex = signed_type_for (type);
724 return convert (type,
725 fold_build1 (ex_form, typex,
727 TREE_OPERAND (expr, 0))));
732 "can't convert between vector values of different size" error. */
733 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
734 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
735 != GET_MODE_SIZE (TYPE_MODE (type))))
737 /* If truncating after truncating, might as well do all at once.
738 If truncating after extending, we may get rid of wasted work. */
739 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
742 /* It is sometimes worthwhile to push the narrowing down through
743 the conditional and never loses. A COND_EXPR may have a throw
744 as one operand, which then has void type. Just leave void
745 operands as they are. */
746 return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
747 VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1)))
748 ? TREE_OPERAND (expr, 1)
749 : convert (type, TREE_OPERAND (expr, 1)),
750 VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 2)))
751 ? TREE_OPERAND (expr, 2)
752 : convert (type, TREE_OPERAND (expr, 2)));
758 return build1 (CONVERT_EXPR, type, expr);
761 return build1 (FIX_TRUNC_EXPR, type, expr);
763 case FIXED_POINT_TYPE:
764 return build1 (FIXED_CONVERT_EXPR, type, expr);
767 return convert (type,
768 fold_build1 (REALPART_EXPR,
769 TREE_TYPE (TREE_TYPE (expr)), expr));
772 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
774 error ("can't convert between vector values of different size");
775 return error_mark_node;
777 return build1 (VIEW_CONVERT_EXPR, type, expr);
780 error ("aggregate value used where an integer was expected");
781 return convert (type, integer_zero_node);
785 /* Convert EXPR to the complex type TYPE in the usual ways. */
788 convert_to_complex (tree type, tree expr)
790 tree subtype = TREE_TYPE (type);
792 switch (TREE_CODE (TREE_TYPE (expr)))
795 case FIXED_POINT_TYPE:
799 return build2 (COMPLEX_EXPR, type, convert (subtype, expr),
800 convert (subtype, integer_zero_node));
804 tree elt_type = TREE_TYPE (TREE_TYPE (expr));
806 if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
808 else if (TREE_CODE (expr) == COMPLEX_EXPR)
809 return fold_build2 (COMPLEX_EXPR, type,
810 convert (subtype, TREE_OPERAND (expr, 0)),
811 convert (subtype, TREE_OPERAND (expr, 1)));
814 expr = save_expr (expr);
816 fold_build2 (COMPLEX_EXPR, type,
818 fold_build1 (REALPART_EXPR,
819 TREE_TYPE (TREE_TYPE (expr)),
822 fold_build1 (IMAGPART_EXPR,
823 TREE_TYPE (TREE_TYPE (expr)),
830 error ("pointer value used where a complex was expected");
831 return convert_to_complex (type, integer_zero_node);
834 error ("aggregate value used where a complex was expected");
835 return convert_to_complex (type, integer_zero_node);
839 /* Convert EXPR to the vector type TYPE in the usual ways. */
842 convert_to_vector (tree type, tree expr)
844 switch (TREE_CODE (TREE_TYPE (expr)))
848 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
850 error ("can't convert between vector values of different size");
851 return error_mark_node;
853 return build1 (VIEW_CONVERT_EXPR, type, expr);
856 error ("can't convert value to a vector");
857 return error_mark_node;
861 /* Convert EXPR to some fixed-point type TYPE.
863 EXPR must be fixed-point, float, integer, or enumeral;
864 in other cases error is called. */
867 convert_to_fixed (tree type, tree expr)
869 if (integer_zerop (expr))
871 tree fixed_zero_node = build_fixed (type, FCONST0 (TYPE_MODE (type)));
872 return fixed_zero_node;
874 else if (integer_onep (expr) && ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)))
876 tree fixed_one_node = build_fixed (type, FCONST1 (TYPE_MODE (type)));
877 return fixed_one_node;
880 switch (TREE_CODE (TREE_TYPE (expr)))
882 case FIXED_POINT_TYPE:
887 return build1 (FIXED_CONVERT_EXPR, type, expr);
890 return convert (type,
891 fold_build1 (REALPART_EXPR,
892 TREE_TYPE (TREE_TYPE (expr)), expr));
895 error ("aggregate value used where a fixed-point was expected");
896 return error_mark_node;