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),
53 switch (TREE_CODE (TREE_TYPE (expr)))
57 return fold_build1 (NOP_EXPR, type, expr);
62 if (TYPE_PRECISION (TREE_TYPE (expr)) != POINTER_SIZE)
63 expr = fold_build1 (NOP_EXPR,
64 lang_hooks.types.type_for_size (POINTER_SIZE, 0),
66 return fold_build1 (CONVERT_EXPR, type, expr);
70 error ("cannot convert to a pointer type");
71 return convert_to_pointer (type, integer_zero_node);
75 /* Avoid any floating point extensions from EXP. */
77 strip_float_extensions (tree exp)
81 /* For floating point constant look up the narrowest type that can hold
82 it properly and handle it like (type)(narrowest_type)constant.
83 This way we can optimize for instance a=a*2.0 where "a" is float
84 but 2.0 is double constant. */
85 if (TREE_CODE (exp) == REAL_CST)
90 orig = TREE_REAL_CST (exp);
91 if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
92 && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
93 type = float_type_node;
94 else if (TYPE_PRECISION (TREE_TYPE (exp))
95 > TYPE_PRECISION (double_type_node)
96 && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
97 type = double_type_node;
99 return build_real (type, real_value_truncate (TYPE_MODE (type), orig));
102 if (TREE_CODE (exp) != NOP_EXPR
103 && TREE_CODE (exp) != CONVERT_EXPR)
106 sub = TREE_OPERAND (exp, 0);
107 subt = TREE_TYPE (sub);
108 expt = TREE_TYPE (exp);
110 if (!FLOAT_TYPE_P (subt))
113 if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
116 return strip_float_extensions (sub);
120 /* Convert EXPR to some floating-point type TYPE.
122 EXPR must be float, integer, or enumeral;
123 in other cases error is called. */
126 convert_to_real (tree type, tree expr)
128 enum built_in_function fcode = builtin_mathfn_code (expr);
129 tree itype = TREE_TYPE (expr);
131 /* Disable until we figure out how to decide whether the functions are
132 present in runtime. */
133 /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
135 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
136 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
140 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
177 tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
180 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
181 the both as the safe type for operation. */
182 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
183 newtype = TREE_TYPE (arg0);
185 /* Be careful about integer to fp conversions.
186 These may overflow still. */
187 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
188 && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
189 && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
190 || TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
193 tree fn = mathfn_built_in (newtype, fcode);
197 arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
198 expr = build_function_call_expr (fn, arglist);
209 && (((fcode == BUILT_IN_FLOORL
210 || fcode == BUILT_IN_CEILL
211 || fcode == BUILT_IN_ROUNDL
212 || fcode == BUILT_IN_RINTL
213 || fcode == BUILT_IN_TRUNCL
214 || fcode == BUILT_IN_NEARBYINTL)
215 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
216 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
217 || ((fcode == BUILT_IN_FLOOR
218 || fcode == BUILT_IN_CEIL
219 || fcode == BUILT_IN_ROUND
220 || fcode == BUILT_IN_RINT
221 || fcode == BUILT_IN_TRUNC
222 || fcode == BUILT_IN_NEARBYINT)
223 && (TYPE_MODE (type) == TYPE_MODE (float_type_node)))))
225 tree fn = mathfn_built_in (type, fcode);
230 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
232 /* Make sure (type)arg0 is an extension, otherwise we could end up
233 changing (float)floor(double d) into floorf((float)d), which is
234 incorrect because (float)d uses round-to-nearest and can round
235 up to the next integer. */
236 if (TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (arg)))
238 build_function_call_expr (fn,
239 build_tree_list (NULL_TREE,
240 fold (convert_to_real (type, arg))));
244 /* Propagate the cast into the operation. */
245 if (itype != type && FLOAT_TYPE_P (type))
246 switch (TREE_CODE (expr))
248 /* Convert (float)-x into -(float)x. This is safe for
249 round-to-nearest rounding mode. */
252 if (!flag_rounding_math
253 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
254 return build1 (TREE_CODE (expr), type,
255 fold (convert_to_real (type,
256 TREE_OPERAND (expr, 0))));
258 /* Convert (outertype)((innertype0)a+(innertype1)b)
259 into ((newtype)a+(newtype)b) where newtype
260 is the widest mode from all of these. */
266 tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
267 tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
269 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
270 && FLOAT_TYPE_P (TREE_TYPE (arg1)))
274 if (TYPE_MODE (TREE_TYPE (arg0)) == SDmode
275 || TYPE_MODE (TREE_TYPE (arg1)) == SDmode)
276 newtype = dfloat32_type_node;
277 if (TYPE_MODE (TREE_TYPE (arg0)) == DDmode
278 || TYPE_MODE (TREE_TYPE (arg1)) == DDmode)
279 newtype = dfloat64_type_node;
280 if (TYPE_MODE (TREE_TYPE (arg0)) == TDmode
281 || TYPE_MODE (TREE_TYPE (arg1)) == TDmode)
282 newtype = dfloat128_type_node;
283 if (newtype == dfloat32_type_node
284 || newtype == dfloat64_type_node
285 || newtype == dfloat128_type_node)
287 expr = build2 (TREE_CODE (expr), newtype,
288 fold (convert_to_real (newtype, arg0)),
289 fold (convert_to_real (newtype, arg1)));
295 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
296 newtype = TREE_TYPE (arg0);
297 if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
298 newtype = TREE_TYPE (arg1);
299 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype))
301 expr = build2 (TREE_CODE (expr), newtype,
302 fold (convert_to_real (newtype, arg0)),
303 fold (convert_to_real (newtype, arg1)));
314 switch (TREE_CODE (TREE_TYPE (expr)))
317 /* Ignore the conversion if we don't need to store intermediate
318 results and neither type is a decimal float. */
319 return build1 ((flag_float_store
320 || DECIMAL_FLOAT_TYPE_P (type)
321 || DECIMAL_FLOAT_TYPE_P (itype))
322 ? CONVERT_EXPR : NOP_EXPR, type, expr);
327 return build1 (FLOAT_EXPR, type, expr);
330 return convert (type,
331 fold_build1 (REALPART_EXPR,
332 TREE_TYPE (TREE_TYPE (expr)), expr));
336 error ("pointer value used where a floating point value was expected");
337 return convert_to_real (type, integer_zero_node);
340 error ("aggregate value used where a float was expected");
341 return convert_to_real (type, integer_zero_node);
345 /* Convert EXPR to some integer (or enum) type TYPE.
347 EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
348 vector; in other cases error is called.
350 The result of this is always supposed to be a newly created tree node
351 not in use in any existing structure. */
354 convert_to_integer (tree type, tree expr)
356 enum tree_code ex_form = TREE_CODE (expr);
357 tree intype = TREE_TYPE (expr);
358 unsigned int inprec = TYPE_PRECISION (intype);
359 unsigned int outprec = TYPE_PRECISION (type);
361 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
362 be. Consider `enum E = { a, b = (enum E) 3 };'. */
363 if (!COMPLETE_TYPE_P (type))
365 error ("conversion to incomplete type");
366 return error_mark_node;
369 /* Convert e.g. (long)round(d) -> lround(d). */
370 /* If we're converting to char, we may encounter differing behavior
371 between converting from double->char vs double->long->char.
372 We're in "undefined" territory but we prefer to be conservative,
373 so only proceed in "unsafe" math mode. */
375 && (flag_unsafe_math_optimizations
376 || (long_integer_type_node
377 && outprec >= TYPE_PRECISION (long_integer_type_node))))
379 tree s_expr = strip_float_extensions (expr);
380 tree s_intype = TREE_TYPE (s_expr);
381 const enum built_in_function fcode = builtin_mathfn_code (s_expr);
386 CASE_FLT_FN (BUILT_IN_CEIL):
387 /* Only convert in ISO C99 mode. */
388 if (!TARGET_C99_FUNCTIONS)
390 if (outprec < TYPE_PRECISION (long_integer_type_node)
391 || (outprec == TYPE_PRECISION (long_integer_type_node)
392 && !TYPE_UNSIGNED (type)))
393 fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
394 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
395 && !TYPE_UNSIGNED (type))
396 fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL);
399 CASE_FLT_FN (BUILT_IN_FLOOR):
400 /* Only convert in ISO C99 mode. */
401 if (!TARGET_C99_FUNCTIONS)
403 if (outprec < TYPE_PRECISION (long_integer_type_node)
404 || (outprec == TYPE_PRECISION (long_integer_type_node)
405 && !TYPE_UNSIGNED (type)))
406 fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
407 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
408 && !TYPE_UNSIGNED (type))
409 fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR);
412 CASE_FLT_FN (BUILT_IN_ROUND):
413 if (outprec < TYPE_PRECISION (long_integer_type_node)
414 || (outprec == TYPE_PRECISION (long_integer_type_node)
415 && !TYPE_UNSIGNED (type)))
416 fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
417 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
418 && !TYPE_UNSIGNED (type))
419 fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
422 CASE_FLT_FN (BUILT_IN_RINT):
423 /* Only convert rint* if we can ignore math exceptions. */
424 if (flag_trapping_math)
426 /* ... Fall through ... */
427 CASE_FLT_FN (BUILT_IN_NEARBYINT):
428 if (outprec < TYPE_PRECISION (long_integer_type_node)
429 || (outprec == TYPE_PRECISION (long_integer_type_node)
430 && !TYPE_UNSIGNED (type)))
431 fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
432 else if (outprec == TYPE_PRECISION (long_long_integer_type_node)
433 && !TYPE_UNSIGNED (type))
434 fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT);
437 CASE_FLT_FN (BUILT_IN_TRUNC):
439 tree arglist = TREE_OPERAND (s_expr, 1);
440 return convert_to_integer (type, TREE_VALUE (arglist));
449 tree arglist = TREE_OPERAND (s_expr, 1);
450 tree newexpr = build_function_call_expr (fn, arglist);
451 return convert_to_integer (type, newexpr);
455 switch (TREE_CODE (intype))
459 if (integer_zerop (expr))
460 return build_int_cst (type, 0);
462 /* Convert to an unsigned integer of the correct width first,
463 and from there widen/truncate to the required type. */
464 expr = fold_build1 (CONVERT_EXPR,
465 lang_hooks.types.type_for_size (POINTER_SIZE, 0),
467 return fold_convert (type, expr);
472 /* If this is a logical operation, which just returns 0 or 1, we can
473 change the type of the expression. */
475 if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
477 expr = copy_node (expr);
478 TREE_TYPE (expr) = type;
482 /* If we are widening the type, put in an explicit conversion.
483 Similarly if we are not changing the width. After this, we know
484 we are truncating EXPR. */
486 else if (outprec >= inprec)
491 /* If the precision of the EXPR's type is K bits and the
492 destination mode has more bits, and the sign is changing,
493 it is not safe to use a NOP_EXPR. For example, suppose
494 that EXPR's type is a 3-bit unsigned integer type, the
495 TYPE is a 3-bit signed integer type, and the machine mode
496 for the types is 8-bit QImode. In that case, the
497 conversion necessitates an explicit sign-extension. In
498 the signed-to-unsigned case the high-order bits have to
500 if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
501 && (TYPE_PRECISION (TREE_TYPE (expr))
502 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
507 tem = fold_unary (code, type, expr);
511 tem = build1 (code, type, expr);
512 TREE_NO_WARNING (tem) = 1;
516 /* If TYPE is an enumeral type or a type with a precision less
517 than the number of bits in its mode, do the conversion to the
518 type corresponding to its mode, then do a nop conversion
520 else if (TREE_CODE (type) == ENUMERAL_TYPE
521 || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
522 return build1 (NOP_EXPR, type,
523 convert (lang_hooks.types.type_for_mode
524 (TYPE_MODE (type), TYPE_UNSIGNED (type)),
527 /* Here detect when we can distribute the truncation down past some
528 arithmetic. For example, if adding two longs and converting to an
529 int, we can equally well convert both to ints and then add.
530 For the operations handled here, such truncation distribution
532 It is desirable in these cases:
533 1) when truncating down to full-word from a larger size
534 2) when truncating takes no work.
535 3) when at least one operand of the arithmetic has been extended
536 (as by C's default conversions). In this case we need two conversions
537 if we do the arithmetic as already requested, so we might as well
538 truncate both and then combine. Perhaps that way we need only one.
540 Note that in general we cannot do the arithmetic in a type
541 shorter than the desired result of conversion, even if the operands
542 are both extended from a shorter type, because they might overflow
543 if combined in that type. The exceptions to this--the times when
544 two narrow values can be combined in their narrow type even to
545 make a wider result--are handled by "shorten" in build_binary_op. */
550 /* We can pass truncation down through right shifting
551 when the shift count is a nonpositive constant. */
552 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
553 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) <= 0)
558 /* We can pass truncation down through left shifting
559 when the shift count is a nonnegative constant and
560 the target type is unsigned. */
561 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
562 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
563 && TYPE_UNSIGNED (type)
564 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
566 /* If shift count is less than the width of the truncated type,
568 if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
569 /* In this case, shifting is like multiplication. */
573 /* If it is >= that width, result is zero.
574 Handling this with trunc1 would give the wrong result:
575 (int) ((long long) a << 32) is well defined (as 0)
576 but (int) a << 32 is undefined and would get a
579 tree t = build_int_cst (type, 0);
581 /* If the original expression had side-effects, we must
583 if (TREE_SIDE_EFFECTS (expr))
584 return build2 (COMPOUND_EXPR, type, expr, t);
595 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
596 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
598 /* Don't distribute unless the output precision is at least as big
599 as the actual inputs. Otherwise, the comparison of the
600 truncated values will be wrong. */
601 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
602 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
603 /* If signedness of arg0 and arg1 don't match,
604 we can't necessarily find a type to compare them in. */
605 && (TYPE_UNSIGNED (TREE_TYPE (arg0))
606 == TYPE_UNSIGNED (TREE_TYPE (arg1))))
618 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
619 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
621 if (outprec >= BITS_PER_WORD
622 || TRULY_NOOP_TRUNCATION (outprec, inprec)
623 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
624 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
626 /* Do the arithmetic in type TYPEX,
627 then convert result to TYPE. */
630 /* Can't do arithmetic in enumeral types
631 so use an integer type that will hold the values. */
632 if (TREE_CODE (typex) == ENUMERAL_TYPE)
633 typex = lang_hooks.types.type_for_size
634 (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
636 /* But now perhaps TYPEX is as wide as INPREC.
637 In that case, do nothing special here.
638 (Otherwise would recurse infinitely in convert. */
639 if (TYPE_PRECISION (typex) != inprec)
641 /* Don't do unsigned arithmetic where signed was wanted,
643 Exception: if both of the original operands were
644 unsigned then we can safely do the work as unsigned.
645 Exception: shift operations take their type solely
646 from the first argument.
647 Exception: the LSHIFT_EXPR case above requires that
648 we perform this operation unsigned lest we produce
649 signed-overflow undefinedness.
650 And we may need to do it as unsigned
651 if we truncate to the original size. */
652 if (TYPE_UNSIGNED (TREE_TYPE (expr))
653 || (TYPE_UNSIGNED (TREE_TYPE (arg0))
654 && (TYPE_UNSIGNED (TREE_TYPE (arg1))
655 || ex_form == LSHIFT_EXPR
656 || ex_form == RSHIFT_EXPR
657 || ex_form == LROTATE_EXPR
658 || ex_form == RROTATE_EXPR))
659 || ex_form == LSHIFT_EXPR
660 /* If we have !flag_wrapv, and either ARG0 or
661 ARG1 is of a signed type, we have to do
662 PLUS_EXPR or MINUS_EXPR in an unsigned
663 type. Otherwise, we would introduce
664 signed-overflow undefinedness. */
666 && (ex_form == PLUS_EXPR
667 || ex_form == MINUS_EXPR)
668 && (!TYPE_UNSIGNED (TREE_TYPE (arg0))
669 || !TYPE_UNSIGNED (TREE_TYPE (arg1)))))
670 typex = lang_hooks.types.unsigned_type (typex);
672 typex = lang_hooks.types.signed_type (typex);
673 return convert (type,
674 fold_build2 (ex_form, typex,
675 convert (typex, arg0),
676 convert (typex, arg1)));
684 /* This is not correct for ABS_EXPR,
685 since we must test the sign before truncation. */
689 /* Don't do unsigned arithmetic where signed was wanted,
691 if (TYPE_UNSIGNED (TREE_TYPE (expr)))
692 typex = lang_hooks.types.unsigned_type (type);
694 typex = lang_hooks.types.signed_type (type);
695 return convert (type,
696 fold_build1 (ex_form, typex,
698 TREE_OPERAND (expr, 0))));
703 "can't convert between vector values of different size" error. */
704 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
705 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
706 != GET_MODE_SIZE (TYPE_MODE (type))))
708 /* If truncating after truncating, might as well do all at once.
709 If truncating after extending, we may get rid of wasted work. */
710 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
713 /* It is sometimes worthwhile to push the narrowing down through
714 the conditional and never loses. */
715 return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
716 convert (type, TREE_OPERAND (expr, 1)),
717 convert (type, TREE_OPERAND (expr, 2)));
723 return build1 (CONVERT_EXPR, type, expr);
726 return build1 (FIX_TRUNC_EXPR, type, expr);
729 return convert (type,
730 fold_build1 (REALPART_EXPR,
731 TREE_TYPE (TREE_TYPE (expr)), expr));
734 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
736 error ("can't convert between vector values of different size");
737 return error_mark_node;
739 return build1 (VIEW_CONVERT_EXPR, type, expr);
742 error ("aggregate value used where an integer was expected");
743 return convert (type, integer_zero_node);
747 /* Convert EXPR to the complex type TYPE in the usual ways. */
750 convert_to_complex (tree type, tree expr)
752 tree subtype = TREE_TYPE (type);
754 switch (TREE_CODE (TREE_TYPE (expr)))
760 return build2 (COMPLEX_EXPR, type, convert (subtype, expr),
761 convert (subtype, integer_zero_node));
765 tree elt_type = TREE_TYPE (TREE_TYPE (expr));
767 if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
769 else if (TREE_CODE (expr) == COMPLEX_EXPR)
770 return fold_build2 (COMPLEX_EXPR, type,
771 convert (subtype, TREE_OPERAND (expr, 0)),
772 convert (subtype, TREE_OPERAND (expr, 1)));
775 expr = save_expr (expr);
777 fold_build2 (COMPLEX_EXPR, type,
779 fold_build1 (REALPART_EXPR,
780 TREE_TYPE (TREE_TYPE (expr)),
783 fold_build1 (IMAGPART_EXPR,
784 TREE_TYPE (TREE_TYPE (expr)),
791 error ("pointer value used where a complex was expected");
792 return convert_to_complex (type, integer_zero_node);
795 error ("aggregate value used where a complex was expected");
796 return convert_to_complex (type, integer_zero_node);
800 /* Convert EXPR to the vector type TYPE in the usual ways. */
803 convert_to_vector (tree type, tree expr)
805 switch (TREE_CODE (TREE_TYPE (expr)))
809 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
811 error ("can't convert between vector values of different size");
812 return error_mark_node;
814 return build1 (VIEW_CONVERT_EXPR, type, expr);
817 error ("can't convert value to a vector");
818 return error_mark_node;