1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992 Free Software Foundation, Inc.
4 This file is part of GNU CC.
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)
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.
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. */
28 extern struct obstack permanent_obstack;
30 /* Make bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
33 declare_function_name ()
35 tree decl, type, init;
36 char *name, *printable_name;
39 if (current_function_decl == NULL)
42 printable_name = "top level";
46 char *kind = "function";
47 if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
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));
54 printable_name = (*decl_printable_name) (current_function_decl, &kind);
57 /* If the default size of char arrays isn't big enough for the name,
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)))
63 type = build_array_type (char_type_node,
64 build_index_type (build_int_2 (len, 0)));
66 push_obstacks_nochange ();
67 decl = build_decl (VAR_DECL, get_identifier ("__FUNCTION__"), type);
68 TREE_STATIC (decl) = 1;
69 TREE_READONLY (decl) = 1;
70 DECL_SOURCE_LINE (decl) = 0;
71 DECL_IN_SYSTEM_HEADER (decl) = 1;
72 DECL_IGNORED_P (decl) = 1;
73 init = build_string (len, name);
74 TREE_TYPE (init) = type;
75 DECL_INITIAL (decl) = init;
76 finish_decl (pushdecl (decl), init, NULL_TREE);
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)))
82 type = build_array_type (char_type_node,
83 build_index_type (build_int_2 (len, 0)));
85 push_obstacks_nochange ();
86 decl = build_decl (VAR_DECL, get_identifier ("__PRETTY_FUNCTION__"), type);
87 TREE_STATIC (decl) = 1;
88 TREE_READONLY (decl) = 1;
89 DECL_SOURCE_LINE (decl) = 0;
90 DECL_IN_SYSTEM_HEADER (decl) = 1;
91 DECL_IGNORED_P (decl) = 1;
92 init = build_string (len, printable_name);
93 TREE_TYPE (init) = type;
94 DECL_INITIAL (decl) = init;
95 finish_decl (pushdecl (decl), init, NULL_TREE);
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. */
103 combine_strings (strings)
106 register tree value, t;
107 register int length = 1;
110 int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
113 if (TREE_CHAIN (strings))
115 /* More than one in the chain, so concatenate. */
116 register char *p, *q;
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))
123 if (TREE_TYPE (t) == wchar_array_type_node)
125 wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
129 length += (TREE_STRING_LENGTH (t) - 1);
132 /* If anything is wide, the non-wides will be converted,
133 which makes them take more space. */
135 length = length * wchar_bytes + wide_length;
137 p = savealloc (length);
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. */
144 for (t = strings; t; t = TREE_CHAIN (t))
146 int len = (TREE_STRING_LENGTH (t)
147 - ((TREE_TYPE (t) == wchar_array_type_node)
149 if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
151 bcopy (TREE_STRING_POINTER (t), q, len);
157 for (i = 0; i < len; i++)
158 ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
159 q += len * wchar_bytes;
165 for (i = 0; i < wchar_bytes; i++)
171 value = make_node (STRING_CST);
172 TREE_STRING_POINTER (value) = p;
173 TREE_STRING_LENGTH (value) = length;
174 TREE_CONSTANT (value) = 1;
179 length = TREE_STRING_LENGTH (value);
180 if (TREE_TYPE (value) == wchar_array_type_node)
184 /* Compute the number of elements, for the array type. */
185 nchars = wide_flag ? length / wchar_bytes : length;
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))
194 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
197 = build_array_type (elements,
198 build_index_type (build_int_2 (nchars - 1, 0)));
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;
209 /* Process the attributes listed in ATTRIBUTES
210 and install them in DECL. */
213 decl_attributes (decl, attributes)
214 tree decl, attributes;
217 for (a = attributes; a; a = TREE_CHAIN (a))
218 if (TREE_VALUE (a) == get_identifier ("packed"))
220 if (TREE_CODE (decl) == FIELD_DECL)
221 DECL_PACKED (decl) = 1;
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. */
225 else if (TREE_VALUE (a) != 0
226 && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
227 && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("mode"))
231 = IDENTIFIER_POINTER (TREE_VALUE (TREE_VALUE (a)));
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)))
238 = type_for_mode (i, TREE_UNSIGNED (TREE_TYPE (decl)));
241 TREE_TYPE (decl) = type;
242 DECL_SIZE (decl) = 0;
243 layout_decl (decl, 0);
246 error ("no data type for mode `%s'", specified_name);
249 if (i == NUM_MACHINE_MODES)
250 error ("unknown machine mode `%s'", specified_name);
252 else if (TREE_VALUE (a) != 0
253 && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
254 && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("aligned"))
256 int align = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (a)))
259 if (exact_log2 (align) == -1)
260 error_with_decl (decl,
261 "requested alignment of `%s' is not a power of 2");
262 else if (TREE_CODE (decl) != VAR_DECL
263 && TREE_CODE (decl) != FIELD_DECL)
264 error_with_decl (decl,
265 "alignment specified for `%s'");
267 DECL_ALIGN (decl) = align;
269 else if (TREE_VALUE (a) != 0
270 && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
271 && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("format"))
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)));
281 if (TREE_CODE (decl) != FUNCTION_DECL)
283 error_with_decl (decl,
284 "argument format specified for non-function `%s'");
288 if (format_type == get_identifier ("printf"))
290 else if (format_type == get_identifier ("scanf"))
294 error_with_decl (decl, "unrecognized format specifier for `%s'");
298 if (first_arg_num != 0 && first_arg_num <= format_num)
300 error_with_decl (decl,
301 "format string arg follows the args to be formatted, for `%s'");
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)
310 if (argument == 0 || arg_num == format_num)
312 argument = TREE_CHAIN (argument);
315 || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
316 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
319 error_with_decl (decl,
320 "format string arg not a string type, for `%s'");
323 /* Verify that first_arg_num points to the last argument, the ... */
325 arg_num++, argument = TREE_CHAIN (argument);
326 if (arg_num != first_arg_num)
328 error_with_decl (decl,
329 "args to be formatted is not ..., for `%s'");
333 record_format_info (DECL_NAME (decl), is_scan, format_num,
338 /* Print a warning if a constant expression had overflow in folding.
339 Invoke this function on every expression that the language
340 requires to be a constant expression.
341 Note the ANSI C standard says it is erroneous for a
342 constant expression to overflow. */
345 constant_expression_warning (value)
348 if (TREE_CODE (value) == INTEGER_CST && TREE_CONSTANT_OVERFLOW (value))
350 /* ??? This is a warning, not a pedwarn, in 2.4,
351 because it happens in contexts that are not
352 "constant expressions" in ANSI C.
353 Fix the problem differently in 2.5. */
354 warning ("overflow in constant expression");
355 /* Suppress duplicate warnings. */
356 TREE_CONSTANT_OVERFLOW (value) = 0;
360 /* Print a warning if an expression had overflow in folding.
361 Invoke this function on every expression that
362 (1) appears in the source code, and
363 (2) might be a constant expression that overflowed, and
364 (3) is not already checked by convert_and_check;
365 however, do not invoke this function on operands of explicit casts. */
368 overflow_warning (value)
371 if (TREE_CODE (value) == INTEGER_CST && TREE_CONSTANT_OVERFLOW (value))
373 /* ??? This is a warning, not a pedwarn, in 2.4,
374 because it happens in contexts that are not
375 "constant expressions" in ANSI C.
376 Fix the problem differently in 2.5. */
377 warning ("integer overflow in expression");
378 TREE_CONSTANT_OVERFLOW (value) = 0;
382 /* Print a warning if a large constant is truncated to unsigned,
383 or if -Wconversion is used and a constant < 0 is converted to unsigned.
384 Invoke this function on every expression that might be implicitly
385 converted to an unsigned type. */
388 unsigned_conversion_warning (result, operand)
389 tree result, operand;
391 if (TREE_CODE (operand) == INTEGER_CST
392 && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
393 && TREE_UNSIGNED (TREE_TYPE (result))
394 && !int_fits_type_p (operand, TREE_TYPE (result)))
396 if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
397 /* This detects cases like converting -129 or 256 to unsigned char. */
398 pedwarn ("large integer implicitly truncated to unsigned type");
399 else if (warn_conversion)
400 pedwarn ("negative integer implicitly converted to unsigned type");
404 /* Convert EXPR to TYPE, warning about conversion problems with constants.
405 Invoke this function on every expression that is converted implicitly,
406 i.e. because of language rules and not because of an explicit cast. */
409 convert_and_check (type, expr)
412 tree t = convert (type, expr);
413 if (TREE_CODE (t) == INTEGER_CST)
415 if (TREE_UNSIGNED (TREE_TYPE (expr))
416 && !TREE_UNSIGNED (type)
417 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
418 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr)))
419 /* No warning for converting 0x80000000 to int. */
420 TREE_CONSTANT_OVERFLOW (t) = 0;
421 else if (TREE_CONSTANT_OVERFLOW (t))
423 /* ??? This is a warning, not a pedwarn, in 2.4,
424 because it happens in contexts that are not
425 "constant expressions" in ANSI C.
426 Fix the problem differently in 2.5. */
427 warning ("overflow in implicit constant conversion");
428 TREE_CONSTANT_OVERFLOW (t) = 0;
431 unsigned_conversion_warning (t, expr);
437 c_expand_expr_stmt (expr)
440 /* Do default conversion if safe and possibly important,
441 in case within ({...}). */
442 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
443 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
444 expr = default_conversion (expr);
446 if (TREE_TYPE (expr) != error_mark_node
447 && TYPE_SIZE (TREE_TYPE (expr)) == 0
448 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
449 error ("expression statement has incomplete type");
451 expand_expr_stmt (expr);
454 /* Validate the expression after `case' and apply default promotions. */
457 check_case_value (value)
460 if (value == NULL_TREE)
463 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
464 STRIP_TYPE_NOPS (value);
466 if (TREE_CODE (value) != INTEGER_CST
467 && value != error_mark_node)
469 error ("case label does not reduce to an integer constant");
470 value = error_mark_node;
473 /* Promote char or short to int. */
474 value = default_conversion (value);
476 constant_expression_warning (value);
481 /* Return an integer type with BITS bits of precision,
482 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
485 type_for_size (bits, unsignedp)
489 if (bits == TYPE_PRECISION (signed_char_type_node))
490 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
492 if (bits == TYPE_PRECISION (short_integer_type_node))
493 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
495 if (bits == TYPE_PRECISION (integer_type_node))
496 return unsignedp ? unsigned_type_node : integer_type_node;
498 if (bits == TYPE_PRECISION (long_integer_type_node))
499 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
501 if (bits == TYPE_PRECISION (long_long_integer_type_node))
502 return (unsignedp ? long_long_unsigned_type_node
503 : long_long_integer_type_node);
505 if (bits <= TYPE_PRECISION (intQI_type_node))
506 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
508 if (bits <= TYPE_PRECISION (intHI_type_node))
509 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
511 if (bits <= TYPE_PRECISION (intSI_type_node))
512 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
514 if (bits <= TYPE_PRECISION (intDI_type_node))
515 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
520 /* Return a data type that has machine mode MODE.
521 If the mode is an integer,
522 then UNSIGNEDP selects between signed and unsigned types. */
525 type_for_mode (mode, unsignedp)
526 enum machine_mode mode;
529 if (mode == TYPE_MODE (signed_char_type_node))
530 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
532 if (mode == TYPE_MODE (short_integer_type_node))
533 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
535 if (mode == TYPE_MODE (integer_type_node))
536 return unsignedp ? unsigned_type_node : integer_type_node;
538 if (mode == TYPE_MODE (long_integer_type_node))
539 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
541 if (mode == TYPE_MODE (long_long_integer_type_node))
542 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
544 if (mode == TYPE_MODE (intQI_type_node))
545 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
547 if (mode == TYPE_MODE (intHI_type_node))
548 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
550 if (mode == TYPE_MODE (intSI_type_node))
551 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
553 if (mode == TYPE_MODE (intDI_type_node))
554 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
556 if (mode == TYPE_MODE (float_type_node))
557 return float_type_node;
559 if (mode == TYPE_MODE (double_type_node))
560 return double_type_node;
562 if (mode == TYPE_MODE (long_double_type_node))
563 return long_double_type_node;
565 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
566 return build_pointer_type (char_type_node);
568 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
569 return build_pointer_type (integer_type_node);
574 /* Print an error message for invalid operands to arith operation CODE.
575 NOP_EXPR is used as a special case (see truthvalue_conversion). */
578 binary_op_error (code)
581 register char *opname;
585 error ("invalid truth-value expression");
595 opname = "max"; break;
597 opname = "min"; break;
599 opname = "=="; break;
601 opname = "!="; break;
603 opname = "<="; break;
605 opname = ">="; break;
611 opname = "<<"; break;
613 opname = ">>"; break;
624 case TRUTH_ANDIF_EXPR:
625 opname = "&&"; break;
626 case TRUTH_ORIF_EXPR:
627 opname = "||"; break;
632 opname = "rotate"; break;
634 error ("invalid operands to binary %s", opname);
637 /* Subroutine of build_binary_op, used for comparison operations.
638 See if the operands have both been converted from subword integer types
639 and, if so, perhaps change them both back to their original type.
641 The arguments of this function are all pointers to local variables
642 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
643 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
645 If this function returns nonzero, it means that the comparison has
646 a constant value. What this function returns is an expression for
650 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
651 tree *op0_ptr, *op1_ptr;
653 enum tree_code *rescode_ptr;
658 int unsignedp0, unsignedp1;
660 tree primop0, primop1;
661 enum tree_code code = *rescode_ptr;
663 /* Throw away any conversions to wider types
664 already present in the operands. */
666 primop0 = get_narrower (op0, &unsignedp0);
667 primop1 = get_narrower (op1, &unsignedp1);
669 /* Handle the case that OP0 does not *contain* a conversion
670 but it *requires* conversion to FINAL_TYPE. */
672 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
673 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
674 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
675 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
677 /* If one of the operands must be floated, we cannot optimize. */
678 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
679 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
681 /* If first arg is constant, swap the args (changing operation
682 so value is preserved), for canonicalization. */
684 if (TREE_CONSTANT (primop0))
686 register tree tem = primop0;
687 register int temi = unsignedp0;
695 unsignedp0 = unsignedp1;
719 /* If comparing an integer against a constant more bits wide,
720 maybe we can deduce a value of 1 or 0 independent of the data.
721 Or else truncate the constant now
722 rather than extend the variable at run time.
724 This is only interesting if the constant is the wider arg.
725 Also, it is not safe if the constant is unsigned and the
726 variable arg is signed, since in this case the variable
727 would be sign-extended and then regarded as unsigned.
728 Our technique fails in this case because the lowest/highest
729 possible unsigned results don't follow naturally from the
730 lowest/highest possible values of the variable operand.
731 For just EQ_EXPR and NE_EXPR there is another technique that
732 could be used: see if the constant can be faithfully represented
733 in the other operand's type, by truncating it and reextending it
734 and see if that preserves the constant's value. */
737 && TREE_CODE (primop1) == INTEGER_CST
738 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
740 int min_gt, max_gt, min_lt, max_lt;
742 /* 1 if comparison is nominally unsigned. */
743 int unsignedp = TREE_UNSIGNED (*restype_ptr);
746 type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
748 maxval = TYPE_MAX_VALUE (type);
749 minval = TYPE_MIN_VALUE (type);
751 if (unsignedp && !unsignedp0)
752 *restype_ptr = signed_type (*restype_ptr);
754 if (TREE_TYPE (primop1) != *restype_ptr)
755 primop1 = convert (*restype_ptr, primop1);
756 if (type != *restype_ptr)
758 minval = convert (*restype_ptr, minval);
759 maxval = convert (*restype_ptr, maxval);
762 if (unsignedp && unsignedp0)
764 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
765 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
766 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
767 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
771 min_gt = INT_CST_LT (primop1, minval);
772 max_gt = INT_CST_LT (primop1, maxval);
773 min_lt = INT_CST_LT (minval, primop1);
774 max_lt = INT_CST_LT (maxval, primop1);
778 /* This used to be a switch, but Genix compiler can't handle that. */
781 if (max_lt || min_gt)
782 val = integer_one_node;
784 else if (code == EQ_EXPR)
786 if (max_lt || min_gt)
787 val = integer_zero_node;
789 else if (code == LT_EXPR)
792 val = integer_one_node;
794 val = integer_zero_node;
796 else if (code == GT_EXPR)
799 val = integer_one_node;
801 val = integer_zero_node;
803 else if (code == LE_EXPR)
806 val = integer_one_node;
808 val = integer_zero_node;
810 else if (code == GE_EXPR)
813 val = integer_one_node;
815 val = integer_zero_node;
818 /* If primop0 was sign-extended and unsigned comparison specd,
819 we did a signed comparison above using the signed type bounds.
820 But the comparison we output must be unsigned.
822 Also, for inequalities, VAL is no good; but if the signed
823 comparison had *any* fixed result, it follows that the
824 unsigned comparison just tests the sign in reverse
825 (positive values are LE, negative ones GE).
826 So we can generate an unsigned comparison
827 against an extreme value of the signed type. */
829 if (unsignedp && !unsignedp0)
836 primop1 = TYPE_MIN_VALUE (type);
842 primop1 = TYPE_MAX_VALUE (type);
846 type = unsigned_type (type);
849 if (!max_gt && !unsignedp0)
851 /* This is the case of (char)x >?< 0x80, which people used to use
852 expecting old C compilers to change the 0x80 into -0x80. */
853 if (val == integer_zero_node)
854 warning ("comparison is always 0 due to limited range of data type");
855 if (val == integer_one_node)
856 warning ("comparison is always 1 due to limited range of data type");
859 if (!min_lt && unsignedp0)
861 /* This is the case of (unsigned char)x >?< -1 or < 0. */
862 if (val == integer_zero_node)
863 warning ("comparison is always 0 due to limited range of data type");
864 if (val == integer_one_node)
865 warning ("comparison is always 1 due to limited range of data type");
870 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
871 if (TREE_SIDE_EFFECTS (primop0))
872 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
876 /* Value is not predetermined, but do the comparison
877 in the type of the operand that is not constant.
878 TYPE is already properly set. */
880 else if (real1 && real2
881 && (TYPE_PRECISION (TREE_TYPE (primop0))
882 == TYPE_PRECISION (TREE_TYPE (primop1))))
883 type = TREE_TYPE (primop0);
885 /* If args' natural types are both narrower than nominal type
886 and both extend in the same manner, compare them
887 in the type of the wider arg.
888 Otherwise must actually extend both to the nominal
889 common type lest different ways of extending
891 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
893 else if (unsignedp0 == unsignedp1 && real1 == real2
894 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
895 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
897 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
898 type = signed_or_unsigned_type (unsignedp0
899 || TREE_UNSIGNED (*restype_ptr),
901 /* Make sure shorter operand is extended the right way
902 to match the longer operand. */
903 primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
905 primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
910 /* Here we must do the comparison on the nominal type
911 using the args exactly as we received them. */
916 if (!real1 && !real2 && integer_zerop (primop1)
917 && TREE_UNSIGNED (TREE_TYPE (primop0)))
924 warning ("unsigned value >= 0 is always 1");
925 value = integer_one_node;
930 warning ("unsigned value < 0 is always 0");
931 value = integer_zero_node;
936 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
937 if (TREE_SIDE_EFFECTS (primop0))
938 return build (COMPOUND_EXPR, TREE_TYPE (value),
945 *op0_ptr = convert (type, primop0);
946 *op1_ptr = convert (type, primop1);
948 *restype_ptr = integer_type_node;
953 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
954 or validate its data type for an `if' or `while' statement or ?..: exp.
956 This preparation consists of taking the ordinary
957 representation of an expression expr and producing a valid tree
958 boolean expression describing whether expr is nonzero. We could
959 simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
960 but we optimize comparisons, &&, ||, and !.
962 The resulting type should always be `integer_type_node'. */
965 truthvalue_conversion (expr)
968 register enum tree_code code;
970 if (TREE_CODE (expr) == ERROR_MARK)
973 #if 0 /* This appears to be wrong for C++. */
974 /* These really should return error_mark_node after 2.4 is stable.
975 But not all callers handle ERROR_MARK properly. */
976 switch (TREE_CODE (TREE_TYPE (expr)))
979 error ("struct type value used where scalar is required");
980 return integer_zero_node;
983 error ("union type value used where scalar is required");
984 return integer_zero_node;
987 error ("array type value used where scalar is required");
988 return integer_zero_node;
995 switch (TREE_CODE (expr))
997 /* It is simpler and generates better code to have only TRUTH_*_EXPR
998 or comparison expressions as truth values at this level. */
1001 /* A one-bit unsigned bit-field is already acceptable. */
1002 if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1)))
1003 && TREE_UNSIGNED (TREE_OPERAND (expr, 1)))
1009 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1010 or comparison expressions as truth values at this level. */
1012 if (integer_zerop (TREE_OPERAND (expr, 1)))
1013 return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0);
1015 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
1016 case TRUTH_ANDIF_EXPR:
1017 case TRUTH_ORIF_EXPR:
1018 case TRUTH_AND_EXPR:
1020 case TRUTH_XOR_EXPR:
1025 return integer_zerop (expr) ? integer_zero_node : integer_one_node;
1028 return real_zerop (expr) ? integer_zero_node : integer_one_node;
1031 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
1032 return build (COMPOUND_EXPR, integer_type_node,
1033 TREE_OPERAND (expr, 0), integer_one_node);
1035 return integer_one_node;
1038 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
1039 ? TRUTH_AND_EXPR : TRUTH_ANDIF_EXPR),
1040 truthvalue_conversion (TREE_OPERAND (expr, 0)),
1041 truthvalue_conversion (TREE_OPERAND (expr, 1)),
1048 /* These don't change whether an object is non-zero or zero. */
1049 return truthvalue_conversion (TREE_OPERAND (expr, 0));
1053 /* These don't change whether an object is zero or non-zero, but
1054 we can't ignore them if their second arg has side-effects. */
1055 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
1056 return build (COMPOUND_EXPR, integer_type_node, TREE_OPERAND (expr, 1),
1057 truthvalue_conversion (TREE_OPERAND (expr, 0)));
1059 return truthvalue_conversion (TREE_OPERAND (expr, 0));
1062 /* Distribute the conversion into the arms of a COND_EXPR. */
1063 return fold (build (COND_EXPR, integer_type_node, TREE_OPERAND (expr, 0),
1064 truthvalue_conversion (TREE_OPERAND (expr, 1)),
1065 truthvalue_conversion (TREE_OPERAND (expr, 2))));
1068 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
1069 since that affects how `default_conversion' will behave. */
1070 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
1071 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
1073 /* fall through... */
1075 /* If this is widening the argument, we can ignore it. */
1076 if (TYPE_PRECISION (TREE_TYPE (expr))
1077 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
1078 return truthvalue_conversion (TREE_OPERAND (expr, 0));
1082 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
1084 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
1085 && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
1087 /* fall through... */
1089 /* This and MINUS_EXPR can be changed into a comparison of the
1091 if (TREE_TYPE (TREE_OPERAND (expr, 0))
1092 == TREE_TYPE (TREE_OPERAND (expr, 1)))
1093 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
1094 TREE_OPERAND (expr, 1), 1);
1095 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
1096 fold (build1 (NOP_EXPR,
1097 TREE_TYPE (TREE_OPERAND (expr, 0)),
1098 TREE_OPERAND (expr, 1))), 1);
1101 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
1102 warning ("suggest parentheses around assignment used as truth value");
1106 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
1107 return (build_binary_op
1108 ((TREE_SIDE_EFFECTS (expr)
1109 ? TRUTH_AND_EXPR : TRUTH_ANDIF_EXPR),
1110 truthvalue_conversion (build_unary_op (REALPART_EXPR, expr, 0)),
1111 truthvalue_conversion (build_unary_op (IMAGPART_EXPR, expr, 0)),
1114 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
1117 /* Read the rest of a #-directive from input stream FINPUT.
1118 In normal use, the directive name and the white space after it
1119 have already been read, so they won't be included in the result.
1120 We allow for the fact that the directive line may contain
1121 a newline embedded within a character or string literal which forms
1122 a part of the directive.
1124 The value is a string in a reusable buffer. It remains valid
1125 only until the next time this function is called. */
1128 get_directive_line (finput)
1129 register FILE *finput;
1131 static char *directive_buffer = NULL;
1132 static unsigned buffer_length = 0;
1134 register char *buffer_limit;
1135 register int looking_for = 0;
1136 register int char_escaped = 0;
1138 if (buffer_length == 0)
1140 directive_buffer = (char *)xmalloc (128);
1141 buffer_length = 128;
1144 buffer_limit = &directive_buffer[buffer_length];
1146 for (p = directive_buffer; ; )
1150 /* Make buffer bigger if it is full. */
1151 if (p >= buffer_limit)
1153 register unsigned bytes_used = (p - directive_buffer);
1157 = (char *)xrealloc (directive_buffer, buffer_length);
1158 p = &directive_buffer[bytes_used];
1159 buffer_limit = &directive_buffer[buffer_length];
1164 /* Discard initial whitespace. */
1165 if ((c == ' ' || c == '\t') && p == directive_buffer)
1168 /* Detect the end of the directive. */
1169 if (c == '\n' && looking_for == 0)
1178 return directive_buffer;
1180 /* Handle string and character constant syntax. */
1183 if (looking_for == c && !char_escaped)
1184 looking_for = 0; /* Found terminator... stop looking. */
1187 if (c == '\'' || c == '"')
1188 looking_for = c; /* Don't stop buffering until we see another
1189 another one of these (or an EOF). */
1191 /* Handle backslash. */
1192 char_escaped = (c == '\\' && ! char_escaped);
1196 /* Make a variant type in the proper way for C/C++, propagating qualifiers
1197 down to the element type of an array. */
1200 c_build_type_variant (type, constp, volatilep)
1202 int constp, volatilep;
1204 if (TREE_CODE (type) == ARRAY_TYPE)
1206 tree real_main_variant = TYPE_MAIN_VARIANT (type);
1207 int permanent = TREE_PERMANENT (type);
1210 push_obstacks (&permanent_obstack, &permanent_obstack);
1211 type = build_array_type (c_build_type_variant (TREE_TYPE (type),
1213 TYPE_DOMAIN (type));
1214 TYPE_MAIN_VARIANT (type) = real_main_variant;
1218 return build_type_variant (type, constp, volatilep);