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 (outprec >= inprec)
141 return build1 (NOP_EXPR, type, expr);
143 /* Here detect when we can distribute the truncation down past some arithmetic.
144 For example, if adding two longs and converting to an int,
145 we can equally well convert both to ints and then add.
146 For the operations handled here, such truncation distribution
148 It is desirable in these cases:
149 1) when truncating down to full-word from a larger size
150 2) when truncating takes no work.
151 3) when at least one operand of the arithmetic has been extended
152 (as by C's default conversions). In this case we need two conversions
153 if we do the arithmetic as already requested, so we might as well
154 truncate both and then combine. Perhaps that way we need only one.
156 Note that in general we cannot do the arithmetic in a type
157 shorter than the desired result of conversion, even if the operands
158 are both extended from a shorter type, because they might overflow
159 if combined in that type. The exceptions to this--the times when
160 two narrow values can be combined in their narrow type even to
161 make a wider result--are handled by "shorten" in build_binary_op. */
166 /* We can pass truncation down through right shifting
167 when the shift count is a negative constant. */
168 if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
169 || TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) > 0)
174 /* We can pass truncation down through left shifting
175 when the shift count is a positive constant. */
176 if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
177 || TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) < 0)
179 /* In this case, shifting is like multiplication. */
186 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
187 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
189 /* Don't distribute unless the output precision is at least as big
190 as the actual inputs. Otherwise, the comparison of the
191 truncated values will be wrong. */
192 if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
193 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
194 /* If signedness of arg0 and arg1 don't match,
195 we can't necessarily find a type to compare them in. */
196 && (TREE_UNSIGNED (TREE_TYPE (arg0))
197 == TREE_UNSIGNED (TREE_TYPE (arg1))))
210 tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
211 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
213 if (outprec >= BITS_PER_WORD
214 || TRULY_NOOP_TRUNCATION (outprec, inprec)
215 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
216 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
218 /* Do the arithmetic in type TYPEX,
219 then convert result to TYPE. */
220 register tree typex = type;
222 /* Can't do arithmetic in enumeral types
223 so use an integer type that will hold the values. */
224 if (TREE_CODE (typex) == ENUMERAL_TYPE)
225 typex = type_for_size (TYPE_PRECISION (typex),
226 TREE_UNSIGNED (typex));
228 /* But now perhaps TYPEX is as wide as INPREC.
229 In that case, do nothing special here.
230 (Otherwise would recurse infinitely in convert. */
231 if (TYPE_PRECISION (typex) != inprec)
233 /* Don't do unsigned arithmetic where signed was wanted,
235 Exception: if either of the original operands were
236 unsigned then can safely do the work as unsigned.
237 And we may need to do it as unsigned
238 if we truncate to the original size. */
239 typex = ((TREE_UNSIGNED (TREE_TYPE (expr))
240 || TREE_UNSIGNED (TREE_TYPE (arg0))
241 || TREE_UNSIGNED (TREE_TYPE (arg1)))
242 ? unsigned_type (typex) : signed_type (typex));
243 return convert (type,
244 build_binary_op (ex_form,
245 convert (typex, arg0),
246 convert (typex, arg1),
260 case TRUTH_ANDIF_EXPR:
262 case TRUTH_ORIF_EXPR:
264 /* If we want result of comparison converted to a byte,
265 we can just regard it as a byte, since it is 0 or 1. */
266 TREE_TYPE (expr) = type;
272 register tree typex = type;
274 /* Can't do arithmetic in enumeral types
275 so use an integer type that will hold the values. */
276 if (TREE_CODE (typex) == ENUMERAL_TYPE)
277 typex = type_for_size (TYPE_PRECISION (typex),
278 TREE_UNSIGNED (typex));
280 /* But now perhaps TYPEX is as wide as INPREC.
281 In that case, do nothing special here.
282 (Otherwise would recurse infinitely in convert. */
283 if (TYPE_PRECISION (typex) != inprec)
285 /* Don't do unsigned arithmetic where signed was wanted,
287 typex = (TREE_UNSIGNED (TREE_TYPE (expr))
288 ? unsigned_type (typex) : signed_type (typex));
289 return convert (type,
290 build_unary_op (ex_form,
291 convert (typex, TREE_OPERAND (expr, 0)),
297 /* If truncating after truncating, might as well do all at once.
298 If truncating after extending, we may get rid of wasted work. */
299 return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
302 /* Can treat the two alternative values like the operands
303 of an arithmetic expression. */
305 tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
306 tree arg2 = get_unwidened (TREE_OPERAND (expr, 2), type);
308 if (outprec >= BITS_PER_WORD
309 || TRULY_NOOP_TRUNCATION (outprec, inprec)
310 || inprec > TYPE_PRECISION (TREE_TYPE (arg1))
311 || inprec > TYPE_PRECISION (TREE_TYPE (arg2)))
313 /* Do the arithmetic in type TYPEX,
314 then convert result to TYPE. */
315 register tree typex = type;
317 /* Can't do arithmetic in enumeral types
318 so use an integer type that will hold the values. */
319 if (TREE_CODE (typex) == ENUMERAL_TYPE)
320 typex = type_for_size (TYPE_PRECISION (typex),
321 TREE_UNSIGNED (typex));
323 /* But now perhaps TYPEX is as wide as INPREC.
324 In that case, do nothing special here.
325 (Otherwise would recurse infinitely in convert. */
326 if (TYPE_PRECISION (typex) != inprec)
328 /* Don't do unsigned arithmetic where signed was wanted,
330 typex = (TREE_UNSIGNED (TREE_TYPE (expr))
331 ? unsigned_type (typex) : signed_type (typex));
332 return convert (type,
333 fold (build (COND_EXPR, typex,
334 TREE_OPERAND (expr, 0),
335 convert (typex, arg1),
336 convert (typex, arg2))));
339 /* It is sometimes worthwhile
340 to push the narrowing down through the conditional. */
341 return fold (build (COND_EXPR, type,
342 TREE_OPERAND (expr, 0),
343 convert (type, TREE_OPERAND (expr, 1)),
344 convert (type, TREE_OPERAND (expr, 2))));
349 return build1 (NOP_EXPR, type, expr);
352 if (form == REAL_TYPE)
353 return build1 (FIX_TRUNC_EXPR, type, expr);
355 error ("aggregate value used where an integer was expected");
358 register tree tem = build_int_2 (0, 0);
359 TREE_TYPE (tem) = type;
364 /* Create an expression whose value is that of EXPR,
365 converted to type TYPE. The TREE_TYPE of the value
366 is always TYPE. This function implements all reasonable
367 conversions; callers should filter out those that are
368 not permitted by the language being compiled. */
374 register tree e = expr;
375 register enum tree_code code = TREE_CODE (type);
377 if (type == TREE_TYPE (expr) || TREE_CODE (expr) == ERROR_MARK)
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;