![[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 [GCC 2.x] / gcc|
Return to convert.c CVS log | Up to [GCC 2.x] / gcc |
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: case ABS_EXPR:
295: {
296: register tree typex = type;
297:
298: /* Can't do arithmetic in enumeral types
299: so use an integer type that will hold the values. */
300: if (TREE_CODE (typex) == ENUMERAL_TYPE)
301: typex = type_for_size (TYPE_PRECISION (typex),
302: TREE_UNSIGNED (typex));
303:
304: /* But now perhaps TYPEX is as wide as INPREC.
305: In that case, do nothing special here.
306: (Otherwise would recurse infinitely in convert. */
307: if (TYPE_PRECISION (typex) != inprec)
308: {
309: /* Don't do unsigned arithmetic where signed was wanted,
310: or vice versa. */
311: typex = (TREE_UNSIGNED (TREE_TYPE (expr))
312: ? unsigned_type (typex) : signed_type (typex));
313: return convert (type,
314: fold (build1 (ex_form, typex,
315: convert (typex,
316: TREE_OPERAND (expr, 0)))));
317: }
318: }
319:
320: case NOP_EXPR:
321: /* If truncating after truncating, might as well do all at once.
322: If truncating after extending, we may get rid of wasted work. */
323: return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
324:
325: case COND_EXPR:
326: /* Can treat the two alternative values like the operands
327: of an arithmetic expression. */
328: {
329: tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
330: tree arg2 = get_unwidened (TREE_OPERAND (expr, 2), type);
331:
332: if (outprec >= BITS_PER_WORD
333: || TRULY_NOOP_TRUNCATION (outprec, inprec)
334: || inprec > TYPE_PRECISION (TREE_TYPE (arg1))
335: || inprec > TYPE_PRECISION (TREE_TYPE (arg2)))
336: {
337: /* Do the arithmetic in type TYPEX,
338: then convert result to TYPE. */
339: register tree typex = type;
340:
341: /* Can't do arithmetic in enumeral types
342: so use an integer type that will hold the values. */
343: if (TREE_CODE (typex) == ENUMERAL_TYPE)
344: typex = type_for_size (TYPE_PRECISION (typex),
345: TREE_UNSIGNED (typex));
346:
347: /* But now perhaps TYPEX is as wide as INPREC.
348: In that case, do nothing special here.
349: (Otherwise would recurse infinitely in convert. */
350: if (TYPE_PRECISION (typex) != inprec)
351: {
352: /* Don't do unsigned arithmetic where signed was wanted,
353: or vice versa. */
354: typex = (TREE_UNSIGNED (TREE_TYPE (expr))
355: ? unsigned_type (typex) : signed_type (typex));
356: return convert (type,
357: fold (build (COND_EXPR, typex,
358: TREE_OPERAND (expr, 0),
359: convert (typex, arg1),
360: convert (typex, arg2))));
361: }
362: else
363: /* It is sometimes worthwhile
364: to push the narrowing down through the conditional. */
365: return fold (build (COND_EXPR, type,
366: TREE_OPERAND (expr, 0),
367: convert (type, TREE_OPERAND (expr, 1)),
368: convert (type, TREE_OPERAND (expr, 2))));
369: }
370: }
371:
372: }
373:
374: return build1 (NOP_EXPR, type, expr);
375: }
376:
377: if (form == REAL_TYPE)
378: return build1 (FIX_TRUNC_EXPR, type, expr);
379:
380: if (form == COMPLEX_TYPE)
381: return convert (type, fold (build1 (REALPART_EXPR,
382: TREE_TYPE (TREE_TYPE (expr)), expr)));
383:
384: error ("aggregate value used where an integer was expected");
385:
386: {
387: register tree tem = build_int_2 (0, 0);
388: TREE_TYPE (tem) = type;
389: return tem;
390: }
391: }
392:
393: /* Convert EXPR to the complex type TYPE in the usual ways. */
394:
395: tree
396: convert_to_complex (type, expr)
397: tree type, expr;
398: {
399: register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
400: tree subtype = TREE_TYPE (type);
401:
402: if (form == REAL_TYPE || form == INTEGER_TYPE || form == ENUMERAL_TYPE)
403: {
404: expr = convert (subtype, expr);
405: return build (COMPLEX_EXPR, type, expr,
406: convert (subtype, integer_zero_node));
407: }
408:
409: if (form == COMPLEX_TYPE)
410: {
411: tree elt_type = TREE_TYPE (TREE_TYPE (expr));
412: if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
413: return expr;
414: else if (TREE_CODE (expr) == COMPLEX_EXPR)
415: return fold (build (COMPLEX_EXPR,
416: type,
417: convert (subtype, TREE_OPERAND (expr, 0)),
418: convert (subtype, TREE_OPERAND (expr, 1))));
419: else
420: {
421: expr = save_expr (expr);
422: return fold (build (COMPLEX_EXPR,
423: type,
424: convert (subtype,
425: fold (build1 (REALPART_EXPR,
426: TREE_TYPE (TREE_TYPE (expr)),
427: expr))),
428: convert (subtype,
429: fold (build1 (IMAGPART_EXPR,
430: TREE_TYPE (TREE_TYPE (expr)),
431: expr)))));
432: }
433: }
434:
435: if (form == POINTER_TYPE)
436: error ("pointer value used where a complex was expected");
437: else
438: error ("aggregate value used where a complex was expected");
439:
440: return build (COMPLEX_EXPR, type,
441: convert (subtype, integer_zero_node),
442: convert (subtype, integer_zero_node));
443: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.