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 if (first_arg_num
!= 0)
325 /* Verify that first_arg_num points to the last arg, the ... */
327 arg_num
++, argument
= TREE_CHAIN (argument
);
328 if (arg_num
!= first_arg_num
)
330 error_with_decl (decl
,
331 "args to be formatted is not ..., for `%s'");
336 record_format_info (DECL_NAME (decl
), is_scan
, format_num
,
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. */
348 constant_expression_warning (value
)
351 if (TREE_CODE (value
) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (value
))
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;
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. */
371 overflow_warning (value
)
374 if (TREE_CODE (value
) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (value
))
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;
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. */
391 unsigned_conversion_warning (result
, operand
)
392 tree result
, operand
;
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
)))
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");
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. */
412 convert_and_check (type
, expr
)
415 tree t
= convert (type
, expr
);
416 if (TREE_CODE (t
) == INTEGER_CST
)
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
))
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;
434 unsigned_conversion_warning (t
, expr
);
440 c_expand_expr_stmt (expr
)
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
);
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");
454 expand_expr_stmt (expr
);
457 /* Validate the expression after `case' and apply default promotions. */
460 check_case_value (value
)
463 if (value
== NULL_TREE
)
466 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
467 STRIP_TYPE_NOPS (value
);
469 if (TREE_CODE (value
) != INTEGER_CST
470 && value
!= error_mark_node
)
472 error ("case label does not reduce to an integer constant");
473 value
= error_mark_node
;
476 /* Promote char or short to int. */
477 value
= default_conversion (value
);
479 constant_expression_warning (value
);
484 /* Return an integer type with BITS bits of precision,
485 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
488 type_for_size (bits
, unsignedp
)
492 if (bits
== TYPE_PRECISION (signed_char_type_node
))
493 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
495 if (bits
== TYPE_PRECISION (short_integer_type_node
))
496 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
498 if (bits
== TYPE_PRECISION (integer_type_node
))
499 return unsignedp
? unsigned_type_node
: integer_type_node
;
501 if (bits
== TYPE_PRECISION (long_integer_type_node
))
502 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
504 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
505 return (unsignedp
? long_long_unsigned_type_node
506 : long_long_integer_type_node
);
508 if (bits
<= TYPE_PRECISION (intQI_type_node
))
509 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
511 if (bits
<= TYPE_PRECISION (intHI_type_node
))
512 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
514 if (bits
<= TYPE_PRECISION (intSI_type_node
))
515 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
517 if (bits
<= TYPE_PRECISION (intDI_type_node
))
518 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
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. */
528 type_for_mode (mode
, unsignedp
)
529 enum machine_mode mode
;
532 if (mode
== TYPE_MODE (signed_char_type_node
))
533 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
535 if (mode
== TYPE_MODE (short_integer_type_node
))
536 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
538 if (mode
== TYPE_MODE (integer_type_node
))
539 return unsignedp
? unsigned_type_node
: integer_type_node
;
541 if (mode
== TYPE_MODE (long_integer_type_node
))
542 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
544 if (mode
== TYPE_MODE (long_long_integer_type_node
))
545 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
547 if (mode
== TYPE_MODE (intQI_type_node
))
548 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
550 if (mode
== TYPE_MODE (intHI_type_node
))
551 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
553 if (mode
== TYPE_MODE (intSI_type_node
))
554 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
556 if (mode
== TYPE_MODE (intDI_type_node
))
557 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
559 if (mode
== TYPE_MODE (float_type_node
))
560 return float_type_node
;
562 if (mode
== TYPE_MODE (double_type_node
))
563 return double_type_node
;
565 if (mode
== TYPE_MODE (long_double_type_node
))
566 return long_double_type_node
;
568 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
569 return build_pointer_type (char_type_node
);
571 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
572 return build_pointer_type (integer_type_node
);
577 /* Print an error message for invalid operands to arith operation CODE.
578 NOP_EXPR is used as a special case (see truthvalue_conversion). */
581 binary_op_error (code
)
584 register char *opname
;
588 error ("invalid truth-value expression");
598 opname
= "max"; break;
600 opname
= "min"; break;
602 opname
= "=="; break;
604 opname
= "!="; break;
606 opname
= "<="; break;
608 opname
= ">="; break;
614 opname
= "<<"; break;
616 opname
= ">>"; break;
627 case TRUTH_ANDIF_EXPR
:
628 opname
= "&&"; break;
629 case TRUTH_ORIF_EXPR
:
630 opname
= "||"; break;
635 opname
= "rotate"; break;
637 error ("invalid operands to binary %s", opname
);
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.
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.
648 If this function returns nonzero, it means that the comparison has
649 a constant value. What this function returns is an expression for
653 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
654 tree
*op0_ptr
, *op1_ptr
;
656 enum tree_code
*rescode_ptr
;
661 int unsignedp0
, unsignedp1
;
663 tree primop0
, primop1
;
664 enum tree_code code
= *rescode_ptr
;
666 /* Throw away any conversions to wider types
667 already present in the operands. */
669 primop0
= get_narrower (op0
, &unsignedp0
);
670 primop1
= get_narrower (op1
, &unsignedp1
);
672 /* Handle the case that OP0 does not *contain* a conversion
673 but it *requires* conversion to FINAL_TYPE. */
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
));
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
;
684 /* If first arg is constant, swap the args (changing operation
685 so value is preserved), for canonicalization. */
687 if (TREE_CONSTANT (primop0
))
689 register tree tem
= primop0
;
690 register int temi
= unsignedp0
;
698 unsignedp0
= unsignedp1
;
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.
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. */
740 && TREE_CODE (primop1
) == INTEGER_CST
741 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
743 int min_gt
, max_gt
, min_lt
, max_lt
;
745 /* 1 if comparison is nominally unsigned. */
746 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
749 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
751 maxval
= TYPE_MAX_VALUE (type
);
752 minval
= TYPE_MIN_VALUE (type
);
754 if (unsignedp
&& !unsignedp0
)
755 *restype_ptr
= signed_type (*restype_ptr
);
757 if (TREE_TYPE (primop1
) != *restype_ptr
)
758 primop1
= convert (*restype_ptr
, primop1
);
759 if (type
!= *restype_ptr
)
761 minval
= convert (*restype_ptr
, minval
);
762 maxval
= convert (*restype_ptr
, maxval
);
765 if (unsignedp
&& unsignedp0
)
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
);
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
);
781 /* This used to be a switch, but Genix compiler can't handle that. */
784 if (max_lt
|| min_gt
)
785 val
= integer_one_node
;
787 else if (code
== EQ_EXPR
)
789 if (max_lt
|| min_gt
)
790 val
= integer_zero_node
;
792 else if (code
== LT_EXPR
)
795 val
= integer_one_node
;
797 val
= integer_zero_node
;
799 else if (code
== GT_EXPR
)
802 val
= integer_one_node
;
804 val
= integer_zero_node
;
806 else if (code
== LE_EXPR
)
809 val
= integer_one_node
;
811 val
= integer_zero_node
;
813 else if (code
== GE_EXPR
)
816 val
= integer_one_node
;
818 val
= integer_zero_node
;
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.
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. */
832 if (unsignedp
&& !unsignedp0
)
839 primop1
= TYPE_MIN_VALUE (type
);
845 primop1
= TYPE_MAX_VALUE (type
);
849 type
= unsigned_type (type
);
852 if (!max_gt
&& !unsignedp0
)
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");
862 if (!min_lt
&& unsignedp0
)
864 /* This is the case of (unsigned char)x >?< -1 or < 0. */
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");
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
);
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. */
883 else if (real1
&& real2
884 && (TYPE_PRECISION (TREE_TYPE (primop0
))
885 == TYPE_PRECISION (TREE_TYPE (primop1
))))
886 type
= TREE_TYPE (primop0
);
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
894 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
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
))
900 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
901 type
= signed_or_unsigned_type (unsignedp0
902 || TREE_UNSIGNED (*restype_ptr
),
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
)),
908 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
913 /* Here we must do the comparison on the nominal type
914 using the args exactly as we received them. */
919 if (!real1
&& !real2
&& integer_zerop (primop1
)
920 && TREE_UNSIGNED (TREE_TYPE (primop0
)))
927 warning ("unsigned value >= 0 is always 1");
928 value
= integer_one_node
;
933 warning ("unsigned value < 0 is always 0");
934 value
= integer_zero_node
;
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
),
948 *op0_ptr
= convert (type
, primop0
);
949 *op1_ptr
= convert (type
, primop1
);
951 *restype_ptr
= integer_type_node
;
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.
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 !.
965 The resulting type should always be `integer_type_node'. */
968 truthvalue_conversion (expr
)
971 register enum tree_code code
;
973 if (TREE_CODE (expr
) == ERROR_MARK
)
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
)))
982 error ("struct type value used where scalar is required");
983 return integer_zero_node
;
986 error ("union type value used where scalar is required");
987 return integer_zero_node
;
990 error ("array type value used where scalar is required");
991 return integer_zero_node
;
998 switch (TREE_CODE (expr
))
1000 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1001 or comparison expressions as truth values at this level. */
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)))
1012 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1013 or comparison expressions as truth values at this level. */
1015 if (integer_zerop (TREE_OPERAND (expr
, 1)))
1016 return build_unary_op (TRUTH_NOT_EXPR
, TREE_OPERAND (expr
, 0), 0);
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
:
1023 case TRUTH_XOR_EXPR
:
1028 return integer_zerop (expr
) ? integer_zero_node
: integer_one_node
;
1031 return real_zerop (expr
) ? integer_zero_node
: integer_one_node
;
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
);
1038 return integer_one_node
;
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)),
1051 /* These don't change whether an object is non-zero or zero. */
1052 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
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)));
1062 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
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))));
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
)
1076 /* fall through... */
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));
1085 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
1087 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
1088 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
1090 /* fall through... */
1092 /* This and MINUS_EXPR can be changed into a comparison of the
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);
1104 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
1105 warning ("suggest parentheses around assignment used as truth value");
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)),
1117 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
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.
1127 The value is a string in a reusable buffer. It remains valid
1128 only until the next time this function is called. */
1131 get_directive_line (finput
)
1132 register FILE *finput
;
1134 static char *directive_buffer
= NULL
;
1135 static unsigned buffer_length
= 0;
1137 register char *buffer_limit
;
1138 register int looking_for
= 0;
1139 register int char_escaped
= 0;
1141 if (buffer_length
== 0)
1143 directive_buffer
= (char *)xmalloc (128);
1144 buffer_length
= 128;
1147 buffer_limit
= &directive_buffer
[buffer_length
];
1149 for (p
= directive_buffer
; ; )
1153 /* Make buffer bigger if it is full. */
1154 if (p
>= buffer_limit
)
1156 register unsigned bytes_used
= (p
- directive_buffer
);
1160 = (char *)xrealloc (directive_buffer
, buffer_length
);
1161 p
= &directive_buffer
[bytes_used
];
1162 buffer_limit
= &directive_buffer
[buffer_length
];
1167 /* Discard initial whitespace. */
1168 if ((c
== ' ' || c
== '\t') && p
== directive_buffer
)
1171 /* Detect the end of the directive. */
1172 if (c
== '\n' && looking_for
== 0)
1181 return directive_buffer
;
1183 /* Handle string and character constant syntax. */
1186 if (looking_for
== c
&& !char_escaped
)
1187 looking_for
= 0; /* Found terminator... stop looking. */
1190 if (c
== '\'' || c
== '"')
1191 looking_for
= c
; /* Don't stop buffering until we see another
1192 another one of these (or an EOF). */
1194 /* Handle backslash. */
1195 char_escaped
= (c
== '\\' && ! char_escaped
);
1199 /* Make a variant type in the proper way for C/C++, propagating qualifiers
1200 down to the element type of an array. */
1203 c_build_type_variant (type
, constp
, volatilep
)
1205 int constp
, volatilep
;
1207 if (TREE_CODE (type
) == ARRAY_TYPE
)
1209 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
1210 int permanent
= TREE_PERMANENT (type
);
1213 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1214 type
= build_array_type (c_build_type_variant (TREE_TYPE (type
),
1216 TYPE_DOMAIN (type
));
1217 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
1221 return build_type_variant (type
, constp
, volatilep
);