]>
gcc.gnu.org Git - gcc.git/blob - gcc/c-convert.c
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
;
273 register tree typex
= type
;
275 /* Can't do arithmetic in enumeral types
276 so use an integer type that will hold the values. */
277 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
278 typex
= type_for_size (TYPE_PRECISION (typex
),
279 TREE_UNSIGNED (typex
));
281 /* But now perhaps TYPEX is as wide as INPREC.
282 In that case, do nothing special here.
283 (Otherwise would recurse infinitely in convert. */
284 if (TYPE_PRECISION (typex
) != inprec
)
286 /* Don't do unsigned arithmetic where signed was wanted,
288 typex
= (TREE_UNSIGNED (TREE_TYPE (expr
))
289 ? unsigned_type (typex
) : signed_type (typex
));
290 return convert (type
,
291 build_unary_op (ex_form
,
292 convert (typex
, TREE_OPERAND (expr
, 0)),
298 /* If truncating after truncating, might as well do all at once.
299 If truncating after extending, we may get rid of wasted work. */
300 return convert (type
, get_unwidened (TREE_OPERAND (expr
, 0), type
));
303 /* Can treat the two alternative values like the operands
304 of an arithmetic expression. */
306 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
307 tree arg2
= get_unwidened (TREE_OPERAND (expr
, 2), type
);
309 if (outprec
>= BITS_PER_WORD
310 || TRULY_NOOP_TRUNCATION (outprec
, inprec
)
311 || inprec
> TYPE_PRECISION (TREE_TYPE (arg1
))
312 || inprec
> TYPE_PRECISION (TREE_TYPE (arg2
)))
314 /* Do the arithmetic in type TYPEX,
315 then convert result to TYPE. */
316 register tree typex
= type
;
318 /* Can't do arithmetic in enumeral types
319 so use an integer type that will hold the values. */
320 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
321 typex
= type_for_size (TYPE_PRECISION (typex
),
322 TREE_UNSIGNED (typex
));
324 /* But now perhaps TYPEX is as wide as INPREC.
325 In that case, do nothing special here.
326 (Otherwise would recurse infinitely in convert. */
327 if (TYPE_PRECISION (typex
) != inprec
)
329 /* Don't do unsigned arithmetic where signed was wanted,
331 typex
= (TREE_UNSIGNED (TREE_TYPE (expr
))
332 ? unsigned_type (typex
) : signed_type (typex
));
333 return convert (type
,
334 fold (build (COND_EXPR
, typex
,
335 TREE_OPERAND (expr
, 0),
336 convert (typex
, arg1
),
337 convert (typex
, arg2
))));
343 return build1 (NOP_EXPR
, type
, expr
);
346 if (form
== REAL_TYPE
)
347 return build1 (FIX_TRUNC_EXPR
, type
, expr
);
349 error ("aggregate value used where an integer was expected");
352 register tree tem
= build_int_2 (0, 0);
353 TREE_TYPE (tem
) = type
;
358 /* Create an expression whose value is that of EXPR,
359 converted to type TYPE. The TREE_TYPE of the value
360 is always TYPE. This function implements all reasonable
361 conversions; callers should filter out those that are
362 not permitted by the language being compiled. */
368 register tree e
= expr
;
369 register enum tree_code code
= TREE_CODE (type
);
371 if (type
== TREE_TYPE (expr
) || TREE_CODE (expr
) == ERROR_MARK
)
373 if (TREE_CODE (TREE_TYPE (expr
)) == ERROR_MARK
)
374 return error_mark_node
;
375 if (TREE_CODE (TREE_TYPE (expr
)) == VOID_TYPE
)
377 error ("void value not ignored as it ought to be");
378 return error_mark_node
;
380 if (code
== VOID_TYPE
)
381 return build1 (CONVERT_EXPR
, type
, e
);
383 /* This is incorrect. A truncation can't be stripped this way.
384 Extensions will be stripped by the use of get_unwidened. */
385 if (TREE_CODE (expr
) == NOP_EXPR
)
386 return convert (type
, TREE_OPERAND (expr
, 0));
388 if (code
== INTEGER_TYPE
|| code
== ENUMERAL_TYPE
)
389 return fold (convert_to_integer (type
, e
));
390 if (code
== POINTER_TYPE
)
391 return fold (convert_to_pointer (type
, e
));
392 if (code
== REAL_TYPE
)
393 return fold (convert_to_real (type
, e
));
395 error ("conversion to non-scalar type requested");
396 return error_mark_node
;
This page took 0.051385 seconds and 5 git commands to generate.