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
);
225 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr
, 1)));
227 /* Make sure (type)arg0 is an extension, otherwise we could end up
228 changing (float)floor(double d) into floorf((float)d), which is
229 incorrect because (float)d uses round-to-nearest and can round
230 up to the next integer. */
231 if (TYPE_PRECISION (type
) >= TYPE_PRECISION (TREE_TYPE (arg
)))
233 build_function_call_expr (fn
,
234 build_tree_list (NULL_TREE
,
235 fold (convert_to_real (type
, arg
))));
239 /* Propagate the cast into the operation. */
240 if (itype
!= type
&& FLOAT_TYPE_P (type
))
241 switch (TREE_CODE (expr
))
243 /* Convert (float)-x into -(float)x. This is always safe. */
246 if (TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (expr
)))
247 return build1 (TREE_CODE (expr
), type
,
248 fold (convert_to_real (type
,
249 TREE_OPERAND (expr
, 0))));
251 /* Convert (outertype)((innertype0)a+(innertype1)b)
252 into ((newtype)a+(newtype)b) where newtype
253 is the widest mode from all of these. */
259 tree arg0
= strip_float_extensions (TREE_OPERAND (expr
, 0));
260 tree arg1
= strip_float_extensions (TREE_OPERAND (expr
, 1));
262 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
263 && FLOAT_TYPE_P (TREE_TYPE (arg1
)))
266 if (TYPE_PRECISION (TREE_TYPE (arg0
)) > TYPE_PRECISION (newtype
))
267 newtype
= TREE_TYPE (arg0
);
268 if (TYPE_PRECISION (TREE_TYPE (arg1
)) > TYPE_PRECISION (newtype
))
269 newtype
= TREE_TYPE (arg1
);
270 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (itype
))
272 expr
= build2 (TREE_CODE (expr
), newtype
,
273 fold (convert_to_real (newtype
, arg0
)),
274 fold (convert_to_real (newtype
, arg1
)));
285 switch (TREE_CODE (TREE_TYPE (expr
)))
288 return build1 (flag_float_store
? CONVERT_EXPR
: NOP_EXPR
,
295 return build1 (FLOAT_EXPR
, type
, expr
);
298 return convert (type
,
299 fold_build1 (REALPART_EXPR
,
300 TREE_TYPE (TREE_TYPE (expr
)), expr
));
304 error ("pointer value used where a floating point value was expected");
305 return convert_to_real (type
, integer_zero_node
);
308 error ("aggregate value used where a float was expected");
309 return convert_to_real (type
, integer_zero_node
);
313 /* Convert EXPR to some integer (or enum) type TYPE.
315 EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
316 vector; in other cases error is called.
318 The result of this is always supposed to be a newly created tree node
319 not in use in any existing structure. */
322 convert_to_integer (tree type
, tree expr
)
324 enum tree_code ex_form
= TREE_CODE (expr
);
325 tree intype
= TREE_TYPE (expr
);
326 unsigned int inprec
= TYPE_PRECISION (intype
);
327 unsigned int outprec
= TYPE_PRECISION (type
);
329 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
330 be. Consider `enum E = { a, b = (enum E) 3 };'. */
331 if (!COMPLETE_TYPE_P (type
))
333 error ("conversion to incomplete type");
334 return error_mark_node
;
337 /* Convert e.g. (long)round(d) -> lround(d). */
338 /* If we're converting to char, we may encounter differing behavior
339 between converting from double->char vs double->long->char.
340 We're in "undefined" territory but we prefer to be conservative,
341 so only proceed in "unsafe" math mode. */
343 && (flag_unsafe_math_optimizations
344 || (long_integer_type_node
345 && outprec
>= TYPE_PRECISION (long_integer_type_node
))))
347 tree s_expr
= strip_float_extensions (expr
);
348 tree s_intype
= TREE_TYPE (s_expr
);
349 const enum built_in_function fcode
= builtin_mathfn_code (s_expr
);
354 CASE_FLT_FN (BUILT_IN_CEIL
):
355 /* Only convert in ISO C99 mode. */
356 if (!TARGET_C99_FUNCTIONS
)
358 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
359 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLCEIL
);
361 fn
= mathfn_built_in (s_intype
, BUILT_IN_LCEIL
);
364 CASE_FLT_FN (BUILT_IN_FLOOR
):
365 /* Only convert in ISO C99 mode. */
366 if (!TARGET_C99_FUNCTIONS
)
368 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
369 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLFLOOR
);
371 fn
= mathfn_built_in (s_intype
, BUILT_IN_LFLOOR
);
374 CASE_FLT_FN (BUILT_IN_ROUND
):
375 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
376 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLROUND
);
378 fn
= mathfn_built_in (s_intype
, BUILT_IN_LROUND
);
381 CASE_FLT_FN (BUILT_IN_RINT
):
382 /* Only convert rint* if we can ignore math exceptions. */
383 if (flag_trapping_math
)
385 /* ... Fall through ... */
386 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
387 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
388 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLRINT
);
390 fn
= mathfn_built_in (s_intype
, BUILT_IN_LRINT
);
393 CASE_FLT_FN (BUILT_IN_TRUNC
):
395 tree arglist
= TREE_OPERAND (s_expr
, 1);
396 return convert_to_integer (type
, TREE_VALUE (arglist
));
405 tree arglist
= TREE_OPERAND (s_expr
, 1);
406 tree newexpr
= build_function_call_expr (fn
, arglist
);
407 return convert_to_integer (type
, newexpr
);
411 switch (TREE_CODE (intype
))
415 if (integer_zerop (expr
))
416 return build_int_cst (type
, 0);
418 /* Convert to an unsigned integer of the correct width first,
419 and from there widen/truncate to the required type. */
420 expr
= fold_build1 (CONVERT_EXPR
,
421 lang_hooks
.types
.type_for_size (POINTER_SIZE
, 0),
423 return fold_build1 (NOP_EXPR
, type
, expr
);
429 /* If this is a logical operation, which just returns 0 or 1, we can
430 change the type of the expression. */
432 if (TREE_CODE_CLASS (ex_form
) == tcc_comparison
)
434 expr
= copy_node (expr
);
435 TREE_TYPE (expr
) = type
;
439 /* If we are widening the type, put in an explicit conversion.
440 Similarly if we are not changing the width. After this, we know
441 we are truncating EXPR. */
443 else if (outprec
>= inprec
)
447 /* If the precision of the EXPR's type is K bits and the
448 destination mode has more bits, and the sign is changing,
449 it is not safe to use a NOP_EXPR. For example, suppose
450 that EXPR's type is a 3-bit unsigned integer type, the
451 TYPE is a 3-bit signed integer type, and the machine mode
452 for the types is 8-bit QImode. In that case, the
453 conversion necessitates an explicit sign-extension. In
454 the signed-to-unsigned case the high-order bits have to
456 if (TYPE_UNSIGNED (type
) != TYPE_UNSIGNED (TREE_TYPE (expr
))
457 && (TYPE_PRECISION (TREE_TYPE (expr
))
458 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)))))
463 return fold_build1 (code
, type
, expr
);
466 /* If TYPE is an enumeral type or a type with a precision less
467 than the number of bits in its mode, do the conversion to the
468 type corresponding to its mode, then do a nop conversion
470 else if (TREE_CODE (type
) == ENUMERAL_TYPE
471 || outprec
!= GET_MODE_BITSIZE (TYPE_MODE (type
)))
472 return build1 (NOP_EXPR
, type
,
473 convert (lang_hooks
.types
.type_for_mode
474 (TYPE_MODE (type
), TYPE_UNSIGNED (type
)),
477 /* Here detect when we can distribute the truncation down past some
478 arithmetic. For example, if adding two longs and converting to an
479 int, we can equally well convert both to ints and then add.
480 For the operations handled here, such truncation distribution
482 It is desirable in these cases:
483 1) when truncating down to full-word from a larger size
484 2) when truncating takes no work.
485 3) when at least one operand of the arithmetic has been extended
486 (as by C's default conversions). In this case we need two conversions
487 if we do the arithmetic as already requested, so we might as well
488 truncate both and then combine. Perhaps that way we need only one.
490 Note that in general we cannot do the arithmetic in a type
491 shorter than the desired result of conversion, even if the operands
492 are both extended from a shorter type, because they might overflow
493 if combined in that type. The exceptions to this--the times when
494 two narrow values can be combined in their narrow type even to
495 make a wider result--are handled by "shorten" in build_binary_op. */
500 /* We can pass truncation down through right shifting
501 when the shift count is a nonpositive constant. */
502 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
503 && tree_int_cst_lt (TREE_OPERAND (expr
, 1),
504 convert (TREE_TYPE (TREE_OPERAND (expr
, 1)),
510 /* We can pass truncation down through left shifting
511 when the shift count is a nonnegative constant and
512 the target type is unsigned. */
513 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
514 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) >= 0
515 && TYPE_UNSIGNED (type
)
516 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
518 /* If shift count is less than the width of the truncated type,
520 if (tree_int_cst_lt (TREE_OPERAND (expr
, 1), TYPE_SIZE (type
)))
521 /* In this case, shifting is like multiplication. */
525 /* If it is >= that width, result is zero.
526 Handling this with trunc1 would give the wrong result:
527 (int) ((long long) a << 32) is well defined (as 0)
528 but (int) a << 32 is undefined and would get a
531 tree t
= convert_to_integer (type
, integer_zero_node
);
533 /* If the original expression had side-effects, we must
535 if (TREE_SIDE_EFFECTS (expr
))
536 return build2 (COMPOUND_EXPR
, type
, expr
, t
);
547 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
548 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
550 /* Don't distribute unless the output precision is at least as big
551 as the actual inputs. Otherwise, the comparison of the
552 truncated values will be wrong. */
553 if (outprec
>= TYPE_PRECISION (TREE_TYPE (arg0
))
554 && outprec
>= TYPE_PRECISION (TREE_TYPE (arg1
))
555 /* If signedness of arg0 and arg1 don't match,
556 we can't necessarily find a type to compare them in. */
557 && (TYPE_UNSIGNED (TREE_TYPE (arg0
))
558 == TYPE_UNSIGNED (TREE_TYPE (arg1
))))
570 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
571 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
573 if (outprec
>= BITS_PER_WORD
574 || TRULY_NOOP_TRUNCATION (outprec
, inprec
)
575 || inprec
> TYPE_PRECISION (TREE_TYPE (arg0
))
576 || inprec
> TYPE_PRECISION (TREE_TYPE (arg1
)))
578 /* Do the arithmetic in type TYPEX,
579 then convert result to TYPE. */
582 /* Can't do arithmetic in enumeral types
583 so use an integer type that will hold the values. */
584 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
585 typex
= lang_hooks
.types
.type_for_size
586 (TYPE_PRECISION (typex
), TYPE_UNSIGNED (typex
));
588 /* But now perhaps TYPEX is as wide as INPREC.
589 In that case, do nothing special here.
590 (Otherwise would recurse infinitely in convert. */
591 if (TYPE_PRECISION (typex
) != inprec
)
593 /* Don't do unsigned arithmetic where signed was wanted,
595 Exception: if both of the original operands were
596 unsigned then we can safely do the work as unsigned.
597 Exception: shift operations take their type solely
598 from the first argument.
599 Exception: the LSHIFT_EXPR case above requires that
600 we perform this operation unsigned lest we produce
601 signed-overflow undefinedness.
602 And we may need to do it as unsigned
603 if we truncate to the original size. */
604 if (TYPE_UNSIGNED (TREE_TYPE (expr
))
605 || (TYPE_UNSIGNED (TREE_TYPE (arg0
))
606 && (TYPE_UNSIGNED (TREE_TYPE (arg1
))
607 || ex_form
== LSHIFT_EXPR
608 || ex_form
== RSHIFT_EXPR
609 || ex_form
== LROTATE_EXPR
610 || ex_form
== RROTATE_EXPR
))
611 || ex_form
== LSHIFT_EXPR
)
612 typex
= lang_hooks
.types
.unsigned_type (typex
);
614 typex
= lang_hooks
.types
.signed_type (typex
);
615 return convert (type
,
616 fold_build2 (ex_form
, typex
,
617 convert (typex
, arg0
),
618 convert (typex
, arg1
)));
626 /* This is not correct for ABS_EXPR,
627 since we must test the sign before truncation. */
631 /* Don't do unsigned arithmetic where signed was wanted,
633 if (TYPE_UNSIGNED (TREE_TYPE (expr
)))
634 typex
= lang_hooks
.types
.unsigned_type (type
);
636 typex
= lang_hooks
.types
.signed_type (type
);
637 return convert (type
,
638 fold_build1 (ex_form
, typex
,
640 TREE_OPERAND (expr
, 0))));
645 "can't convert between vector values of different size" error. */
646 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == VECTOR_TYPE
647 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0))))
648 != GET_MODE_SIZE (TYPE_MODE (type
))))
650 /* If truncating after truncating, might as well do all at once.
651 If truncating after extending, we may get rid of wasted work. */
652 return convert (type
, get_unwidened (TREE_OPERAND (expr
, 0), type
));
655 /* It is sometimes worthwhile to push the narrowing down through
656 the conditional and never loses. */
657 return fold_build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0),
658 convert (type
, TREE_OPERAND (expr
, 1)),
659 convert (type
, TREE_OPERAND (expr
, 2)));
665 return build1 (CONVERT_EXPR
, type
, expr
);
668 return build1 (FIX_TRUNC_EXPR
, type
, expr
);
671 return convert (type
,
672 fold_build1 (REALPART_EXPR
,
673 TREE_TYPE (TREE_TYPE (expr
)), expr
));
676 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
678 error ("can't convert between vector values of different size");
679 return error_mark_node
;
681 return build1 (VIEW_CONVERT_EXPR
, type
, expr
);
684 error ("aggregate value used where an integer was expected");
685 return convert (type
, integer_zero_node
);
689 /* Convert EXPR to the complex type TYPE in the usual ways. */
692 convert_to_complex (tree type
, tree expr
)
694 tree subtype
= TREE_TYPE (type
);
696 switch (TREE_CODE (TREE_TYPE (expr
)))
703 return build2 (COMPLEX_EXPR
, type
, convert (subtype
, expr
),
704 convert (subtype
, integer_zero_node
));
708 tree elt_type
= TREE_TYPE (TREE_TYPE (expr
));
710 if (TYPE_MAIN_VARIANT (elt_type
) == TYPE_MAIN_VARIANT (subtype
))
712 else if (TREE_CODE (expr
) == COMPLEX_EXPR
)
713 return fold_build2 (COMPLEX_EXPR
, type
,
714 convert (subtype
, TREE_OPERAND (expr
, 0)),
715 convert (subtype
, TREE_OPERAND (expr
, 1)));
718 expr
= save_expr (expr
);
720 fold_build2 (COMPLEX_EXPR
, type
,
722 fold_build1 (REALPART_EXPR
,
723 TREE_TYPE (TREE_TYPE (expr
)),
726 fold_build1 (IMAGPART_EXPR
,
727 TREE_TYPE (TREE_TYPE (expr
)),
734 error ("pointer value used where a complex was expected");
735 return convert_to_complex (type
, integer_zero_node
);
738 error ("aggregate value used where a complex was expected");
739 return convert_to_complex (type
, integer_zero_node
);
743 /* Convert EXPR to the vector type TYPE in the usual ways. */
746 convert_to_vector (tree type
, tree expr
)
748 switch (TREE_CODE (TREE_TYPE (expr
)))
752 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
754 error ("can't convert between vector values of different size");
755 return error_mark_node
;
757 return build1 (VIEW_CONVERT_EXPR
, type
, expr
);
760 error ("can't convert value to a vector");
761 return error_mark_node
;