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_convert (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_sgn (TREE_OPERAND (expr
, 1)) < 0)
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
= build_int_cst (type
, 0);
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 /* Don't do unsigned arithmetic where signed was wanted,
631 if (TYPE_UNSIGNED (TREE_TYPE (expr
)))
632 typex
= lang_hooks
.types
.unsigned_type (type
);
634 typex
= lang_hooks
.types
.signed_type (type
);
635 return convert (type
,
636 fold_build1 (ex_form
, typex
,
638 TREE_OPERAND (expr
, 0))));
643 "can't convert between vector values of different size" error. */
644 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == VECTOR_TYPE
645 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0))))
646 != GET_MODE_SIZE (TYPE_MODE (type
))))
648 /* If truncating after truncating, might as well do all at once.
649 If truncating after extending, we may get rid of wasted work. */
650 return convert (type
, get_unwidened (TREE_OPERAND (expr
, 0), type
));
653 /* It is sometimes worthwhile to push the narrowing down through
654 the conditional and never loses. */
655 return fold_build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0),
656 convert (type
, TREE_OPERAND (expr
, 1)),
657 convert (type
, TREE_OPERAND (expr
, 2)));
663 return build1 (CONVERT_EXPR
, type
, expr
);
666 return build1 (FIX_TRUNC_EXPR
, type
, expr
);
669 return convert (type
,
670 fold_build1 (REALPART_EXPR
,
671 TREE_TYPE (TREE_TYPE (expr
)), expr
));
674 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
676 error ("can't convert between vector values of different size");
677 return error_mark_node
;
679 return build1 (VIEW_CONVERT_EXPR
, type
, expr
);
682 error ("aggregate value used where an integer was expected");
683 return convert (type
, integer_zero_node
);
687 /* Convert EXPR to the complex type TYPE in the usual ways. */
690 convert_to_complex (tree type
, tree expr
)
692 tree subtype
= TREE_TYPE (type
);
694 switch (TREE_CODE (TREE_TYPE (expr
)))
701 return build2 (COMPLEX_EXPR
, type
, convert (subtype
, expr
),
702 convert (subtype
, integer_zero_node
));
706 tree elt_type
= TREE_TYPE (TREE_TYPE (expr
));
708 if (TYPE_MAIN_VARIANT (elt_type
) == TYPE_MAIN_VARIANT (subtype
))
710 else if (TREE_CODE (expr
) == COMPLEX_EXPR
)
711 return fold_build2 (COMPLEX_EXPR
, type
,
712 convert (subtype
, TREE_OPERAND (expr
, 0)),
713 convert (subtype
, TREE_OPERAND (expr
, 1)));
716 expr
= save_expr (expr
);
718 fold_build2 (COMPLEX_EXPR
, type
,
720 fold_build1 (REALPART_EXPR
,
721 TREE_TYPE (TREE_TYPE (expr
)),
724 fold_build1 (IMAGPART_EXPR
,
725 TREE_TYPE (TREE_TYPE (expr
)),
732 error ("pointer value used where a complex was expected");
733 return convert_to_complex (type
, integer_zero_node
);
736 error ("aggregate value used where a complex was expected");
737 return convert_to_complex (type
, integer_zero_node
);
741 /* Convert EXPR to the vector type TYPE in the usual ways. */
744 convert_to_vector (tree type
, tree expr
)
746 switch (TREE_CODE (TREE_TYPE (expr
)))
750 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
752 error ("can't convert between vector values of different size");
753 return error_mark_node
;
755 return build1 (VIEW_CONVERT_EXPR
, type
, expr
);
758 error ("can't convert value to a vector");
759 return error_mark_node
;