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