![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to convert.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to convert.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Utility routines for data type conversion for GNU C.
2: Copyright (C) 1987, 1988, 1991, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU C.
5:
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)
9: any later version.
10:
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.
15:
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. */
19:
20:
21: /* These routines are somewhat language-independent utility function
22: intended to be called by the language-specific convert () functions. */
23:
24: #include "config.h"
25: #include "tree.h"
26: #include "flags.h"
27: #include "convert.h"
28:
29: /* Convert EXPR to some pointer type TYPE.
30:
31: EXPR must be pointer, integer, enumeral, or literal zero;
32: in other cases error is called. */
33:
34: tree
35: convert_to_pointer (type, expr)
36: tree type, expr;
37: {
38: register tree intype = TREE_TYPE (expr);
39: register enum tree_code form = TREE_CODE (intype);
40:
41: if (integer_zerop (expr))
42: {
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;
47: return expr;
48: }
49:
50: if (form == POINTER_TYPE)
51: return build1 (NOP_EXPR, type, expr);
52:
53:
54: if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
55: {
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. */
64: abort ();
65: return convert_to_pointer (type, expr);
66: }
67:
68: error ("cannot convert to a pointer type");
69:
70: return null_pointer_node;
71: }
72:
73: /* Convert EXPR to some floating-point type TYPE.
74:
75: EXPR must be float, integer, or enumeral;
76: in other cases error is called. */
77:
78: tree
79: convert_to_real (type, expr)
80: tree type, expr;
81: {
82: register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
83:
84: if (form == REAL_TYPE)
85: return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
86: type, expr);
87:
88: if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
89: return build1 (FLOAT_EXPR, type, expr);
90:
91: if (form == COMPLEX_TYPE)
92: return convert (type, fold (build1 (REALPART_EXPR,
93: TREE_TYPE (TREE_TYPE (expr)), expr)));
94:
95: if (form == POINTER_TYPE)
96: error ("pointer value used where a floating point value was expected");
97: else
98: error ("aggregate value used where a float was expected");
99:
100: {
101: register tree tem = make_node (REAL_CST);
102: TREE_TYPE (tem) = type;
103: TREE_REAL_CST (tem) = REAL_VALUE_ATOF ("0.0", TYPE_MODE (type));
104: return tem;
105: }
106: }
107:
108: /* Convert EXPR to some integer (or enum) type TYPE.
109:
110: EXPR must be pointer, integer, discrete (enum, char, or bool), or float;
111: in other cases error is called.
112:
113: The result of this is always supposed to be a newly created tree node
114: not in use in any existing structure. */
115:
116: tree
117: convert_to_integer (type, expr)
118: tree type, expr;
119: {
120: register tree intype = TREE_TYPE (expr);
121: register enum tree_code form = TREE_CODE (intype);
122:
123: if (form == POINTER_TYPE)
124: {
125: if (integer_zerop (expr))
126: expr = integer_zero_node;
127: else
128: expr = fold (build1 (CONVERT_EXPR,
129: type_for_size (POINTER_SIZE, 0), expr));
130: intype = TREE_TYPE (expr);
131: form = TREE_CODE (intype);
132: if (intype == type)
133: return expr;
134: }
135:
136: if (form == INTEGER_TYPE || form == ENUMERAL_TYPE
137: || form == BOOLEAN_TYPE || form == CHAR_TYPE)
138: {
139: register unsigned outprec = TYPE_PRECISION (type);
140: register unsigned inprec = TYPE_PRECISION (intype);
141: register enum tree_code ex_form = TREE_CODE (expr);
142:
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). */
147:
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)
152: {
153: TREE_TYPE (expr) = type;
154: return expr;
155: }
156: else if (outprec >= inprec)
157: return build1 (NOP_EXPR, type, expr);
158:
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
163: is always safe.
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.
171:
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. */
178:
179: switch (ex_form)
180: {
181: case RSHIFT_EXPR:
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))
186: goto trunc1;
187: break;
188:
189: case LSHIFT_EXPR:
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)
195: {
196: /* If shift count is less than the width of the truncated type,
197: really shift. */
198: if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
199: /* In this case, shifting is like multiplication. */
200: goto trunc1;
201: else
202: {
203: /* If it is >= that width, result is zero.
204: Handling this with trunc1 would give the wrong result:
205: (int) ((long long) a << 32) is well defined (as 0)
206: but (int) a << 32 is undefined and would get a
207: warning. */
208:
209: tree t = convert_to_integer (type, integer_zero_node);
210:
211: /* If the original expression had side-effects, we must
212: preserve it. */
213: if (TREE_SIDE_EFFECTS (expr))
214: return build (COMPOUND_EXPR, type, expr, t);
215: else
216: return t;
217: }
218: }
219: break;
220:
221: case MAX_EXPR:
222: case MIN_EXPR:
223: case MULT_EXPR:
224: {
225: tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
226: tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
227:
228: /* Don't distribute unless the output precision is at least as big
229: as the actual inputs. Otherwise, the comparison of the
230: truncated values will be wrong. */
231: if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
232: && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
233: /* If signedness of arg0 and arg1 don't match,
234: we can't necessarily find a type to compare them in. */
235: && (TREE_UNSIGNED (TREE_TYPE (arg0))
236: == TREE_UNSIGNED (TREE_TYPE (arg1))))
237: goto trunc1;
238: break;
239: }
240:
241: case PLUS_EXPR:
242: case MINUS_EXPR:
243: case BIT_AND_EXPR:
244: case BIT_IOR_EXPR:
245: case BIT_XOR_EXPR:
246: case BIT_ANDTC_EXPR:
247: trunc1:
248: {
249: tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
250: tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
251:
252: if (outprec >= BITS_PER_WORD
253: || TRULY_NOOP_TRUNCATION (outprec, inprec)
254: || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
255: || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
256: {
257: /* Do the arithmetic in type TYPEX,
258: then convert result to TYPE. */
259: register tree typex = type;
260:
261: /* Can't do arithmetic in enumeral types
262: so use an integer type that will hold the values. */
263: if (TREE_CODE (typex) == ENUMERAL_TYPE)
264: typex = type_for_size (TYPE_PRECISION (typex),
265: TREE_UNSIGNED (typex));
266:
267: /* But now perhaps TYPEX is as wide as INPREC.
268: In that case, do nothing special here.
269: (Otherwise would recurse infinitely in convert. */
270: if (TYPE_PRECISION (typex) != inprec)
271: {
272: /* Don't do unsigned arithmetic where signed was wanted,
273: or vice versa.
274: Exception: if either of the original operands were
275: unsigned then can safely do the work as unsigned.
276: And we may need to do it as unsigned
277: if we truncate to the original size. */
278: typex = ((TREE_UNSIGNED (TREE_TYPE (expr))
279: || TREE_UNSIGNED (TREE_TYPE (arg0))
280: || TREE_UNSIGNED (TREE_TYPE (arg1)))
281: ? unsigned_type (typex) : signed_type (typex));
282: return convert (type,
283: fold (build (ex_form, typex,
284: convert (typex, arg0),
285: convert (typex, arg1),
286: 0)));
287: }
288: }
289: }
290: break;
291:
292: case NEGATE_EXPR:
293: case BIT_NOT_EXPR:
294: /* This is not correct for ABS_EXPR,
295: since we must test the sign before truncation. */
296: {
297: register tree typex = type;
298:
299: /* Can't do arithmetic in enumeral types
300: so use an integer type that will hold the values. */
301: if (TREE_CODE (typex) == ENUMERAL_TYPE)
302: typex = type_for_size (TYPE_PRECISION (typex),
303: TREE_UNSIGNED (typex));
304:
305: /* But now perhaps TYPEX is as wide as INPREC.
306: In that case, do nothing special here.
307: (Otherwise would recurse infinitely in convert. */
308: if (TYPE_PRECISION (typex) != inprec)
309: {
310: /* Don't do unsigned arithmetic where signed was wanted,
311: or vice versa. */
312: typex = (TREE_UNSIGNED (TREE_TYPE (expr))
313: ? unsigned_type (typex) : signed_type (typex));
314: return convert (type,
315: fold (build1 (ex_form, typex,
316: convert (typex,
317: TREE_OPERAND (expr, 0)))));
318: }
319: }
320:
321: case NOP_EXPR:
322: /* If truncating after truncating, might as well do all at once.
323: If truncating after extending, we may get rid of wasted work. */
324: return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
325:
326: case COND_EXPR:
327: /* Can treat the two alternative values like the operands
328: of an arithmetic expression. */
329: {
330: tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
331: tree arg2 = get_unwidened (TREE_OPERAND (expr, 2), type);
332:
333: if (outprec >= BITS_PER_WORD
334: || TRULY_NOOP_TRUNCATION (outprec, inprec)
335: || inprec > TYPE_PRECISION (TREE_TYPE (arg1))
336: || inprec > TYPE_PRECISION (TREE_TYPE (arg2)))
337: {
338: /* Do the arithmetic in type TYPEX,
339: then convert result to TYPE. */
340: register tree typex = type;
341:
342: /* Can't do arithmetic in enumeral types
343: so use an integer type that will hold the values. */
344: if (TREE_CODE (typex) == ENUMERAL_TYPE)
345: typex = type_for_size (TYPE_PRECISION (typex),
346: TREE_UNSIGNED (typex));
347:
348: /* But now perhaps TYPEX is as wide as INPREC.
349: In that case, do nothing special here.
350: (Otherwise would recurse infinitely in convert. */
351: if (TYPE_PRECISION (typex) != inprec)
352: {
353: /* Don't do unsigned arithmetic where signed was wanted,
354: or vice versa. */
355: typex = (TREE_UNSIGNED (TREE_TYPE (expr))
356: ? unsigned_type (typex) : signed_type (typex));
357: return convert (type,
358: fold (build (COND_EXPR, typex,
359: TREE_OPERAND (expr, 0),
360: convert (typex, arg1),
361: convert (typex, arg2))));
362: }
363: else
364: /* It is sometimes worthwhile
365: to push the narrowing down through the conditional. */
366: return fold (build (COND_EXPR, type,
367: TREE_OPERAND (expr, 0),
368: convert (type, TREE_OPERAND (expr, 1)),
369: convert (type, TREE_OPERAND (expr, 2))));
370: }
371: }
372:
373: }
374:
375: return build1 (NOP_EXPR, type, expr);
376: }
377:
378: if (form == REAL_TYPE)
379: return build1 (FIX_TRUNC_EXPR, type, expr);
380:
381: if (form == COMPLEX_TYPE)
382: return convert (type, fold (build1 (REALPART_EXPR,
383: TREE_TYPE (TREE_TYPE (expr)), expr)));
384:
385: error ("aggregate value used where an integer was expected");
386:
387: {
388: register tree tem = build_int_2 (0, 0);
389: TREE_TYPE (tem) = type;
390: return tem;
391: }
392: }
393:
394: /* Convert EXPR to the complex type TYPE in the usual ways. */
395:
396: tree
397: convert_to_complex (type, expr)
398: tree type, expr;
399: {
400: register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
401: tree subtype = TREE_TYPE (type);
402:
403: if (form == REAL_TYPE || form == INTEGER_TYPE || form == ENUMERAL_TYPE)
404: {
405: expr = convert (subtype, expr);
406: return build (COMPLEX_EXPR, type, expr,
407: convert (subtype, integer_zero_node));
408: }
409:
410: if (form == COMPLEX_TYPE)
411: {
412: tree elt_type = TREE_TYPE (TREE_TYPE (expr));
413: if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
414: return expr;
415: else if (TREE_CODE (expr) == COMPLEX_EXPR)
416: return fold (build (COMPLEX_EXPR,
417: type,
418: convert (subtype, TREE_OPERAND (expr, 0)),
419: convert (subtype, TREE_OPERAND (expr, 1))));
420: else
421: {
422: expr = save_expr (expr);
423: return fold (build (COMPLEX_EXPR,
424: type,
425: convert (subtype,
426: fold (build1 (REALPART_EXPR,
427: TREE_TYPE (TREE_TYPE (expr)),
428: expr))),
429: convert (subtype,
430: fold (build1 (IMAGPART_EXPR,
431: TREE_TYPE (TREE_TYPE (expr)),
432: expr)))));
433: }
434: }
435:
436: if (form == POINTER_TYPE)
437: error ("pointer value used where a complex was expected");
438: else
439: error ("aggregate value used where a complex was expected");
440:
441: return build (COMPLEX_EXPR, type,
442: convert (subtype, integer_zero_node),
443: convert (subtype, integer_zero_node));
444: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.