Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly
[dragonfly.git] / contrib / gcc-3.4 / gcc / convert.c
CommitLineData
003757ed
MD
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 Free Software Foundation, Inc.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, USA. */
21
22
23/* These routines are somewhat language-independent utility function
24 intended to be called by the language-specific convert () functions. */
25
26#include "config.h"
27#include "system.h"
28#include "coretypes.h"
29#include "tm.h"
30#include "tree.h"
31#include "flags.h"
32#include "convert.h"
33#include "toplev.h"
34#include "langhooks.h"
35#include "real.h"
36/* Convert EXPR to some pointer or reference type TYPE.
37
38 EXPR must be pointer, reference, integer, enumeral, or literal zero;
39 in other cases error is called. */
40
41tree
42convert_to_pointer (tree type, tree expr)
43{
44 if (integer_zerop (expr))
45 {
46 expr = build_int_2 (0, 0);
47 TREE_TYPE (expr) = type;
48 return expr;
49 }
50
51 switch (TREE_CODE (TREE_TYPE (expr)))
52 {
53 case POINTER_TYPE:
54 case REFERENCE_TYPE:
55 return build1 (NOP_EXPR, type, expr);
56
57 case INTEGER_TYPE:
58 case ENUMERAL_TYPE:
59 case BOOLEAN_TYPE:
60 case CHAR_TYPE:
61 if (TYPE_PRECISION (TREE_TYPE (expr)) == POINTER_SIZE)
62 return build1 (CONVERT_EXPR, type, expr);
63
64 return
65 convert_to_pointer (type,
66 convert ((*lang_hooks.types.type_for_size)
67 (POINTER_SIZE, 0), expr));
68
69 default:
70 error ("cannot convert to a pointer type");
71 return convert_to_pointer (type, integer_zero_node);
72 }
73}
74
75/* Avoid any floating point extensions from EXP. */
76tree
77strip_float_extensions (tree exp)
78{
79 tree sub, expt, subt;
80
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)
86 {
87 REAL_VALUE_TYPE orig;
88 tree type = NULL;
89
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;
98 if (type)
99 return build_real (type, real_value_truncate (TYPE_MODE (type), orig));
100 }
101
102 if (TREE_CODE (exp) != NOP_EXPR)
103 return exp;
104
105 sub = TREE_OPERAND (exp, 0);
106 subt = TREE_TYPE (sub);
107 expt = TREE_TYPE (exp);
108
109 if (!FLOAT_TYPE_P (subt))
110 return exp;
111
112 if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
113 return exp;
114
115 return strip_float_extensions (sub);
116}
117
118
119/* Convert EXPR to some floating-point type TYPE.
120
121 EXPR must be float, integer, or enumeral;
122 in other cases error is called. */
123
124tree
125convert_to_real (tree type, tree expr)
126{
127 enum built_in_function fcode = builtin_mathfn_code (expr);
128 tree itype = TREE_TYPE (expr);
129
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) */
133 if (optimize
134 && (fcode == BUILT_IN_SQRT
135 || fcode == BUILT_IN_SQRTL
136 || fcode == BUILT_IN_SIN
137 || fcode == BUILT_IN_SINL
138 || fcode == BUILT_IN_COS
139 || fcode == BUILT_IN_COSL
140 || fcode == BUILT_IN_EXP
141 || fcode == BUILT_IN_EXPL
142 || fcode == BUILT_IN_LOG
143 || fcode == BUILT_IN_LOGL)
144 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
145 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
146 {
147 tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
148 tree newtype = type;
149
150 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
151 the both as the safe type for operation. */
152 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
153 newtype = TREE_TYPE (arg0);
154
155 /* Be careful about integer to fp conversions.
156 These may overflow still. */
157 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
158 && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
159 && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
160 || TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
161 {
162 tree arglist;
163 tree fn = mathfn_built_in (newtype, fcode);
164
165 if (fn)
166 {
167 arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
168 expr = build_function_call_expr (fn, arglist);
169 if (newtype == type)
170 return expr;
171 }
172 }
173 }
174 if (optimize
175 && (((fcode == BUILT_IN_FLOORL
176 || fcode == BUILT_IN_CEILL
177 || fcode == BUILT_IN_ROUND
178 || fcode == BUILT_IN_TRUNC
179 || fcode == BUILT_IN_NEARBYINT)
180 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
181 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
182 || ((fcode == BUILT_IN_FLOOR
183 || fcode == BUILT_IN_CEIL
184 || fcode == BUILT_IN_ROUND
185 || fcode == BUILT_IN_TRUNC
186 || fcode == BUILT_IN_NEARBYINT)
187 && (TYPE_MODE (type) == TYPE_MODE (float_type_node)))))
188 {
189 tree fn = mathfn_built_in (type, fcode);
190
191 if (fn)
192 {
193 tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr,
194 1)));
195 tree arglist = build_tree_list (NULL_TREE,
196 fold (convert_to_real (type, arg0)));
197
198 return build_function_call_expr (fn, arglist);
199 }
200 }
201
202 /* Propagate the cast into the operation. */
203 if (itype != type && FLOAT_TYPE_P (type))
204 switch (TREE_CODE (expr))
205 {
206 /* Convert (float)-x into -(float)x. This is always safe. */
207 case ABS_EXPR:
208 case NEGATE_EXPR:
209 if (TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
210 return build1 (TREE_CODE (expr), type,
211 fold (convert_to_real (type,
212 TREE_OPERAND (expr, 0))));
213 break;
214 /* Convert (outertype)((innertype0)a+(innertype1)b)
215 into ((newtype)a+(newtype)b) where newtype
216 is the widest mode from all of these. */
217 case PLUS_EXPR:
218 case MINUS_EXPR:
219 case MULT_EXPR:
220 case RDIV_EXPR:
221 {
222 tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
223 tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
224
225 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
226 && FLOAT_TYPE_P (TREE_TYPE (arg1)))
227 {
228 tree newtype = type;
229 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
230 newtype = TREE_TYPE (arg0);
231 if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
232 newtype = TREE_TYPE (arg1);
233 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype))
234 {
235 expr = build (TREE_CODE (expr), newtype,
236 fold (convert_to_real (newtype, arg0)),
237 fold (convert_to_real (newtype, arg1)));
238 if (newtype == type)
239 return expr;
240 }
241 }
242 }
243 break;
244 default:
245 break;
246 }
247
248 switch (TREE_CODE (TREE_TYPE (expr)))
249 {
250 case REAL_TYPE:
251 return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
252 type, expr);
253
254 case INTEGER_TYPE:
255 case ENUMERAL_TYPE:
256 case BOOLEAN_TYPE:
257 case CHAR_TYPE:
258 return build1 (FLOAT_EXPR, type, expr);
259
260 case COMPLEX_TYPE:
261 return convert (type,
262 fold (build1 (REALPART_EXPR,
263 TREE_TYPE (TREE_TYPE (expr)), expr)));
264
265 case POINTER_TYPE:
266 case REFERENCE_TYPE:
267 error ("pointer value used where a floating point value was expected");
268 return convert_to_real (type, integer_zero_node);
269
270 default:
271 error ("aggregate value used where a float was expected");
272 return convert_to_real (type, integer_zero_node);
273 }
274}
275
276/* Convert EXPR to some integer (or enum) type TYPE.
277
278 EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
279 vector; in other cases error is called.
280
281 The result of this is always supposed to be a newly created tree node
282 not in use in any existing structure. */
283
284tree
285convert_to_integer (tree type, tree expr)
286{
287 enum tree_code ex_form = TREE_CODE (expr);
288 tree intype = TREE_TYPE (expr);
289 unsigned int inprec = TYPE_PRECISION (intype);
290 unsigned int outprec = TYPE_PRECISION (type);
291
292 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
293 be. Consider `enum E = { a, b = (enum E) 3 };'. */
294 if (!COMPLETE_TYPE_P (type))
295 {
296 error ("conversion to incomplete type");
297 return error_mark_node;
298 }
299
300 switch (TREE_CODE (intype))
301 {
302 case POINTER_TYPE:
303 case REFERENCE_TYPE:
304 if (integer_zerop (expr))
305 expr = integer_zero_node;
306 else
307 expr = fold (build1 (CONVERT_EXPR, (*lang_hooks.types.type_for_size)
308 (POINTER_SIZE, 0), expr));
309
310 return convert_to_integer (type, expr);
311
312 case INTEGER_TYPE:
313 case ENUMERAL_TYPE:
314 case BOOLEAN_TYPE:
315 case CHAR_TYPE:
316 /* If this is a logical operation, which just returns 0 or 1, we can
317 change the type of the expression. For some logical operations,
318 we must also change the types of the operands to maintain type
319 correctness. */
320
321 if (TREE_CODE_CLASS (ex_form) == '<')
322 {
323 expr = copy_node (expr);
324 TREE_TYPE (expr) = type;
325 return expr;
326 }
327
328 else if (ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
329 || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
330 || ex_form == TRUTH_XOR_EXPR)
331 {
332 expr = copy_node (expr);
333 TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
334 TREE_OPERAND (expr, 1) = convert (type, TREE_OPERAND (expr, 1));
335 TREE_TYPE (expr) = type;
336 return expr;
337 }
338
339 else if (ex_form == TRUTH_NOT_EXPR)
340 {
341 expr = copy_node (expr);
342 TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
343 TREE_TYPE (expr) = type;
344 return expr;
345 }
346
347 /* If we are widening the type, put in an explicit conversion.
348 Similarly if we are not changing the width. After this, we know
349 we are truncating EXPR. */
350
351 else if (outprec >= inprec)
352 {
353 enum tree_code code;
354
355 /* If the precision of the EXPR's type is K bits and the
356 destination mode has more bits, and the sign is changing,
357 it is not safe to use a NOP_EXPR. For example, suppose
358 that EXPR's type is a 3-bit unsigned integer type, the
359 TYPE is a 3-bit signed integer type, and the machine mode
360 for the types is 8-bit QImode. In that case, the
361 conversion necessitates an explicit sign-extension. In
362 the signed-to-unsigned case the high-order bits have to
363 be cleared. */
364 if (TREE_UNSIGNED (type) != TREE_UNSIGNED (TREE_TYPE (expr))
365 && (TYPE_PRECISION (TREE_TYPE (expr))
366 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
367 code = CONVERT_EXPR;
368 else
369 code = NOP_EXPR;
370
371 return build1 (code, type, expr);
372 }
373
374 /* If TYPE is an enumeral type or a type with a precision less
375 than the number of bits in its mode, do the conversion to the
376 type corresponding to its mode, then do a nop conversion
377 to TYPE. */
378 else if (TREE_CODE (type) == ENUMERAL_TYPE
379 || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
380 return build1 (NOP_EXPR, type,
381 convert ((*lang_hooks.types.type_for_mode)
382 (TYPE_MODE (type), TREE_UNSIGNED (type)),
383 expr));
384
385 /* Here detect when we can distribute the truncation down past some
386 arithmetic. For example, if adding two longs and converting to an
387 int, we can equally well convert both to ints and then add.
388 For the operations handled here, such truncation distribution
389 is always safe.
390 It is desirable in these cases:
391 1) when truncating down to full-word from a larger size
392 2) when truncating takes no work.
393 3) when at least one operand of the arithmetic has been extended
394 (as by C's default conversions). In this case we need two conversions
395 if we do the arithmetic as already requested, so we might as well
396 truncate both and then combine. Perhaps that way we need only one.
397
398 Note that in general we cannot do the arithmetic in a type
399 shorter than the desired result of conversion, even if the operands
400 are both extended from a shorter type, because they might overflow
401 if combined in that type. The exceptions to this--the times when
402 two narrow values can be combined in their narrow type even to
403 make a wider result--are handled by "shorten" in build_binary_op. */
404
405 switch (ex_form)
406 {
407 case RSHIFT_EXPR:
408 /* We can pass truncation down through right shifting
409 when the shift count is a nonpositive constant. */
410 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
411 && tree_int_cst_lt (TREE_OPERAND (expr, 1),
412 convert (TREE_TYPE (TREE_OPERAND (expr, 1)),
413 integer_one_node)))
414 goto trunc1;
415 break;
416
417 case LSHIFT_EXPR:
418 /* We can pass truncation down through left shifting
419 when the shift count is a nonnegative constant and
420 the target type is unsigned. */
421 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
422 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
423 && TREE_UNSIGNED (type)
424 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
425 {
426 /* If shift count is less than the width of the truncated type,
427 really shift. */
428 if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
429 /* In this case, shifting is like multiplication. */
430 goto trunc1;
431 else
432 {
433 /* If it is >= that width, result is zero.
434 Handling this with trunc1 would give the wrong result:
435 (int) ((long long) a << 32) is well defined (as 0)
436 but (int) a << 32 is undefined and would get a
437 warning. */
438
439 tree t = convert_to_integer (type, integer_zero_node);
440
441 /* If the original expression had side-effects, we must
442 preserve it. */
443 if (TREE_SIDE_EFFECTS (expr))
444 return build (COMPOUND_EXPR, type, expr, t);
445 else
446 return t;
447 }
448 }
449 break;
450
451 case MAX_EXPR:
452 case MIN_EXPR:
453 case MULT_EXPR:
454 {
455 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
456 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
457
458 /* Don't distribute unless the output precision is at least as big
459 as the actual inputs. Otherwise, the comparison of the
460 truncated values will be wrong. */
461 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
462 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
463 /* If signedness of arg0 and arg1 don't match,
464 we can't necessarily find a type to compare them in. */
465 && (TREE_UNSIGNED (TREE_TYPE (arg0))
466 == TREE_UNSIGNED (TREE_TYPE (arg1))))
467 goto trunc1;
468 break;
469 }
470
471 case PLUS_EXPR:
472 case MINUS_EXPR:
473 case BIT_AND_EXPR:
474 case BIT_IOR_EXPR:
475 case BIT_XOR_EXPR:
476 trunc1:
477 {
478 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
479 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
480
481 if (outprec >= BITS_PER_WORD
482 || TRULY_NOOP_TRUNCATION (outprec, inprec)
483 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
484 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
485 {
486 /* Do the arithmetic in type TYPEX,
487 then convert result to TYPE. */
488 tree typex = type;
489
490 /* Can't do arithmetic in enumeral types
491 so use an integer type that will hold the values. */
492 if (TREE_CODE (typex) == ENUMERAL_TYPE)
493 typex = (*lang_hooks.types.type_for_size)
494 (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
495
496 /* But now perhaps TYPEX is as wide as INPREC.
497 In that case, do nothing special here.
498 (Otherwise would recurse infinitely in convert. */
499 if (TYPE_PRECISION (typex) != inprec)
500 {
501 /* Don't do unsigned arithmetic where signed was wanted,
502 or vice versa.
503 Exception: if both of the original operands were
504 unsigned then we can safely do the work as unsigned.
505 Exception: shift operations take their type solely
506 from the first argument.
507 Exception: the LSHIFT_EXPR case above requires that
508 we perform this operation unsigned lest we produce
509 signed-overflow undefinedness.
510 And we may need to do it as unsigned
511 if we truncate to the original size. */
512 if (TREE_UNSIGNED (TREE_TYPE (expr))
513 || (TREE_UNSIGNED (TREE_TYPE (arg0))
514 && (TREE_UNSIGNED (TREE_TYPE (arg1))
515 || ex_form == LSHIFT_EXPR
516 || ex_form == RSHIFT_EXPR
517 || ex_form == LROTATE_EXPR
518 || ex_form == RROTATE_EXPR))
519 || ex_form == LSHIFT_EXPR)
520 typex = (*lang_hooks.types.unsigned_type) (typex);
521 else
522 typex = (*lang_hooks.types.signed_type) (typex);
523 return convert (type,
524 fold (build (ex_form, typex,
525 convert (typex, arg0),
526 convert (typex, arg1),
527 0)));
528 }
529 }
530 }
531 break;
532
533 case NEGATE_EXPR:
534 case BIT_NOT_EXPR:
535 /* This is not correct for ABS_EXPR,
536 since we must test the sign before truncation. */
537 {
538 tree typex = type;
539
540 /* Can't do arithmetic in enumeral types
541 so use an integer type that will hold the values. */
542 if (TREE_CODE (typex) == ENUMERAL_TYPE)
543 typex = (*lang_hooks.types.type_for_size)
544 (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
545
546 /* But now perhaps TYPEX is as wide as INPREC.
547 In that case, do nothing special here.
548 (Otherwise would recurse infinitely in convert. */
549 if (TYPE_PRECISION (typex) != inprec)
550 {
551 /* Don't do unsigned arithmetic where signed was wanted,
552 or vice versa. */
553 if (TREE_UNSIGNED (TREE_TYPE (expr)))
554 typex = (*lang_hooks.types.unsigned_type) (typex);
555 else
556 typex = (*lang_hooks.types.signed_type) (typex);
557 return convert (type,
558 fold (build1 (ex_form, typex,
559 convert (typex,
560 TREE_OPERAND (expr, 0)))));
561 }
562 }
563
564 case NOP_EXPR:
565 /* Don't introduce a
566 "can't convert between vector values of different size" error. */
567 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
568 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
569 != GET_MODE_SIZE (TYPE_MODE (type))))
570 break;
571 /* If truncating after truncating, might as well do all at once.
572 If truncating after extending, we may get rid of wasted work. */
573 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
574
575 case COND_EXPR:
576 /* It is sometimes worthwhile to push the narrowing down through
577 the conditional and never loses. */
578 return fold (build (COND_EXPR, type, TREE_OPERAND (expr, 0),
579 convert (type, TREE_OPERAND (expr, 1)),
580 convert (type, TREE_OPERAND (expr, 2))));
581
582 default:
583 break;
584 }
585
586 return build1 (NOP_EXPR, type, expr);
587
588 case REAL_TYPE:
589 return build1 (FIX_TRUNC_EXPR, type, expr);
590
591 case COMPLEX_TYPE:
592 return convert (type,
593 fold (build1 (REALPART_EXPR,
594 TREE_TYPE (TREE_TYPE (expr)), expr)));
595
596 case VECTOR_TYPE:
597 if (GET_MODE_SIZE (TYPE_MODE (type))
598 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
599 {
600 error ("can't convert between vector values of different size");
601 return error_mark_node;
602 }
603 return build1 (NOP_EXPR, type, expr);
604
605 default:
606 error ("aggregate value used where an integer was expected");
607 return convert (type, integer_zero_node);
608 }
609}
610
611/* Convert EXPR to the complex type TYPE in the usual ways. */
612
613tree
614convert_to_complex (tree type, tree expr)
615{
616 tree subtype = TREE_TYPE (type);
617
618 switch (TREE_CODE (TREE_TYPE (expr)))
619 {
620 case REAL_TYPE:
621 case INTEGER_TYPE:
622 case ENUMERAL_TYPE:
623 case BOOLEAN_TYPE:
624 case CHAR_TYPE:
625 return build (COMPLEX_EXPR, type, convert (subtype, expr),
626 convert (subtype, integer_zero_node));
627
628 case COMPLEX_TYPE:
629 {
630 tree elt_type = TREE_TYPE (TREE_TYPE (expr));
631
632 if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
633 return expr;
634 else if (TREE_CODE (expr) == COMPLEX_EXPR)
635 return fold (build (COMPLEX_EXPR,
636 type,
637 convert (subtype, TREE_OPERAND (expr, 0)),
638 convert (subtype, TREE_OPERAND (expr, 1))));
639 else
640 {
641 expr = save_expr (expr);
642 return
643 fold (build (COMPLEX_EXPR,
644 type, convert (subtype,
645 fold (build1 (REALPART_EXPR,
646 TREE_TYPE (TREE_TYPE (expr)),
647 expr))),
648 convert (subtype,
649 fold (build1 (IMAGPART_EXPR,
650 TREE_TYPE (TREE_TYPE (expr)),
651 expr)))));
652 }
653 }
654
655 case POINTER_TYPE:
656 case REFERENCE_TYPE:
657 error ("pointer value used where a complex was expected");
658 return convert_to_complex (type, integer_zero_node);
659
660 default:
661 error ("aggregate value used where a complex was expected");
662 return convert_to_complex (type, integer_zero_node);
663 }
664}
665
666/* Convert EXPR to the vector type TYPE in the usual ways. */
667
668tree
669convert_to_vector (tree type, tree expr)
670{
671 switch (TREE_CODE (TREE_TYPE (expr)))
672 {
673 case INTEGER_TYPE:
674 case VECTOR_TYPE:
675 if (GET_MODE_SIZE (TYPE_MODE (type))
676 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
677 {
678 error ("can't convert between vector values of different size");
679 return error_mark_node;
680 }
681 return build1 (NOP_EXPR, type, expr);
682
683 default:
684 error ("can't convert value to a vector");
685 return convert_to_vector (type, integer_zero_node);
686 }
687}