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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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 /* Convert EXPR to some pointer or reference type TYPE.
38 EXPR must be pointer, reference, integer, enumeral, or literal zero;
39 in other cases error is called. */
42 convert_to_pointer (tree type
, tree expr
)
44 if (integer_zerop (expr
))
46 expr
= build_int_cst (type
, 0);
50 switch (TREE_CODE (TREE_TYPE (expr
)))
54 return build1 (NOP_EXPR
, type
, expr
);
60 if (TYPE_PRECISION (TREE_TYPE (expr
)) == POINTER_SIZE
)
61 return build1 (CONVERT_EXPR
, type
, expr
);
64 convert_to_pointer (type
,
65 convert (lang_hooks
.types
.type_for_size
66 (POINTER_SIZE
, 0), 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
);
228 tree arg0
= strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr
,
230 tree arglist
= build_tree_list (NULL_TREE
,
231 fold (convert_to_real (type
, arg0
)));
233 return build_function_call_expr (fn
, arglist
);
237 /* Propagate the cast into the operation. */
238 if (itype
!= type
&& FLOAT_TYPE_P (type
))
239 switch (TREE_CODE (expr
))
241 /* Convert (float)-x into -(float)x. This is always safe. */
244 if (TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (expr
)))
245 return build1 (TREE_CODE (expr
), type
,
246 fold (convert_to_real (type
,
247 TREE_OPERAND (expr
, 0))));
249 /* Convert (outertype)((innertype0)a+(innertype1)b)
250 into ((newtype)a+(newtype)b) where newtype
251 is the widest mode from all of these. */
257 tree arg0
= strip_float_extensions (TREE_OPERAND (expr
, 0));
258 tree arg1
= strip_float_extensions (TREE_OPERAND (expr
, 1));
260 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
261 && FLOAT_TYPE_P (TREE_TYPE (arg1
)))
264 if (TYPE_PRECISION (TREE_TYPE (arg0
)) > TYPE_PRECISION (newtype
))
265 newtype
= TREE_TYPE (arg0
);
266 if (TYPE_PRECISION (TREE_TYPE (arg1
)) > TYPE_PRECISION (newtype
))
267 newtype
= TREE_TYPE (arg1
);
268 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (itype
))
270 expr
= build2 (TREE_CODE (expr
), newtype
,
271 fold (convert_to_real (newtype
, arg0
)),
272 fold (convert_to_real (newtype
, arg1
)));
283 switch (TREE_CODE (TREE_TYPE (expr
)))
286 return build1 (flag_float_store
? CONVERT_EXPR
: NOP_EXPR
,
293 return build1 (FLOAT_EXPR
, type
, expr
);
296 return convert (type
,
297 fold (build1 (REALPART_EXPR
,
298 TREE_TYPE (TREE_TYPE (expr
)), expr
)));
302 error ("pointer value used where a floating point value was expected");
303 return convert_to_real (type
, integer_zero_node
);
306 error ("aggregate value used where a float was expected");
307 return convert_to_real (type
, integer_zero_node
);
311 /* Convert EXPR to some integer (or enum) type TYPE.
313 EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
314 vector; in other cases error is called.
316 The result of this is always supposed to be a newly created tree node
317 not in use in any existing structure. */
320 convert_to_integer (tree type
, tree expr
)
322 enum tree_code ex_form
= TREE_CODE (expr
);
323 tree intype
= TREE_TYPE (expr
);
324 unsigned int inprec
= TYPE_PRECISION (intype
);
325 unsigned int outprec
= TYPE_PRECISION (type
);
327 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
328 be. Consider `enum E = { a, b = (enum E) 3 };'. */
329 if (!COMPLETE_TYPE_P (type
))
331 error ("conversion to incomplete type");
332 return error_mark_node
;
335 /* Convert e.g. (long)round(d) -> lround(d). */
336 /* If we're converting to char, we may encounter differing behavior
337 between converting from double->char vs double->long->char.
338 We're in "undefined" territory but we prefer to be conservative,
339 so only proceed in "unsafe" math mode. */
341 && (flag_unsafe_math_optimizations
342 || (long_integer_type_node
343 && outprec
>= TYPE_PRECISION (long_integer_type_node
))))
345 tree s_expr
= strip_float_extensions (expr
);
346 tree s_intype
= TREE_TYPE (s_expr
);
347 const enum built_in_function fcode
= builtin_mathfn_code (s_expr
);
352 case BUILT_IN_CEIL
: case BUILT_IN_CEILF
: case BUILT_IN_CEILL
:
353 /* Only convert in ISO C99 mode. */
354 if (!TARGET_C99_FUNCTIONS
)
356 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
357 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLCEIL
);
359 fn
= mathfn_built_in (s_intype
, BUILT_IN_LCEIL
);
362 case BUILT_IN_FLOOR
: case BUILT_IN_FLOORF
: case BUILT_IN_FLOORL
:
363 /* Only convert in ISO C99 mode. */
364 if (!TARGET_C99_FUNCTIONS
)
366 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
367 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLFLOOR
);
369 fn
= mathfn_built_in (s_intype
, BUILT_IN_LFLOOR
);
372 case BUILT_IN_ROUND
: case BUILT_IN_ROUNDF
: case BUILT_IN_ROUNDL
:
373 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
374 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLROUND
);
376 fn
= mathfn_built_in (s_intype
, BUILT_IN_LROUND
);
379 case BUILT_IN_RINT
: case BUILT_IN_RINTF
: case BUILT_IN_RINTL
:
380 /* Only convert rint* if we can ignore math exceptions. */
381 if (flag_trapping_math
)
383 /* ... Fall through ... */
384 case BUILT_IN_NEARBYINT
: case BUILT_IN_NEARBYINTF
: case BUILT_IN_NEARBYINTL
:
385 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
386 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLRINT
);
388 fn
= mathfn_built_in (s_intype
, BUILT_IN_LRINT
);
391 case BUILT_IN_TRUNC
: case BUILT_IN_TRUNCF
: case BUILT_IN_TRUNCL
:
393 tree arglist
= TREE_OPERAND (s_expr
, 1);
394 return convert_to_integer (type
, TREE_VALUE (arglist
));
403 tree arglist
= TREE_OPERAND (s_expr
, 1);
404 tree newexpr
= build_function_call_expr (fn
, arglist
);
405 return convert_to_integer (type
, newexpr
);
409 switch (TREE_CODE (intype
))
413 if (integer_zerop (expr
))
414 return build_int_cst (type
, 0);
416 /* Convert to an unsigned integer of the correct width first,
417 and from there widen/truncate to the required type. */
418 expr
= fold_build1 (CONVERT_EXPR
,
419 lang_hooks
.types
.type_for_size (POINTER_SIZE
, 0),
421 return fold_build1 (NOP_EXPR
, type
, expr
);
427 /* If this is a logical operation, which just returns 0 or 1, we can
428 change the type of the expression. */
430 if (TREE_CODE_CLASS (ex_form
) == tcc_comparison
)
432 expr
= copy_node (expr
);
433 TREE_TYPE (expr
) = type
;
437 /* If we are widening the type, put in an explicit conversion.
438 Similarly if we are not changing the width. After this, we know
439 we are truncating EXPR. */
441 else if (outprec
>= inprec
)
445 /* If the precision of the EXPR's type is K bits and the
446 destination mode has more bits, and the sign is changing,
447 it is not safe to use a NOP_EXPR. For example, suppose
448 that EXPR's type is a 3-bit unsigned integer type, the
449 TYPE is a 3-bit signed integer type, and the machine mode
450 for the types is 8-bit QImode. In that case, the
451 conversion necessitates an explicit sign-extension. In
452 the signed-to-unsigned case the high-order bits have to
454 if (TYPE_UNSIGNED (type
) != TYPE_UNSIGNED (TREE_TYPE (expr
))
455 && (TYPE_PRECISION (TREE_TYPE (expr
))
456 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)))))
461 return build1 (code
, type
, expr
);
464 /* If TYPE is an enumeral type or a type with a precision less
465 than the number of bits in its mode, do the conversion to the
466 type corresponding to its mode, then do a nop conversion
468 else if (TREE_CODE (type
) == ENUMERAL_TYPE
469 || outprec
!= GET_MODE_BITSIZE (TYPE_MODE (type
)))
470 return build1 (NOP_EXPR
, type
,
471 convert (lang_hooks
.types
.type_for_mode
472 (TYPE_MODE (type
), TYPE_UNSIGNED (type
)),
475 /* Here detect when we can distribute the truncation down past some
476 arithmetic. For example, if adding two longs and converting to an
477 int, we can equally well convert both to ints and then add.
478 For the operations handled here, such truncation distribution
480 It is desirable in these cases:
481 1) when truncating down to full-word from a larger size
482 2) when truncating takes no work.
483 3) when at least one operand of the arithmetic has been extended
484 (as by C's default conversions). In this case we need two conversions
485 if we do the arithmetic as already requested, so we might as well
486 truncate both and then combine. Perhaps that way we need only one.
488 Note that in general we cannot do the arithmetic in a type
489 shorter than the desired result of conversion, even if the operands
490 are both extended from a shorter type, because they might overflow
491 if combined in that type. The exceptions to this--the times when
492 two narrow values can be combined in their narrow type even to
493 make a wider result--are handled by "shorten" in build_binary_op. */
498 /* We can pass truncation down through right shifting
499 when the shift count is a nonpositive constant. */
500 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
501 && tree_int_cst_lt (TREE_OPERAND (expr
, 1),
502 convert (TREE_TYPE (TREE_OPERAND (expr
, 1)),
508 /* We can pass truncation down through left shifting
509 when the shift count is a nonnegative constant and
510 the target type is unsigned. */
511 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
512 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) >= 0
513 && TYPE_UNSIGNED (type
)
514 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
516 /* If shift count is less than the width of the truncated type,
518 if (tree_int_cst_lt (TREE_OPERAND (expr
, 1), TYPE_SIZE (type
)))
519 /* In this case, shifting is like multiplication. */
523 /* If it is >= that width, result is zero.
524 Handling this with trunc1 would give the wrong result:
525 (int) ((long long) a << 32) is well defined (as 0)
526 but (int) a << 32 is undefined and would get a
529 tree t
= convert_to_integer (type
, integer_zero_node
);
531 /* If the original expression had side-effects, we must
533 if (TREE_SIDE_EFFECTS (expr
))
534 return build2 (COMPOUND_EXPR
, type
, expr
, t
);
545 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
546 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
548 /* Don't distribute unless the output precision is at least as big
549 as the actual inputs. Otherwise, the comparison of the
550 truncated values will be wrong. */
551 if (outprec
>= TYPE_PRECISION (TREE_TYPE (arg0
))
552 && outprec
>= TYPE_PRECISION (TREE_TYPE (arg1
))
553 /* If signedness of arg0 and arg1 don't match,
554 we can't necessarily find a type to compare them in. */
555 && (TYPE_UNSIGNED (TREE_TYPE (arg0
))
556 == TYPE_UNSIGNED (TREE_TYPE (arg1
))))
568 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
569 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
571 if (outprec
>= BITS_PER_WORD
572 || TRULY_NOOP_TRUNCATION (outprec
, inprec
)
573 || inprec
> TYPE_PRECISION (TREE_TYPE (arg0
))
574 || inprec
> TYPE_PRECISION (TREE_TYPE (arg1
)))
576 /* Do the arithmetic in type TYPEX,
577 then convert result to TYPE. */
580 /* Can't do arithmetic in enumeral types
581 so use an integer type that will hold the values. */
582 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
583 typex
= lang_hooks
.types
.type_for_size
584 (TYPE_PRECISION (typex
), TYPE_UNSIGNED (typex
));
586 /* But now perhaps TYPEX is as wide as INPREC.
587 In that case, do nothing special here.
588 (Otherwise would recurse infinitely in convert. */
589 if (TYPE_PRECISION (typex
) != inprec
)
591 /* Don't do unsigned arithmetic where signed was wanted,
593 Exception: if both of the original operands were
594 unsigned then we can safely do the work as unsigned.
595 Exception: shift operations take their type solely
596 from the first argument.
597 Exception: the LSHIFT_EXPR case above requires that
598 we perform this operation unsigned lest we produce
599 signed-overflow undefinedness.
600 And we may need to do it as unsigned
601 if we truncate to the original size. */
602 if (TYPE_UNSIGNED (TREE_TYPE (expr
))
603 || (TYPE_UNSIGNED (TREE_TYPE (arg0
))
604 && (TYPE_UNSIGNED (TREE_TYPE (arg1
))
605 || ex_form
== LSHIFT_EXPR
606 || ex_form
== RSHIFT_EXPR
607 || ex_form
== LROTATE_EXPR
608 || ex_form
== RROTATE_EXPR
))
609 || ex_form
== LSHIFT_EXPR
)
610 typex
= lang_hooks
.types
.unsigned_type (typex
);
612 typex
= lang_hooks
.types
.signed_type (typex
);
613 return convert (type
,
614 fold (build2 (ex_form
, typex
,
615 convert (typex
, arg0
),
616 convert (typex
, arg1
))));
624 /* This is not correct for ABS_EXPR,
625 since we must test the sign before truncation. */
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 if (TYPE_UNSIGNED (TREE_TYPE (expr
)))
643 typex
= lang_hooks
.types
.unsigned_type (typex
);
645 typex
= lang_hooks
.types
.signed_type (typex
);
646 return convert (type
,
647 fold (build1 (ex_form
, typex
,
649 TREE_OPERAND (expr
, 0)))));
655 "can't convert between vector values of different size" error. */
656 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == VECTOR_TYPE
657 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0))))
658 != GET_MODE_SIZE (TYPE_MODE (type
))))
660 /* If truncating after truncating, might as well do all at once.
661 If truncating after extending, we may get rid of wasted work. */
662 return convert (type
, get_unwidened (TREE_OPERAND (expr
, 0), type
));
665 /* It is sometimes worthwhile to push the narrowing down through
666 the conditional and never loses. */
667 return fold (build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0),
668 convert (type
, TREE_OPERAND (expr
, 1)),
669 convert (type
, TREE_OPERAND (expr
, 2))));
675 return build1 (CONVERT_EXPR
, type
, expr
);
678 return build1 (FIX_TRUNC_EXPR
, type
, expr
);
681 return convert (type
,
682 fold (build1 (REALPART_EXPR
,
683 TREE_TYPE (TREE_TYPE (expr
)), expr
)));
686 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
688 error ("can't convert between vector values of different size");
689 return error_mark_node
;
691 return build1 (NOP_EXPR
, type
, expr
);
694 error ("aggregate value used where an integer was expected");
695 return convert (type
, integer_zero_node
);
699 /* Convert EXPR to the complex type TYPE in the usual ways. */
702 convert_to_complex (tree type
, tree expr
)
704 tree subtype
= TREE_TYPE (type
);
706 switch (TREE_CODE (TREE_TYPE (expr
)))
713 return build2 (COMPLEX_EXPR
, type
, convert (subtype
, expr
),
714 convert (subtype
, integer_zero_node
));
718 tree elt_type
= TREE_TYPE (TREE_TYPE (expr
));
720 if (TYPE_MAIN_VARIANT (elt_type
) == TYPE_MAIN_VARIANT (subtype
))
722 else if (TREE_CODE (expr
) == COMPLEX_EXPR
)
723 return fold (build2 (COMPLEX_EXPR
, type
,
724 convert (subtype
, TREE_OPERAND (expr
, 0)),
725 convert (subtype
, TREE_OPERAND (expr
, 1))));
728 expr
= save_expr (expr
);
730 fold (build2 (COMPLEX_EXPR
, type
,
732 fold (build1 (REALPART_EXPR
,
733 TREE_TYPE (TREE_TYPE (expr
)),
736 fold (build1 (IMAGPART_EXPR
,
737 TREE_TYPE (TREE_TYPE (expr
)),
744 error ("pointer value used where a complex was expected");
745 return convert_to_complex (type
, integer_zero_node
);
748 error ("aggregate value used where a complex was expected");
749 return convert_to_complex (type
, integer_zero_node
);
753 /* Convert EXPR to the vector type TYPE in the usual ways. */
756 convert_to_vector (tree type
, tree expr
)
758 switch (TREE_CODE (TREE_TYPE (expr
)))
762 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
764 error ("can't convert between vector values of different size");
765 return error_mark_node
;
767 return build1 (NOP_EXPR
, type
, expr
);
770 error ("can't convert value to a vector");
771 return error_mark_node
;