![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c-common.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 c-common.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Subroutines shared by all languages that are variants of C.
2: Copyright (C) 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
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: #include "config.h"
21: #include "tree.h"
22: #include "c-lex.h"
23: #include "c-tree.h"
24: #include "flags.h"
25: #include <stdio.h>
26:
27: #undef NULL
28: #define NULL 0
29:
30: /* Given a chain of STRING_CST nodes,
31: concatenate them into one STRING_CST
32: and give it a suitable array-of-chars data type. */
33:
34: tree
35: combine_strings (strings)
36: tree strings;
37: {
38: register tree value, t;
39: register int length = 1;
40: int wide_length = 0;
41: int wide_flag = 0;
42: int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
43: int nchars;
44:
45: if (TREE_CHAIN (strings))
46: {
47: /* More than one in the chain, so concatenate. */
48: register char *p, *q;
49:
50: /* Don't include the \0 at the end of each substring,
51: except for the last one.
52: Count wide strings and ordinary strings separately. */
53: for (t = strings; t; t = TREE_CHAIN (t))
54: {
55: if (TREE_TYPE (t) == wchar_array_type_node)
56: {
57: wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
58: wide_flag = 1;
59: }
60: else
61: length += (TREE_STRING_LENGTH (t) - 1);
62: }
63:
64: /* If anything is wide, the non-wides will be converted,
65: which makes them take more space. */
66: if (wide_flag)
67: length = length * wchar_bytes + wide_length;
68:
69: p = savealloc (length);
70:
71: /* Copy the individual strings into the new combined string.
72: If the combined string is wide, convert the chars to ints
73: for any individual strings that are not wide. */
74:
75: q = p;
76: for (t = strings; t; t = TREE_CHAIN (t))
77: {
78: int len = (TREE_STRING_LENGTH (t)
79: - ((TREE_TYPE (t) == wchar_array_type_node)
80: ? wchar_bytes : 1));
81: if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
82: {
83: bcopy (TREE_STRING_POINTER (t), q, len);
84: q += len;
85: }
86: else
87: {
88: int i;
89: for (i = 0; i < len; i++)
90: ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
91: q += len * wchar_bytes;
92: }
93: }
94: if (wide_flag)
95: {
96: int i;
97: for (i = 0; i < wchar_bytes; i++)
98: *q++ = 0;
99: }
100: else
101: *q = 0;
102:
103: value = make_node (STRING_CST);
104: TREE_STRING_POINTER (value) = p;
105: TREE_STRING_LENGTH (value) = length;
106: TREE_CONSTANT (value) = 1;
107: }
108: else
109: {
110: value = strings;
111: length = TREE_STRING_LENGTH (value);
112: if (TREE_TYPE (value) == wchar_array_type_node)
113: wide_flag = 1;
114: }
115:
116: /* Compute the number of elements, for the array type. */
117: nchars = wide_flag ? length / wchar_bytes : length;
118:
119: /* Create the array type for the string constant.
120: -Wwrite-strings says make the string constant an array of const char
121: so that copying it to a non-const pointer will get a warning. */
122: if (warn_write_strings
123: && (! flag_traditional && ! flag_writable_strings))
124: {
125: tree elements
126: = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
127: 1, 0);
128: TREE_TYPE (value)
129: = build_array_type (elements,
130: build_index_type (build_int_2 (nchars - 1, 0)));
131: }
132: else
133: TREE_TYPE (value)
134: = build_array_type (wide_flag ? wchar_type_node : char_type_node,
135: build_index_type (build_int_2 (nchars - 1, 0)));
136: TREE_CONSTANT (value) = 1;
137: TREE_STATIC (value) = 1;
138: return value;
139: }
140:
141: /* Process the attributes listed in ATTRIBUTES
142: and install them in DECL. */
143:
144: void
145: decl_attributes (decl, attributes)
146: tree decl, attributes;
147: {
148: tree a;
149: for (a = attributes; a; a = TREE_CHAIN (a))
150: if (TREE_VALUE (a) != 0
151: && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
152: && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("aligned"))
153: {
154: int align = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (a)))
155: * BITS_PER_UNIT;
156:
157: if (exact_log2 (align) == -1)
158: warning_with_decl (decl,
159: "requested alignment of `%s' is not a power of 2");
160: else if (TREE_CODE (decl) != VAR_DECL
161: && TREE_CODE (decl) != FIELD_DECL)
162: warning_with_decl (decl,
163: "alignment specified for `%s' which is not a variable");
164:
165: /* ??? The maximum alignment gcc can currently handle is 16 bytes!
166: We should change the representation to be the log of the
167: actual alignment since we only handle powers of 2 anyway. */
168: else if (align > 255)
169: warning_with_decl (decl,
170: "requested alignment of `%s' exceeds compiler limits");
171: else
172: DECL_ALIGN (decl) = align;
173: }
174: else if (TREE_VALUE (a) != 0
175: && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
176: && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("packed"))
177: {
178: if (TREE_CODE (decl) == FIELD_DECL)
179: DECL_PACKED (decl) = 1;
180: }
181: else if (TREE_VALUE (a) != 0
182: && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
183: && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("format"))
184: {
185: tree list = TREE_VALUE (TREE_VALUE (a));
186: tree format_type = TREE_PURPOSE (list);
187: int format_num = TREE_INT_CST_LOW (TREE_PURPOSE (TREE_VALUE (list)));
188: int first_arg_num = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (list)));
189: int is_scan;
190:
191: if (TREE_CODE (decl) != FUNCTION_DECL)
192: {
193: warning_with_decl (decl,
194: "argument format specified for non-function `%s'");
195: return;
196: }
197:
198: if (format_type == get_identifier ("printf"))
199: is_scan = 0;
200: else if (format_type == get_identifier ("scanf"))
201: is_scan = 1;
202: else
203: {
204: warning_with_decl (decl,"unrecognized format specifier for `%s'");
205: return;
206: }
207:
208: if (first_arg_num != 0 && first_arg_num <= format_num)
209: {
210: warning_with_decl (decl,
211: "format string arg follows the args to be formatted, for `%s'");
212: return;
213: }
214:
215: record_format_info (DECL_NAME (decl), is_scan, format_num,
216: first_arg_num);
217: }
218: }
219:
220: void
221: c_expand_expr_stmt (expr)
222: tree expr;
223: {
224: /* Do default conversion if safe and possibly important,
225: in case within ({...}). */
226: if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
227: || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
228: expr = default_conversion (expr);
229:
230: if (TREE_TYPE (expr) != error_mark_node
231: && TYPE_SIZE (TREE_TYPE (expr)) == 0
232: && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
233: error ("expression statement has incomplete type");
234:
235: expand_expr_stmt (expr);
236: }
237:
238: /* Validate the expression after `case' and apply default promotions. */
239:
240: tree
241: check_case_value (value)
242: tree value;
243: {
244: if (value == NULL_TREE)
245: return value;
246:
247: /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
248: if (TREE_CODE (value) == NON_LVALUE_EXPR)
249: value = TREE_OPERAND (value, 0);
250:
251: if (TREE_CODE (value) != INTEGER_CST
252: && value != error_mark_node)
253: {
254: error ("case label does not reduce to an integer constant");
255: value = error_mark_node;
256: }
257: else
258: /* Promote char or short to int. */
259: value = default_conversion (value);
260:
261: return value;
262: }
263:
264: /* Return an integer type with BITS bits of precision,
265: that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
266:
267: tree
268: type_for_size (bits, unsignedp)
269: unsigned bits;
270: int unsignedp;
271: {
272: if (bits <= TYPE_PRECISION (signed_char_type_node))
273: return unsignedp ? unsigned_char_type_node : signed_char_type_node;
274:
275: if (bits <= TYPE_PRECISION (short_integer_type_node))
276: return unsignedp ? short_unsigned_type_node : short_integer_type_node;
277:
278: if (bits <= TYPE_PRECISION (integer_type_node))
279: return unsignedp ? unsigned_type_node : integer_type_node;
280:
281: if (bits <= TYPE_PRECISION (long_integer_type_node))
282: return unsignedp ? long_unsigned_type_node : long_integer_type_node;
283:
284: if (bits <= TYPE_PRECISION (long_long_integer_type_node))
285: return (unsignedp ? long_long_unsigned_type_node
286: : long_long_integer_type_node);
287:
288: return 0;
289: }
290:
291: /* Return a data type that has machine mode MODE.
292: If the mode is an integer,
293: then UNSIGNEDP selects between signed and unsigned types. */
294:
295: tree
296: type_for_mode (mode, unsignedp)
297: enum machine_mode mode;
298: int unsignedp;
299: {
300: if (mode == TYPE_MODE (signed_char_type_node))
301: return unsignedp ? unsigned_char_type_node : signed_char_type_node;
302:
303: if (mode == TYPE_MODE (short_integer_type_node))
304: return unsignedp ? short_unsigned_type_node : short_integer_type_node;
305:
306: if (mode == TYPE_MODE (integer_type_node))
307: return unsignedp ? unsigned_type_node : integer_type_node;
308:
309: if (mode == TYPE_MODE (long_integer_type_node))
310: return unsignedp ? long_unsigned_type_node : long_integer_type_node;
311:
312: if (mode == TYPE_MODE (long_long_integer_type_node))
313: return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
314:
315: if (mode == TYPE_MODE (float_type_node))
316: return float_type_node;
317:
318: if (mode == TYPE_MODE (double_type_node))
319: return double_type_node;
320:
321: if (mode == TYPE_MODE (long_double_type_node))
322: return long_double_type_node;
323:
324: if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
325: return build_pointer_type (char_type_node);
326:
327: if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
328: return build_pointer_type (integer_type_node);
329:
330: return 0;
331: }
332:
333: /* Print an error message for invalid operands to arith operation CODE.
334: NOP_EXPR is used as a special case (see truthvalue_conversion). */
335:
336: void
337: binary_op_error (code)
338: enum tree_code code;
339: {
340: register char *opname;
341: switch (code)
342: {
343: case NOP_EXPR:
344: error ("invalid truth-value expression");
345: return;
346:
347: case PLUS_EXPR:
348: opname = "+"; break;
349: case MINUS_EXPR:
350: opname = "-"; break;
351: case MULT_EXPR:
352: opname = "*"; break;
353: case MAX_EXPR:
354: opname = "max"; break;
355: case MIN_EXPR:
356: opname = "min"; break;
357: case EQ_EXPR:
358: opname = "=="; break;
359: case NE_EXPR:
360: opname = "!="; break;
361: case LE_EXPR:
362: opname = "<="; break;
363: case GE_EXPR:
364: opname = ">="; break;
365: case LT_EXPR:
366: opname = "<"; break;
367: case GT_EXPR:
368: opname = ">"; break;
369: case LSHIFT_EXPR:
370: opname = "<<"; break;
371: case RSHIFT_EXPR:
372: opname = ">>"; break;
373: case TRUNC_MOD_EXPR:
374: opname = "%"; break;
375: case TRUNC_DIV_EXPR:
376: opname = "/"; break;
377: case BIT_AND_EXPR:
378: opname = "&"; break;
379: case BIT_IOR_EXPR:
380: opname = "|"; break;
381: case TRUTH_ANDIF_EXPR:
382: opname = "&&"; break;
383: case TRUTH_ORIF_EXPR:
384: opname = "||"; break;
385: case BIT_XOR_EXPR:
386: opname = "^"; break;
387: }
388: error ("invalid operands to binary %s", opname);
389: }
390:
391: /* Subroutine of build_binary_op, used for comparison operations.
392: See if the operands have both been converted from subword integer types
393: and, if so, perhaps change them both back to their original type.
394:
395: The arguments of this function are all pointers to local variables
396: of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
397: RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
398:
399: If this function returns nonzero, it means that the comparison has
400: a constant value. What this function returns is an expression for
401: that value. */
402:
403: tree
404: shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
405: tree *op0_ptr, *op1_ptr;
406: tree *restype_ptr;
407: enum tree_code *rescode_ptr;
408: {
409: register tree type;
410: tree op0 = *op0_ptr;
411: tree op1 = *op1_ptr;
412: int unsignedp0, unsignedp1;
413: int real1, real2;
414: tree primop0, primop1;
415: enum tree_code code = *rescode_ptr;
416:
417: /* Throw away any conversions to wider types
418: already present in the operands. */
419:
420: primop0 = get_narrower (op0, &unsignedp0);
421: primop1 = get_narrower (op1, &unsignedp1);
422:
423: /* Handle the case that OP0 does not *contain* a conversion
424: but it *requires* conversion to FINAL_TYPE. */
425:
426: if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
427: unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
428: if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
429: unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
430:
431: /* If one of the operands must be floated, we cannot optimize. */
432: real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
433: real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
434:
435: /* If first arg is constant, swap the args (changing operation
436: so value is preserved), for canonicalization. */
437:
438: if (TREE_CONSTANT (primop0))
439: {
440: register tree tem = primop0;
441: register int temi = unsignedp0;
442: primop0 = primop1;
443: primop1 = tem;
444: tem = op0;
445: op0 = op1;
446: op1 = tem;
447: *op0_ptr = op0;
448: *op1_ptr = op1;
449: unsignedp0 = unsignedp1;
450: unsignedp1 = temi;
451: temi = real1;
452: real1 = real2;
453: real2 = temi;
454:
455: switch (code)
456: {
457: case LT_EXPR:
458: code = GT_EXPR;
459: break;
460: case GT_EXPR:
461: code = LT_EXPR;
462: break;
463: case LE_EXPR:
464: code = GE_EXPR;
465: break;
466: case GE_EXPR:
467: code = LE_EXPR;
468: break;
469: }
470: *rescode_ptr = code;
471: }
472:
473: /* If comparing an integer against a constant more bits wide,
474: maybe we can deduce a value of 1 or 0 independent of the data.
475: Or else truncate the constant now
476: rather than extend the variable at run time.
477:
478: This is only interesting if the constant is the wider arg.
479: Also, it is not safe if the constant is unsigned and the
480: variable arg is signed, since in this case the variable
481: would be sign-extended and then regarded as unsigned.
482: Our technique fails in this case because the lowest/highest
483: possible unsigned results don't follow naturally from the
484: lowest/highest possible values of the variable operand.
485: For just EQ_EXPR and NE_EXPR there is another technique that
486: could be used: see if the constant can be faithfully represented
487: in the other operand's type, by truncating it and reextending it
488: and see if that preserves the constant's value. */
489:
490: if (!real1 && !real2
491: && TREE_CODE (primop1) == INTEGER_CST
492: && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
493: {
494: int min_gt, max_gt, min_lt, max_lt;
495: tree maxval, minval;
496: /* 1 if comparison is nominally unsigned. */
497: int unsignedp = TREE_UNSIGNED (*restype_ptr);
498: tree val;
499:
500: type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
501:
502: maxval = TYPE_MAX_VALUE (type);
503: minval = TYPE_MIN_VALUE (type);
504:
505: if (unsignedp && !unsignedp0)
506: *restype_ptr = signed_type (*restype_ptr);
507:
508: if (TREE_TYPE (primop1) != *restype_ptr)
509: primop1 = convert (*restype_ptr, primop1);
510: if (type != *restype_ptr)
511: {
512: minval = convert (*restype_ptr, minval);
513: maxval = convert (*restype_ptr, maxval);
514: }
515:
516: if (unsignedp && unsignedp0)
517: {
518: min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
519: max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
520: min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
521: max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
522: }
523: else
524: {
525: min_gt = INT_CST_LT (primop1, minval);
526: max_gt = INT_CST_LT (primop1, maxval);
527: min_lt = INT_CST_LT (minval, primop1);
528: max_lt = INT_CST_LT (maxval, primop1);
529: }
530:
531: val = 0;
532: /* This used to be a switch, but Genix compiler can't handle that. */
533: if (code == NE_EXPR)
534: {
535: if (max_lt || min_gt)
536: val = integer_one_node;
537: }
538: else if (code == EQ_EXPR)
539: {
540: if (max_lt || min_gt)
541: val = integer_zero_node;
542: }
543: else if (code == LT_EXPR)
544: {
545: if (max_lt)
546: val = integer_one_node;
547: if (!min_lt)
548: val = integer_zero_node;
549: }
550: else if (code == GT_EXPR)
551: {
552: if (min_gt)
553: val = integer_one_node;
554: if (!max_gt)
555: val = integer_zero_node;
556: }
557: else if (code == LE_EXPR)
558: {
559: if (!max_gt)
560: val = integer_one_node;
561: if (min_gt)
562: val = integer_zero_node;
563: }
564: else if (code == GE_EXPR)
565: {
566: if (!min_lt)
567: val = integer_one_node;
568: if (max_lt)
569: val = integer_zero_node;
570: }
571:
572: /* If primop0 was sign-extended and unsigned comparison specd,
573: we did a signed comparison above using the signed type bounds.
574: But the comparison we output must be unsigned.
575:
576: Also, for inequalities, VAL is no good; but if the signed
577: comparison had *any* fixed result, it follows that the
578: unsigned comparison just tests the sign in reverse
579: (positive values are LE, negative ones GE).
580: So we can generate an unsigned comparison
581: against an extreme value of the signed type. */
582:
583: if (unsignedp && !unsignedp0)
584: {
585: if (val != 0)
586: switch (code)
587: {
588: case LT_EXPR:
589: case GE_EXPR:
590: primop1 = TYPE_MIN_VALUE (type);
591: val = 0;
592: break;
593:
594: case LE_EXPR:
595: case GT_EXPR:
596: primop1 = TYPE_MAX_VALUE (type);
597: val = 0;
598: break;
599: }
600: type = unsigned_type (type);
601: }
602:
603: if (max_lt && !unsignedp0)
604: {
605: /* This is the case of (char)x >?< 0x80, which people used to use
606: expecting old C compilers to change the 0x80 into -0x80. */
607: if (val == integer_zero_node)
608: warning ("comparison is always 0 due to limited range of data type");
609: if (val == integer_one_node)
610: warning ("comparison is always 1 due to limited range of data type");
611: }
612:
613: if (min_gt && unsignedp0)
614: {
615: /* This is the case of (unsigned char)x >?< -1. */
616: if (val == integer_zero_node)
617: warning ("comparison is always 0 due to limited range of data type");
618: if (val == integer_one_node)
619: warning ("comparison is always 1 due to limited range of data type");
620: }
621:
622: if (val != 0)
623: {
624: /* Don't forget to evaluate PRIMOP0 if it has side effects. */
625: if (TREE_SIDE_EFFECTS (primop0))
626: return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
627: return val;
628: }
629:
630: /* Value is not predetermined, but do the comparison
631: in the type of the operand that is not constant.
632: TYPE is already properly set. */
633: }
634: else if (real1 && real2
635: && TYPE_PRECISION (TREE_TYPE (primop0)) == TYPE_PRECISION (TREE_TYPE (primop1)))
636: type = TREE_TYPE (primop0);
637:
638: /* If args' natural types are both narrower than nominal type
639: and both extend in the same manner, compare them
640: in the type of the wider arg.
641: Otherwise must actually extend both to the nominal
642: common type lest different ways of extending
643: alter the result.
644: (eg, (short)-1 == (unsigned short)-1 should be 0.) */
645:
646: else if (unsignedp0 == unsignedp1 && real1 == real2
647: && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
648: && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
649: {
650: type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
651: type = signed_or_unsigned_type (unsignedp0
652: || TREE_UNSIGNED (*restype_ptr),
653: type);
654: /* Make sure shorter operand is extended the right way
655: to match the longer operand. */
656: primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
657: primop0);
658: primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
659: primop1);
660: }
661: else
662: {
663: /* Here we must do the comparison on the nominal type
664: using the args exactly as we received them. */
665: type = *restype_ptr;
666: primop0 = op0;
667: primop1 = op1;
668:
669: if (!real1 && !real2 && integer_zerop (primop1)
670: && TREE_UNSIGNED (TREE_TYPE (primop0)))
671: {
672: tree value = 0;
673: switch (code)
674: {
675: case GE_EXPR:
676: if (extra_warnings)
677: warning ("unsigned value >= 0 is always 1");
678: value = integer_one_node;
679: break;
680:
681: case LT_EXPR:
682: if (extra_warnings)
683: warning ("unsigned value < 0 is always 0");
684: value = integer_zero_node;
685: }
686:
687: if (value != 0)
688: {
689: /* Don't forget to evaluate PRIMOP0 if it has side effects. */
690: if (TREE_SIDE_EFFECTS (primop0))
691: return build (COMPOUND_EXPR, TREE_TYPE (value),
692: primop0, value);
693: return value;
694: }
695: }
696: }
697:
698: *op0_ptr = convert (type, primop0);
699: *op1_ptr = convert (type, primop1);
700:
701: *restype_ptr = integer_type_node;
702:
703: return 0;
704: }
705:
706: /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
707: or validate its data type for an `if' or `while' statement or ?..: exp.
708:
709: This preparation consists of taking the ordinary
710: representation of an expression expr and producing a valid tree
711: boolean expression describing whether expr is nonzero. We could
712: simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
713: but we optimize comparisons, &&, ||, and !.
714:
715: The resulting type should always be `integer_type_node'. */
716:
717: tree
718: truthvalue_conversion (expr)
719: tree expr;
720: {
721: register enum tree_code code;
722:
723: switch (TREE_CODE (expr))
724: {
725: /* It is simpler and generates better code to have only TRUTH_*_EXPR
726: or comparison expressions as truth values at this level. */
727: #if 0
728: case COMPONENT_REF:
729: /* A one-bit unsigned bit-field is already acceptable. */
730: if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1)))
731: && TREE_UNSIGNED (TREE_OPERAND (expr, 1)))
732: return expr;
733: break;
734: #endif
735:
736: case EQ_EXPR:
737: /* It is simpler and generates better code to have only TRUTH_*_EXPR
738: or comparison expressions as truth values at this level. */
739: #if 0
740: if (integer_zerop (TREE_OPERAND (expr, 1)))
741: return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0);
742: #endif
743: case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
744: case TRUTH_ANDIF_EXPR:
745: case TRUTH_ORIF_EXPR:
746: case TRUTH_AND_EXPR:
747: case TRUTH_OR_EXPR:
748: case ERROR_MARK:
749: return expr;
750:
751: case INTEGER_CST:
752: return integer_zerop (expr) ? integer_zero_node : integer_one_node;
753:
754: case REAL_CST:
755: return real_zerop (expr) ? integer_zero_node : integer_one_node;
756:
757: case ADDR_EXPR:
758: if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
759: return build (COMPOUND_EXPR, integer_type_node,
760: TREE_OPERAND (expr, 0), integer_one_node);
761: else
762: return integer_one_node;
763:
764: case NEGATE_EXPR:
765: case ABS_EXPR:
766: case FLOAT_EXPR:
767: case FFS_EXPR:
768: /* These don't change whether an object is non-zero or zero. */
769: return truthvalue_conversion (TREE_OPERAND (expr, 0));
770:
771: case LROTATE_EXPR:
772: case RROTATE_EXPR:
773: /* These don't change whether an object is zero or non-zero, but
774: we can't ignore them if their second arg has side-effects. */
775: if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
776: return build (COMPOUND_EXPR, integer_type_node, TREE_OPERAND (expr, 1),
777: truthvalue_conversion (TREE_OPERAND (expr, 0)));
778: else
779: return truthvalue_conversion (TREE_OPERAND (expr, 0));
780:
781: case COND_EXPR:
782: /* Distribute the conversion into the arms of a COND_EXPR. */
783: return fold (build (COND_EXPR, integer_type_node, TREE_OPERAND (expr, 0),
784: truthvalue_conversion (TREE_OPERAND (expr, 1)),
785: truthvalue_conversion (TREE_OPERAND (expr, 2))));
786:
787: case CONVERT_EXPR:
788: /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
789: since that affects how `default_conversion' will behave. */
790: if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
791: || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
792: break;
793: /* fall through... */
794: case NOP_EXPR:
795: /* If this is widening the argument, we can ignore it. */
796: if (TYPE_PRECISION (TREE_TYPE (expr))
797: >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
798: return truthvalue_conversion (TREE_OPERAND (expr, 0));
799: break;
800:
801: case BIT_XOR_EXPR:
802: case MINUS_EXPR:
803: /* These can be changed into a comparison of the two objects. */
804: if (TREE_TYPE (TREE_OPERAND (expr, 0))
805: == TREE_TYPE (TREE_OPERAND (expr, 1)))
806: return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
807: TREE_OPERAND (expr, 1), 1);
808: return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
809: fold (build1 (NOP_EXPR,
810: TREE_TYPE (TREE_OPERAND (expr, 0)),
811: TREE_OPERAND (expr, 1))), 1);
812: }
813:
814: return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
815: }
816:
817: /* Read the rest of a #-directive from input stream FINPUT.
818: In normal use, the directive name and the white space after it
819: have already been read, so they won't be included in the result.
820: We allow for the fact that the directive line may contain
821: a newline embedded within a character or string literal which forms
822: a part of the directive.
823:
824: The value is a string in a reusable buffer. It remains valid
825: only until the next time this function is called. */
826:
827: char *
828: get_directive_line (finput)
829: register FILE *finput;
830: {
831: static char *directive_buffer = NULL;
832: static unsigned buffer_length = 0;
833: register char *p;
834: register char *buffer_limit;
835: register int looking_for = 0;
836: register int char_escaped = 0;
837:
838: if (buffer_length == 0)
839: {
840: directive_buffer = (char *)xmalloc (128);
841: buffer_length = 128;
842: }
843:
844: buffer_limit = &directive_buffer[buffer_length];
845:
846: for (p = directive_buffer; ; )
847: {
848: int c;
849:
850: /* Make buffer bigger if it is full. */
851: if (p >= buffer_limit)
852: {
853: register unsigned bytes_used = (p - directive_buffer);
854:
855: buffer_length *= 2;
856: directive_buffer
857: = (char *)xrealloc (directive_buffer, buffer_length);
858: p = &directive_buffer[bytes_used];
859: buffer_limit = &directive_buffer[buffer_length];
860: }
861:
862: c = getc (finput);
863:
864: /* Discard initial whitespace. */
865: if ((c == ' ' || c == '\t') && p == directive_buffer)
866: continue;
867:
868: /* Detect the end of the directive. */
869: if (c == '\n' && looking_for == 0)
870: {
871: ungetc (c, finput);
872: c = '\0';
873: }
874:
875: *p++ = c;
876:
877: if (c == 0)
878: return directive_buffer;
879:
880: /* Handle string and character constant syntax. */
881: if (looking_for)
882: {
883: if (looking_for == c && !char_escaped)
884: looking_for = 0; /* Found terminator... stop looking. */
885: }
886: else
887: if (c == '\'' || c == '"')
888: looking_for = c; /* Don't stop buffering until we see another
889: another one of these (or an EOF). */
890:
891: /* Handle backslash. */
892: char_escaped = (c == '\\' && ! char_escaped);
893: }
894: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.