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, 51 Franklin Street, Fifth Floor, 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
))
45 return build_int_cst (type
, 0);
47 switch (TREE_CODE (TREE_TYPE (expr
)))
51 return build1 (NOP_EXPR
, type
, expr
);
57 if (TYPE_PRECISION (TREE_TYPE (expr
)) != POINTER_SIZE
)
58 expr
= fold_build1 (NOP_EXPR
,
59 lang_hooks
.types
.type_for_size (POINTER_SIZE
, 0),
61 return fold_build1 (CONVERT_EXPR
, type
, expr
);
65 error ("cannot convert to a pointer type");
66 return convert_to_pointer (type
, integer_zero_node
);
70 /* Avoid any floating point extensions from EXP. */
72 strip_float_extensions (tree exp
)
76 /* For floating point constant look up the narrowest type that can hold
77 it properly and handle it like (type)(narrowest_type)constant.
78 This way we can optimize for instance a=a*2.0 where "a" is float
79 but 2.0 is double constant. */
80 if (TREE_CODE (exp
) == REAL_CST
)
85 orig
= TREE_REAL_CST (exp
);
86 if (TYPE_PRECISION (TREE_TYPE (exp
)) > TYPE_PRECISION (float_type_node
)
87 && exact_real_truncate (TYPE_MODE (float_type_node
), &orig
))
88 type
= float_type_node
;
89 else if (TYPE_PRECISION (TREE_TYPE (exp
))
90 > TYPE_PRECISION (double_type_node
)
91 && exact_real_truncate (TYPE_MODE (double_type_node
), &orig
))
92 type
= double_type_node
;
94 return build_real (type
, real_value_truncate (TYPE_MODE (type
), orig
));
97 if (TREE_CODE (exp
) != NOP_EXPR
98 && TREE_CODE (exp
) != CONVERT_EXPR
)
101 sub
= TREE_OPERAND (exp
, 0);
102 subt
= TREE_TYPE (sub
);
103 expt
= TREE_TYPE (exp
);
105 if (!FLOAT_TYPE_P (subt
))
108 if (TYPE_PRECISION (subt
) > TYPE_PRECISION (expt
))
111 return strip_float_extensions (sub
);
115 /* Convert EXPR to some floating-point type TYPE.
117 EXPR must be float, integer, or enumeral;
118 in other cases error is called. */
121 convert_to_real (tree type
, tree expr
)
123 enum built_in_function fcode
= builtin_mathfn_code (expr
);
124 tree itype
= TREE_TYPE (expr
);
126 /* Disable until we figure out how to decide whether the functions are
127 present in runtime. */
128 /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
130 && (TYPE_MODE (type
) == TYPE_MODE (double_type_node
)
131 || TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))
135 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
172 tree arg0
= strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr
, 1)));
175 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
176 the both as the safe type for operation. */
177 if (TYPE_PRECISION (TREE_TYPE (arg0
)) > TYPE_PRECISION (type
))
178 newtype
= TREE_TYPE (arg0
);
180 /* Be careful about integer to fp conversions.
181 These may overflow still. */
182 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
183 && TYPE_PRECISION (newtype
) < TYPE_PRECISION (itype
)
184 && (TYPE_MODE (newtype
) == TYPE_MODE (double_type_node
)
185 || TYPE_MODE (newtype
) == TYPE_MODE (float_type_node
)))
188 tree fn
= mathfn_built_in (newtype
, fcode
);
192 arglist
= build_tree_list (NULL_TREE
, fold (convert_to_real (newtype
, arg0
)));
193 expr
= build_function_call_expr (fn
, arglist
);
204 && (((fcode
== BUILT_IN_FLOORL
205 || fcode
== BUILT_IN_CEILL
206 || fcode
== BUILT_IN_ROUNDL
207 || fcode
== BUILT_IN_RINTL
208 || fcode
== BUILT_IN_TRUNCL
209 || fcode
== BUILT_IN_NEARBYINTL
)
210 && (TYPE_MODE (type
) == TYPE_MODE (double_type_node
)
211 || TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))
212 || ((fcode
== BUILT_IN_FLOOR
213 || fcode
== BUILT_IN_CEIL
214 || fcode
== BUILT_IN_ROUND
215 || fcode
== BUILT_IN_RINT
216 || fcode
== BUILT_IN_TRUNC
217 || fcode
== BUILT_IN_NEARBYINT
)
218 && (TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))))
220 tree fn
= mathfn_built_in (type
, fcode
);
224 tree arg0
= strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr
,
226 tree arglist
= build_tree_list (NULL_TREE
,
227 fold (convert_to_real (type
, arg0
)));
229 return build_function_call_expr (fn
, arglist
);
233 /* Propagate the cast into the operation. */
234 if (itype
!= type
&& FLOAT_TYPE_P (type
))
235 switch (TREE_CODE (expr
))
237 /* Convert (float)-x into -(float)x. This is always safe. */
240 if (TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (expr
)))
241 return build1 (TREE_CODE (expr
), type
,
242 fold (convert_to_real (type
,
243 TREE_OPERAND (expr
, 0))));
245 /* Convert (outertype)((innertype0)a+(innertype1)b)
246 into ((newtype)a+(newtype)b) where newtype
247 is the widest mode from all of these. */
253 tree arg0
= strip_float_extensions (TREE_OPERAND (expr
, 0));
254 tree arg1
= strip_float_extensions (TREE_OPERAND (expr
, 1));
256 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
257 && FLOAT_TYPE_P (TREE_TYPE (arg1
)))
260 if (TYPE_PRECISION (TREE_TYPE (arg0
)) > TYPE_PRECISION (newtype
))
261 newtype
= TREE_TYPE (arg0
);
262 if (TYPE_PRECISION (TREE_TYPE (arg1
)) > TYPE_PRECISION (newtype
))
263 newtype
= TREE_TYPE (arg1
);
264 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (itype
))
266 expr
= build2 (TREE_CODE (expr
), newtype
,
267 fold (convert_to_real (newtype
, arg0
)),
268 fold (convert_to_real (newtype
, arg1
)));
279 switch (TREE_CODE (TREE_TYPE (expr
)))
282 return build1 (flag_float_store
? CONVERT_EXPR
: NOP_EXPR
,
289 return build1 (FLOAT_EXPR
, type
, expr
);
292 return convert (type
,
293 fold_build1 (REALPART_EXPR
,
294 TREE_TYPE (TREE_TYPE (expr
)), expr
));
298 error ("pointer value used where a floating point value was expected");
299 return convert_to_real (type
, integer_zero_node
);
302 error ("aggregate value used where a float was expected");
303 return convert_to_real (type
, integer_zero_node
);
307 /* Convert EXPR to some integer (or enum) type TYPE.
309 EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
310 vector; in other cases error is called.
312 The result of this is always supposed to be a newly created tree node
313 not in use in any existing structure. */
316 convert_to_integer (tree type
, tree expr
)
318 enum tree_code ex_form
= TREE_CODE (expr
);
319 tree intype
= TREE_TYPE (expr
);
320 unsigned int inprec
= TYPE_PRECISION (intype
);
321 unsigned int outprec
= TYPE_PRECISION (type
);
323 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
324 be. Consider `enum E = { a, b = (enum E) 3 };'. */
325 if (!COMPLETE_TYPE_P (type
))
327 error ("conversion to incomplete type");
328 return error_mark_node
;
331 /* Convert e.g. (long)round(d) -> lround(d). */
332 /* If we're converting to char, we may encounter differing behavior
333 between converting from double->char vs double->long->char.
334 We're in "undefined" territory but we prefer to be conservative,
335 so only proceed in "unsafe" math mode. */
337 && (flag_unsafe_math_optimizations
338 || (long_integer_type_node
339 && outprec
>= TYPE_PRECISION (long_integer_type_node
))))
341 tree s_expr
= strip_float_extensions (expr
);
342 tree s_intype
= TREE_TYPE (s_expr
);
343 const enum built_in_function fcode
= builtin_mathfn_code (s_expr
);
348 case BUILT_IN_CEIL
: case BUILT_IN_CEILF
: case BUILT_IN_CEILL
:
349 /* Only convert in ISO C99 mode. */
350 if (!TARGET_C99_FUNCTIONS
)
352 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
353 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLCEIL
);
355 fn
= mathfn_built_in (s_intype
, BUILT_IN_LCEIL
);
358 case BUILT_IN_FLOOR
: case BUILT_IN_FLOORF
: case BUILT_IN_FLOORL
:
359 /* Only convert in ISO C99 mode. */
360 if (!TARGET_C99_FUNCTIONS
)
362 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
363 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLFLOOR
);
365 fn
= mathfn_built_in (s_intype
, BUILT_IN_LFLOOR
);
368 case BUILT_IN_ROUND
: case BUILT_IN_ROUNDF
: case BUILT_IN_ROUNDL
:
369 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
370 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLROUND
);
372 fn
= mathfn_built_in (s_intype
, BUILT_IN_LROUND
);
375 case BUILT_IN_RINT
: case BUILT_IN_RINTF
: case BUILT_IN_RINTL
:
376 /* Only convert rint* if we can ignore math exceptions. */
377 if (flag_trapping_math
)
379 /* ... Fall through ... */
380 case BUILT_IN_NEARBYINT
: case BUILT_IN_NEARBYINTF
: case BUILT_IN_NEARBYINTL
:
381 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
382 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLRINT
);
384 fn
= mathfn_built_in (s_intype
, BUILT_IN_LRINT
);
387 case BUILT_IN_TRUNC
: case BUILT_IN_TRUNCF
: case BUILT_IN_TRUNCL
:
389 tree arglist
= TREE_OPERAND (s_expr
, 1);
390 return convert_to_integer (type
, TREE_VALUE (arglist
));
399 tree arglist
= TREE_OPERAND (s_expr
, 1);
400 tree newexpr
= build_function_call_expr (fn
, arglist
);
401 return convert_to_integer (type
, newexpr
);
405 switch (TREE_CODE (intype
))
409 if (integer_zerop (expr
))
410 return build_int_cst (type
, 0);
412 /* Convert to an unsigned integer of the correct width first,
413 and from there widen/truncate to the required type. */
414 expr
= fold_build1 (CONVERT_EXPR
,
415 lang_hooks
.types
.type_for_size (POINTER_SIZE
, 0),
417 return fold_build1 (NOP_EXPR
, type
, expr
);
423 /* If this is a logical operation, which just returns 0 or 1, we can
424 change the type of the expression. */
426 if (TREE_CODE_CLASS (ex_form
) == tcc_comparison
)
428 expr
= copy_node (expr
);
429 TREE_TYPE (expr
) = type
;
433 /* If we are widening the type, put in an explicit conversion.
434 Similarly if we are not changing the width. After this, we know
435 we are truncating EXPR. */
437 else if (outprec
>= inprec
)
441 /* If the precision of the EXPR's type is K bits and the
442 destination mode has more bits, and the sign is changing,
443 it is not safe to use a NOP_EXPR. For example, suppose
444 that EXPR's type is a 3-bit unsigned integer type, the
445 TYPE is a 3-bit signed integer type, and the machine mode
446 for the types is 8-bit QImode. In that case, the
447 conversion necessitates an explicit sign-extension. In
448 the signed-to-unsigned case the high-order bits have to
450 if (TYPE_UNSIGNED (type
) != TYPE_UNSIGNED (TREE_TYPE (expr
))
451 && (TYPE_PRECISION (TREE_TYPE (expr
))
452 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)))))
457 return fold_build1 (code
, type
, expr
);
460 /* If TYPE is an enumeral type or a type with a precision less
461 than the number of bits in its mode, do the conversion to the
462 type corresponding to its mode, then do a nop conversion
464 else if (TREE_CODE (type
) == ENUMERAL_TYPE
465 || outprec
!= GET_MODE_BITSIZE (TYPE_MODE (type
)))
466 return build1 (NOP_EXPR
, type
,
467 convert (lang_hooks
.types
.type_for_mode
468 (TYPE_MODE (type
), TYPE_UNSIGNED (type
)),
471 /* Here detect when we can distribute the truncation down past some
472 arithmetic. For example, if adding two longs and converting to an
473 int, we can equally well convert both to ints and then add.
474 For the operations handled here, such truncation distribution
476 It is desirable in these cases:
477 1) when truncating down to full-word from a larger size
478 2) when truncating takes no work.
479 3) when at least one operand of the arithmetic has been extended
480 (as by C's default conversions). In this case we need two conversions
481 if we do the arithmetic as already requested, so we might as well
482 truncate both and then combine. Perhaps that way we need only one.
484 Note that in general we cannot do the arithmetic in a type
485 shorter than the desired result of conversion, even if the operands
486 are both extended from a shorter type, because they might overflow
487 if combined in that type. The exceptions to this--the times when
488 two narrow values can be combined in their narrow type even to
489 make a wider result--are handled by "shorten" in build_binary_op. */
494 /* We can pass truncation down through right shifting
495 when the shift count is a nonpositive constant. */
496 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
497 && tree_int_cst_lt (TREE_OPERAND (expr
, 1),
498 convert (TREE_TYPE (TREE_OPERAND (expr
, 1)),
504 /* We can pass truncation down through left shifting
505 when the shift count is a nonnegative constant and
506 the target type is unsigned. */
507 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
508 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) >= 0
509 && TYPE_UNSIGNED (type
)
510 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
512 /* If shift count is less than the width of the truncated type,
514 if (tree_int_cst_lt (TREE_OPERAND (expr
, 1), TYPE_SIZE (type
)))
515 /* In this case, shifting is like multiplication. */
519 /* If it is >= that width, result is zero.
520 Handling this with trunc1 would give the wrong result:
521 (int) ((long long) a << 32) is well defined (as 0)
522 but (int) a << 32 is undefined and would get a
525 tree t
= convert_to_integer (type
, integer_zero_node
);
527 /* If the original expression had side-effects, we must
529 if (TREE_SIDE_EFFECTS (expr
))
530 return build2 (COMPOUND_EXPR
, type
, expr
, t
);
541 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
542 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
544 /* Don't distribute unless the output precision is at least as big
545 as the actual inputs. Otherwise, the comparison of the
546 truncated values will be wrong. */
547 if (outprec
>= TYPE_PRECISION (TREE_TYPE (arg0
))
548 && outprec
>= TYPE_PRECISION (TREE_TYPE (arg1
))
549 /* If signedness of arg0 and arg1 don't match,
550 we can't necessarily find a type to compare them in. */
551 && (TYPE_UNSIGNED (TREE_TYPE (arg0
))
552 == TYPE_UNSIGNED (TREE_TYPE (arg1
))))
564 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
565 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
567 if (outprec
>= BITS_PER_WORD
568 || TRULY_NOOP_TRUNCATION (outprec
, inprec
)
569 || inprec
> TYPE_PRECISION (TREE_TYPE (arg0
))
570 || inprec
> TYPE_PRECISION (TREE_TYPE (arg1
)))
572 /* Do the arithmetic in type TYPEX,
573 then convert result to TYPE. */
576 /* Can't do arithmetic in enumeral types
577 so use an integer type that will hold the values. */
578 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
579 typex
= lang_hooks
.types
.type_for_size
580 (TYPE_PRECISION (typex
), TYPE_UNSIGNED (typex
));
582 /* But now perhaps TYPEX is as wide as INPREC.
583 In that case, do nothing special here.
584 (Otherwise would recurse infinitely in convert. */
585 if (TYPE_PRECISION (typex
) != inprec
)
587 /* Don't do unsigned arithmetic where signed was wanted,
589 Exception: if both of the original operands were
590 unsigned then we can safely do the work as unsigned.
591 Exception: shift operations take their type solely
592 from the first argument.
593 Exception: the LSHIFT_EXPR case above requires that
594 we perform this operation unsigned lest we produce
595 signed-overflow undefinedness.
596 And we may need to do it as unsigned
597 if we truncate to the original size. */
598 if (TYPE_UNSIGNED (TREE_TYPE (expr
))
599 || (TYPE_UNSIGNED (TREE_TYPE (arg0
))
600 && (TYPE_UNSIGNED (TREE_TYPE (arg1
))
601 || ex_form
== LSHIFT_EXPR
602 || ex_form
== RSHIFT_EXPR
603 || ex_form
== LROTATE_EXPR
604 || ex_form
== RROTATE_EXPR
))
605 || ex_form
== LSHIFT_EXPR
)
606 typex
= lang_hooks
.types
.unsigned_type (typex
);
608 typex
= lang_hooks
.types
.signed_type (typex
);
609 return convert (type
,
610 fold_build2 (ex_form
, typex
,
611 convert (typex
, arg0
),
612 convert (typex
, arg1
)));
620 /* This is not correct for ABS_EXPR,
621 since we must test the sign before truncation. */
625 /* Can't do arithmetic in enumeral types
626 so use an integer type that will hold the values. */
627 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
628 typex
= lang_hooks
.types
.type_for_size
629 (TYPE_PRECISION (typex
), TYPE_UNSIGNED (typex
));
631 /* But now perhaps TYPEX is as wide as INPREC.
632 In that case, do nothing special here.
633 (Otherwise would recurse infinitely in convert. */
634 if (TYPE_PRECISION (typex
) != inprec
)
636 /* Don't do unsigned arithmetic where signed was wanted,
638 if (TYPE_UNSIGNED (TREE_TYPE (expr
)))
639 typex
= lang_hooks
.types
.unsigned_type (typex
);
641 typex
= lang_hooks
.types
.signed_type (typex
);
642 return convert (type
,
643 fold_build1 (ex_form
, typex
,
645 TREE_OPERAND (expr
, 0))));
651 "can't convert between vector values of different size" error. */
652 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == VECTOR_TYPE
653 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0))))
654 != GET_MODE_SIZE (TYPE_MODE (type
))))
656 /* If truncating after truncating, might as well do all at once.
657 If truncating after extending, we may get rid of wasted work. */
658 return convert (type
, get_unwidened (TREE_OPERAND (expr
, 0), type
));
661 /* It is sometimes worthwhile to push the narrowing down through
662 the conditional and never loses. */
663 return fold_build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0),
664 convert (type
, TREE_OPERAND (expr
, 1)),
665 convert (type
, TREE_OPERAND (expr
, 2)));
671 return build1 (CONVERT_EXPR
, type
, expr
);
674 return build1 (FIX_TRUNC_EXPR
, type
, expr
);
677 return convert (type
,
678 fold_build1 (REALPART_EXPR
,
679 TREE_TYPE (TREE_TYPE (expr
)), expr
));
682 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
684 error ("can't convert between vector values of different size");
685 return error_mark_node
;
687 return build1 (NOP_EXPR
, type
, expr
);
690 error ("aggregate value used where an integer was expected");
691 return convert (type
, integer_zero_node
);
695 /* Convert EXPR to the complex type TYPE in the usual ways. */
698 convert_to_complex (tree type
, tree expr
)
700 tree subtype
= TREE_TYPE (type
);
702 switch (TREE_CODE (TREE_TYPE (expr
)))
709 return build2 (COMPLEX_EXPR
, type
, convert (subtype
, expr
),
710 convert (subtype
, integer_zero_node
));
714 tree elt_type
= TREE_TYPE (TREE_TYPE (expr
));
716 if (TYPE_MAIN_VARIANT (elt_type
) == TYPE_MAIN_VARIANT (subtype
))
718 else if (TREE_CODE (expr
) == COMPLEX_EXPR
)
719 return fold_build2 (COMPLEX_EXPR
, type
,
720 convert (subtype
, TREE_OPERAND (expr
, 0)),
721 convert (subtype
, TREE_OPERAND (expr
, 1)));
724 expr
= save_expr (expr
);
726 fold_build2 (COMPLEX_EXPR
, type
,
728 fold_build1 (REALPART_EXPR
,
729 TREE_TYPE (TREE_TYPE (expr
)),
732 fold_build1 (IMAGPART_EXPR
,
733 TREE_TYPE (TREE_TYPE (expr
)),
740 error ("pointer value used where a complex was expected");
741 return convert_to_complex (type
, integer_zero_node
);
744 error ("aggregate value used where a complex was expected");
745 return convert_to_complex (type
, integer_zero_node
);
749 /* Convert EXPR to the vector type TYPE in the usual ways. */
752 convert_to_vector (tree type
, tree expr
)
754 switch (TREE_CODE (TREE_TYPE (expr
)))
758 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
760 error ("can't convert between vector values of different size");
761 return error_mark_node
;
763 return build1 (NOP_EXPR
, type
, expr
);
766 error ("can't convert value to a vector");
767 return error_mark_node
;