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);
203 /* This code formerly changed (float)floor(double d) to
204 floorf((float)d). This is incorrect, because (float)d uses
205 round-to-nearest and can round up to the next integer. */
207 /* Propagate the cast into the operation. */
208 if (itype != type && FLOAT_TYPE_P (type))
209 switch (TREE_CODE (expr))
211 /* Convert (float)-x into -(float)x. This is always safe. */
214 if (TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
215 return build1 (TREE_CODE (expr), type,
216 fold (convert_to_real (type,
217 TREE_OPERAND (expr, 0))));
219 /* Convert (outertype)((innertype0)a+(innertype1)b)
220 into ((newtype)a+(newtype)b) where newtype
221 is the widest mode from all of these. */
227 tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
228 tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
230 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
231 && FLOAT_TYPE_P (TREE_TYPE (arg1)))
234 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
235 newtype = TREE_TYPE (arg0);
236 if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
237 newtype = TREE_TYPE (arg1);
238 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype))
240 expr = build2 (TREE_CODE (expr), newtype,
241 fold (convert_to_real (newtype, arg0)),
242 fold (convert_to_real (newtype, arg1)));
253 switch (TREE_CODE (TREE_TYPE (expr)))
256 return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
263 return build1 (FLOAT_EXPR, type, expr);
266 return convert (type,
267 fold_build1 (REALPART_EXPR,
268 TREE_TYPE (TREE_TYPE (expr)), expr));
272 error ("pointer value used where a floating point value was expected");
273 return convert_to_real (type, integer_zero_node);
276 error ("aggregate value used where a float was expected");
277 return convert_to_real (type, integer_zero_node);
281 /* Convert EXPR to some integer (or enum) type TYPE.
283 EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
284 vector; in other cases error is called.
286 The result of this is always supposed to be a newly created tree node
287 not in use in any existing structure. */
290 convert_to_integer (tree type, tree expr)
292 enum tree_code ex_form = TREE_CODE (expr);
293 tree intype = TREE_TYPE (expr);
294 unsigned int inprec = TYPE_PRECISION (intype);
295 unsigned int outprec = TYPE_PRECISION (type);
297 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
298 be. Consider `enum E = { a, b = (enum E) 3 };'. */
299 if (!COMPLETE_TYPE_P (type))
301 error ("conversion to incomplete type");
302 return error_mark_node;
305 /* Convert e.g. (long)round(d) -> lround(d). */
306 /* If we're converting to char, we may encounter differing behavior
307 between converting from double->char vs double->long->char.
308 We're in "undefined" territory but we prefer to be conservative,
309 so only proceed in "unsafe" math mode. */
311 && (flag_unsafe_math_optimizations
312 || (long_integer_type_node
313 && outprec >= TYPE_PRECISION (long_integer_type_node))))
315 tree s_expr = strip_float_extensions (expr);
316 tree s_intype = TREE_TYPE (s_expr);
317 const enum built_in_function fcode = builtin_mathfn_code (s_expr);
322 case BUILT_IN_CEIL: case BUILT_IN_CEILF: case BUILT_IN_CEILL:
323 /* Only convert in ISO C99 mode. */
324 if (!TARGET_C99_FUNCTIONS)
326 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
327 fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL);
329 fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
332 case BUILT_IN_FLOOR: case BUILT_IN_FLOORF: case BUILT_IN_FLOORL:
333 /* Only convert in ISO C99 mode. */
334 if (!TARGET_C99_FUNCTIONS)
336 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
337 fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR);
339 fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
342 case BUILT_IN_ROUND: case BUILT_IN_ROUNDF: case BUILT_IN_ROUNDL:
343 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
344 fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
346 fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
349 case BUILT_IN_RINT: case BUILT_IN_RINTF: case BUILT_IN_RINTL:
350 /* Only convert rint* if we can ignore math exceptions. */
351 if (flag_trapping_math)
353 /* ... Fall through ... */
354 case BUILT_IN_NEARBYINT: case BUILT_IN_NEARBYINTF: case BUILT_IN_NEARBYINTL:
355 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
356 fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT);
358 fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
361 case BUILT_IN_TRUNC: case BUILT_IN_TRUNCF: case BUILT_IN_TRUNCL:
363 tree arglist = TREE_OPERAND (s_expr, 1);
364 return convert_to_integer (type, TREE_VALUE (arglist));
373 tree arglist = TREE_OPERAND (s_expr, 1);
374 tree newexpr = build_function_call_expr (fn, arglist);
375 return convert_to_integer (type, newexpr);
379 switch (TREE_CODE (intype))
383 if (integer_zerop (expr))
384 return build_int_cst (type, 0);
386 /* Convert to an unsigned integer of the correct width first,
387 and from there widen/truncate to the required type. */
388 expr = fold_build1 (CONVERT_EXPR,
389 lang_hooks.types.type_for_size (POINTER_SIZE, 0),
391 return fold_build1 (NOP_EXPR, type, expr);
397 /* If this is a logical operation, which just returns 0 or 1, we can
398 change the type of the expression. */
400 if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
402 expr = copy_node (expr);
403 TREE_TYPE (expr) = type;
407 /* If we are widening the type, put in an explicit conversion.
408 Similarly if we are not changing the width. After this, we know
409 we are truncating EXPR. */
411 else if (outprec >= inprec)
415 /* If the precision of the EXPR's type is K bits and the
416 destination mode has more bits, and the sign is changing,
417 it is not safe to use a NOP_EXPR. For example, suppose
418 that EXPR's type is a 3-bit unsigned integer type, the
419 TYPE is a 3-bit signed integer type, and the machine mode
420 for the types is 8-bit QImode. In that case, the
421 conversion necessitates an explicit sign-extension. In
422 the signed-to-unsigned case the high-order bits have to
424 if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
425 && (TYPE_PRECISION (TREE_TYPE (expr))
426 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
431 return fold_build1 (code, type, expr);
434 /* If TYPE is an enumeral type or a type with a precision less
435 than the number of bits in its mode, do the conversion to the
436 type corresponding to its mode, then do a nop conversion
438 else if (TREE_CODE (type) == ENUMERAL_TYPE
439 || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
440 return build1 (NOP_EXPR, type,
441 convert (lang_hooks.types.type_for_mode
442 (TYPE_MODE (type), TYPE_UNSIGNED (type)),
445 /* Here detect when we can distribute the truncation down past some
446 arithmetic. For example, if adding two longs and converting to an
447 int, we can equally well convert both to ints and then add.
448 For the operations handled here, such truncation distribution
450 It is desirable in these cases:
451 1) when truncating down to full-word from a larger size
452 2) when truncating takes no work.
453 3) when at least one operand of the arithmetic has been extended
454 (as by C's default conversions). In this case we need two conversions
455 if we do the arithmetic as already requested, so we might as well
456 truncate both and then combine. Perhaps that way we need only one.
458 Note that in general we cannot do the arithmetic in a type
459 shorter than the desired result of conversion, even if the operands
460 are both extended from a shorter type, because they might overflow
461 if combined in that type. The exceptions to this--the times when
462 two narrow values can be combined in their narrow type even to
463 make a wider result--are handled by "shorten" in build_binary_op. */
468 /* We can pass truncation down through right shifting
469 when the shift count is a nonpositive constant. */
470 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
471 && tree_int_cst_lt (TREE_OPERAND (expr, 1),
472 convert (TREE_TYPE (TREE_OPERAND (expr, 1)),
478 /* We can pass truncation down through left shifting
479 when the shift count is a nonnegative constant and
480 the target type is unsigned. */
481 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
482 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
483 && TYPE_UNSIGNED (type)
484 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
486 /* If shift count is less than the width of the truncated type,
488 if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
489 /* In this case, shifting is like multiplication. */
493 /* If it is >= that width, result is zero.
494 Handling this with trunc1 would give the wrong result:
495 (int) ((long long) a << 32) is well defined (as 0)
496 but (int) a << 32 is undefined and would get a
499 tree t = convert_to_integer (type, integer_zero_node);
501 /* If the original expression had side-effects, we must
503 if (TREE_SIDE_EFFECTS (expr))
504 return build2 (COMPOUND_EXPR, type, expr, t);
515 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
516 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
518 /* Don't distribute unless the output precision is at least as big
519 as the actual inputs. Otherwise, the comparison of the
520 truncated values will be wrong. */
521 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
522 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
523 /* If signedness of arg0 and arg1 don't match,
524 we can't necessarily find a type to compare them in. */
525 && (TYPE_UNSIGNED (TREE_TYPE (arg0))
526 == TYPE_UNSIGNED (TREE_TYPE (arg1))))
538 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
539 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
541 if (outprec >= BITS_PER_WORD
542 || TRULY_NOOP_TRUNCATION (outprec, inprec)
543 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
544 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
546 /* Do the arithmetic in type TYPEX,
547 then convert result to TYPE. */
550 /* Can't do arithmetic in enumeral types
551 so use an integer type that will hold the values. */
552 if (TREE_CODE (typex) == ENUMERAL_TYPE)
553 typex = lang_hooks.types.type_for_size
554 (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
556 /* But now perhaps TYPEX is as wide as INPREC.
557 In that case, do nothing special here.
558 (Otherwise would recurse infinitely in convert. */
559 if (TYPE_PRECISION (typex) != inprec)
561 /* Don't do unsigned arithmetic where signed was wanted,
563 Exception: if both of the original operands were
564 unsigned then we can safely do the work as unsigned.
565 Exception: shift operations take their type solely
566 from the first argument.
567 Exception: the LSHIFT_EXPR case above requires that
568 we perform this operation unsigned lest we produce
569 signed-overflow undefinedness.
570 And we may need to do it as unsigned
571 if we truncate to the original size. */
572 if (TYPE_UNSIGNED (TREE_TYPE (expr))
573 || (TYPE_UNSIGNED (TREE_TYPE (arg0))
574 && (TYPE_UNSIGNED (TREE_TYPE (arg1))
575 || ex_form == LSHIFT_EXPR
576 || ex_form == RSHIFT_EXPR
577 || ex_form == LROTATE_EXPR
578 || ex_form == RROTATE_EXPR))
579 || ex_form == LSHIFT_EXPR)
580 typex = lang_hooks.types.unsigned_type (typex);
582 typex = lang_hooks.types.signed_type (typex);
583 return convert (type,
584 fold_build2 (ex_form, typex,
585 convert (typex, arg0),
586 convert (typex, arg1)));
594 /* This is not correct for ABS_EXPR,
595 since we must test the sign before truncation. */
599 /* Don't do unsigned arithmetic where signed was wanted,
601 if (TYPE_UNSIGNED (TREE_TYPE (expr)))
602 typex = lang_hooks.types.unsigned_type (type);
604 typex = lang_hooks.types.signed_type (type);
605 return convert (type,
606 fold_build1 (ex_form, typex,
608 TREE_OPERAND (expr, 0))));
613 "can't convert between vector values of different size" error. */
614 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
615 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
616 != GET_MODE_SIZE (TYPE_MODE (type))))
618 /* If truncating after truncating, might as well do all at once.
619 If truncating after extending, we may get rid of wasted work. */
620 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
623 /* It is sometimes worthwhile to push the narrowing down through
624 the conditional and never loses. */
625 return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
626 convert (type, TREE_OPERAND (expr, 1)),
627 convert (type, TREE_OPERAND (expr, 2)));
633 return build1 (CONVERT_EXPR, type, expr);
636 return build1 (FIX_TRUNC_EXPR, type, expr);
639 return convert (type,
640 fold_build1 (REALPART_EXPR,
641 TREE_TYPE (TREE_TYPE (expr)), expr));
644 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
646 error ("can't convert between vector values of different size");
647 return error_mark_node;
649 return build1 (VIEW_CONVERT_EXPR, type, expr);
652 error ("aggregate value used where an integer was expected");
653 return convert (type, integer_zero_node);
657 /* Convert EXPR to the complex type TYPE in the usual ways. */
660 convert_to_complex (tree type, tree expr)
662 tree subtype = TREE_TYPE (type);
664 switch (TREE_CODE (TREE_TYPE (expr)))
671 return build2 (COMPLEX_EXPR, type, convert (subtype, expr),
672 convert (subtype, integer_zero_node));
676 tree elt_type = TREE_TYPE (TREE_TYPE (expr));
678 if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
680 else if (TREE_CODE (expr) == COMPLEX_EXPR)
681 return fold_build2 (COMPLEX_EXPR, type,
682 convert (subtype, TREE_OPERAND (expr, 0)),
683 convert (subtype, TREE_OPERAND (expr, 1)));
686 expr = save_expr (expr);
688 fold_build2 (COMPLEX_EXPR, type,
690 fold_build1 (REALPART_EXPR,
691 TREE_TYPE (TREE_TYPE (expr)),
694 fold_build1 (IMAGPART_EXPR,
695 TREE_TYPE (TREE_TYPE (expr)),
702 error ("pointer value used where a complex was expected");
703 return convert_to_complex (type, integer_zero_node);
706 error ("aggregate value used where a complex was expected");
707 return convert_to_complex (type, integer_zero_node);
711 /* Convert EXPR to the vector type TYPE in the usual ways. */
714 convert_to_vector (tree type, tree expr)
716 switch (TREE_CODE (TREE_TYPE (expr)))
720 if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
722 error ("can't convert between vector values of different size");
723 return error_mark_node;
725 return build1 (VIEW_CONVERT_EXPR, type, expr);
728 error ("can't convert value to a vector");
729 return error_mark_node;