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