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)
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 && (fcode == BUILT_IN_SQRT
135 || fcode == BUILT_IN_SQRTL
136 || fcode == BUILT_IN_SIN
137 || fcode == BUILT_IN_SINL
138 || fcode == BUILT_IN_COS
139 || fcode == BUILT_IN_COSL
140 || fcode == BUILT_IN_EXP
141 || fcode == BUILT_IN_EXPL
142 || fcode == BUILT_IN_LOG
143 || fcode == BUILT_IN_LOGL)
144 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
145 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
147 tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
150 /* We have (outertype)sqrt((innertype)x). Choose the wider mode from
151 the both as the safe type for operation. */
152 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
153 newtype = TREE_TYPE (arg0);
155 /* Be careful about integer to fp conversions.
156 These may overflow still. */
157 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
158 && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
159 && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
160 || TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
163 tree fn = mathfn_built_in (newtype, fcode);
167 arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
168 expr = build_function_call_expr (fn, arglist);
175 && (((fcode == BUILT_IN_FLOORL
176 || fcode == BUILT_IN_CEILL
177 || fcode == BUILT_IN_ROUNDL
178 || fcode == BUILT_IN_TRUNCL
179 || fcode == BUILT_IN_NEARBYINTL)
180 && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
181 || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
182 || ((fcode == BUILT_IN_FLOOR
183 || fcode == BUILT_IN_CEIL
184 || fcode == BUILT_IN_ROUND
185 || fcode == BUILT_IN_TRUNC
186 || fcode == BUILT_IN_NEARBYINT)
187 && (TYPE_MODE (type) == TYPE_MODE (float_type_node)))))
189 tree fn = mathfn_built_in (type, fcode);
193 tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr,
195 tree arglist = build_tree_list (NULL_TREE,
196 fold (convert_to_real (type, arg0)));
198 return build_function_call_expr (fn, arglist);
202 /* Propagate the cast into the operation. */
203 if (itype != type && FLOAT_TYPE_P (type))
204 switch (TREE_CODE (expr))
206 /* Convert (float)-x into -(float)x. This is always safe. */
209 if (TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
210 return build1 (TREE_CODE (expr), type,
211 fold (convert_to_real (type,
212 TREE_OPERAND (expr, 0))));
214 /* Convert (outertype)((innertype0)a+(innertype1)b)
215 into ((newtype)a+(newtype)b) where newtype
216 is the widest mode from all of these. */
222 tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
223 tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
225 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
226 && FLOAT_TYPE_P (TREE_TYPE (arg1)))
229 if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
230 newtype = TREE_TYPE (arg0);
231 if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
232 newtype = TREE_TYPE (arg1);
233 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype))
235 expr = build (TREE_CODE (expr), newtype,
236 fold (convert_to_real (newtype, arg0)),
237 fold (convert_to_real (newtype, arg1)));
248 switch (TREE_CODE (TREE_TYPE (expr)))
251 return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
258 return build1 (FLOAT_EXPR, type, expr);
261 return convert (type,
262 fold (build1 (REALPART_EXPR,
263 TREE_TYPE (TREE_TYPE (expr)), expr)));
267 error ("pointer value used where a floating point value was expected");
268 return convert_to_real (type, integer_zero_node);
271 error ("aggregate value used where a float was expected");
272 return convert_to_real (type, integer_zero_node);
276 /* Convert EXPR to some integer (or enum) type TYPE.
278 EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
279 vector; in other cases error is called.
281 The result of this is always supposed to be a newly created tree node
282 not in use in any existing structure. */
285 convert_to_integer (tree type, tree expr)
287 enum tree_code ex_form = TREE_CODE (expr);
288 tree intype = TREE_TYPE (expr);
289 unsigned int inprec = TYPE_PRECISION (intype);
290 unsigned int outprec = TYPE_PRECISION (type);
292 /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
293 be. Consider `enum E = { a, b = (enum E) 3 };'. */
294 if (!COMPLETE_TYPE_P (type))
296 error ("conversion to incomplete type");
297 return error_mark_node;
300 switch (TREE_CODE (intype))
304 if (integer_zerop (expr))
305 expr = integer_zero_node;
307 expr = fold (build1 (CONVERT_EXPR,
308 lang_hooks.types.type_for_size (POINTER_SIZE, 0),
311 return convert_to_integer (type, expr);
317 /* If this is a logical operation, which just returns 0 or 1, we can
318 change the type of the expression. For some logical operations,
319 we must also change the types of the operands to maintain type
322 if (TREE_CODE_CLASS (ex_form) == '<')
324 expr = copy_node (expr);
325 TREE_TYPE (expr) = type;
329 else if (ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
330 || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
331 || ex_form == TRUTH_XOR_EXPR)
333 expr = copy_node (expr);
334 TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
335 TREE_OPERAND (expr, 1) = convert (type, TREE_OPERAND (expr, 1));
336 TREE_TYPE (expr) = type;
340 else if (ex_form == TRUTH_NOT_EXPR)
342 expr = copy_node (expr);
343 TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
344 TREE_TYPE (expr) = type;
348 /* If we are widening the type, put in an explicit conversion.
349 Similarly if we are not changing the width. After this, we know
350 we are truncating EXPR. */
352 else if (outprec >= inprec)
356 /* If the precision of the EXPR's type is K bits and the
357 destination mode has more bits, and the sign is changing,
358 it is not safe to use a NOP_EXPR. For example, suppose
359 that EXPR's type is a 3-bit unsigned integer type, the
360 TYPE is a 3-bit signed integer type, and the machine mode
361 for the types is 8-bit QImode. In that case, the
362 conversion necessitates an explicit sign-extension. In
363 the signed-to-unsigned case the high-order bits have to
365 if (TREE_UNSIGNED (type) != TREE_UNSIGNED (TREE_TYPE (expr))
366 && (TYPE_PRECISION (TREE_TYPE (expr))
367 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
372 return build1 (code, type, expr);
375 /* If TYPE is an enumeral type or a type with a precision less
376 than the number of bits in its mode, do the conversion to the
377 type corresponding to its mode, then do a nop conversion
379 else if (TREE_CODE (type) == ENUMERAL_TYPE
380 || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
381 return build1 (NOP_EXPR, type,
382 convert (lang_hooks.types.type_for_mode
383 (TYPE_MODE (type), TREE_UNSIGNED (type)),
386 /* Here detect when we can distribute the truncation down past some
387 arithmetic. For example, if adding two longs and converting to an
388 int, we can equally well convert both to ints and then add.
389 For the operations handled here, such truncation distribution
391 It is desirable in these cases:
392 1) when truncating down to full-word from a larger size
393 2) when truncating takes no work.
394 3) when at least one operand of the arithmetic has been extended
395 (as by C's default conversions). In this case we need two conversions
396 if we do the arithmetic as already requested, so we might as well
397 truncate both and then combine. Perhaps that way we need only one.
399 Note that in general we cannot do the arithmetic in a type
400 shorter than the desired result of conversion, even if the operands
401 are both extended from a shorter type, because they might overflow
402 if combined in that type. The exceptions to this--the times when
403 two narrow values can be combined in their narrow type even to
404 make a wider result--are handled by "shorten" in build_binary_op. */
409 /* We can pass truncation down through right shifting
410 when the shift count is a nonpositive constant. */
411 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
412 && tree_int_cst_lt (TREE_OPERAND (expr, 1),
413 convert (TREE_TYPE (TREE_OPERAND (expr, 1)),
419 /* We can pass truncation down through left shifting
420 when the shift count is a nonnegative constant and
421 the target type is unsigned. */
422 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
423 && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
424 && TREE_UNSIGNED (type)
425 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
427 /* If shift count is less than the width of the truncated type,
429 if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
430 /* In this case, shifting is like multiplication. */
434 /* If it is >= that width, result is zero.
435 Handling this with trunc1 would give the wrong result:
436 (int) ((long long) a << 32) is well defined (as 0)
437 but (int) a << 32 is undefined and would get a
440 tree t = convert_to_integer (type, integer_zero_node);
442 /* If the original expression had side-effects, we must
444 if (TREE_SIDE_EFFECTS (expr))
445 return build (COMPOUND_EXPR, type, expr, t);
456 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
457 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
459 /* Don't distribute unless the output precision is at least as big
460 as the actual inputs. Otherwise, the comparison of the
461 truncated values will be wrong. */
462 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
463 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
464 /* If signedness of arg0 and arg1 don't match,
465 we can't necessarily find a type to compare them in. */
466 && (TREE_UNSIGNED (TREE_TYPE (arg0))
467 == TREE_UNSIGNED (TREE_TYPE (arg1))))
479 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
480 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
482 if (outprec >= BITS_PER_WORD
483 || TRULY_NOOP_TRUNCATION (outprec, inprec)
484 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
485 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
487 /* Do the arithmetic in type TYPEX,
488 then convert result to TYPE. */
491 /* Can't do arithmetic in enumeral types
492 so use an integer type that will hold the values. */
493 if (TREE_CODE (typex) == ENUMERAL_TYPE)
494 typex = lang_hooks.types.type_for_size
495 (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
497 /* But now perhaps TYPEX is as wide as INPREC.
498 In that case, do nothing special here.
499 (Otherwise would recurse infinitely in convert. */
500 if (TYPE_PRECISION (typex) != inprec)
502 /* Don't do unsigned arithmetic where signed was wanted,
504 Exception: if both of the original operands were
505 unsigned then we can safely do the work as unsigned.
506 Exception: shift operations take their type solely
507 from the first argument.
508 Exception: the LSHIFT_EXPR case above requires that
509 we perform this operation unsigned lest we produce
510 signed-overflow undefinedness.
511 And we may need to do it as unsigned
512 if we truncate to the original size. */
513 if (TREE_UNSIGNED (TREE_TYPE (expr))
514 || (TREE_UNSIGNED (TREE_TYPE (arg0))
515 && (TREE_UNSIGNED (TREE_TYPE (arg1))
516 || ex_form == LSHIFT_EXPR
517 || ex_form == RSHIFT_EXPR
518 || ex_form == LROTATE_EXPR
519 || ex_form == RROTATE_EXPR))
520 || ex_form == LSHIFT_EXPR)
521 typex = lang_hooks.types.unsigned_type (typex);
523 typex = lang_hooks.types.signed_type (typex);
524 return convert (type,
525 fold (build (ex_form, typex,
526 convert (typex, arg0),
527 convert (typex, arg1))));
535 /* This is not correct for ABS_EXPR,
536 since we must test the sign before truncation. */
540 /* Can't do arithmetic in enumeral types
541 so use an integer type that will hold the values. */
542 if (TREE_CODE (typex) == ENUMERAL_TYPE)
543 typex = lang_hooks.types.type_for_size
544 (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
546 /* But now perhaps TYPEX is as wide as INPREC.
547 In that case, do nothing special here.
548 (Otherwise would recurse infinitely in convert. */
549 if (TYPE_PRECISION (typex) != inprec)
551 /* Don't do unsigned arithmetic where signed was wanted,
553 if (TREE_UNSIGNED (TREE_TYPE (expr)))
554 typex = lang_hooks.types.unsigned_type (typex);
556 typex = lang_hooks.types.signed_type (typex);
557 return convert (type,
558 fold (build1 (ex_form, typex,
560 TREE_OPERAND (expr, 0)))));
566 "can't convert between vector values of different size" error. */
567 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
568 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
569 != GET_MODE_SIZE (TYPE_MODE (type))))
571 /* If truncating after truncating, might as well do all at once.
572 If truncating after extending, we may get rid of wasted work. */
573 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
576 /* It is sometimes worthwhile to push the narrowing down through
577 the conditional and never loses. */
578 return fold (build (COND_EXPR, type, TREE_OPERAND (expr, 0),
579 convert (type, TREE_OPERAND (expr, 1)),
580 convert (type, TREE_OPERAND (expr, 2))));
586 return build1 (NOP_EXPR, type, expr);
589 return build1 (FIX_TRUNC_EXPR, type, expr);
592 return convert (type,
593 fold (build1 (REALPART_EXPR,
594 TREE_TYPE (TREE_TYPE (expr)), expr)));
597 if (GET_MODE_SIZE (TYPE_MODE (type))
598 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
600 error ("can't convert between vector values of different size");
601 return error_mark_node;
603 return build1 (NOP_EXPR, type, expr);
606 error ("aggregate value used where an integer was expected");
607 return convert (type, integer_zero_node);
611 /* Convert EXPR to the complex type TYPE in the usual ways. */
614 convert_to_complex (tree type, tree expr)
616 tree subtype = TREE_TYPE (type);
618 switch (TREE_CODE (TREE_TYPE (expr)))
625 return build (COMPLEX_EXPR, type, convert (subtype, expr),
626 convert (subtype, integer_zero_node));
630 tree elt_type = TREE_TYPE (TREE_TYPE (expr));
632 if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
634 else if (TREE_CODE (expr) == COMPLEX_EXPR)
635 return fold (build (COMPLEX_EXPR,
637 convert (subtype, TREE_OPERAND (expr, 0)),
638 convert (subtype, TREE_OPERAND (expr, 1))));
641 expr = save_expr (expr);
643 fold (build (COMPLEX_EXPR,
644 type, convert (subtype,
645 fold (build1 (REALPART_EXPR,
646 TREE_TYPE (TREE_TYPE (expr)),
649 fold (build1 (IMAGPART_EXPR,
650 TREE_TYPE (TREE_TYPE (expr)),
657 error ("pointer value used where a complex was expected");
658 return convert_to_complex (type, integer_zero_node);
661 error ("aggregate value used where a complex was expected");
662 return convert_to_complex (type, integer_zero_node);
666 /* Convert EXPR to the vector type TYPE in the usual ways. */
669 convert_to_vector (tree type, tree expr)
671 switch (TREE_CODE (TREE_TYPE (expr)))
675 if (GET_MODE_SIZE (TYPE_MODE (type))
676 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
678 error ("can't convert between vector values of different size");
679 return error_mark_node;
681 return build1 (NOP_EXPR, type, expr);
684 error ("can't convert value to a vector");
685 return convert_to_vector (type, integer_zero_node);