]>
gcc.gnu.org Git - gcc.git/blob - gcc/convert.c
a063a6e88e109f6585c1880c29cf401708febb0b
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");
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. */
202 /* If it is >= that width, result is zero.
203 Handling this with trunc1 would give the wrong result:
204 (int) ((long long) a << 32) is well defined (as 0)
205 but (int) a << 32 is undefined and would get a warning. */
206 return convert_to_integer (type
, integer_zero_node
);
214 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
215 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
217 /* Don't distribute unless the output precision is at least as big
218 as the actual inputs. Otherwise, the comparison of the
219 truncated values will be wrong. */
220 if (outprec
>= TYPE_PRECISION (TREE_TYPE (arg0
))
221 && outprec
>= TYPE_PRECISION (TREE_TYPE (arg1
))
222 /* If signedness of arg0 and arg1 don't match,
223 we can't necessarily find a type to compare them in. */
224 && (TREE_UNSIGNED (TREE_TYPE (arg0
))
225 == TREE_UNSIGNED (TREE_TYPE (arg1
))))
238 tree arg0
= get_unwidened (TREE_OPERAND (expr
, 0), type
);
239 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
241 if (outprec
>= BITS_PER_WORD
242 || TRULY_NOOP_TRUNCATION (outprec
, inprec
)
243 || inprec
> TYPE_PRECISION (TREE_TYPE (arg0
))
244 || inprec
> TYPE_PRECISION (TREE_TYPE (arg1
)))
246 /* Do the arithmetic in type TYPEX,
247 then convert result to TYPE. */
248 register tree typex
= type
;
250 /* Can't do arithmetic in enumeral types
251 so use an integer type that will hold the values. */
252 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
253 typex
= type_for_size (TYPE_PRECISION (typex
),
254 TREE_UNSIGNED (typex
));
256 /* But now perhaps TYPEX is as wide as INPREC.
257 In that case, do nothing special here.
258 (Otherwise would recurse infinitely in convert. */
259 if (TYPE_PRECISION (typex
) != inprec
)
261 /* Don't do unsigned arithmetic where signed was wanted,
263 Exception: if either of the original operands were
264 unsigned then can safely do the work as unsigned.
265 And we may need to do it as unsigned
266 if we truncate to the original size. */
267 typex
= ((TREE_UNSIGNED (TREE_TYPE (expr
))
268 || TREE_UNSIGNED (TREE_TYPE (arg0
))
269 || TREE_UNSIGNED (TREE_TYPE (arg1
)))
270 ? unsigned_type (typex
) : signed_type (typex
));
271 return convert (type
,
272 build_binary_op (ex_form
,
273 convert (typex
, arg0
),
274 convert (typex
, arg1
),
285 register tree typex
= type
;
287 /* Can't do arithmetic in enumeral types
288 so use an integer type that will hold the values. */
289 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
290 typex
= type_for_size (TYPE_PRECISION (typex
),
291 TREE_UNSIGNED (typex
));
293 /* But now perhaps TYPEX is as wide as INPREC.
294 In that case, do nothing special here.
295 (Otherwise would recurse infinitely in convert. */
296 if (TYPE_PRECISION (typex
) != inprec
)
298 /* Don't do unsigned arithmetic where signed was wanted,
300 typex
= (TREE_UNSIGNED (TREE_TYPE (expr
))
301 ? unsigned_type (typex
) : signed_type (typex
));
302 return convert (type
,
303 build_unary_op (ex_form
,
304 convert (typex
, TREE_OPERAND (expr
, 0)),
310 /* If truncating after truncating, might as well do all at once.
311 If truncating after extending, we may get rid of wasted work. */
312 return convert (type
, get_unwidened (TREE_OPERAND (expr
, 0), type
));
315 /* Can treat the two alternative values like the operands
316 of an arithmetic expression. */
318 tree arg1
= get_unwidened (TREE_OPERAND (expr
, 1), type
);
319 tree arg2
= get_unwidened (TREE_OPERAND (expr
, 2), type
);
321 if (outprec
>= BITS_PER_WORD
322 || TRULY_NOOP_TRUNCATION (outprec
, inprec
)
323 || inprec
> TYPE_PRECISION (TREE_TYPE (arg1
))
324 || inprec
> TYPE_PRECISION (TREE_TYPE (arg2
)))
326 /* Do the arithmetic in type TYPEX,
327 then convert result to TYPE. */
328 register tree typex
= type
;
330 /* Can't do arithmetic in enumeral types
331 so use an integer type that will hold the values. */
332 if (TREE_CODE (typex
) == ENUMERAL_TYPE
)
333 typex
= type_for_size (TYPE_PRECISION (typex
),
334 TREE_UNSIGNED (typex
));
336 /* But now perhaps TYPEX is as wide as INPREC.
337 In that case, do nothing special here.
338 (Otherwise would recurse infinitely in convert. */
339 if (TYPE_PRECISION (typex
) != inprec
)
341 /* Don't do unsigned arithmetic where signed was wanted,
343 typex
= (TREE_UNSIGNED (TREE_TYPE (expr
))
344 ? unsigned_type (typex
) : signed_type (typex
));
345 return convert (type
,
346 fold (build (COND_EXPR
, typex
,
347 TREE_OPERAND (expr
, 0),
348 convert (typex
, arg1
),
349 convert (typex
, arg2
))));
352 /* It is sometimes worthwhile
353 to push the narrowing down through the conditional. */
354 return fold (build (COND_EXPR
, type
,
355 TREE_OPERAND (expr
, 0),
356 convert (type
, TREE_OPERAND (expr
, 1)),
357 convert (type
, TREE_OPERAND (expr
, 2))));
363 return build1 (NOP_EXPR
, type
, expr
);
366 if (form
== REAL_TYPE
)
367 return build1 (FIX_TRUNC_EXPR
, type
, expr
);
369 if (form
== COMPLEX_TYPE
)
370 return convert (type
, fold (build1 (REALPART_EXPR
,
371 TREE_TYPE (TREE_TYPE (expr
)), expr
)));
373 error ("aggregate value used where an integer was expected");
376 register tree tem
= build_int_2 (0, 0);
377 TREE_TYPE (tem
) = type
;
382 /* Convert EXPR to the complex type TYPE in the usual ways. */
385 convert_to_complex (type
, expr
)
388 register enum tree_code form
= TREE_CODE (TREE_TYPE (expr
));
389 tree subtype
= TREE_TYPE (type
);
391 if (form
== REAL_TYPE
|| form
== INTEGER_TYPE
|| form
== ENUMERAL_TYPE
)
393 expr
= convert (subtype
, expr
);
394 return build (COMPLEX_EXPR
, type
, expr
,
395 convert (subtype
, integer_zero_node
));
398 if (form
== COMPLEX_TYPE
)
400 tree elt_type
= TREE_TYPE (TREE_TYPE (expr
));
401 if (TYPE_MAIN_VARIANT (elt_type
) == TYPE_MAIN_VARIANT (subtype
))
403 else if (TREE_CODE (expr
) == COMPLEX_EXPR
)
404 return fold (build (COMPLEX_EXPR
,
406 convert (subtype
, TREE_OPERAND (expr
, 0)),
407 convert (subtype
, TREE_OPERAND (expr
, 1))));
410 expr
= save_expr (expr
);
411 return fold (build (COMPLEX_EXPR
,
414 build_unary_op (REALPART_EXPR
, expr
, 1)),
416 build_unary_op (IMAGPART_EXPR
, expr
, 1))));
420 if (form
== POINTER_TYPE
)
421 error ("pointer value used where a complex was expected");
423 error ("aggregate value used where a complex was expected");
425 return build (COMPLEX_EXPR
, type
,
426 convert (subtype
, integer_zero_node
),
427 convert (subtype
, integer_zero_node
));
This page took 0.058766 seconds and 5 git commands to generate.