1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993 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. */
29 extern struct obstack permanent_obstack
;
31 static void declare_hidden_char_array
PROTO((char *, char *));
33 /* Make bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
36 declare_function_name ()
38 char *name
, *printable_name
;
40 if (current_function_decl
== NULL
)
43 printable_name
= "top level";
47 char *kind
= "function";
48 if (TREE_CODE (TREE_TYPE (current_function_decl
)) == METHOD_TYPE
)
50 /* Allow functions to be nameless (such as artificial ones). */
51 if (DECL_NAME (current_function_decl
))
52 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
55 printable_name
= (*decl_printable_name
) (current_function_decl
, &kind
);
58 declare_hidden_char_array ("__FUNCTION__", name
);
59 declare_hidden_char_array ("__PRETTY_FUNCTION__", printable_name
);
63 declare_hidden_char_array (name
, value
)
66 tree decl
, type
, init
;
69 /* If the default size of char arrays isn't big enough for the name,
71 vlen
= strlen (value
) + 1;
72 type
= char_array_type_node
;
73 if (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TREE_TYPE (type
))) < vlen
)
74 type
= build_array_type (char_type_node
,
75 build_index_type (build_int_2 (vlen
, 0)));
77 push_obstacks_nochange ();
78 decl
= build_decl (VAR_DECL
, get_identifier (name
), type
);
79 TREE_STATIC (decl
) = 1;
80 TREE_READONLY (decl
) = 1;
81 TREE_ASM_WRITTEN (decl
) = 1;
82 DECL_SOURCE_LINE (decl
) = 0;
83 DECL_IN_SYSTEM_HEADER (decl
) = 1;
84 DECL_IGNORED_P (decl
) = 1;
85 init
= build_string (vlen
, value
);
86 TREE_TYPE (init
) = type
;
87 DECL_INITIAL (decl
) = init
;
88 finish_decl (pushdecl (decl
), init
, NULL_TREE
);
91 /* Given a chain of STRING_CST nodes,
92 concatenate them into one STRING_CST
93 and give it a suitable array-of-chars data type. */
96 combine_strings (strings
)
99 register tree value
, t
;
100 register int length
= 1;
103 int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
106 if (TREE_CHAIN (strings
))
108 /* More than one in the chain, so concatenate. */
109 register char *p
, *q
;
111 /* Don't include the \0 at the end of each substring,
112 except for the last one.
113 Count wide strings and ordinary strings separately. */
114 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
116 if (TREE_TYPE (t
) == wchar_array_type_node
)
118 wide_length
+= (TREE_STRING_LENGTH (t
) - wchar_bytes
);
122 length
+= (TREE_STRING_LENGTH (t
) - 1);
125 /* If anything is wide, the non-wides will be converted,
126 which makes them take more space. */
128 length
= length
* wchar_bytes
+ wide_length
;
130 p
= savealloc (length
);
132 /* Copy the individual strings into the new combined string.
133 If the combined string is wide, convert the chars to ints
134 for any individual strings that are not wide. */
137 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
139 int len
= (TREE_STRING_LENGTH (t
)
140 - ((TREE_TYPE (t
) == wchar_array_type_node
)
142 if ((TREE_TYPE (t
) == wchar_array_type_node
) == wide_flag
)
144 bcopy (TREE_STRING_POINTER (t
), q
, len
);
150 for (i
= 0; i
< len
; i
++)
151 ((int *) q
)[i
] = TREE_STRING_POINTER (t
)[i
];
152 q
+= len
* wchar_bytes
;
158 for (i
= 0; i
< wchar_bytes
; i
++)
164 value
= make_node (STRING_CST
);
165 TREE_STRING_POINTER (value
) = p
;
166 TREE_STRING_LENGTH (value
) = length
;
167 TREE_CONSTANT (value
) = 1;
172 length
= TREE_STRING_LENGTH (value
);
173 if (TREE_TYPE (value
) == wchar_array_type_node
)
177 /* Compute the number of elements, for the array type. */
178 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
180 /* Create the array type for the string constant.
181 -Wwrite-strings says make the string constant an array of const char
182 so that copying it to a non-const pointer will get a warning. */
183 if (warn_write_strings
184 && (! flag_traditional
&& ! flag_writable_strings
))
187 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
190 = build_array_type (elements
,
191 build_index_type (build_int_2 (nchars
- 1, 0)));
195 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
196 build_index_type (build_int_2 (nchars
- 1, 0)));
197 TREE_CONSTANT (value
) = 1;
198 TREE_STATIC (value
) = 1;
202 /* Process the attributes listed in ATTRIBUTES
203 and install them in DECL. */
206 decl_attributes (decl
, attributes
)
207 tree decl
, attributes
;
210 for (a
= attributes
; a
; a
= TREE_CHAIN (a
))
211 if (TREE_VALUE (a
) == get_identifier ("packed"))
213 if (TREE_CODE (decl
) == FIELD_DECL
)
214 DECL_PACKED (decl
) = 1;
215 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
216 used for DECL_REGISTER. It wouldn't mean anything anyway. */
218 else if (TREE_VALUE (a
) == get_identifier ("noreturn")
219 || TREE_VALUE (a
) == get_identifier ("volatile"))
221 if (TREE_CODE (decl
) == FUNCTION_DECL
)
222 TREE_THIS_VOLATILE (decl
) = 1;
224 else if (TREE_VALUE (a
) == get_identifier ("const"))
226 if (TREE_CODE (decl
) == FUNCTION_DECL
)
227 TREE_READONLY (decl
) = 1;
229 else if (TREE_VALUE (a
) != 0
230 && TREE_CODE (TREE_VALUE (a
)) == TREE_LIST
231 && TREE_PURPOSE (TREE_VALUE (a
)) == get_identifier ("mode"))
235 = IDENTIFIER_POINTER (TREE_VALUE (TREE_VALUE (a
)));
237 /* Give this decl a type with the specified mode. */
238 for (i
= 0; i
< NUM_MACHINE_MODES
; i
++)
239 if (!strcmp (specified_name
, GET_MODE_NAME (i
)))
242 = type_for_mode (i
, TREE_UNSIGNED (TREE_TYPE (decl
)));
245 TREE_TYPE (decl
) = type
;
246 DECL_SIZE (decl
) = 0;
247 layout_decl (decl
, 0);
250 error ("no data type for mode `%s'", specified_name
);
253 if (i
== NUM_MACHINE_MODES
)
254 error ("unknown machine mode `%s'", specified_name
);
256 else if (TREE_VALUE (a
) != 0
257 && TREE_CODE (TREE_VALUE (a
)) == TREE_LIST
258 && TREE_PURPOSE (TREE_VALUE (a
)) == get_identifier ("aligned"))
260 int align
= TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (a
)))
263 if (exact_log2 (align
) == -1)
264 error_with_decl (decl
,
265 "requested alignment of `%s' is not a power of 2");
266 else if (TREE_CODE (decl
) != VAR_DECL
267 && TREE_CODE (decl
) != FIELD_DECL
)
268 error_with_decl (decl
,
269 "alignment specified for `%s'");
271 DECL_ALIGN (decl
) = align
;
273 else if (TREE_VALUE (a
) != 0
274 && TREE_CODE (TREE_VALUE (a
)) == TREE_LIST
275 && TREE_PURPOSE (TREE_VALUE (a
)) == get_identifier ("format"))
277 tree list
= TREE_VALUE (TREE_VALUE (a
));
278 tree format_type
= TREE_PURPOSE (list
);
279 int format_num
= TREE_INT_CST_LOW (TREE_PURPOSE (TREE_VALUE (list
)));
280 int first_arg_num
= TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (list
)));
285 if (TREE_CODE (decl
) != FUNCTION_DECL
)
287 error_with_decl (decl
,
288 "argument format specified for non-function `%s'");
292 if (format_type
== get_identifier ("printf"))
294 else if (format_type
== get_identifier ("scanf"))
298 error_with_decl (decl
, "unrecognized format specifier for `%s'");
302 if (first_arg_num
!= 0 && first_arg_num
<= format_num
)
304 error_with_decl (decl
,
305 "format string arg follows the args to be formatted, for `%s'");
309 /* Verify that the format_num argument is actually a string, in case
310 the format attribute is in error. */
311 argument
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
312 for (arg_num
= 1; ; ++arg_num
)
314 if (argument
== 0 || arg_num
== format_num
)
316 argument
= TREE_CHAIN (argument
);
319 || TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
320 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument
)))
323 error_with_decl (decl
,
324 "format string arg not a string type, for `%s'");
327 if (first_arg_num
!= 0)
329 /* Verify that first_arg_num points to the last arg, the ... */
331 arg_num
++, argument
= TREE_CHAIN (argument
);
332 if (arg_num
!= first_arg_num
)
334 error_with_decl (decl
,
335 "args to be formatted is not ..., for `%s'");
340 record_function_format (DECL_NAME (decl
), DECL_ASSEMBLER_NAME (decl
),
341 is_scan
, format_num
, first_arg_num
);
345 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
348 #define T_I &integer_type_node
349 #define T_L &long_integer_type_node
350 #define T_S &short_integer_type_node
351 #define T_UI &unsigned_type_node
352 #define T_UL &long_unsigned_type_node
353 #define T_US &short_unsigned_type_node
354 #define T_F &float_type_node
355 #define T_D &double_type_node
356 #define T_LD &long_double_type_node
357 #define T_C &char_type_node
358 #define T_V &void_type_node
359 #define T_W &wchar_type_node
364 /* Type of argument if no length modifier is used. */
366 /* Type of argument if length modifier for shortening is used.
367 If NULL, then this modifier is not allowed. */
369 /* Type of argument if length modifier `l' is used.
370 If NULL, then this modifier is not allowed. */
372 /* Type of argument if length modifier `L' is used.
373 If NULL, then this modifier is not allowed. */
375 /* List of other modifier characters allowed with these options. */
379 static format_char_info print_char_table
[] = {
380 { "di", 0, T_I
, T_I
, T_L
, NULL
, "-wp0 +" },
381 { "oxX", 0, T_UI
, T_UI
, T_UL
, NULL
, "-wp0#" },
382 { "u", 0, T_UI
, T_UI
, T_UL
, NULL
, "-wp0" },
383 { "feEgG", 0, T_D
, NULL
, NULL
, T_LD
, "-wp0 +#" },
384 { "c", 0, T_I
, NULL
, T_W
, NULL
, "-w" },
385 { "C", 0, T_W
, NULL
, NULL
, NULL
, "-w" },
386 { "s", 1, T_C
, NULL
, T_W
, NULL
, "-wp" },
387 { "S", 1, T_W
, NULL
, NULL
, NULL
, "-wp" },
388 { "p", 1, T_V
, NULL
, NULL
, NULL
, "-w" },
389 { "n", 1, T_I
, T_S
, T_L
, NULL
, "" },
393 static format_char_info scan_char_table
[] = {
394 { "di", 1, T_I
, T_S
, T_L
, NULL
, "*" },
395 { "ouxX", 1, T_UI
, T_US
, T_UL
, NULL
, "*" },
396 { "efgEG", 1, T_F
, NULL
, T_D
, T_LD
, "*" },
397 { "sc", 1, T_C
, NULL
, T_W
, NULL
, "*" },
398 { "[", 1, T_C
, NULL
, NULL
, NULL
, "*" },
399 { "C", 1, T_W
, NULL
, NULL
, NULL
, "*" },
400 { "S", 1, T_W
, NULL
, NULL
, NULL
, "*" },
401 { "p", 2, T_V
, NULL
, NULL
, NULL
, "*" },
402 { "n", 1, T_I
, T_S
, T_L
, NULL
, "" },
406 typedef struct function_format_info
{
407 struct function_format_info
*next
; /* next structure on the list */
408 tree name
; /* identifier such as "printf" */
409 tree assembler_name
; /* optional mangled identifier (for C++) */
410 int is_scan
; /* TRUE if *scanf */
411 int format_num
; /* number of format argument */
412 int first_arg_num
; /* number of first arg (zero for varargs) */
413 } function_format_info
;
415 static function_format_info
*function_format_list
= NULL
;
417 static void check_format_info
PROTO((function_format_info
*, tree
));
419 /* Initialize the table of functions to perform format checking on.
420 The ANSI functions are always checked (whether <stdio.h> is
421 included or not), since it is common to call printf without
422 including <stdio.h>. There shouldn't be a problem with this,
423 since ANSI reserves these function names whether you include the
424 header file or not. In any case, the checking is harmless. */
427 init_function_format_info ()
429 record_function_format (get_identifier ("printf"), NULL_TREE
, 0, 1, 2);
430 record_function_format (get_identifier ("fprintf"), NULL_TREE
, 0, 2, 3);
431 record_function_format (get_identifier ("sprintf"), NULL_TREE
, 0, 2, 3);
432 record_function_format (get_identifier ("scanf"), NULL_TREE
, 1, 1, 2);
433 record_function_format (get_identifier ("fscanf"), NULL_TREE
, 1, 2, 3);
434 record_function_format (get_identifier ("sscanf"), NULL_TREE
, 1, 2, 3);
435 record_function_format (get_identifier ("vprintf"), NULL_TREE
, 0, 1, 0);
436 record_function_format (get_identifier ("vfprintf"), NULL_TREE
, 0, 2, 0);
437 record_function_format (get_identifier ("vsprintf"), NULL_TREE
, 0, 2, 0);
440 /* Record information for argument format checking. FUNCTION_IDENT is
441 the identifier node for the name of the function to check (its decl
442 need not exist yet). IS_SCAN is true for scanf-type format checking;
443 false indicates printf-style format checking. FORMAT_NUM is the number
444 of the argument which is the format control string (starting from 1).
445 FIRST_ARG_NUM is the number of the first actual argument to check
446 against teh format string, or zero if no checking is not be done
447 (e.g. for varargs such as vfprintf). */
450 record_function_format (name
, assembler_name
, is_scan
,
451 format_num
, first_arg_num
)
458 function_format_info
*info
;
460 /* Re-use existing structure if it's there. */
462 for (info
= function_format_list
; info
; info
= info
->next
)
464 if (info
->name
== name
&& info
->assembler_name
== assembler_name
)
469 info
= (function_format_info
*) xmalloc (sizeof (function_format_info
));
470 info
->next
= function_format_list
;
471 function_format_list
= info
;
474 info
->assembler_name
= assembler_name
;
477 info
->is_scan
= is_scan
;
478 info
->format_num
= format_num
;
479 info
->first_arg_num
= first_arg_num
;
482 static char tfaff
[] = "too few arguments for format";
484 /* Check the argument list of a call to printf, scanf, etc.
485 NAME is the function identifier.
486 ASSEMBLER_NAME is the function's assembler identifier.
487 (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
488 PARAMS is the list of argument values. */
491 check_function_format (name
, assembler_name
, params
)
496 function_format_info
*info
;
498 /* See if this function is a format function. */
499 for (info
= function_format_list
; info
; info
= info
->next
)
501 if (info
->assembler_name
502 ? (info
->assembler_name
== assembler_name
)
503 : (info
->name
== name
))
506 check_format_info (info
, params
);
512 /* Check the argument list of a call to printf, scanf, etc.
513 INFO points to the function_format_info structure.
514 PARAMS is the list of argument values. */
517 check_format_info (info
, params
)
518 function_format_info
*info
;
523 int suppressed
, wide
, precise
;
531 tree first_fillin_param
;
533 format_char_info
*fci
;
534 static char message
[132];
536 int has_operand_number
= 0;
538 /* Skip to format argument. If the argument isn't available, there's
539 no work for us to do; prototype checking will catch the problem. */
540 for (arg_num
= 1; ; ++arg_num
)
544 if (arg_num
== info
->format_num
)
546 params
= TREE_CHAIN (params
);
548 format_tree
= TREE_VALUE (params
);
549 params
= TREE_CHAIN (params
);
550 if (format_tree
== 0)
552 /* We can only check the format if it's a string constant. */
553 while (TREE_CODE (format_tree
) == NOP_EXPR
)
554 format_tree
= TREE_OPERAND (format_tree
, 0); /* strip coercion */
555 if (format_tree
== null_pointer_node
)
557 warning ("null format string");
560 if (TREE_CODE (format_tree
) != ADDR_EXPR
)
562 format_tree
= TREE_OPERAND (format_tree
, 0);
563 if (TREE_CODE (format_tree
) != STRING_CST
)
565 format_chars
= TREE_STRING_POINTER (format_tree
);
566 format_length
= TREE_STRING_LENGTH (format_tree
);
567 if (format_length
<= 1)
568 warning ("zero-length format string");
569 if (format_chars
[--format_length
] != 0)
571 warning ("unterminated format string");
574 /* Skip to first argument to check. */
575 while (arg_num
+ 1 < info
->first_arg_num
)
579 params
= TREE_CHAIN (params
);
583 first_fillin_param
= params
;
586 if (*format_chars
== 0)
588 if (format_chars
- TREE_STRING_POINTER (format_tree
) != format_length
)
589 warning ("embedded `\\0' in format");
590 if (info
->first_arg_num
!= 0 && params
!= 0 && ! has_operand_number
)
591 warning ("too many arguments for format");
594 if (*format_chars
++ != '%')
596 if (*format_chars
== 0)
598 warning ("spurious trailing `%%' in format");
601 if (*format_chars
== '%')
607 suppressed
= wide
= precise
= FALSE
;
610 suppressed
= *format_chars
== '*';
613 while (isdigit (*format_chars
))
618 /* See if we have a number followed by a dollar sign. If we do,
619 it is an operand number, so set PARAMS to that operand. */
620 if (*format_chars
>= '0' && *format_chars
<= '9')
622 char *p
= format_chars
;
624 while (*p
>= '0' && *p
++ <= '9')
629 int opnum
= atoi (format_chars
);
631 params
= first_fillin_param
;
632 format_chars
= p
+ 1;
633 has_operand_number
= 1;
635 for (i
= 1; i
< opnum
&& params
!= 0; i
++)
636 params
= TREE_CHAIN (params
);
638 if (opnum
== 0 || params
== 0)
640 warning ("operand number out of range in format");
646 while (*format_chars
!= 0 && index (" +#0-", *format_chars
) != 0)
648 if (index (flag_chars
, *format_chars
) != 0)
650 sprintf (message
, "repeated `%c' flag in format",
654 i
= strlen (flag_chars
);
655 flag_chars
[i
++] = *format_chars
++;
658 /* "If the space and + flags both appear,
659 the space flag will be ignored." */
660 if (index (flag_chars
, ' ') != 0
661 && index (flag_chars
, '+') != 0)
662 warning ("use of both ` ' and `+' flags in format");
663 /* "If the 0 and - flags both appear,
664 the 0 flag will be ignored." */
665 if (index (flag_chars
, '0') != 0
666 && index (flag_chars
, '-') != 0)
667 warning ("use of both `0' and `-' flags in format");
668 if (*format_chars
== '*')
671 /* "...a field width...may be indicated by an asterisk.
672 In this case, an int argument supplies the field width..." */
679 if (info
->first_arg_num
!= 0)
681 cur_param
= TREE_VALUE (params
);
682 params
= TREE_CHAIN (params
);
684 /* size_t is generally not valid here.
685 It will work on most machines, because size_t and int
686 have the same mode. But might as well warn anyway,
687 since it will fail on other machines. */
688 if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
689 != integer_type_node
)
692 "field width is not type int (arg %d)",
700 while (isdigit (*format_chars
))
706 if (*format_chars
== '.')
710 if (*format_chars
!= '*' && !isdigit (*format_chars
))
711 warning ("`.' not followed by `*' or digit in format");
712 /* "...a...precision...may be indicated by an asterisk.
713 In this case, an int argument supplies the...precision." */
714 if (*format_chars
== '*')
716 if (info
->first_arg_num
!= 0)
724 cur_param
= TREE_VALUE (params
);
725 params
= TREE_CHAIN (params
);
727 if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
728 != integer_type_node
)
731 "field width is not type int (arg %d)",
739 while (isdigit (*format_chars
))
744 if (*format_chars
== 'h' || *format_chars
== 'l' || *format_chars
== 'L')
745 length_char
= *format_chars
++;
748 if (suppressed
&& length_char
!= 0)
751 "use of `*' and `%c' together in format",
755 format_char
= *format_chars
;
756 if (format_char
== 0)
758 warning ("conversion lacks type at end of format");
762 fci
= info
->is_scan
? scan_char_table
: print_char_table
;
763 while (fci
->format_chars
!= 0
764 && index (fci
->format_chars
, format_char
) == 0)
766 if (fci
->format_chars
== 0)
768 if (format_char
>= 040 && format_char
< 0177)
770 "unknown conversion type character `%c' in format",
774 "unknown conversion type character 0x%x in format",
779 if (wide
&& index (fci
->flag_chars
, 'w') == 0)
781 sprintf (message
, "width used with `%c' format",
785 if (precise
&& index (fci
->flag_chars
, 'p') == 0)
787 sprintf (message
, "precision used with `%c' format",
791 if (info
->is_scan
&& format_char
== '[')
793 /* Skip over scan set, in case it happens to have '%' in it. */
794 if (*format_chars
== '^')
796 /* Find closing bracket; if one is hit immediately, then
797 it's part of the scan set rather than a terminator. */
798 if (*format_chars
== ']')
800 while (*format_chars
&& *format_chars
!= ']')
802 if (*format_chars
!= ']')
803 /* The end of the format string was reached. */
804 warning ("no closing `]' for `%%[' format");
808 if (index (fci
->flag_chars
, '*') == 0)
811 "suppression of `%c' conversion in format",
817 for (i
= 0; flag_chars
[i
] != 0; ++i
)
819 if (index (fci
->flag_chars
, flag_chars
[i
]) == 0)
821 sprintf (message
, "flag `%c' used with type `%c'",
822 flag_chars
[i
], format_char
);
826 if (precise
&& index (flag_chars
, '0') != 0
827 && (format_char
== 'd' || format_char
== 'i'
828 || format_char
== 'o' || format_char
== 'u'
829 || format_char
== 'x' || format_char
== 'x'))
832 "precision and `0' flag not both allowed with `%c' format",
838 default: wanted_type
= fci
->nolen
? *(fci
->nolen
) : 0; break;
839 case 'h': wanted_type
= fci
->hlen
? *(fci
->hlen
) : 0; break;
840 case 'l': wanted_type
= fci
->llen
? *(fci
->llen
) : 0; break;
841 case 'L': wanted_type
= fci
->bigllen
? *(fci
->bigllen
) : 0; break;
843 if (wanted_type
== 0)
846 "use of `%c' length character with `%c' type character",
847 length_char
, format_char
);
852 ** XXX -- should kvetch about stuff such as
860 /* Finally. . .check type of argument against desired type! */
861 if (info
->first_arg_num
== 0)
868 cur_param
= TREE_VALUE (params
);
869 params
= TREE_CHAIN (params
);
871 cur_type
= TREE_TYPE (cur_param
);
873 /* Check the types of any additional pointer arguments
874 that precede the "real" argument. */
875 for (i
= 0; i
< fci
->pointer_count
; ++i
)
877 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
879 cur_type
= TREE_TYPE (cur_type
);
883 "format argument is not a %s (arg %d)",
884 ((fci
->pointer_count
== 1) ? "pointer" : "pointer to a pointer"),
890 /* Check the type of the "real" argument, if there's a type we want. */
891 if (i
== fci
->pointer_count
&& wanted_type
!= 0
892 && wanted_type
!= TYPE_MAIN_VARIANT (cur_type
)
893 /* If we want `void *', allow any pointer type.
894 (Anything else would already have got a warning.) */
895 && ! (wanted_type
== void_type_node
896 && fci
->pointer_count
> 0)
897 /* Don't warn about differences merely in signedness. */
898 && !(TREE_CODE (wanted_type
) == INTEGER_TYPE
899 && TREE_CODE (cur_type
) == INTEGER_TYPE
900 && (TREE_UNSIGNED (wanted_type
)
901 ? wanted_type
== unsigned_type (cur_type
)
902 : wanted_type
== signed_type (cur_type
))))
907 this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type
)));
909 if (TREE_CODE (cur_type
) != ERROR_MARK
910 && TYPE_NAME (cur_type
) != 0
911 && TREE_CODE (cur_type
) != INTEGER_TYPE
912 && !(TREE_CODE (cur_type
) == POINTER_TYPE
913 && TREE_CODE (TREE_TYPE (cur_type
)) == INTEGER_TYPE
))
915 if (TREE_CODE (TYPE_NAME (cur_type
)) == TYPE_DECL
916 && DECL_NAME (TYPE_NAME (cur_type
)) != 0)
917 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type
)));
919 that
= IDENTIFIER_POINTER (TYPE_NAME (cur_type
));
922 /* A nameless type can't possibly match what the format wants.
923 So there will be a warning for it.
924 Make up a string to describe vaguely what it is. */
927 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
930 that
= "different type";
933 if (strcmp (this, that
) != 0)
935 sprintf (message
, "%s format, %s arg (arg %d)",
936 this, that
, arg_num
);
943 /* Print a warning if a constant expression had overflow in folding.
944 Invoke this function on every expression that the language
945 requires to be a constant expression.
946 Note the ANSI C standard says it is erroneous for a
947 constant expression to overflow. */
950 constant_expression_warning (value
)
953 if (TREE_CODE (value
) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (value
))
955 pedwarn ("overflow in constant expression");
958 /* Print a warning if an expression had overflow in folding.
959 Invoke this function on every expression that
960 (1) appears in the source code, and
961 (2) might be a constant expression that overflowed, and
962 (3) is not already checked by convert_and_check;
963 however, do not invoke this function on operands of explicit casts. */
966 overflow_warning (value
)
969 if (TREE_CODE (value
) == INTEGER_CST
&& TREE_OVERFLOW (value
))
971 TREE_OVERFLOW (value
) = 0;
972 warning ("integer overflow in expression");
976 /* Print a warning if a large constant is truncated to unsigned,
977 or if -Wconversion is used and a constant < 0 is converted to unsigned.
978 Invoke this function on every expression that might be implicitly
979 converted to an unsigned type. */
982 unsigned_conversion_warning (result
, operand
)
983 tree result
, operand
;
985 if (TREE_CODE (operand
) == INTEGER_CST
986 && TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
987 && TREE_UNSIGNED (TREE_TYPE (result
))
988 && !int_fits_type_p (operand
, TREE_TYPE (result
)))
990 if (!int_fits_type_p (operand
, signed_type (TREE_TYPE (result
))))
991 /* This detects cases like converting -129 or 256 to unsigned char. */
992 warning ("large integer implicitly truncated to unsigned type");
993 else if (warn_conversion
)
994 warning ("negative integer implicitly converted to unsigned type");
998 /* Convert EXPR to TYPE, warning about conversion problems with constants.
999 Invoke this function on every expression that is converted implicitly,
1000 i.e. because of language rules and not because of an explicit cast. */
1003 convert_and_check (type
, expr
)
1006 tree t
= convert (type
, expr
);
1007 if (TREE_CODE (t
) == INTEGER_CST
)
1009 if (TREE_OVERFLOW (t
))
1011 TREE_OVERFLOW (t
) = 0;
1013 /* No warning for converting 0x80000000 to int. */
1014 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
1015 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1016 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1017 warning ("overflow in implicit constant conversion");
1020 unsigned_conversion_warning (t
, expr
);
1026 c_expand_expr_stmt (expr
)
1029 /* Do default conversion if safe and possibly important,
1030 in case within ({...}). */
1031 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
&& lvalue_p (expr
))
1032 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1033 expr
= default_conversion (expr
);
1035 if (TREE_TYPE (expr
) != error_mark_node
1036 && TYPE_SIZE (TREE_TYPE (expr
)) == 0
1037 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1038 error ("expression statement has incomplete type");
1040 expand_expr_stmt (expr
);
1043 /* Validate the expression after `case' and apply default promotions. */
1046 check_case_value (value
)
1049 if (value
== NULL_TREE
)
1052 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1053 STRIP_TYPE_NOPS (value
);
1055 if (TREE_CODE (value
) != INTEGER_CST
1056 && value
!= error_mark_node
)
1058 error ("case label does not reduce to an integer constant");
1059 value
= error_mark_node
;
1062 /* Promote char or short to int. */
1063 value
= default_conversion (value
);
1065 constant_expression_warning (value
);
1070 /* Return an integer type with BITS bits of precision,
1071 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1074 type_for_size (bits
, unsignedp
)
1078 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1079 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1081 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1082 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1084 if (bits
== TYPE_PRECISION (integer_type_node
))
1085 return unsignedp
? unsigned_type_node
: integer_type_node
;
1087 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1088 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1090 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1091 return (unsignedp
? long_long_unsigned_type_node
1092 : long_long_integer_type_node
);
1094 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1095 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1097 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1098 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1100 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1101 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1103 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1104 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1109 /* Return a data type that has machine mode MODE.
1110 If the mode is an integer,
1111 then UNSIGNEDP selects between signed and unsigned types. */
1114 type_for_mode (mode
, unsignedp
)
1115 enum machine_mode mode
;
1118 if (mode
== TYPE_MODE (signed_char_type_node
))
1119 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1121 if (mode
== TYPE_MODE (short_integer_type_node
))
1122 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1124 if (mode
== TYPE_MODE (integer_type_node
))
1125 return unsignedp
? unsigned_type_node
: integer_type_node
;
1127 if (mode
== TYPE_MODE (long_integer_type_node
))
1128 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1130 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1131 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1133 if (mode
== TYPE_MODE (intQI_type_node
))
1134 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1136 if (mode
== TYPE_MODE (intHI_type_node
))
1137 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1139 if (mode
== TYPE_MODE (intSI_type_node
))
1140 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1142 if (mode
== TYPE_MODE (intDI_type_node
))
1143 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1145 if (mode
== TYPE_MODE (float_type_node
))
1146 return float_type_node
;
1148 if (mode
== TYPE_MODE (double_type_node
))
1149 return double_type_node
;
1151 if (mode
== TYPE_MODE (long_double_type_node
))
1152 return long_double_type_node
;
1154 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1155 return build_pointer_type (char_type_node
);
1157 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1158 return build_pointer_type (integer_type_node
);
1163 /* Print an error message for invalid operands to arith operation CODE.
1164 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1167 binary_op_error (code
)
1168 enum tree_code code
;
1170 register char *opname
;
1174 error ("invalid truth-value expression");
1178 opname
= "+"; break;
1180 opname
= "-"; break;
1182 opname
= "*"; break;
1184 opname
= "max"; break;
1186 opname
= "min"; break;
1188 opname
= "=="; break;
1190 opname
= "!="; break;
1192 opname
= "<="; break;
1194 opname
= ">="; break;
1196 opname
= "<"; break;
1198 opname
= ">"; break;
1200 opname
= "<<"; break;
1202 opname
= ">>"; break;
1203 case TRUNC_MOD_EXPR
:
1204 case FLOOR_MOD_EXPR
:
1205 opname
= "%"; break;
1206 case TRUNC_DIV_EXPR
:
1207 case FLOOR_DIV_EXPR
:
1208 opname
= "/"; break;
1210 opname
= "&"; break;
1212 opname
= "|"; break;
1213 case TRUTH_ANDIF_EXPR
:
1214 opname
= "&&"; break;
1215 case TRUTH_ORIF_EXPR
:
1216 opname
= "||"; break;
1218 opname
= "^"; break;
1221 opname
= "rotate"; break;
1223 error ("invalid operands to binary %s", opname
);
1226 /* Subroutine of build_binary_op, used for comparison operations.
1227 See if the operands have both been converted from subword integer types
1228 and, if so, perhaps change them both back to their original type.
1230 The arguments of this function are all pointers to local variables
1231 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1232 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1234 If this function returns nonzero, it means that the comparison has
1235 a constant value. What this function returns is an expression for
1239 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
1240 tree
*op0_ptr
, *op1_ptr
;
1242 enum tree_code
*rescode_ptr
;
1245 tree op0
= *op0_ptr
;
1246 tree op1
= *op1_ptr
;
1247 int unsignedp0
, unsignedp1
;
1249 tree primop0
, primop1
;
1250 enum tree_code code
= *rescode_ptr
;
1252 /* Throw away any conversions to wider types
1253 already present in the operands. */
1255 primop0
= get_narrower (op0
, &unsignedp0
);
1256 primop1
= get_narrower (op1
, &unsignedp1
);
1258 /* Handle the case that OP0 does not *contain* a conversion
1259 but it *requires* conversion to FINAL_TYPE. */
1261 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
1262 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
1263 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
1264 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
1266 /* If one of the operands must be floated, we cannot optimize. */
1267 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
1268 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
1270 /* If first arg is constant, swap the args (changing operation
1271 so value is preserved), for canonicalization. */
1273 if (TREE_CONSTANT (primop0
))
1275 register tree tem
= primop0
;
1276 register int temi
= unsignedp0
;
1284 unsignedp0
= unsignedp1
;
1305 *rescode_ptr
= code
;
1308 /* If comparing an integer against a constant more bits wide,
1309 maybe we can deduce a value of 1 or 0 independent of the data.
1310 Or else truncate the constant now
1311 rather than extend the variable at run time.
1313 This is only interesting if the constant is the wider arg.
1314 Also, it is not safe if the constant is unsigned and the
1315 variable arg is signed, since in this case the variable
1316 would be sign-extended and then regarded as unsigned.
1317 Our technique fails in this case because the lowest/highest
1318 possible unsigned results don't follow naturally from the
1319 lowest/highest possible values of the variable operand.
1320 For just EQ_EXPR and NE_EXPR there is another technique that
1321 could be used: see if the constant can be faithfully represented
1322 in the other operand's type, by truncating it and reextending it
1323 and see if that preserves the constant's value. */
1325 if (!real1
&& !real2
1326 && TREE_CODE (primop1
) == INTEGER_CST
1327 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
1329 int min_gt
, max_gt
, min_lt
, max_lt
;
1330 tree maxval
, minval
;
1331 /* 1 if comparison is nominally unsigned. */
1332 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
1335 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
1337 maxval
= TYPE_MAX_VALUE (type
);
1338 minval
= TYPE_MIN_VALUE (type
);
1340 if (unsignedp
&& !unsignedp0
)
1341 *restype_ptr
= signed_type (*restype_ptr
);
1343 if (TREE_TYPE (primop1
) != *restype_ptr
)
1344 primop1
= convert (*restype_ptr
, primop1
);
1345 if (type
!= *restype_ptr
)
1347 minval
= convert (*restype_ptr
, minval
);
1348 maxval
= convert (*restype_ptr
, maxval
);
1351 if (unsignedp
&& unsignedp0
)
1353 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
1354 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
1355 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
1356 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
1360 min_gt
= INT_CST_LT (primop1
, minval
);
1361 max_gt
= INT_CST_LT (primop1
, maxval
);
1362 min_lt
= INT_CST_LT (minval
, primop1
);
1363 max_lt
= INT_CST_LT (maxval
, primop1
);
1367 /* This used to be a switch, but Genix compiler can't handle that. */
1368 if (code
== NE_EXPR
)
1370 if (max_lt
|| min_gt
)
1371 val
= integer_one_node
;
1373 else if (code
== EQ_EXPR
)
1375 if (max_lt
|| min_gt
)
1376 val
= integer_zero_node
;
1378 else if (code
== LT_EXPR
)
1381 val
= integer_one_node
;
1383 val
= integer_zero_node
;
1385 else if (code
== GT_EXPR
)
1388 val
= integer_one_node
;
1390 val
= integer_zero_node
;
1392 else if (code
== LE_EXPR
)
1395 val
= integer_one_node
;
1397 val
= integer_zero_node
;
1399 else if (code
== GE_EXPR
)
1402 val
= integer_one_node
;
1404 val
= integer_zero_node
;
1407 /* If primop0 was sign-extended and unsigned comparison specd,
1408 we did a signed comparison above using the signed type bounds.
1409 But the comparison we output must be unsigned.
1411 Also, for inequalities, VAL is no good; but if the signed
1412 comparison had *any* fixed result, it follows that the
1413 unsigned comparison just tests the sign in reverse
1414 (positive values are LE, negative ones GE).
1415 So we can generate an unsigned comparison
1416 against an extreme value of the signed type. */
1418 if (unsignedp
&& !unsignedp0
)
1425 primop1
= TYPE_MIN_VALUE (type
);
1431 primop1
= TYPE_MAX_VALUE (type
);
1435 type
= unsigned_type (type
);
1438 if (!max_gt
&& !unsignedp0
)
1440 /* This is the case of (char)x >?< 0x80, which people used to use
1441 expecting old C compilers to change the 0x80 into -0x80. */
1442 if (val
== integer_zero_node
)
1443 warning ("comparison is always 0 due to limited range of data type");
1444 if (val
== integer_one_node
)
1445 warning ("comparison is always 1 due to limited range of data type");
1448 if (!min_lt
&& unsignedp0
)
1450 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1451 if (val
== integer_zero_node
)
1452 warning ("comparison is always 0 due to limited range of data type");
1453 if (val
== integer_one_node
)
1454 warning ("comparison is always 1 due to limited range of data type");
1459 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1460 if (TREE_SIDE_EFFECTS (primop0
))
1461 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
1465 /* Value is not predetermined, but do the comparison
1466 in the type of the operand that is not constant.
1467 TYPE is already properly set. */
1469 else if (real1
&& real2
1470 && (TYPE_PRECISION (TREE_TYPE (primop0
))
1471 == TYPE_PRECISION (TREE_TYPE (primop1
))))
1472 type
= TREE_TYPE (primop0
);
1474 /* If args' natural types are both narrower than nominal type
1475 and both extend in the same manner, compare them
1476 in the type of the wider arg.
1477 Otherwise must actually extend both to the nominal
1478 common type lest different ways of extending
1480 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1482 else if (unsignedp0
== unsignedp1
&& real1
== real2
1483 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
1484 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
1486 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
1487 type
= signed_or_unsigned_type (unsignedp0
1488 || TREE_UNSIGNED (*restype_ptr
),
1490 /* Make sure shorter operand is extended the right way
1491 to match the longer operand. */
1492 primop0
= convert (signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
)),
1494 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
1499 /* Here we must do the comparison on the nominal type
1500 using the args exactly as we received them. */
1501 type
= *restype_ptr
;
1505 if (!real1
&& !real2
&& integer_zerop (primop1
)
1506 && TREE_UNSIGNED (TREE_TYPE (primop0
)))
1513 warning ("unsigned value >= 0 is always 1");
1514 value
= integer_one_node
;
1519 warning ("unsigned value < 0 is always 0");
1520 value
= integer_zero_node
;
1525 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1526 if (TREE_SIDE_EFFECTS (primop0
))
1527 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1534 *op0_ptr
= convert (type
, primop0
);
1535 *op1_ptr
= convert (type
, primop1
);
1537 *restype_ptr
= integer_type_node
;
1542 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1543 or validate its data type for an `if' or `while' statement or ?..: exp.
1545 This preparation consists of taking the ordinary
1546 representation of an expression expr and producing a valid tree
1547 boolean expression describing whether expr is nonzero. We could
1548 simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
1549 but we optimize comparisons, &&, ||, and !.
1551 The resulting type should always be `integer_type_node'. */
1554 truthvalue_conversion (expr
)
1557 register enum tree_code code
;
1559 if (TREE_CODE (expr
) == ERROR_MARK
)
1562 #if 0 /* This appears to be wrong for C++. */
1563 /* These really should return error_mark_node after 2.4 is stable.
1564 But not all callers handle ERROR_MARK properly. */
1565 switch (TREE_CODE (TREE_TYPE (expr
)))
1568 error ("struct type value used where scalar is required");
1569 return integer_zero_node
;
1572 error ("union type value used where scalar is required");
1573 return integer_zero_node
;
1576 error ("array type value used where scalar is required");
1577 return integer_zero_node
;
1584 switch (TREE_CODE (expr
))
1586 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1587 or comparison expressions as truth values at this level. */
1590 /* A one-bit unsigned bit-field is already acceptable. */
1591 if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr
, 1)))
1592 && TREE_UNSIGNED (TREE_OPERAND (expr
, 1)))
1598 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1599 or comparison expressions as truth values at this level. */
1601 if (integer_zerop (TREE_OPERAND (expr
, 1)))
1602 return build_unary_op (TRUTH_NOT_EXPR
, TREE_OPERAND (expr
, 0), 0);
1604 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
1605 case TRUTH_ANDIF_EXPR
:
1606 case TRUTH_ORIF_EXPR
:
1607 case TRUTH_AND_EXPR
:
1609 case TRUTH_XOR_EXPR
:
1614 return integer_zerop (expr
) ? integer_zero_node
: integer_one_node
;
1617 return real_zerop (expr
) ? integer_zero_node
: integer_one_node
;
1620 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
1621 return build (COMPOUND_EXPR
, integer_type_node
,
1622 TREE_OPERAND (expr
, 0), integer_one_node
);
1624 return integer_one_node
;
1627 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
1628 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
1629 truthvalue_conversion (TREE_OPERAND (expr
, 0)),
1630 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
1637 /* These don't change whether an object is non-zero or zero. */
1638 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
1642 /* These don't change whether an object is zero or non-zero, but
1643 we can't ignore them if their second arg has side-effects. */
1644 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
1645 return build (COMPOUND_EXPR
, integer_type_node
, TREE_OPERAND (expr
, 1),
1646 truthvalue_conversion (TREE_OPERAND (expr
, 0)));
1648 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
1651 /* Distribute the conversion into the arms of a COND_EXPR. */
1652 return fold (build (COND_EXPR
, integer_type_node
, TREE_OPERAND (expr
, 0),
1653 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
1654 truthvalue_conversion (TREE_OPERAND (expr
, 2))));
1657 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
1658 since that affects how `default_conversion' will behave. */
1659 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
1660 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
1662 /* fall through... */
1664 /* If this is widening the argument, we can ignore it. */
1665 if (TYPE_PRECISION (TREE_TYPE (expr
))
1666 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
1667 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
1671 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
1673 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
1674 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
1676 /* fall through... */
1678 /* This and MINUS_EXPR can be changed into a comparison of the
1680 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
1681 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
1682 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
1683 TREE_OPERAND (expr
, 1), 1);
1684 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
1685 fold (build1 (NOP_EXPR
,
1686 TREE_TYPE (TREE_OPERAND (expr
, 0)),
1687 TREE_OPERAND (expr
, 1))), 1);
1690 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
1691 warning ("suggest parentheses around assignment used as truth value");
1695 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
1696 return (build_binary_op
1697 ((TREE_SIDE_EFFECTS (expr
)
1698 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
1699 truthvalue_conversion (build_unary_op (REALPART_EXPR
, expr
, 0)),
1700 truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, expr
, 0)),
1703 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
1706 /* Read the rest of a #-directive from input stream FINPUT.
1707 In normal use, the directive name and the white space after it
1708 have already been read, so they won't be included in the result.
1709 We allow for the fact that the directive line may contain
1710 a newline embedded within a character or string literal which forms
1711 a part of the directive.
1713 The value is a string in a reusable buffer. It remains valid
1714 only until the next time this function is called. */
1717 get_directive_line (finput
)
1718 register FILE *finput
;
1720 static char *directive_buffer
= NULL
;
1721 static unsigned buffer_length
= 0;
1723 register char *buffer_limit
;
1724 register int looking_for
= 0;
1725 register int char_escaped
= 0;
1727 if (buffer_length
== 0)
1729 directive_buffer
= (char *)xmalloc (128);
1730 buffer_length
= 128;
1733 buffer_limit
= &directive_buffer
[buffer_length
];
1735 for (p
= directive_buffer
; ; )
1739 /* Make buffer bigger if it is full. */
1740 if (p
>= buffer_limit
)
1742 register unsigned bytes_used
= (p
- directive_buffer
);
1746 = (char *)xrealloc (directive_buffer
, buffer_length
);
1747 p
= &directive_buffer
[bytes_used
];
1748 buffer_limit
= &directive_buffer
[buffer_length
];
1753 /* Discard initial whitespace. */
1754 if ((c
== ' ' || c
== '\t') && p
== directive_buffer
)
1757 /* Detect the end of the directive. */
1758 if (c
== '\n' && looking_for
== 0)
1767 return directive_buffer
;
1769 /* Handle string and character constant syntax. */
1772 if (looking_for
== c
&& !char_escaped
)
1773 looking_for
= 0; /* Found terminator... stop looking. */
1776 if (c
== '\'' || c
== '"')
1777 looking_for
= c
; /* Don't stop buffering until we see another
1778 another one of these (or an EOF). */
1780 /* Handle backslash. */
1781 char_escaped
= (c
== '\\' && ! char_escaped
);
1785 /* Make a variant type in the proper way for C/C++, propagating qualifiers
1786 down to the element type of an array. */
1789 c_build_type_variant (type
, constp
, volatilep
)
1791 int constp
, volatilep
;
1793 if (TREE_CODE (type
) == ARRAY_TYPE
)
1795 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
1797 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
1798 type
= build_array_type (c_build_type_variant (TREE_TYPE (type
),
1800 TYPE_DOMAIN (type
));
1801 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
1804 return build_type_variant (type
, constp
, volatilep
);