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
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 2, 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 COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 /* These routines are somewhat language-independent utility function
25 intended to be called by the language-specific convert () functions. */
29 #include "coretypes.h"
35 #include "langhooks.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
)
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 (TREE_CODE (exp
) != NOP_EXPR
102 && TREE_CODE (exp
) != CONVERT_EXPR
)
105 sub
= TREE_OPERAND (exp
, 0);
106 subt
= TREE_TYPE (sub
);
107 expt
= TREE_TYPE (exp
);
109 if (!FLOAT_TYPE_P (subt
))
112 if (TYPE_PRECISION (subt
) > TYPE_PRECISION (expt
))
115 return strip_float_extensions (sub
);
119 /* Convert EXPR to some floating-point type TYPE.
121 EXPR must be float, integer, or enumeral;
122 in other cases error is called. */
125 convert_to_real (tree type
, tree expr
)
127 enum built_in_function fcode
= builtin_mathfn_code (expr
);
128 tree itype
= TREE_TYPE (expr
);
130 /* Disable until we figure out how to decide whether the functions are
131 present in runtime. */
132 /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
134 && (TYPE_MODE (type
) == TYPE_MODE (double_type_node
)
135 || TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))
139 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
176 tree arg0
= strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr
, 1)));
179 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
180 the both as the safe type for operation. */
181 if (TYPE_PRECISION (TREE_TYPE (arg0
)) > TYPE_PRECISION (type
))
182 newtype
= TREE_TYPE (arg0
);
184 /* Be careful about integer to fp conversions.
185 These may overflow still. */
186 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
187 && TYPE_PRECISION (newtype
) < TYPE_PRECISION (itype
)
188 && (TYPE_MODE (newtype
) == TYPE_MODE (double_type_node
)
189 || TYPE_MODE (newtype
) == TYPE_MODE (float_type_node
)))
192 tree fn
= mathfn_built_in (newtype
, fcode
);
196 arglist
= build_tree_list (NULL_TREE
, fold (convert_to_real (newtype
, arg0
)));
197 expr
= build_function_call_expr (fn
, arglist
);
208 && (((fcode
== BUILT_IN_FLOORL
209 || fcode
== BUILT_IN_CEILL
210 || fcode
== BUILT_IN_ROUNDL
211 || fcode
== BUILT_IN_RINTL
212 || fcode
== BUILT_IN_TRUNCL
213 || fcode
== BUILT_IN_NEARBYINTL
)
214 && (TYPE_MODE (type
) == TYPE_MODE (double_type_node
)
215 || TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))
216 || ((fcode
== BUILT_IN_FLOOR
217 || fcode
== BUILT_IN_CEIL
218 || fcode
== BUILT_IN_ROUND
219 || fcode
== BUILT_IN_RINT
220 || fcode
== BUILT_IN_TRUNC
221 || fcode
== BUILT_IN_NEARBYINT
)
222 && (TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))))
224 tree fn
= mathfn_built_in (type
, fcode
);
229 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr
, 1)));
231 /* Make sure (type)arg0 is an extension, otherwise we could end up
232 changing (float)floor(double d) into floorf((float)d), which is
233 incorrect because (float)d uses round-to-nearest and can round
234 up to the next integer. */
235 if (TYPE_PRECISION (type
) >= TYPE_PRECISION (TREE_TYPE (arg
)))
237 build_function_call_expr (fn
,
238 build_tree_list (NULL_TREE
,
239 fold (convert_to_real (type
, arg
))));
243 /* Propagate the cast into the operation. */
244 if (itype
!= type
&& FLOAT_TYPE_P (type
))
245 switch (TREE_CODE (expr
))
247 /* Convert (float)-x into -(float)x. This is safe for
248 round-to-nearest rounding mode. */
251 if (!flag_rounding_math
252 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (expr
)))
253 return build1 (TREE_CODE (expr
), type
,
254 fold (convert_to_real (type
,
255 TREE_OPERAND (expr
, 0))));
257 /* Convert (outertype)((innertype0)a+(innertype1)b)
258 into ((newtype)a+(newtype)b) where newtype
259 is the widest mode from all of these. */
265 tree arg0
= strip_float_extensions (TREE_OPERAND (expr
, 0));
266 tree arg1
= strip_float_extensions (TREE_OPERAND (expr
, 1));
268 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
269 && FLOAT_TYPE_P (TREE_TYPE (arg1
)))
273 if (TYPE_MODE (TREE_TYPE (arg0
)) == SDmode
274 || TYPE_MODE (TREE_TYPE (arg1
)) == SDmode
)
275 newtype
= dfloat32_type_node
;
276 if (TYPE_MODE (TREE_TYPE (arg0
)) == DDmode
277 || TYPE_MODE (TREE_TYPE (arg1
)) == DDmode
)
278 newtype
= dfloat64_type_node
;
279 if (TYPE_MODE (TREE_TYPE (arg0
)) == TDmode
280 || TYPE_MODE (TREE_TYPE (arg1
)) == TDmode
)
281 newtype
= dfloat128_type_node
;
282 if (newtype
== dfloat32_type_node
283 || newtype
== dfloat64_type_node
284 || newtype
== dfloat128_type_node
)
286 expr
= build2 (TREE_CODE (expr
), newtype
,
287 fold (convert_to_real (newtype
, arg0
)),
288 fold (convert_to_real (newtype
, arg1
)));
294 if (TYPE_PRECISION (TREE_TYPE (arg0
)) > TYPE_PRECISION (newtype
))
295 newtype
= TREE_TYPE (arg0
);
296 if (TYPE_PRECISION (TREE_TYPE (arg1
)) > TYPE_PRECISION (newtype
))
297 newtype
= TREE_TYPE (arg1
);
298 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (itype
))
300 expr
= build2 (TREE_CODE (expr
), newtype
,
301 fold (convert_to_real (newtype
, arg0
)),
302 fold (convert_to_real (newtype
, arg1
)));
313 switch (TREE_CODE (TREE_TYPE (expr
)))
316 /* Ignore the conversion if we don't need to store intermediate
317 results and neither type is a decimal float. */
318 return build1 ((flag_float_store
319 || DECIMAL_FLOAT_TYPE_P (type
)
320 || DECIMAL_FLOAT_TYPE_P (itype
))
321 ? CONVERT_EXPR
: NOP_EXPR
, type
, expr
);
326 return build1 (FLOAT_EXPR
, type
, expr
);
329 return convert (type
,
330 fold_build1 (REALPART_EXPR
,
331 TREE_TYPE (TREE_TYPE (expr
)), expr
));
335 error ("pointer value used where a floating point value was expected");
336 return convert_to_real (type
, integer_zero_node
);
339 error ("aggregate value used where a float was expected");
340 return convert_to_real (type
, integer_zero_node
);
344 /* Convert EXPR to some integer (or enum) type TYPE.
346 EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
347 vector; in other cases error is called.
349 The result of this is always supposed to be a newly created tree node
350 not in use in any existing structure. */
353 convert_to_integer (tree type
, tree expr
)
355 enum tree_code ex_form
= TREE_CODE (expr
);
356 tree intype
= TREE_TYPE (expr
);
357 unsigned int inprec
= TYPE_PRECISION (intype
);
358 unsigned int outprec
= TYPE_PRECISION (type
);
360 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
361 be. Consider `enum E = { a, b = (enum E) 3 };'. */
362 if (!COMPLETE_TYPE_P (type
))
364 error ("conversion to incomplete type");
365 return error_mark_node
;
368 /* Convert e.g. (long)round(d) -> lround(d). */
369 /* If we're converting to char, we may encounter differing behavior
370 between converting from double->char vs double->long->char.
371 We're in "undefined" territory but we prefer to be conservative,
372 so only proceed in "unsafe" math mode. */
374 && (flag_unsafe_math_optimizations
375 || (long_integer_type_node
376 && outprec
>= TYPE_PRECISION (long_integer_type_node
))))
378 tree s_expr
= strip_float_extensions (expr
);
379 tree s_intype
= TREE_TYPE (s_expr
);
380 const enum built_in_function fcode
= builtin_mathfn_code (s_expr
);
385 CASE_FLT_FN (BUILT_IN_CEIL
):
386 /* Only convert in ISO C99 mode. */
387 if (!TARGET_C99_FUNCTIONS
)
389 if (outprec
< TYPE_PRECISION (long_integer_type_node
)
390 || (outprec
== TYPE_PRECISION (long_integer_type_node
)
391 && !TYPE_UNSIGNED (type
)))
392 fn
= mathfn_built_in (s_intype
, BUILT_IN_LCEIL
);
393 else if (outprec
== TYPE_PRECISION (long_long_integer_type_node
)
394 && !TYPE_UNSIGNED (type
))
395 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLCEIL
);
398 CASE_FLT_FN (BUILT_IN_FLOOR
):
399 /* Only convert in ISO C99 mode. */
400 if (!TARGET_C99_FUNCTIONS
)
402 if (outprec
< TYPE_PRECISION (long_integer_type_node
)
403 || (outprec
== TYPE_PRECISION (long_integer_type_node
)
404 && !TYPE_UNSIGNED (type
)))
405 fn
= mathfn_built_in (s_intype
, BUILT_IN_LFLOOR
);
406 else if (outprec
== TYPE_PRECISION (long_long_integer_type_node
)
407 && !TYPE_UNSIGNED (type
))
408 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLFLOOR
);
411 CASE_FLT_FN (BUILT_IN_ROUND
):
412 if (outprec
< TYPE_PRECISION (long_integer_type_node
)
413 || (outprec
== TYPE_PRECISION (long_integer_type_node
)
414 && !TYPE_UNSIGNED (type
)))
415 fn
= mathfn_built_in (s_intype
, BUILT_IN_LROUND
);
416 else if (outprec
== TYPE_PRECISION (long_long_integer_type_node
)
417 && !TYPE_UNSIGNED (type
))
418 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLROUND
);
421 CASE_FLT_FN (BUILT_IN_RINT
):
422 /* Only convert rint* if we can ignore math exceptions. */
423 if (flag_trapping_math
)
425 /* ... Fall through ... */
426 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
427 if (outprec
< TYPE_PRECISION (long_integer_type_node
)
428 || (outprec
== TYPE_PRECISION (long_integer_type_node
)
429 && !TYPE_UNSIGNED (type
)))
430 fn
= mathfn_built_in (s_intype
, BUILT_IN_LRINT
);
431 else if (outprec
== TYPE_PRECISION (long_long_integer_type_node
)
432 && !TYPE_UNSIGNED (type
))
433 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLRINT
);
436 CASE_FLT_FN (BUILT_IN_TRUNC
):
438 tree arglist
= TREE_OPERAND (s_expr
, 1);
439 return convert_to_integer (type
, TREE_VALUE (arglist
));
448 tree arglist
= TREE_OPERAND (s_expr
, 1);
449 tree newexpr
= build_function_call_expr (fn
, arglist
);
450 return convert_to_integer (type
, newexpr
);
454 switch (TREE_CODE (intype
))
458 if (integer_zerop (expr
))
459 return build_int_cst (type
, 0);
461 /* Convert to an unsigned integer of the correct width first,
462 and from there widen/truncate to the required type. */
463 expr
= fold_build1 (CONVERT_EXPR
,
464 lang_hooks
.types
.type_for_size (POINTER_SIZE
, 0),
466 return fold_convert (type
, expr
);
471 /* If this is a logical operation, which just returns 0 or 1, we can
472 change the type of the expression. */
474 if (TREE_CODE_CLASS (ex_form
) == tcc_comparison
)
476 expr
= copy_node (expr
);
477 TREE_TYPE (expr
) = type
;
481 /* If we are widening the type, put in an explicit conversion.
482 Similarly if we are not changing the width. After this, we know
483 we are truncating EXPR. */
485 else if (outprec
>= inprec
)
490 /* If the precision of the EXPR's type is K bits and the
491 destination mode has more bits, and the sign is changing,
492 it is not safe to use a NOP_EXPR. For example, suppose
493 that EXPR's type is a 3-bit unsigned integer type, the
494 TYPE is a 3-bit signed integer type, and the machine mode
495 for the types is 8-bit QImode. In that case, the
496 conversion necessitates an explicit sign-extension. In
497 the signed-to-unsigned case the high-order bits have to
499 if (TYPE_UNSIGNED (type
) != TYPE_UNSIGNED (TREE_TYPE (expr
))
500 && (TYPE_PRECISION (TREE_TYPE (expr
))
501 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)))))
506 tem
= fold_unary (code
, type
, expr
);
510 tem
= build1 (code
, type
, expr
);
511 TREE_NO_WARNING (tem
) = 1;
515 /* If TYPE is an enumeral type or a type with a precision less
516 than the number of bits in its mode, do the conversion to the
517 type corresponding to its mode, then do a nop conversion
519 else if (TREE_CODE (type
) == ENUMERAL_TYPE
520 || outprec
!= GET_MODE_BITSIZE (TYPE_MODE (type
)))
521 return build1 (NOP_EXPR
, type
,
522 convert (lang_hooks
.types
.type_for_mode
523 (TYPE_MODE (type
), TYPE_UNSIGNED (type
)),
526 /* Here detect when we can distribute the truncation down past some
527 arithmetic. For example, if adding two longs and converting to an
528 int, we can equally well convert both to ints and then add.
529 For the operations handled here, such truncation distribution
531 It is desirable in these cases:
532 1) when truncating down to full-word from a larger size
533 2) when truncating takes no work.
534 3) when at least one operand of the arithmetic has been extended
535 (as by C's default conversions). In this case we need two conversions
536 if we do the arithmetic as already requested, so we might as well
537 truncate both and then combine. Perhaps that way we need only one.
539 Note that in general we cannot do the arithmetic in a type
540 shorter than the desired result of conversion, even if the operands
541 are both extended from a shorter type, because they might overflow
542 if combined in that type. The exceptions to this--the times when
543 two narrow values can be combined in their narrow type even to
544 make a wider result--are handled by "shorten" in build_binary_op. */
549 /* We can pass truncation down through right shifting
550 when the shift count is a nonpositive constant. */
551 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
552 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) <= 0)
557 /* We can pass truncation down through left shifting
558 when the shift count is a nonnegative constant and
559 the target type is unsigned. */
560 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
561 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) >= 0
562 && TYPE_UNSIGNED (type
)
563 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
565 /* If shift count is less than the width of the truncated type,
567 if (tree_int_cst_lt (TREE_OPERAND (expr
, 1), TYPE_SIZE (type
)))
568 /* In this case, shifting is like multiplication. */
572 /* If it is >= that width, result is zero.
573 Handling this with trunc1 would give the wrong result:
574 (int) ((long long) a << 32) is well defined (as 0)
575 but (int) a << 32 is undefined and would get a
578 tree t
= build_int_cst (type
, 0);
580 /* If the original expression had side-effects, we must
582 if (TREE_SIDE_EFFECTS (expr
))
583 return build2 (COMPOUND_EXPR
, type
, expr
, t
);
594 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
595 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
597 /* Don't distribute unless the output precision is at least as big
598 as the actual inputs. Otherwise, the comparison of the
599 truncated values will be wrong. */
600 if (outprec
>= TYPE_PRECISION (TREE_TYPE (arg0
))
601 && outprec
>= TYPE_PRECISION (TREE_TYPE (arg1
))
602 /* If signedness of arg0 and arg1 don't match,
603 we can't necessarily find a type to compare them in. */
604 && (TYPE_UNSIGNED (TREE_TYPE (arg0
))
605 == TYPE_UNSIGNED (TREE_TYPE (arg1
))))
617 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
618 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
620 if (outprec
>= BITS_PER_WORD
621 || TRULY_NOOP_TRUNCATION (outprec
, inprec
)
622 || inprec
> TYPE_PRECISION (TREE_TYPE (arg0
))
623 || inprec
> TYPE_PRECISION (TREE_TYPE (arg1
)))
625 /* Do the arithmetic in type TYPEX,
626 then convert result to TYPE. */
629 /* Can't do arithmetic in enumeral types
630 so use an integer type that will hold the values. */
631 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
632 typex
= lang_hooks
.types
.type_for_size
633 (TYPE_PRECISION (typex
), TYPE_UNSIGNED (typex
));
635 /* But now perhaps TYPEX is as wide as INPREC.
636 In that case, do nothing special here.
637 (Otherwise would recurse infinitely in convert. */
638 if (TYPE_PRECISION (typex
) != inprec
)
640 /* Don't do unsigned arithmetic where signed was wanted,
642 Exception: if both of the original operands were
643 unsigned then we can safely do the work as unsigned.
644 Exception: shift operations take their type solely
645 from the first argument.
646 Exception: the LSHIFT_EXPR case above requires that
647 we perform this operation unsigned lest we produce
648 signed-overflow undefinedness.
649 And we may need to do it as unsigned
650 if we truncate to the original size. */
651 if (TYPE_UNSIGNED (TREE_TYPE (expr
))
652 || (TYPE_UNSIGNED (TREE_TYPE (arg0
))
653 && (TYPE_UNSIGNED (TREE_TYPE (arg1
))
654 || ex_form
== LSHIFT_EXPR
655 || ex_form
== RSHIFT_EXPR
656 || ex_form
== LROTATE_EXPR
657 || ex_form
== RROTATE_EXPR
))
658 || ex_form
== LSHIFT_EXPR
659 /* If we have !flag_wrapv, and either ARG0 or
660 ARG1 is of a signed type, we have to do
661 PLUS_EXPR or MINUS_EXPR in an unsigned
662 type. Otherwise, we would introduce
663 signed-overflow undefinedness. */
664 || ((!TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
665 || !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1
)))
666 && (ex_form
== PLUS_EXPR
667 || ex_form
== MINUS_EXPR
)))
668 typex
= lang_hooks
.types
.unsigned_type (typex
);
670 typex
= lang_hooks
.types
.signed_type (typex
);
671 return convert (type
,
672 fold_build2 (ex_form
, typex
,
673 convert (typex
, arg0
),
674 convert (typex
, arg1
)));
682 /* This is not correct for ABS_EXPR,
683 since we must test the sign before truncation. */
687 /* Don't do unsigned arithmetic where signed was wanted,
689 if (TYPE_UNSIGNED (TREE_TYPE (expr
)))
690 typex
= lang_hooks
.types
.unsigned_type (type
);
692 typex
= lang_hooks
.types
.signed_type (type
);
693 return convert (type
,
694 fold_build1 (ex_form
, typex
,
696 TREE_OPERAND (expr
, 0))));
701 "can't convert between vector values of different size" error. */
702 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == VECTOR_TYPE
703 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0))))
704 != GET_MODE_SIZE (TYPE_MODE (type
))))
706 /* If truncating after truncating, might as well do all at once.
707 If truncating after extending, we may get rid of wasted work. */
708 return convert (type
, get_unwidened (TREE_OPERAND (expr
, 0), type
));
711 /* It is sometimes worthwhile to push the narrowing down through
712 the conditional and never loses. */
713 return fold_build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0),
714 convert (type
, TREE_OPERAND (expr
, 1)),
715 convert (type
, TREE_OPERAND (expr
, 2)));
721 return build1 (CONVERT_EXPR
, type
, expr
);
724 return build1 (FIX_TRUNC_EXPR
, type
, expr
);
727 return convert (type
,
728 fold_build1 (REALPART_EXPR
,
729 TREE_TYPE (TREE_TYPE (expr
)), expr
));
732 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
734 error ("can't convert between vector values of different size");
735 return error_mark_node
;
737 return build1 (VIEW_CONVERT_EXPR
, type
, expr
);
740 error ("aggregate value used where an integer was expected");
741 return convert (type
, integer_zero_node
);
745 /* Convert EXPR to the complex type TYPE in the usual ways. */
748 convert_to_complex (tree type
, tree expr
)
750 tree subtype
= TREE_TYPE (type
);
752 switch (TREE_CODE (TREE_TYPE (expr
)))
758 return build2 (COMPLEX_EXPR
, type
, convert (subtype
, expr
),
759 convert (subtype
, integer_zero_node
));
763 tree elt_type
= TREE_TYPE (TREE_TYPE (expr
));
765 if (TYPE_MAIN_VARIANT (elt_type
) == TYPE_MAIN_VARIANT (subtype
))
767 else if (TREE_CODE (expr
) == COMPLEX_EXPR
)
768 return fold_build2 (COMPLEX_EXPR
, type
,
769 convert (subtype
, TREE_OPERAND (expr
, 0)),
770 convert (subtype
, TREE_OPERAND (expr
, 1)));
773 expr
= save_expr (expr
);
775 fold_build2 (COMPLEX_EXPR
, type
,
777 fold_build1 (REALPART_EXPR
,
778 TREE_TYPE (TREE_TYPE (expr
)),
781 fold_build1 (IMAGPART_EXPR
,
782 TREE_TYPE (TREE_TYPE (expr
)),
789 error ("pointer value used where a complex was expected");
790 return convert_to_complex (type
, integer_zero_node
);
793 error ("aggregate value used where a complex was expected");
794 return convert_to_complex (type
, integer_zero_node
);
798 /* Convert EXPR to the vector type TYPE in the usual ways. */
801 convert_to_vector (tree type
, tree expr
)
803 switch (TREE_CODE (TREE_TYPE (expr
)))
807 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
809 error ("can't convert between vector values of different size");
810 return error_mark_node
;
812 return build1 (VIEW_CONVERT_EXPR
, type
, expr
);
815 error ("can't convert value to a vector");
816 return error_mark_node
;