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))));
342 return build1 (NOP_EXPR, type, expr);
345 if (form == REAL_TYPE)
346 return build1 (FIX_TRUNC_EXPR, type, expr);
348 error ("aggregate value used where an integer was expected");
351 register tree tem = build_int_2 (0, 0);
352 TREE_TYPE (tem) = type;
357 /* Create an expression whose value is that of EXPR,
358 converted to type TYPE. The TREE_TYPE of the value
359 is always TYPE. This function implements all reasonable
360 conversions; callers should filter out those that are
361 not permitted by the language being compiled. */
367 register tree e = expr;
368 register enum tree_code code = TREE_CODE (type);
370 if (type == TREE_TYPE (expr) || TREE_CODE (expr) == ERROR_MARK)
372 if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
373 return error_mark_node;
374 if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
376 error ("void value not ignored as it ought to be");
377 return error_mark_node;
379 if (code == VOID_TYPE)
380 return build1 (CONVERT_EXPR, type, e);
382 /* This is incorrect. A truncation can't be stripped this way.
383 Extensions will be stripped by the use of get_unwidened. */
384 if (TREE_CODE (expr) == NOP_EXPR)
385 return convert (type, TREE_OPERAND (expr, 0));
387 if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
388 return fold (convert_to_integer (type, e));
389 if (code == POINTER_TYPE)
390 return fold (convert_to_pointer (type, e));
391 if (code == REAL_TYPE)
392 return fold (convert_to_real (type, e));
394 error ("conversion to non-scalar type requested");
395 return error_mark_node;