1 /* Language-level data type conversion for GNU C.
2 Copyright (C) 1987, 1988, 1991 Free Software Foundation, Inc.
4 This file is part of GNU CC.
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 /* This file contains the functions for converting C expressions
22 to different data types. The only entry point is `convert'.
23 Every language front end must have a `convert' function
24 but what kind of conversions it does will depend on the language. */
30 /* Change of width--truncation and extension of integers or reals--
31 is represented with NOP_EXPR. Proper functioning of many things
32 assumes that no other conversions can be NOP_EXPRs.
34 Conversion between integer and pointer is represented with CONVERT_EXPR.
35 Converting integer to real uses FLOAT_EXPR
36 and real to integer uses FIX_TRUNC_EXPR.
38 Here is a list of all the functions that assume that widening and
39 narrowing is always done with a NOP_EXPR:
40 In c-convert.c, convert_to_integer.
41 In c-typeck.c, build_binary_op (boolean ops), and truthvalue_conversion.
42 In expr.c: expand_expr, for operands of a MULT_EXPR.
43 In fold-const.c: fold.
44 In tree.c: get_narrower and get_unwidened. */
46 /* Subroutines of `convert'. */
49 convert_to_pointer (type, expr)
52 register tree intype = TREE_TYPE (expr);
53 register enum tree_code form = TREE_CODE (intype);
55 if (integer_zerop (expr))
57 if (type == TREE_TYPE (null_pointer_node))
58 return null_pointer_node;
59 expr = build_int_2 (0, 0);
60 TREE_TYPE (expr) = type;
64 if (form == POINTER_TYPE)
65 return build1 (NOP_EXPR, type, expr);
68 if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
70 if (type_precision (intype) == POINTER_SIZE)
71 return build1 (CONVERT_EXPR, type, expr);
72 expr = convert (type_for_size (POINTER_SIZE, 0), expr);
73 if (TYPE_MODE (TREE_TYPE (expr)) != TYPE_MODE (type))
74 /* There is supposed to be some integral type
75 that is the same width as a pointer. */
77 return convert_to_pointer (type, expr);
80 error ("cannot convert to a pointer type");
82 return null_pointer_node;
86 convert_to_real (type, expr)
89 register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
91 if (form == REAL_TYPE)
92 return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
95 if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
96 return build1 (FLOAT_EXPR, type, expr);
98 if (form == POINTER_TYPE)
99 error ("pointer value used where a float was expected");
101 error ("aggregate value used where a float was expected");
104 register tree tem = make_node (REAL_CST);
105 TREE_TYPE (tem) = type;
106 TREE_REAL_CST (tem) = REAL_VALUE_ATOF ("0.0");
111 /* The result of this is always supposed to be a newly created tree node
112 not in use in any existing structure. */
115 convert_to_integer (type, expr)
118 register tree intype = TREE_TYPE (expr);
119 register enum tree_code form = TREE_CODE (intype);
121 if (form == POINTER_TYPE)
123 if (integer_zerop (expr))
124 expr = integer_zero_node;
126 expr = fold (build1 (CONVERT_EXPR,
127 type_for_size (POINTER_SIZE, 0), expr));
128 intype = TREE_TYPE (expr);
129 form = TREE_CODE (intype);
134 if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
136 register unsigned outprec = TYPE_PRECISION (type);
137 register unsigned inprec = TYPE_PRECISION (intype);
138 register enum tree_code ex_form = TREE_CODE (expr);
140 /* If we are widening the type, put in an explicit conversion.
141 Similarly if we are not changing the width. However, if this is
142 a logical operation that just returns 0 or 1, we can change the
143 type of the expression (see below). */
145 if (TREE_CODE_CLASS (ex_form) == '<'
146 || ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
147 || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
148 || ex_form == TRUTH_NOT_EXPR)
150 TREE_TYPE (expr) = type;
153 else if (outprec >= inprec)
154 return build1 (NOP_EXPR, type, expr);
156 /* Here detect when we can distribute the truncation down past some arithmetic.
157 For example, if adding two longs and converting to an int,
158 we can equally well convert both to ints and then add.
159 For the operations handled here, such truncation distribution
161 It is desirable in these cases:
162 1) when truncating down to full-word from a larger size
163 2) when truncating takes no work.
164 3) when at least one operand of the arithmetic has been extended
165 (as by C's default conversions). In this case we need two conversions
166 if we do the arithmetic as already requested, so we might as well
167 truncate both and then combine. Perhaps that way we need only one.
169 Note that in general we cannot do the arithmetic in a type
170 shorter than the desired result of conversion, even if the operands
171 are both extended from a shorter type, because they might overflow
172 if combined in that type. The exceptions to this--the times when
173 two narrow values can be combined in their narrow type even to
174 make a wider result--are handled by "shorten" in build_binary_op. */
179 /* We can pass truncation down through right shifting
180 when the shift count is a nonpositive constant. */
181 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
182 && tree_int_cst_lt (TREE_OPERAND (expr, 1), integer_one_node))
187 /* We can pass truncation down through left shifting
188 when the shift count is a nonnegative constant. */
189 if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
190 && ! tree_int_cst_lt (TREE_OPERAND (expr, 1), integer_zero_node))
191 /* In this case, shifting is like multiplication. */
199 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
200 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
202 /* Don't distribute unless the output precision is at least as big
203 as the actual inputs. Otherwise, the comparison of the
204 truncated values will be wrong. */
205 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
206 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
207 /* If signedness of arg0 and arg1 don't match,
208 we can't necessarily find a type to compare them in. */
209 && (TREE_UNSIGNED (TREE_TYPE (arg0))
210 == TREE_UNSIGNED (TREE_TYPE (arg1))))
223 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
224 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
226 if (outprec >= BITS_PER_WORD
227 || TRULY_NOOP_TRUNCATION (outprec, inprec)
228 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
229 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
231 /* Do the arithmetic in type TYPEX,
232 then convert result to TYPE. */
233 register tree typex = type;
235 /* Can't do arithmetic in enumeral types
236 so use an integer type that will hold the values. */
237 if (TREE_CODE (typex) == ENUMERAL_TYPE)
238 typex = type_for_size (TYPE_PRECISION (typex),
239 TREE_UNSIGNED (typex));
241 /* But now perhaps TYPEX is as wide as INPREC.
242 In that case, do nothing special here.
243 (Otherwise would recurse infinitely in convert. */
244 if (TYPE_PRECISION (typex) != inprec)
246 /* Don't do unsigned arithmetic where signed was wanted,
248 Exception: if either of the original operands were
249 unsigned then can safely do the work as unsigned.
250 And we may need to do it as unsigned
251 if we truncate to the original size. */
252 typex = ((TREE_UNSIGNED (TREE_TYPE (expr))
253 || TREE_UNSIGNED (TREE_TYPE (arg0))
254 || TREE_UNSIGNED (TREE_TYPE (arg1)))
255 ? unsigned_type (typex) : signed_type (typex));
256 return convert (type,
257 build_binary_op (ex_form,
258 convert (typex, arg0),
259 convert (typex, arg1),
269 register tree typex = type;
271 /* Can't do arithmetic in enumeral types
272 so use an integer type that will hold the values. */
273 if (TREE_CODE (typex) == ENUMERAL_TYPE)
274 typex = type_for_size (TYPE_PRECISION (typex),
275 TREE_UNSIGNED (typex));
277 /* But now perhaps TYPEX is as wide as INPREC.
278 In that case, do nothing special here.
279 (Otherwise would recurse infinitely in convert. */
280 if (TYPE_PRECISION (typex) != inprec)
282 /* Don't do unsigned arithmetic where signed was wanted,
284 typex = (TREE_UNSIGNED (TREE_TYPE (expr))
285 ? unsigned_type (typex) : signed_type (typex));
286 return convert (type,
287 build_unary_op (ex_form,
288 convert (typex, TREE_OPERAND (expr, 0)),
294 /* If truncating after truncating, might as well do all at once.
295 If truncating after extending, we may get rid of wasted work. */
296 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
299 /* Can treat the two alternative values like the operands
300 of an arithmetic expression. */
302 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
303 tree arg2 = get_unwidened (TREE_OPERAND (expr, 2), type);
305 if (outprec >= BITS_PER_WORD
306 || TRULY_NOOP_TRUNCATION (outprec, inprec)
307 || inprec > TYPE_PRECISION (TREE_TYPE (arg1))
308 || inprec > TYPE_PRECISION (TREE_TYPE (arg2)))
310 /* Do the arithmetic in type TYPEX,
311 then convert result to TYPE. */
312 register tree typex = type;
314 /* Can't do arithmetic in enumeral types
315 so use an integer type that will hold the values. */
316 if (TREE_CODE (typex) == ENUMERAL_TYPE)
317 typex = type_for_size (TYPE_PRECISION (typex),
318 TREE_UNSIGNED (typex));
320 /* But now perhaps TYPEX is as wide as INPREC.
321 In that case, do nothing special here.
322 (Otherwise would recurse infinitely in convert. */
323 if (TYPE_PRECISION (typex) != inprec)
325 /* Don't do unsigned arithmetic where signed was wanted,
327 typex = (TREE_UNSIGNED (TREE_TYPE (expr))
328 ? unsigned_type (typex) : signed_type (typex));
329 return convert (type,
330 fold (build (COND_EXPR, typex,
331 TREE_OPERAND (expr, 0),
332 convert (typex, arg1),
333 convert (typex, arg2))));
336 /* It is sometimes worthwhile
337 to push the narrowing down through the conditional. */
338 return fold (build (COND_EXPR, type,
339 TREE_OPERAND (expr, 0),
340 convert (type, TREE_OPERAND (expr, 1)),
341 convert (type, TREE_OPERAND (expr, 2))));
346 return build1 (NOP_EXPR, type, expr);
349 if (form == REAL_TYPE)
350 return build1 (FIX_TRUNC_EXPR, type, expr);
352 error ("aggregate value used where an integer was expected");
355 register tree tem = build_int_2 (0, 0);
356 TREE_TYPE (tem) = type;
361 /* Create an expression whose value is that of EXPR,
362 converted to type TYPE. The TREE_TYPE of the value
363 is always TYPE. This function implements all reasonable
364 conversions; callers should filter out those that are
365 not permitted by the language being compiled. */
371 register tree e = expr;
372 register enum tree_code code = TREE_CODE (type);
374 if (type == TREE_TYPE (expr)
375 || TREE_CODE (expr) == ERROR_MARK)
377 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
378 return fold (build1 (NOP_EXPR, type, expr));
379 if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
380 return error_mark_node;
381 if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
383 error ("void value not ignored as it ought to be");
384 return error_mark_node;
386 if (code == VOID_TYPE)
387 return build1 (CONVERT_EXPR, type, e);
389 /* This is incorrect. A truncation can't be stripped this way.
390 Extensions will be stripped by the use of get_unwidened. */
391 if (TREE_CODE (expr) == NOP_EXPR)
392 return convert (type, TREE_OPERAND (expr, 0));
394 if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
395 return fold (convert_to_integer (type, e));
396 if (code == POINTER_TYPE)
397 return fold (convert_to_pointer (type, e));
398 if (code == REAL_TYPE)
399 return fold (convert_to_real (type, e));
401 error ("conversion to non-scalar type requested");
402 return error_mark_node;