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_FLOOR
: case BUILT_IN_FLOORF
: case BUILT_IN_FLOORL
:
353 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
354 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLFLOOR
);
356 fn
= mathfn_built_in (s_intype
, BUILT_IN_LFLOOR
);
359 case BUILT_IN_ROUND
: case BUILT_IN_ROUNDF
: case BUILT_IN_ROUNDL
:
360 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
361 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLROUND
);
363 fn
= mathfn_built_in (s_intype
, BUILT_IN_LROUND
);
366 case BUILT_IN_RINT
: case BUILT_IN_RINTF
: case BUILT_IN_RINTL
:
367 /* Only convert rint* if we can ignore math exceptions. */
368 if (flag_trapping_math
)
370 /* ... Fall through ... */
371 case BUILT_IN_NEARBYINT
: case BUILT_IN_NEARBYINTF
: case BUILT_IN_NEARBYINTL
:
372 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
373 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLRINT
);
375 fn
= mathfn_built_in (s_intype
, BUILT_IN_LRINT
);
383 tree arglist
= TREE_OPERAND (s_expr
, 1);
384 tree newexpr
= build_function_call_expr (fn
, arglist
);
385 return convert_to_integer (type
, newexpr
);
389 switch (TREE_CODE (intype
))
393 if (integer_zerop (expr
))
394 expr
= integer_zero_node
;
396 expr
= fold (build1 (CONVERT_EXPR
,
397 lang_hooks
.types
.type_for_size (POINTER_SIZE
, 0),
400 return convert_to_integer (type
, expr
);
406 /* If this is a logical operation, which just returns 0 or 1, we can
407 change the type of the expression. */
409 if (TREE_CODE_CLASS (ex_form
) == tcc_comparison
)
411 expr
= copy_node (expr
);
412 TREE_TYPE (expr
) = type
;
416 /* If we are widening the type, put in an explicit conversion.
417 Similarly if we are not changing the width. After this, we know
418 we are truncating EXPR. */
420 else if (outprec
>= inprec
)
424 /* If the precision of the EXPR's type is K bits and the
425 destination mode has more bits, and the sign is changing,
426 it is not safe to use a NOP_EXPR. For example, suppose
427 that EXPR's type is a 3-bit unsigned integer type, the
428 TYPE is a 3-bit signed integer type, and the machine mode
429 for the types is 8-bit QImode. In that case, the
430 conversion necessitates an explicit sign-extension. In
431 the signed-to-unsigned case the high-order bits have to
433 if (TYPE_UNSIGNED (type
) != TYPE_UNSIGNED (TREE_TYPE (expr
))
434 && (TYPE_PRECISION (TREE_TYPE (expr
))
435 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)))))
440 return build1 (code
, type
, expr
);
443 /* If TYPE is an enumeral type or a type with a precision less
444 than the number of bits in its mode, do the conversion to the
445 type corresponding to its mode, then do a nop conversion
447 else if (TREE_CODE (type
) == ENUMERAL_TYPE
448 || outprec
!= GET_MODE_BITSIZE (TYPE_MODE (type
)))
449 return build1 (NOP_EXPR
, type
,
450 convert (lang_hooks
.types
.type_for_mode
451 (TYPE_MODE (type
), TYPE_UNSIGNED (type
)),
454 /* Here detect when we can distribute the truncation down past some
455 arithmetic. For example, if adding two longs and converting to an
456 int, we can equally well convert both to ints and then add.
457 For the operations handled here, such truncation distribution
459 It is desirable in these cases:
460 1) when truncating down to full-word from a larger size
461 2) when truncating takes no work.
462 3) when at least one operand of the arithmetic has been extended
463 (as by C's default conversions). In this case we need two conversions
464 if we do the arithmetic as already requested, so we might as well
465 truncate both and then combine. Perhaps that way we need only one.
467 Note that in general we cannot do the arithmetic in a type
468 shorter than the desired result of conversion, even if the operands
469 are both extended from a shorter type, because they might overflow
470 if combined in that type. The exceptions to this--the times when
471 two narrow values can be combined in their narrow type even to
472 make a wider result--are handled by "shorten" in build_binary_op. */
477 /* We can pass truncation down through right shifting
478 when the shift count is a nonpositive constant. */
479 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
480 && tree_int_cst_lt (TREE_OPERAND (expr
, 1),
481 convert (TREE_TYPE (TREE_OPERAND (expr
, 1)),
487 /* We can pass truncation down through left shifting
488 when the shift count is a nonnegative constant and
489 the target type is unsigned. */
490 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
491 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) >= 0
492 && TYPE_UNSIGNED (type
)
493 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
495 /* If shift count is less than the width of the truncated type,
497 if (tree_int_cst_lt (TREE_OPERAND (expr
, 1), TYPE_SIZE (type
)))
498 /* In this case, shifting is like multiplication. */
502 /* If it is >= that width, result is zero.
503 Handling this with trunc1 would give the wrong result:
504 (int) ((long long) a << 32) is well defined (as 0)
505 but (int) a << 32 is undefined and would get a
508 tree t
= convert_to_integer (type
, integer_zero_node
);
510 /* If the original expression had side-effects, we must
512 if (TREE_SIDE_EFFECTS (expr
))
513 return build2 (COMPOUND_EXPR
, type
, expr
, t
);
524 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
525 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
527 /* Don't distribute unless the output precision is at least as big
528 as the actual inputs. Otherwise, the comparison of the
529 truncated values will be wrong. */
530 if (outprec
>= TYPE_PRECISION (TREE_TYPE (arg0
))
531 && outprec
>= TYPE_PRECISION (TREE_TYPE (arg1
))
532 /* If signedness of arg0 and arg1 don't match,
533 we can't necessarily find a type to compare them in. */
534 && (TYPE_UNSIGNED (TREE_TYPE (arg0
))
535 == TYPE_UNSIGNED (TREE_TYPE (arg1
))))
547 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
548 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
550 if (outprec
>= BITS_PER_WORD
551 || TRULY_NOOP_TRUNCATION (outprec
, inprec
)
552 || inprec
> TYPE_PRECISION (TREE_TYPE (arg0
))
553 || inprec
> TYPE_PRECISION (TREE_TYPE (arg1
)))
555 /* Do the arithmetic in type TYPEX,
556 then convert result to TYPE. */
559 /* Can't do arithmetic in enumeral types
560 so use an integer type that will hold the values. */
561 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
562 typex
= lang_hooks
.types
.type_for_size
563 (TYPE_PRECISION (typex
), TYPE_UNSIGNED (typex
));
565 /* But now perhaps TYPEX is as wide as INPREC.
566 In that case, do nothing special here.
567 (Otherwise would recurse infinitely in convert. */
568 if (TYPE_PRECISION (typex
) != inprec
)
570 /* Don't do unsigned arithmetic where signed was wanted,
572 Exception: if both of the original operands were
573 unsigned then we can safely do the work as unsigned.
574 Exception: shift operations take their type solely
575 from the first argument.
576 Exception: the LSHIFT_EXPR case above requires that
577 we perform this operation unsigned lest we produce
578 signed-overflow undefinedness.
579 And we may need to do it as unsigned
580 if we truncate to the original size. */
581 if (TYPE_UNSIGNED (TREE_TYPE (expr
))
582 || (TYPE_UNSIGNED (TREE_TYPE (arg0
))
583 && (TYPE_UNSIGNED (TREE_TYPE (arg1
))
584 || ex_form
== LSHIFT_EXPR
585 || ex_form
== RSHIFT_EXPR
586 || ex_form
== LROTATE_EXPR
587 || ex_form
== RROTATE_EXPR
))
588 || ex_form
== LSHIFT_EXPR
)
589 typex
= lang_hooks
.types
.unsigned_type (typex
);
591 typex
= lang_hooks
.types
.signed_type (typex
);
592 return convert (type
,
593 fold (build2 (ex_form
, typex
,
594 convert (typex
, arg0
),
595 convert (typex
, arg1
))));
603 /* This is not correct for ABS_EXPR,
604 since we must test the sign before truncation. */
608 /* Can't do arithmetic in enumeral types
609 so use an integer type that will hold the values. */
610 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
611 typex
= lang_hooks
.types
.type_for_size
612 (TYPE_PRECISION (typex
), TYPE_UNSIGNED (typex
));
614 /* But now perhaps TYPEX is as wide as INPREC.
615 In that case, do nothing special here.
616 (Otherwise would recurse infinitely in convert. */
617 if (TYPE_PRECISION (typex
) != inprec
)
619 /* Don't do unsigned arithmetic where signed was wanted,
621 if (TYPE_UNSIGNED (TREE_TYPE (expr
)))
622 typex
= lang_hooks
.types
.unsigned_type (typex
);
624 typex
= lang_hooks
.types
.signed_type (typex
);
625 return convert (type
,
626 fold (build1 (ex_form
, typex
,
628 TREE_OPERAND (expr
, 0)))));
634 "can't convert between vector values of different size" error. */
635 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == VECTOR_TYPE
636 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0))))
637 != GET_MODE_SIZE (TYPE_MODE (type
))))
639 /* If truncating after truncating, might as well do all at once.
640 If truncating after extending, we may get rid of wasted work. */
641 return convert (type
, get_unwidened (TREE_OPERAND (expr
, 0), type
));
644 /* It is sometimes worthwhile to push the narrowing down through
645 the conditional and never loses. */
646 return fold (build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0),
647 convert (type
, TREE_OPERAND (expr
, 1)),
648 convert (type
, TREE_OPERAND (expr
, 2))));
654 return build1 (CONVERT_EXPR
, type
, expr
);
657 return build1 (FIX_TRUNC_EXPR
, type
, expr
);
660 return convert (type
,
661 fold (build1 (REALPART_EXPR
,
662 TREE_TYPE (TREE_TYPE (expr
)), expr
)));
665 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
667 error ("can't convert between vector values of different size");
668 return error_mark_node
;
670 return build1 (NOP_EXPR
, type
, expr
);
673 error ("aggregate value used where an integer was expected");
674 return convert (type
, integer_zero_node
);
678 /* Convert EXPR to the complex type TYPE in the usual ways. */
681 convert_to_complex (tree type
, tree expr
)
683 tree subtype
= TREE_TYPE (type
);
685 switch (TREE_CODE (TREE_TYPE (expr
)))
692 return build2 (COMPLEX_EXPR
, type
, convert (subtype
, expr
),
693 convert (subtype
, integer_zero_node
));
697 tree elt_type
= TREE_TYPE (TREE_TYPE (expr
));
699 if (TYPE_MAIN_VARIANT (elt_type
) == TYPE_MAIN_VARIANT (subtype
))
701 else if (TREE_CODE (expr
) == COMPLEX_EXPR
)
702 return fold (build2 (COMPLEX_EXPR
, type
,
703 convert (subtype
, TREE_OPERAND (expr
, 0)),
704 convert (subtype
, TREE_OPERAND (expr
, 1))));
707 expr
= save_expr (expr
);
709 fold (build2 (COMPLEX_EXPR
, type
,
711 fold (build1 (REALPART_EXPR
,
712 TREE_TYPE (TREE_TYPE (expr
)),
715 fold (build1 (IMAGPART_EXPR
,
716 TREE_TYPE (TREE_TYPE (expr
)),
723 error ("pointer value used where a complex was expected");
724 return convert_to_complex (type
, integer_zero_node
);
727 error ("aggregate value used where a complex was expected");
728 return convert_to_complex (type
, integer_zero_node
);
732 /* Convert EXPR to the vector type TYPE in the usual ways. */
735 convert_to_vector (tree type
, tree expr
)
737 switch (TREE_CODE (TREE_TYPE (expr
)))
741 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
743 error ("can't convert between vector values of different size");
744 return error_mark_node
;
746 return build1 (NOP_EXPR
, type
, expr
);
749 error ("can't convert value to a vector");
750 return error_mark_node
;