1 /* Utility routines for data type conversion for GNU C.
2 Copyright (C) 1987, 1988, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GNU C.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* These routines are somewhat language-independent utility function
22 intended to be called by the language-specific convert () functions. */
29 /* Convert EXPR to some pointer type TYPE.
31 EXPR must be pointer, integer, enumeral, or literal zero;
32 in other cases error is called. */
35 convert_to_pointer (type, expr)
38 register tree intype = TREE_TYPE (expr);
39 register enum tree_code form = TREE_CODE (intype);
41 if (integer_zerop (expr))
43 if (type == TREE_TYPE (null_pointer_node))
44 return null_pointer_node;
45 expr = build_int_2 (0, 0);
46 TREE_TYPE (expr) = type;
50 if (form == POINTER_TYPE)
51 return build1 (NOP_EXPR, type, expr);
54 if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
56 if (type_precision (intype) == POINTER_SIZE)
57 return build1 (CONVERT_EXPR, type, expr);
58 expr = convert (type_for_size (POINTER_SIZE, 0), expr);
59 /* Modes may be different but sizes should be the same. */
60 if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
61 != GET_MODE_SIZE (TYPE_MODE (type)))
62 /* There is supposed to be some integral type
63 that is the same width as a pointer. */
65 return convert_to_pointer (type, expr);
68 error ("cannot convert to a pointer type");
70 return null_pointer_node;
73 /* Convert EXPR to some floating-point type TYPE.
75 EXPR must be float, integer, or enumeral;
76 in other cases error is called. */
79 convert_to_real (type, expr)
82 register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
84 if (form == REAL_TYPE)
85 return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
88 if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
89 return build1 (FLOAT_EXPR, type, expr);
91 if (form == COMPLEX_TYPE)
92 return convert (type, fold (build1 (REALPART_EXPR,
93 TREE_TYPE (TREE_TYPE (expr)), expr)));
95 if (form == POINTER_TYPE)
96 error ("pointer value used where a floating point value was expected");
98 error ("aggregate value used where a float was expected");
101 register tree tem = make_node (REAL_CST);
102 TREE_TYPE (tem) = type;
103 TREE_REAL_CST (tem) = REAL_VALUE_ATOF ("0.0", TYPE_MODE (type));
108 /* Convert EXPR to some integer (or enum) type TYPE.
110 EXPR must be pointer, integer, discrete (enum, char, or bool), or float;
111 in other cases error is called.
113 The result of this is always supposed to be a newly created tree node
114 not in use in any existing structure. */
117 convert_to_integer (type, expr)
120 register tree intype = TREE_TYPE (expr);
121 register enum tree_code form = TREE_CODE (intype);
123 if (form == POINTER_TYPE)
125 if (integer_zerop (expr))
126 expr = integer_zero_node;
128 expr = fold (build1 (CONVERT_EXPR,
129 type_for_size (POINTER_SIZE, 0), expr));
130 intype = TREE_TYPE (expr);
131 form = TREE_CODE (intype);
136 if (form == INTEGER_TYPE || form == ENUMERAL_TYPE
137 || form == BOOLEAN_TYPE || form == CHAR_TYPE)
139 register unsigned outprec = TYPE_PRECISION (type);
140 register unsigned inprec = TYPE_PRECISION (intype);
141 register enum tree_code ex_form = TREE_CODE (expr);
143 /* If we are widening the type, put in an explicit conversion.
144 Similarly if we are not changing the width. However, if this is
145 a logical operation that just returns 0 or 1, we can change the
146 type of the expression (see below). */
148 if (TREE_CODE_CLASS (ex_form) == '<'
149 || ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
150 || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
151 || ex_form == TRUTH_XOR_EXPR || ex_form == TRUTH_NOT_EXPR)
153 TREE_TYPE (expr) = type;
156 else if (outprec >= inprec)
157 return build1 (NOP_EXPR, type, expr);
159 /* Here detect when we can distribute the truncation down past some arithmetic.
160 For example, if adding two longs and converting to an int,
161 we can equally well convert both to ints and then add.
162 For the operations handled here, such truncation distribution
164 It is desirable in these cases:
165 1) when truncating down to full-word from a larger size
166 2) when truncating takes no work.
167 3) when at least one operand of the arithmetic has been extended
168 (as by C's default conversions). In this case we need two conversions
169 if we do the arithmetic as already requested, so we might as well
170 truncate both and then combine. Perhaps that way we need only one.
172 Note that in general we cannot do the arithmetic in a type
173 shorter than the desired result of conversion, even if the operands
174 are both extended from a shorter type, because they might overflow
175 if combined in that type. The exceptions to this--the times when
176 two narrow values can be combined in their narrow type even to
177 make a wider result--are handled by "shorten" in build_binary_op. */
182 /* We can pass truncation down through right shifting
183 when the shift count is a nonpositive constant. */
184 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
185 && tree_int_cst_lt (TREE_OPERAND (expr, 1), integer_one_node))
190 /* We can pass truncation down through left shifting
191 when the shift count is a nonnegative constant. */
192 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
193 && ! tree_int_cst_lt (TREE_OPERAND (expr, 1), integer_zero_node)
194 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
196 /* If shift count is less than the width of the truncated type,
198 if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
199 /* In this case, shifting is like multiplication. */
203 /* If it is >= that width, result is zero.
204 Handling this with trunc1 would give the wrong result:
205 (int) ((long long) a << 32) is well defined (as 0)
206 but (int) a << 32 is undefined and would get a
209 tree t = convert_to_integer (type, integer_zero_node);
211 /* If the original expression had side-effects, we must
213 if (TREE_SIDE_EFFECTS (expr))
214 return build (COMPOUND_EXPR, type, expr, t);
225 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
226 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
228 /* Don't distribute unless the output precision is at least as big
229 as the actual inputs. Otherwise, the comparison of the
230 truncated values will be wrong. */
231 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
232 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
233 /* If signedness of arg0 and arg1 don't match,
234 we can't necessarily find a type to compare them in. */
235 && (TREE_UNSIGNED (TREE_TYPE (arg0))
236 == TREE_UNSIGNED (TREE_TYPE (arg1))))
249 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
250 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
252 if (outprec >= BITS_PER_WORD
253 || TRULY_NOOP_TRUNCATION (outprec, inprec)
254 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
255 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
257 /* Do the arithmetic in type TYPEX,
258 then convert result to TYPE. */
259 register tree typex = type;
261 /* Can't do arithmetic in enumeral types
262 so use an integer type that will hold the values. */
263 if (TREE_CODE (typex) == ENUMERAL_TYPE)
264 typex = type_for_size (TYPE_PRECISION (typex),
265 TREE_UNSIGNED (typex));
267 /* But now perhaps TYPEX is as wide as INPREC.
268 In that case, do nothing special here.
269 (Otherwise would recurse infinitely in convert. */
270 if (TYPE_PRECISION (typex) != inprec)
272 /* Don't do unsigned arithmetic where signed was wanted,
274 Exception: if either of the original operands were
275 unsigned then can safely do the work as unsigned.
276 And we may need to do it as unsigned
277 if we truncate to the original size. */
278 typex = ((TREE_UNSIGNED (TREE_TYPE (expr))
279 || TREE_UNSIGNED (TREE_TYPE (arg0))
280 || TREE_UNSIGNED (TREE_TYPE (arg1)))
281 ? unsigned_type (typex) : signed_type (typex));
282 return convert (type,
283 fold (build (ex_form, typex,
284 convert (typex, arg0),
285 convert (typex, arg1),
294 /* This is not correct for ABS_EXPR,
295 since we must test the sign before truncation. */
297 register tree typex = type;
299 /* Can't do arithmetic in enumeral types
300 so use an integer type that will hold the values. */
301 if (TREE_CODE (typex) == ENUMERAL_TYPE)
302 typex = type_for_size (TYPE_PRECISION (typex),
303 TREE_UNSIGNED (typex));
305 /* But now perhaps TYPEX is as wide as INPREC.
306 In that case, do nothing special here.
307 (Otherwise would recurse infinitely in convert. */
308 if (TYPE_PRECISION (typex) != inprec)
310 /* Don't do unsigned arithmetic where signed was wanted,
312 typex = (TREE_UNSIGNED (TREE_TYPE (expr))
313 ? unsigned_type (typex) : signed_type (typex));
314 return convert (type,
315 fold (build1 (ex_form, typex,
317 TREE_OPERAND (expr, 0)))));
322 /* If truncating after truncating, might as well do all at once.
323 If truncating after extending, we may get rid of wasted work. */
324 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
327 /* Can treat the two alternative values like the operands
328 of an arithmetic expression. */
330 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
331 tree arg2 = get_unwidened (TREE_OPERAND (expr, 2), type);
333 if (outprec >= BITS_PER_WORD
334 || TRULY_NOOP_TRUNCATION (outprec, inprec)
335 || inprec > TYPE_PRECISION (TREE_TYPE (arg1))
336 || inprec > TYPE_PRECISION (TREE_TYPE (arg2)))
338 /* Do the arithmetic in type TYPEX,
339 then convert result to TYPE. */
340 register tree typex = type;
342 /* Can't do arithmetic in enumeral types
343 so use an integer type that will hold the values. */
344 if (TREE_CODE (typex) == ENUMERAL_TYPE)
345 typex = type_for_size (TYPE_PRECISION (typex),
346 TREE_UNSIGNED (typex));
348 /* But now perhaps TYPEX is as wide as INPREC.
349 In that case, do nothing special here.
350 (Otherwise would recurse infinitely in convert. */
351 if (TYPE_PRECISION (typex) != inprec)
353 /* Don't do unsigned arithmetic where signed was wanted,
355 typex = (TREE_UNSIGNED (TREE_TYPE (expr))
356 ? unsigned_type (typex) : signed_type (typex));
357 return convert (type,
358 fold (build (COND_EXPR, typex,
359 TREE_OPERAND (expr, 0),
360 convert (typex, arg1),
361 convert (typex, arg2))));
364 /* It is sometimes worthwhile
365 to push the narrowing down through the conditional. */
366 return fold (build (COND_EXPR, type,
367 TREE_OPERAND (expr, 0),
368 convert (type, TREE_OPERAND (expr, 1)),
369 convert (type, TREE_OPERAND (expr, 2))));
375 return build1 (NOP_EXPR, type, expr);
378 if (form == REAL_TYPE)
379 return build1 (FIX_TRUNC_EXPR, type, expr);
381 if (form == COMPLEX_TYPE)
382 return convert (type, fold (build1 (REALPART_EXPR,
383 TREE_TYPE (TREE_TYPE (expr)), expr)));
385 error ("aggregate value used where an integer was expected");
388 register tree tem = build_int_2 (0, 0);
389 TREE_TYPE (tem) = type;
394 /* Convert EXPR to the complex type TYPE in the usual ways. */
397 convert_to_complex (type, expr)
400 register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
401 tree subtype = TREE_TYPE (type);
403 if (form == REAL_TYPE || form == INTEGER_TYPE || form == ENUMERAL_TYPE)
405 expr = convert (subtype, expr);
406 return build (COMPLEX_EXPR, type, expr,
407 convert (subtype, integer_zero_node));
410 if (form == COMPLEX_TYPE)
412 tree elt_type = TREE_TYPE (TREE_TYPE (expr));
413 if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
415 else if (TREE_CODE (expr) == COMPLEX_EXPR)
416 return fold (build (COMPLEX_EXPR,
418 convert (subtype, TREE_OPERAND (expr, 0)),
419 convert (subtype, TREE_OPERAND (expr, 1))));
422 expr = save_expr (expr);
423 return fold (build (COMPLEX_EXPR,
426 fold (build1 (REALPART_EXPR,
427 TREE_TYPE (TREE_TYPE (expr)),
430 fold (build1 (IMAGPART_EXPR,
431 TREE_TYPE (TREE_TYPE (expr)),
436 if (form == POINTER_TYPE)
437 error ("pointer value used where a complex was expected");
439 error ("aggregate value used where a complex was expected");
441 return build (COMPLEX_EXPR, type,
442 convert (subtype, integer_zero_node),
443 convert (subtype, integer_zero_node));