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 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_2 (0, 0);
47 TREE_TYPE (expr
) = type
;
51 switch (TREE_CODE (TREE_TYPE (expr
)))
55 return build1 (NOP_EXPR
, type
, expr
);
61 if (TYPE_PRECISION (TREE_TYPE (expr
)) == POINTER_SIZE
)
62 return build1 (CONVERT_EXPR
, type
, expr
);
65 convert_to_pointer (type
,
66 convert (lang_hooks
.types
.type_for_size
67 (POINTER_SIZE
, 0), expr
));
70 error ("cannot convert to a pointer type");
71 return convert_to_pointer (type
, integer_zero_node
);
75 /* Avoid any floating point extensions from EXP. */
77 strip_float_extensions (tree exp
)
81 /* For floating point constant look up the narrowest type that can hold
82 it properly and handle it like (type)(narrowest_type)constant.
83 This way we can optimize for instance a=a*2.0 where "a" is float
84 but 2.0 is double constant. */
85 if (TREE_CODE (exp
) == REAL_CST
)
90 orig
= TREE_REAL_CST (exp
);
91 if (TYPE_PRECISION (TREE_TYPE (exp
)) > TYPE_PRECISION (float_type_node
)
92 && exact_real_truncate (TYPE_MODE (float_type_node
), &orig
))
93 type
= float_type_node
;
94 else if (TYPE_PRECISION (TREE_TYPE (exp
))
95 > TYPE_PRECISION (double_type_node
)
96 && exact_real_truncate (TYPE_MODE (double_type_node
), &orig
))
97 type
= double_type_node
;
99 return build_real (type
, real_value_truncate (TYPE_MODE (type
), orig
));
102 if (TREE_CODE (exp
) != NOP_EXPR
103 && TREE_CODE (exp
) != CONVERT_EXPR
)
106 sub
= TREE_OPERAND (exp
, 0);
107 subt
= TREE_TYPE (sub
);
108 expt
= TREE_TYPE (exp
);
110 if (!FLOAT_TYPE_P (subt
))
113 if (TYPE_PRECISION (subt
) > TYPE_PRECISION (expt
))
116 return strip_float_extensions (sub
);
120 /* Convert EXPR to some floating-point type TYPE.
122 EXPR must be float, integer, or enumeral;
123 in other cases error is called. */
126 convert_to_real (tree type
, tree expr
)
128 enum built_in_function fcode
= builtin_mathfn_code (expr
);
129 tree itype
= TREE_TYPE (expr
);
131 /* Disable until we figure out how to decide whether the functions are
132 present in runtime. */
133 /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
135 && (TYPE_MODE (type
) == TYPE_MODE (double_type_node
)
136 || TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))
140 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
177 tree arg0
= strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr
, 1)));
180 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
181 the both as the safe type for operation. */
182 if (TYPE_PRECISION (TREE_TYPE (arg0
)) > TYPE_PRECISION (type
))
183 newtype
= TREE_TYPE (arg0
);
185 /* Be careful about integer to fp conversions.
186 These may overflow still. */
187 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
188 && TYPE_PRECISION (newtype
) < TYPE_PRECISION (itype
)
189 && (TYPE_MODE (newtype
) == TYPE_MODE (double_type_node
)
190 || TYPE_MODE (newtype
) == TYPE_MODE (float_type_node
)))
193 tree fn
= mathfn_built_in (newtype
, fcode
);
197 arglist
= build_tree_list (NULL_TREE
, fold (convert_to_real (newtype
, arg0
)));
198 expr
= build_function_call_expr (fn
, arglist
);
209 && (((fcode
== BUILT_IN_FLOORL
210 || fcode
== BUILT_IN_CEILL
211 || fcode
== BUILT_IN_ROUNDL
212 || fcode
== BUILT_IN_RINTL
213 || fcode
== BUILT_IN_TRUNCL
214 || fcode
== BUILT_IN_NEARBYINTL
)
215 && (TYPE_MODE (type
) == TYPE_MODE (double_type_node
)
216 || TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))
217 || ((fcode
== BUILT_IN_FLOOR
218 || fcode
== BUILT_IN_CEIL
219 || fcode
== BUILT_IN_ROUND
220 || fcode
== BUILT_IN_RINT
221 || fcode
== BUILT_IN_TRUNC
222 || fcode
== BUILT_IN_NEARBYINT
)
223 && (TYPE_MODE (type
) == TYPE_MODE (float_type_node
)))))
225 tree fn
= mathfn_built_in (type
, fcode
);
229 tree arg0
= strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr
,
231 tree arglist
= build_tree_list (NULL_TREE
,
232 fold (convert_to_real (type
, arg0
)));
234 return build_function_call_expr (fn
, arglist
);
238 /* Propagate the cast into the operation. */
239 if (itype
!= type
&& FLOAT_TYPE_P (type
))
240 switch (TREE_CODE (expr
))
242 /* Convert (float)-x into -(float)x. This is always safe. */
245 if (TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (expr
)))
246 return build1 (TREE_CODE (expr
), type
,
247 fold (convert_to_real (type
,
248 TREE_OPERAND (expr
, 0))));
250 /* Convert (outertype)((innertype0)a+(innertype1)b)
251 into ((newtype)a+(newtype)b) where newtype
252 is the widest mode from all of these. */
258 tree arg0
= strip_float_extensions (TREE_OPERAND (expr
, 0));
259 tree arg1
= strip_float_extensions (TREE_OPERAND (expr
, 1));
261 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
262 && FLOAT_TYPE_P (TREE_TYPE (arg1
)))
265 if (TYPE_PRECISION (TREE_TYPE (arg0
)) > TYPE_PRECISION (newtype
))
266 newtype
= TREE_TYPE (arg0
);
267 if (TYPE_PRECISION (TREE_TYPE (arg1
)) > TYPE_PRECISION (newtype
))
268 newtype
= TREE_TYPE (arg1
);
269 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (itype
))
271 expr
= build (TREE_CODE (expr
), newtype
,
272 fold (convert_to_real (newtype
, arg0
)),
273 fold (convert_to_real (newtype
, arg1
)));
284 switch (TREE_CODE (TREE_TYPE (expr
)))
287 return build1 (flag_float_store
? CONVERT_EXPR
: NOP_EXPR
,
294 return build1 (FLOAT_EXPR
, type
, expr
);
297 return convert (type
,
298 fold (build1 (REALPART_EXPR
,
299 TREE_TYPE (TREE_TYPE (expr
)), expr
)));
303 error ("pointer value used where a floating point value was expected");
304 return convert_to_real (type
, integer_zero_node
);
307 error ("aggregate value used where a float was expected");
308 return convert_to_real (type
, integer_zero_node
);
312 /* Convert EXPR to some integer (or enum) type TYPE.
314 EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
315 vector; in other cases error is called.
317 The result of this is always supposed to be a newly created tree node
318 not in use in any existing structure. */
321 convert_to_integer (tree type
, tree expr
)
323 enum tree_code ex_form
= TREE_CODE (expr
);
324 tree intype
= TREE_TYPE (expr
);
325 unsigned int inprec
= TYPE_PRECISION (intype
);
326 unsigned int outprec
= TYPE_PRECISION (type
);
328 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
329 be. Consider `enum E = { a, b = (enum E) 3 };'. */
330 if (!COMPLETE_TYPE_P (type
))
332 error ("conversion to incomplete type");
333 return error_mark_node
;
336 /* Convert e.g. (long)round(d) -> lround(d). */
337 /* If we're converting to char, we may encounter differing behavior
338 between converting from double->char vs double->long->char.
339 We're in "undefined" territory but we prefer to be conservative,
340 so only proceed in "unsafe" math mode. */
342 && (flag_unsafe_math_optimizations
343 || (long_integer_type_node
344 && outprec
>= TYPE_PRECISION (long_integer_type_node
))))
346 tree s_expr
= strip_float_extensions (expr
);
347 tree s_intype
= TREE_TYPE (s_expr
);
348 const enum built_in_function fcode
= builtin_mathfn_code (s_expr
);
353 case BUILT_IN_ROUND
: case BUILT_IN_ROUNDF
: case BUILT_IN_ROUNDL
:
354 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
355 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLROUND
);
357 fn
= mathfn_built_in (s_intype
, BUILT_IN_LROUND
);
360 case BUILT_IN_RINT
: case BUILT_IN_RINTF
: case BUILT_IN_RINTL
:
361 /* Only convert rint* if we can ignore math exceptions. */
362 if (flag_trapping_math
)
364 /* ... Fall through ... */
365 case BUILT_IN_NEARBYINT
: case BUILT_IN_NEARBYINTF
: case BUILT_IN_NEARBYINTL
:
366 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (long_long_integer_type_node
))
367 fn
= mathfn_built_in (s_intype
, BUILT_IN_LLRINT
);
369 fn
= mathfn_built_in (s_intype
, BUILT_IN_LRINT
);
377 tree arglist
= TREE_OPERAND (s_expr
, 1);
378 tree newexpr
= build_function_call_expr (fn
, arglist
);
379 return convert_to_integer (type
, newexpr
);
383 switch (TREE_CODE (intype
))
387 if (integer_zerop (expr
))
388 expr
= integer_zero_node
;
390 expr
= fold (build1 (CONVERT_EXPR
,
391 lang_hooks
.types
.type_for_size (POINTER_SIZE
, 0),
394 return convert_to_integer (type
, expr
);
400 /* If this is a logical operation, which just returns 0 or 1, we can
401 change the type of the expression. For some logical operations,
402 we must also change the types of the operands to maintain type
405 if (TREE_CODE_CLASS (ex_form
) == '<')
407 expr
= copy_node (expr
);
408 TREE_TYPE (expr
) = type
;
412 else if (ex_form
== TRUTH_AND_EXPR
|| ex_form
== TRUTH_ANDIF_EXPR
413 || ex_form
== TRUTH_OR_EXPR
|| ex_form
== TRUTH_ORIF_EXPR
414 || ex_form
== TRUTH_XOR_EXPR
)
416 expr
= copy_node (expr
);
417 TREE_OPERAND (expr
, 0) = convert (type
, TREE_OPERAND (expr
, 0));
418 TREE_OPERAND (expr
, 1) = convert (type
, TREE_OPERAND (expr
, 1));
419 TREE_TYPE (expr
) = type
;
423 else if (ex_form
== TRUTH_NOT_EXPR
)
425 expr
= copy_node (expr
);
426 TREE_OPERAND (expr
, 0) = convert (type
, TREE_OPERAND (expr
, 0));
427 TREE_TYPE (expr
) = type
;
431 /* If we are widening the type, put in an explicit conversion.
432 Similarly if we are not changing the width. After this, we know
433 we are truncating EXPR. */
435 else if (outprec
>= inprec
)
439 /* If the precision of the EXPR's type is K bits and the
440 destination mode has more bits, and the sign is changing,
441 it is not safe to use a NOP_EXPR. For example, suppose
442 that EXPR's type is a 3-bit unsigned integer type, the
443 TYPE is a 3-bit signed integer type, and the machine mode
444 for the types is 8-bit QImode. In that case, the
445 conversion necessitates an explicit sign-extension. In
446 the signed-to-unsigned case the high-order bits have to
448 if (TYPE_UNSIGNED (type
) != TYPE_UNSIGNED (TREE_TYPE (expr
))
449 && (TYPE_PRECISION (TREE_TYPE (expr
))
450 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)))))
455 return build1 (code
, type
, expr
);
458 /* If TYPE is an enumeral type or a type with a precision less
459 than the number of bits in its mode, do the conversion to the
460 type corresponding to its mode, then do a nop conversion
462 else if (TREE_CODE (type
) == ENUMERAL_TYPE
463 || outprec
!= GET_MODE_BITSIZE (TYPE_MODE (type
)))
464 return build1 (NOP_EXPR
, type
,
465 convert (lang_hooks
.types
.type_for_mode
466 (TYPE_MODE (type
), TYPE_UNSIGNED (type
)),
469 /* Here detect when we can distribute the truncation down past some
470 arithmetic. For example, if adding two longs and converting to an
471 int, we can equally well convert both to ints and then add.
472 For the operations handled here, such truncation distribution
474 It is desirable in these cases:
475 1) when truncating down to full-word from a larger size
476 2) when truncating takes no work.
477 3) when at least one operand of the arithmetic has been extended
478 (as by C's default conversions). In this case we need two conversions
479 if we do the arithmetic as already requested, so we might as well
480 truncate both and then combine. Perhaps that way we need only one.
482 Note that in general we cannot do the arithmetic in a type
483 shorter than the desired result of conversion, even if the operands
484 are both extended from a shorter type, because they might overflow
485 if combined in that type. The exceptions to this--the times when
486 two narrow values can be combined in their narrow type even to
487 make a wider result--are handled by "shorten" in build_binary_op. */
492 /* We can pass truncation down through right shifting
493 when the shift count is a nonpositive constant. */
494 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
495 && tree_int_cst_lt (TREE_OPERAND (expr
, 1),
496 convert (TREE_TYPE (TREE_OPERAND (expr
, 1)),
502 /* We can pass truncation down through left shifting
503 when the shift count is a nonnegative constant and
504 the target type is unsigned. */
505 if (TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
506 && tree_int_cst_sgn (TREE_OPERAND (expr
, 1)) >= 0
507 && TYPE_UNSIGNED (type
)
508 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
510 /* If shift count is less than the width of the truncated type,
512 if (tree_int_cst_lt (TREE_OPERAND (expr
, 1), TYPE_SIZE (type
)))
513 /* In this case, shifting is like multiplication. */
517 /* If it is >= that width, result is zero.
518 Handling this with trunc1 would give the wrong result:
519 (int) ((long long) a << 32) is well defined (as 0)
520 but (int) a << 32 is undefined and would get a
523 tree t
= convert_to_integer (type
, integer_zero_node
);
525 /* If the original expression had side-effects, we must
527 if (TREE_SIDE_EFFECTS (expr
))
528 return build (COMPOUND_EXPR
, type
, expr
, t
);
539 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
540 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
542 /* Don't distribute unless the output precision is at least as big
543 as the actual inputs. Otherwise, the comparison of the
544 truncated values will be wrong. */
545 if (outprec
>= TYPE_PRECISION (TREE_TYPE (arg0
))
546 && outprec
>= TYPE_PRECISION (TREE_TYPE (arg1
))
547 /* If signedness of arg0 and arg1 don't match,
548 we can't necessarily find a type to compare them in. */
549 && (TYPE_UNSIGNED (TREE_TYPE (arg0
))
550 == TYPE_UNSIGNED (TREE_TYPE (arg1
))))
562 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
563 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
565 if (outprec
>= BITS_PER_WORD
566 || TRULY_NOOP_TRUNCATION (outprec
, inprec
)
567 || inprec
> TYPE_PRECISION (TREE_TYPE (arg0
))
568 || inprec
> TYPE_PRECISION (TREE_TYPE (arg1
)))
570 /* Do the arithmetic in type TYPEX,
571 then convert result to TYPE. */
574 /* Can't do arithmetic in enumeral types
575 so use an integer type that will hold the values. */
576 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
577 typex
= lang_hooks
.types
.type_for_size
578 (TYPE_PRECISION (typex
), TYPE_UNSIGNED (typex
));
580 /* But now perhaps TYPEX is as wide as INPREC.
581 In that case, do nothing special here.
582 (Otherwise would recurse infinitely in convert. */
583 if (TYPE_PRECISION (typex
) != inprec
)
585 /* Don't do unsigned arithmetic where signed was wanted,
587 Exception: if both of the original operands were
588 unsigned then we can safely do the work as unsigned.
589 Exception: shift operations take their type solely
590 from the first argument.
591 Exception: the LSHIFT_EXPR case above requires that
592 we perform this operation unsigned lest we produce
593 signed-overflow undefinedness.
594 And we may need to do it as unsigned
595 if we truncate to the original size. */
596 if (TYPE_UNSIGNED (TREE_TYPE (expr
))
597 || (TYPE_UNSIGNED (TREE_TYPE (arg0
))
598 && (TYPE_UNSIGNED (TREE_TYPE (arg1
))
599 || ex_form
== LSHIFT_EXPR
600 || ex_form
== RSHIFT_EXPR
601 || ex_form
== LROTATE_EXPR
602 || ex_form
== RROTATE_EXPR
))
603 || ex_form
== LSHIFT_EXPR
)
604 typex
= lang_hooks
.types
.unsigned_type (typex
);
606 typex
= lang_hooks
.types
.signed_type (typex
);
607 return convert (type
,
608 fold (build (ex_form
, typex
,
609 convert (typex
, arg0
),
610 convert (typex
, arg1
))));
618 /* This is not correct for ABS_EXPR,
619 since we must test the sign before truncation. */
623 /* Can't do arithmetic in enumeral types
624 so use an integer type that will hold the values. */
625 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
626 typex
= lang_hooks
.types
.type_for_size
627 (TYPE_PRECISION (typex
), TYPE_UNSIGNED (typex
));
629 /* But now perhaps TYPEX is as wide as INPREC.
630 In that case, do nothing special here.
631 (Otherwise would recurse infinitely in convert. */
632 if (TYPE_PRECISION (typex
) != inprec
)
634 /* Don't do unsigned arithmetic where signed was wanted,
636 if (TYPE_UNSIGNED (TREE_TYPE (expr
)))
637 typex
= lang_hooks
.types
.unsigned_type (typex
);
639 typex
= lang_hooks
.types
.signed_type (typex
);
640 return convert (type
,
641 fold (build1 (ex_form
, typex
,
643 TREE_OPERAND (expr
, 0)))));
649 "can't convert between vector values of different size" error. */
650 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == VECTOR_TYPE
651 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0))))
652 != GET_MODE_SIZE (TYPE_MODE (type
))))
654 /* If truncating after truncating, might as well do all at once.
655 If truncating after extending, we may get rid of wasted work. */
656 return convert (type
, get_unwidened (TREE_OPERAND (expr
, 0), type
));
659 /* It is sometimes worthwhile to push the narrowing down through
660 the conditional and never loses. */
661 return fold (build (COND_EXPR
, type
, TREE_OPERAND (expr
, 0),
662 convert (type
, TREE_OPERAND (expr
, 1)),
663 convert (type
, TREE_OPERAND (expr
, 2))));
669 return build1 (CONVERT_EXPR
, type
, expr
);
672 return build1 (FIX_TRUNC_EXPR
, type
, expr
);
675 return convert (type
,
676 fold (build1 (REALPART_EXPR
,
677 TREE_TYPE (TREE_TYPE (expr
)), expr
)));
680 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
682 error ("can't convert between vector values of different size");
683 return error_mark_node
;
685 return build1 (NOP_EXPR
, type
, expr
);
688 error ("aggregate value used where an integer was expected");
689 return convert (type
, integer_zero_node
);
693 /* Convert EXPR to the complex type TYPE in the usual ways. */
696 convert_to_complex (tree type
, tree expr
)
698 tree subtype
= TREE_TYPE (type
);
700 switch (TREE_CODE (TREE_TYPE (expr
)))
707 return build (COMPLEX_EXPR
, type
, convert (subtype
, expr
),
708 convert (subtype
, integer_zero_node
));
712 tree elt_type
= TREE_TYPE (TREE_TYPE (expr
));
714 if (TYPE_MAIN_VARIANT (elt_type
) == TYPE_MAIN_VARIANT (subtype
))
716 else if (TREE_CODE (expr
) == COMPLEX_EXPR
)
717 return fold (build (COMPLEX_EXPR
,
719 convert (subtype
, TREE_OPERAND (expr
, 0)),
720 convert (subtype
, TREE_OPERAND (expr
, 1))));
723 expr
= save_expr (expr
);
725 fold (build (COMPLEX_EXPR
,
726 type
, convert (subtype
,
727 fold (build1 (REALPART_EXPR
,
728 TREE_TYPE (TREE_TYPE (expr
)),
731 fold (build1 (IMAGPART_EXPR
,
732 TREE_TYPE (TREE_TYPE (expr
)),
739 error ("pointer value used where a complex was expected");
740 return convert_to_complex (type
, integer_zero_node
);
743 error ("aggregate value used where a complex was expected");
744 return convert_to_complex (type
, integer_zero_node
);
748 /* Convert EXPR to the vector type TYPE in the usual ways. */
751 convert_to_vector (tree type
, tree expr
)
753 switch (TREE_CODE (TREE_TYPE (expr
)))
757 if (!tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (TREE_TYPE (expr
))))
759 error ("can't convert between vector values of different size");
760 return error_mark_node
;
762 return build1 (NOP_EXPR
, type
, expr
);
765 error ("can't convert value to a vector");
766 return convert_to_vector (type
, integer_zero_node
);