1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994 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
;
211 for (a
= attributes
; a
; a
= TREE_CHAIN (a
))
212 if (TREE_VALUE (a
) == get_identifier ("packed"))
214 if (TREE_CODE (decl
) == FIELD_DECL
)
215 DECL_PACKED (decl
) = 1;
216 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
217 used for DECL_REGISTER. It wouldn't mean anything anyway. */
219 warning_with_decl (decl
, "`packed' attribute ignore");
222 else if (TREE_VALUE (a
) == get_identifier ("noreturn")
223 || TREE_VALUE (a
) == get_identifier ("volatile"))
225 tree type
= TREE_TYPE (decl
);
227 if (TREE_CODE (decl
) == FUNCTION_DECL
)
228 TREE_THIS_VOLATILE (decl
) = 1;
229 else if (TREE_CODE (type
) == POINTER_TYPE
230 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
233 (build_type_variant (TREE_TYPE (type
),
234 TREE_READONLY (TREE_TYPE (type
)), 1));
236 warning_with_decl (decl
, "`%s' attribute ignored",
237 IDENTIFIER_POINTER (TREE_VALUE (a
)));
239 else if (TREE_VALUE (a
) == get_identifier ("const"))
241 tree type
= TREE_TYPE (decl
);
243 if (TREE_CODE (decl
) == FUNCTION_DECL
)
244 TREE_READONLY (decl
) = 1;
245 else if (TREE_CODE (type
) == POINTER_TYPE
246 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
249 (build_type_variant (TREE_TYPE (type
), 1,
250 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
252 warning_with_decl (decl
, "`const' attribute ignored");
254 else if (TREE_VALUE (a
) != 0
255 && TREE_CODE (TREE_VALUE (a
)) == TREE_LIST
256 && TREE_PURPOSE (TREE_VALUE (a
)) == get_identifier ("mode"))
260 = IDENTIFIER_POINTER (TREE_VALUE (TREE_VALUE (a
)));
262 /* Give this decl a type with the specified mode. */
263 for (i
= 0; i
< NUM_MACHINE_MODES
; i
++)
264 if (!strcmp (specified_name
, GET_MODE_NAME (i
)))
267 = type_for_mode (i
, TREE_UNSIGNED (TREE_TYPE (decl
)));
270 TREE_TYPE (decl
) = type
;
271 DECL_SIZE (decl
) = 0;
272 layout_decl (decl
, 0);
275 error ("no data type for mode `%s'", specified_name
);
278 if (i
== NUM_MACHINE_MODES
)
279 error_with_decl (decl
, "unknown machine mode `%s'", specified_name
);
281 else if (TREE_VALUE (a
) != 0
282 && TREE_CODE (TREE_VALUE (a
)) == TREE_LIST
283 && TREE_PURPOSE (TREE_VALUE (a
)) == get_identifier ("section"))
285 #ifdef ASM_OUTPUT_SECTION_NAME
286 if (TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
288 if (TREE_CODE (decl
) == VAR_DECL
&& current_function_decl
!= NULL_TREE
)
289 error_with_decl (decl
,
290 "section attribute cannot be specified for local variables");
291 /* The decl may have already been given a section attribute from
292 a previous declaration. Ensure they match. */
293 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
294 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
295 TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (a
)))) != 0)
296 error_with_decl (decl
,
297 "section of `%s' conflicts with previous declaration");
299 DECL_SECTION_NAME (decl
) = TREE_VALUE (TREE_VALUE (a
));
302 error_with_decl (decl
,
303 "section attribute not allowed for `%s'");
305 error_with_decl (decl
, "section attributes are not supported for this target");
308 else if (TREE_VALUE (a
) != 0
309 && TREE_CODE (TREE_VALUE (a
)) == TREE_LIST
310 && TREE_PURPOSE (TREE_VALUE (a
)) == get_identifier ("aligned"))
312 tree align_expr
= TREE_VALUE (TREE_VALUE (a
));
315 /* Strip any NOPs of any kind. */
316 while (TREE_CODE (align_expr
) == NOP_EXPR
317 || TREE_CODE (align_expr
) == CONVERT_EXPR
318 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
319 align_expr
= TREE_OPERAND (align_expr
, 0);
321 if (TREE_CODE (align_expr
) != INTEGER_CST
)
323 error_with_decl (decl
,
324 "requested alignment of `%s' is not a constant");
328 align
= TREE_INT_CST_LOW (align_expr
) * BITS_PER_UNIT
;
330 if (exact_log2 (align
) == -1)
331 error_with_decl (decl
,
332 "requested alignment of `%s' is not a power of 2");
333 else if (TREE_CODE (decl
) != VAR_DECL
334 && TREE_CODE (decl
) != FIELD_DECL
)
335 error_with_decl (decl
,
336 "alignment specified for `%s'");
338 DECL_ALIGN (decl
) = align
;
340 else if (TREE_VALUE (a
) != 0
341 && TREE_CODE (TREE_VALUE (a
)) == TREE_LIST
342 && TREE_PURPOSE (TREE_VALUE (a
)) == get_identifier ("format"))
344 tree list
= TREE_VALUE (TREE_VALUE (a
));
345 tree format_type
= TREE_PURPOSE (list
);
346 tree format_num_expr
= TREE_PURPOSE (TREE_VALUE (list
));
347 tree first_arg_num_expr
= TREE_VALUE (TREE_VALUE (list
));
354 if (TREE_CODE (decl
) != FUNCTION_DECL
)
356 error_with_decl (decl
,
357 "argument format specified for non-function `%s'");
361 if (format_type
== get_identifier ("printf"))
363 else if (format_type
== get_identifier ("scanf"))
367 error_with_decl (decl
, "unrecognized format specifier for `%s'");
371 /* Strip any conversions from the string index and first arg number
372 and verify they are constants. */
373 while (TREE_CODE (format_num_expr
) == NOP_EXPR
374 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
375 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
376 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
378 while (TREE_CODE (first_arg_num_expr
) == NOP_EXPR
379 || TREE_CODE (first_arg_num_expr
) == CONVERT_EXPR
380 || TREE_CODE (first_arg_num_expr
) == NON_LVALUE_EXPR
)
381 first_arg_num_expr
= TREE_OPERAND (first_arg_num_expr
, 0);
383 if (TREE_CODE (format_num_expr
) != INTEGER_CST
384 || TREE_CODE (first_arg_num_expr
) != INTEGER_CST
)
386 error_with_decl (decl
,
387 "format string for `%s' has non-constant operand number");
391 format_num
= TREE_INT_CST_LOW (format_num_expr
);
392 first_arg_num
= TREE_INT_CST_LOW (first_arg_num_expr
);
393 if (first_arg_num
!= 0 && first_arg_num
<= format_num
)
395 error_with_decl (decl
,
396 "format string arg follows the args to be formatted, for `%s'");
400 /* If a parameter list is specified, verify that the format_num
401 argument is actually a string, in case the format attribute
403 argument
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
406 for (arg_num
= 1; ; ++arg_num
)
408 if (argument
== 0 || arg_num
== format_num
)
410 argument
= TREE_CHAIN (argument
);
413 || TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
414 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument
)))
417 error_with_decl (decl
,
418 "format string arg not a string type, for `%s'");
421 if (first_arg_num
!= 0)
423 /* Verify that first_arg_num points to the last arg, the ... */
425 arg_num
++, argument
= TREE_CHAIN (argument
);
426 if (arg_num
!= first_arg_num
)
428 error_with_decl (decl
,
429 "args to be formatted is not ..., for `%s'");
435 record_function_format (DECL_NAME (decl
), DECL_ASSEMBLER_NAME (decl
),
436 is_scan
, format_num
, first_arg_num
);
440 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
443 #define T_I &integer_type_node
444 #define T_L &long_integer_type_node
445 #define T_S &short_integer_type_node
446 #define T_UI &unsigned_type_node
447 #define T_UL &long_unsigned_type_node
448 #define T_US &short_unsigned_type_node
449 #define T_F &float_type_node
450 #define T_D &double_type_node
451 #define T_LD &long_double_type_node
452 #define T_C &char_type_node
453 #define T_V &void_type_node
454 #define T_W &wchar_type_node
455 #define T_ST &sizetype
460 /* Type of argument if no length modifier is used. */
462 /* Type of argument if length modifier for shortening is used.
463 If NULL, then this modifier is not allowed. */
465 /* Type of argument if length modifier `l' is used.
466 If NULL, then this modifier is not allowed. */
468 /* Type of argument if length modifier `L' is used.
469 If NULL, then this modifier is not allowed. */
471 /* List of other modifier characters allowed with these options. */
475 static format_char_info print_char_table
[] = {
476 { "di", 0, T_I
, T_I
, T_L
, NULL
, "-wp0 +" },
477 { "oxX", 0, T_UI
, T_UI
, T_UL
, NULL
, "-wp0#" },
478 { "u", 0, T_UI
, T_UI
, T_UL
, NULL
, "-wp0" },
479 /* Two GNU extensions. */
480 { "Z", 0, T_ST
, NULL
, NULL
, NULL
, "-wp0" },
481 { "m", 0, T_UI
, T_UI
, T_UL
, NULL
, "-wp" },
482 { "feEgG", 0, T_D
, NULL
, NULL
, T_LD
, "-wp0 +#" },
483 { "c", 0, T_I
, NULL
, T_W
, NULL
, "-w" },
484 { "C", 0, T_W
, NULL
, NULL
, NULL
, "-w" },
485 { "s", 1, T_C
, NULL
, T_W
, NULL
, "-wp" },
486 { "S", 1, T_W
, NULL
, NULL
, NULL
, "-wp" },
487 { "p", 1, T_V
, NULL
, NULL
, NULL
, "-w" },
488 { "n", 1, T_I
, T_S
, T_L
, NULL
, "" },
492 static format_char_info scan_char_table
[] = {
493 { "di", 1, T_I
, T_S
, T_L
, NULL
, "*" },
494 { "ouxX", 1, T_UI
, T_US
, T_UL
, NULL
, "*" },
495 { "efgEG", 1, T_F
, NULL
, T_D
, T_LD
, "*" },
496 { "sc", 1, T_C
, NULL
, T_W
, NULL
, "*a" },
497 { "[", 1, T_C
, NULL
, NULL
, NULL
, "*a" },
498 { "C", 1, T_W
, NULL
, NULL
, NULL
, "*" },
499 { "S", 1, T_W
, NULL
, NULL
, NULL
, "*" },
500 { "p", 2, T_V
, NULL
, NULL
, NULL
, "*" },
501 { "n", 1, T_I
, T_S
, T_L
, NULL
, "" },
505 typedef struct function_format_info
{
506 struct function_format_info
*next
; /* next structure on the list */
507 tree name
; /* identifier such as "printf" */
508 tree assembler_name
; /* optional mangled identifier (for C++) */
509 int is_scan
; /* TRUE if *scanf */
510 int format_num
; /* number of format argument */
511 int first_arg_num
; /* number of first arg (zero for varargs) */
512 } function_format_info
;
514 static function_format_info
*function_format_list
= NULL
;
516 static void check_format_info
PROTO((function_format_info
*, tree
));
518 /* Initialize the table of functions to perform format checking on.
519 The ANSI functions are always checked (whether <stdio.h> is
520 included or not), since it is common to call printf without
521 including <stdio.h>. There shouldn't be a problem with this,
522 since ANSI reserves these function names whether you include the
523 header file or not. In any case, the checking is harmless. */
526 init_function_format_info ()
528 record_function_format (get_identifier ("printf"), NULL_TREE
, 0, 1, 2);
529 record_function_format (get_identifier ("fprintf"), NULL_TREE
, 0, 2, 3);
530 record_function_format (get_identifier ("sprintf"), NULL_TREE
, 0, 2, 3);
531 record_function_format (get_identifier ("scanf"), NULL_TREE
, 1, 1, 2);
532 record_function_format (get_identifier ("fscanf"), NULL_TREE
, 1, 2, 3);
533 record_function_format (get_identifier ("sscanf"), NULL_TREE
, 1, 2, 3);
534 record_function_format (get_identifier ("vprintf"), NULL_TREE
, 0, 1, 0);
535 record_function_format (get_identifier ("vfprintf"), NULL_TREE
, 0, 2, 0);
536 record_function_format (get_identifier ("vsprintf"), NULL_TREE
, 0, 2, 0);
539 /* Record information for argument format checking. FUNCTION_IDENT is
540 the identifier node for the name of the function to check (its decl
541 need not exist yet). IS_SCAN is true for scanf-type format checking;
542 false indicates printf-style format checking. FORMAT_NUM is the number
543 of the argument which is the format control string (starting from 1).
544 FIRST_ARG_NUM is the number of the first actual argument to check
545 against teh format string, or zero if no checking is not be done
546 (e.g. for varargs such as vfprintf). */
549 record_function_format (name
, assembler_name
, is_scan
,
550 format_num
, first_arg_num
)
557 function_format_info
*info
;
559 /* Re-use existing structure if it's there. */
561 for (info
= function_format_list
; info
; info
= info
->next
)
563 if (info
->name
== name
&& info
->assembler_name
== assembler_name
)
568 info
= (function_format_info
*) xmalloc (sizeof (function_format_info
));
569 info
->next
= function_format_list
;
570 function_format_list
= info
;
573 info
->assembler_name
= assembler_name
;
576 info
->is_scan
= is_scan
;
577 info
->format_num
= format_num
;
578 info
->first_arg_num
= first_arg_num
;
581 static char tfaff
[] = "too few arguments for format";
583 /* Check the argument list of a call to printf, scanf, etc.
584 NAME is the function identifier.
585 ASSEMBLER_NAME is the function's assembler identifier.
586 (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
587 PARAMS is the list of argument values. */
590 check_function_format (name
, assembler_name
, params
)
595 function_format_info
*info
;
597 /* See if this function is a format function. */
598 for (info
= function_format_list
; info
; info
= info
->next
)
600 if (info
->assembler_name
601 ? (info
->assembler_name
== assembler_name
)
602 : (info
->name
== name
))
605 check_format_info (info
, params
);
611 /* Check the argument list of a call to printf, scanf, etc.
612 INFO points to the function_format_info structure.
613 PARAMS is the list of argument values. */
616 check_format_info (info
, params
)
617 function_format_info
*info
;
622 int suppressed
, wide
, precise
;
630 tree first_fillin_param
;
632 format_char_info
*fci
;
633 static char message
[132];
635 int has_operand_number
= 0;
637 /* Skip to format argument. If the argument isn't available, there's
638 no work for us to do; prototype checking will catch the problem. */
639 for (arg_num
= 1; ; ++arg_num
)
643 if (arg_num
== info
->format_num
)
645 params
= TREE_CHAIN (params
);
647 format_tree
= TREE_VALUE (params
);
648 params
= TREE_CHAIN (params
);
649 if (format_tree
== 0)
651 /* We can only check the format if it's a string constant. */
652 while (TREE_CODE (format_tree
) == NOP_EXPR
)
653 format_tree
= TREE_OPERAND (format_tree
, 0); /* strip coercion */
654 if (format_tree
== null_pointer_node
)
656 warning ("null format string");
659 if (TREE_CODE (format_tree
) != ADDR_EXPR
)
661 format_tree
= TREE_OPERAND (format_tree
, 0);
662 if (TREE_CODE (format_tree
) != STRING_CST
)
664 format_chars
= TREE_STRING_POINTER (format_tree
);
665 format_length
= TREE_STRING_LENGTH (format_tree
);
666 if (format_length
<= 1)
667 warning ("zero-length format string");
668 if (format_chars
[--format_length
] != 0)
670 warning ("unterminated format string");
673 /* Skip to first argument to check. */
674 while (arg_num
+ 1 < info
->first_arg_num
)
678 params
= TREE_CHAIN (params
);
682 first_fillin_param
= params
;
686 if (*format_chars
== 0)
688 if (format_chars
- TREE_STRING_POINTER (format_tree
) != format_length
)
689 warning ("embedded `\\0' in format");
690 if (info
->first_arg_num
!= 0 && params
!= 0 && ! has_operand_number
)
691 warning ("too many arguments for format");
694 if (*format_chars
++ != '%')
696 if (*format_chars
== 0)
698 warning ("spurious trailing `%%' in format");
701 if (*format_chars
== '%')
707 suppressed
= wide
= precise
= FALSE
;
710 suppressed
= *format_chars
== '*';
713 while (isdigit (*format_chars
))
718 /* See if we have a number followed by a dollar sign. If we do,
719 it is an operand number, so set PARAMS to that operand. */
720 if (*format_chars
>= '0' && *format_chars
<= '9')
722 char *p
= format_chars
;
724 while (*p
>= '0' && *p
++ <= '9')
729 int opnum
= atoi (format_chars
);
731 params
= first_fillin_param
;
732 format_chars
= p
+ 1;
733 has_operand_number
= 1;
735 for (i
= 1; i
< opnum
&& params
!= 0; i
++)
736 params
= TREE_CHAIN (params
);
738 if (opnum
== 0 || params
== 0)
740 warning ("operand number out of range in format");
746 while (*format_chars
!= 0 && index (" +#0-", *format_chars
) != 0)
748 if (index (flag_chars
, *format_chars
) != 0)
750 sprintf (message
, "repeated `%c' flag in format",
754 i
= strlen (flag_chars
);
755 flag_chars
[i
++] = *format_chars
++;
758 /* "If the space and + flags both appear,
759 the space flag will be ignored." */
760 if (index (flag_chars
, ' ') != 0
761 && index (flag_chars
, '+') != 0)
762 warning ("use of both ` ' and `+' flags in format");
763 /* "If the 0 and - flags both appear,
764 the 0 flag will be ignored." */
765 if (index (flag_chars
, '0') != 0
766 && index (flag_chars
, '-') != 0)
767 warning ("use of both `0' and `-' flags in format");
768 if (*format_chars
== '*')
771 /* "...a field width...may be indicated by an asterisk.
772 In this case, an int argument supplies the field width..." */
779 if (info
->first_arg_num
!= 0)
781 cur_param
= TREE_VALUE (params
);
782 params
= TREE_CHAIN (params
);
784 /* size_t is generally not valid here.
785 It will work on most machines, because size_t and int
786 have the same mode. But might as well warn anyway,
787 since it will fail on other machines. */
788 if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
789 != integer_type_node
)
791 (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
792 != unsigned_type_node
))
795 "field width is not type int (arg %d)",
803 while (isdigit (*format_chars
))
809 if (*format_chars
== '.')
813 if (*format_chars
!= '*' && !isdigit (*format_chars
))
814 warning ("`.' not followed by `*' or digit in format");
815 /* "...a...precision...may be indicated by an asterisk.
816 In this case, an int argument supplies the...precision." */
817 if (*format_chars
== '*')
819 if (info
->first_arg_num
!= 0)
827 cur_param
= TREE_VALUE (params
);
828 params
= TREE_CHAIN (params
);
830 if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
831 != integer_type_node
)
834 "field width is not type int (arg %d)",
842 while (isdigit (*format_chars
))
847 if (*format_chars
== 'h' || *format_chars
== 'l' || *format_chars
== 'L')
848 length_char
= *format_chars
++;
852 if (*format_chars
== 'a')
857 if (suppressed
&& length_char
!= 0)
860 "use of `*' and `%c' together in format",
864 format_char
= *format_chars
;
865 if (format_char
== 0)
867 warning ("conversion lacks type at end of format");
871 fci
= info
->is_scan
? scan_char_table
: print_char_table
;
872 while (fci
->format_chars
!= 0
873 && index (fci
->format_chars
, format_char
) == 0)
875 if (fci
->format_chars
== 0)
877 if (format_char
>= 040 && format_char
< 0177)
879 "unknown conversion type character `%c' in format",
883 "unknown conversion type character 0x%x in format",
888 if (wide
&& index (fci
->flag_chars
, 'w') == 0)
890 sprintf (message
, "width used with `%c' format",
894 if (precise
&& index (fci
->flag_chars
, 'p') == 0)
896 sprintf (message
, "precision used with `%c' format",
900 if (aflag
&& index (fci
->flag_chars
, 'a') == 0)
902 sprintf (message
, "`a' flag used with `%c' format",
906 if (info
->is_scan
&& format_char
== '[')
908 /* Skip over scan set, in case it happens to have '%' in it. */
909 if (*format_chars
== '^')
911 /* Find closing bracket; if one is hit immediately, then
912 it's part of the scan set rather than a terminator. */
913 if (*format_chars
== ']')
915 while (*format_chars
&& *format_chars
!= ']')
917 if (*format_chars
!= ']')
918 /* The end of the format string was reached. */
919 warning ("no closing `]' for `%%[' format");
923 if (index (fci
->flag_chars
, '*') == 0)
926 "suppression of `%c' conversion in format",
932 for (i
= 0; flag_chars
[i
] != 0; ++i
)
934 if (index (fci
->flag_chars
, flag_chars
[i
]) == 0)
936 sprintf (message
, "flag `%c' used with type `%c'",
937 flag_chars
[i
], format_char
);
941 if (precise
&& index (flag_chars
, '0') != 0
942 && (format_char
== 'd' || format_char
== 'i'
943 || format_char
== 'o' || format_char
== 'u'
944 || format_char
== 'x' || format_char
== 'x'))
947 "precision and `0' flag not both allowed with `%c' format",
953 default: wanted_type
= fci
->nolen
? *(fci
->nolen
) : 0; break;
954 case 'h': wanted_type
= fci
->hlen
? *(fci
->hlen
) : 0; break;
955 case 'l': wanted_type
= fci
->llen
? *(fci
->llen
) : 0; break;
956 case 'L': wanted_type
= fci
->bigllen
? *(fci
->bigllen
) : 0; break;
958 if (wanted_type
== 0)
961 "use of `%c' length character with `%c' type character",
962 length_char
, format_char
);
967 ** XXX -- should kvetch about stuff such as
975 /* Finally. . .check type of argument against desired type! */
976 if (info
->first_arg_num
== 0)
983 cur_param
= TREE_VALUE (params
);
984 params
= TREE_CHAIN (params
);
986 cur_type
= TREE_TYPE (cur_param
);
988 /* Check the types of any additional pointer arguments
989 that precede the "real" argument. */
990 for (i
= 0; i
< fci
->pointer_count
; ++i
)
992 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
994 cur_type
= TREE_TYPE (cur_type
);
998 "format argument is not a %s (arg %d)",
999 ((fci
->pointer_count
== 1) ? "pointer" : "pointer to a pointer"),
1005 /* Check the type of the "real" argument, if there's a type we want. */
1006 if (i
== fci
->pointer_count
&& wanted_type
!= 0
1007 && wanted_type
!= TYPE_MAIN_VARIANT (cur_type
)
1008 /* If we want `void *', allow any pointer type.
1009 (Anything else would already have got a warning.) */
1010 && ! (wanted_type
== void_type_node
1011 && fci
->pointer_count
> 0)
1012 /* Don't warn about differences merely in signedness. */
1013 && !(TREE_CODE (wanted_type
) == INTEGER_TYPE
1014 && TREE_CODE (TYPE_MAIN_VARIANT (cur_type
)) == INTEGER_TYPE
1015 && (TREE_UNSIGNED (wanted_type
)
1016 ? wanted_type
== (cur_type
= unsigned_type (cur_type
))
1017 : wanted_type
== (cur_type
= signed_type (cur_type
))))
1018 /* Likewise, "signed char", "unsigned char" and "char" are
1019 equivalent but the above test won't consider them equivalent. */
1020 && ! (wanted_type
== char_type_node
1021 && (TYPE_MAIN_VARIANT (cur_type
) == signed_char_type_node
1022 || TYPE_MAIN_VARIANT (cur_type
) == unsigned_char_type_node
)))
1024 register char *this;
1025 register char *that
;
1027 this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type
)));
1029 if (TREE_CODE (cur_type
) != ERROR_MARK
1030 && TYPE_NAME (cur_type
) != 0
1031 && TREE_CODE (cur_type
) != INTEGER_TYPE
1032 && !(TREE_CODE (cur_type
) == POINTER_TYPE
1033 && TREE_CODE (TREE_TYPE (cur_type
)) == INTEGER_TYPE
))
1035 if (TREE_CODE (TYPE_NAME (cur_type
)) == TYPE_DECL
1036 && DECL_NAME (TYPE_NAME (cur_type
)) != 0)
1037 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type
)));
1039 that
= IDENTIFIER_POINTER (TYPE_NAME (cur_type
));
1042 /* A nameless type can't possibly match what the format wants.
1043 So there will be a warning for it.
1044 Make up a string to describe vaguely what it is. */
1047 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
1050 that
= "different type";
1053 /* Make the warning better in case of mismatch of int vs long. */
1054 if (TREE_CODE (cur_type
) == INTEGER_TYPE
1055 && TREE_CODE (wanted_type
) == INTEGER_TYPE
1056 && TYPE_PRECISION (cur_type
) == TYPE_PRECISION (wanted_type
)
1057 && TYPE_NAME (cur_type
) != 0
1058 && TREE_CODE (TYPE_NAME (cur_type
)) == TYPE_DECL
)
1059 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type
)));
1061 if (strcmp (this, that
) != 0)
1063 sprintf (message
, "%s format, %s arg (arg %d)",
1064 this, that
, arg_num
);
1071 /* Print a warning if a constant expression had overflow in folding.
1072 Invoke this function on every expression that the language
1073 requires to be a constant expression.
1074 Note the ANSI C standard says it is erroneous for a
1075 constant expression to overflow. */
1078 constant_expression_warning (value
)
1081 if (TREE_CODE (value
) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (value
))
1083 pedwarn ("overflow in constant expression");
1086 /* Print a warning if an expression had overflow in folding.
1087 Invoke this function on every expression that
1088 (1) appears in the source code, and
1089 (2) might be a constant expression that overflowed, and
1090 (3) is not already checked by convert_and_check;
1091 however, do not invoke this function on operands of explicit casts. */
1094 overflow_warning (value
)
1097 if (TREE_CODE (value
) == INTEGER_CST
&& TREE_OVERFLOW (value
))
1099 TREE_OVERFLOW (value
) = 0;
1100 warning ("integer overflow in expression");
1104 /* Print a warning if a large constant is truncated to unsigned,
1105 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1106 Invoke this function on every expression that might be implicitly
1107 converted to an unsigned type. */
1110 unsigned_conversion_warning (result
, operand
)
1111 tree result
, operand
;
1113 if (TREE_CODE (operand
) == INTEGER_CST
1114 && TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
1115 && TREE_UNSIGNED (TREE_TYPE (result
))
1116 && !int_fits_type_p (operand
, TREE_TYPE (result
)))
1118 if (!int_fits_type_p (operand
, signed_type (TREE_TYPE (result
))))
1119 /* This detects cases like converting -129 or 256 to unsigned char. */
1120 warning ("large integer implicitly truncated to unsigned type");
1121 else if (warn_conversion
)
1122 warning ("negative integer implicitly converted to unsigned type");
1126 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1127 Invoke this function on every expression that is converted implicitly,
1128 i.e. because of language rules and not because of an explicit cast. */
1131 convert_and_check (type
, expr
)
1134 tree t
= convert (type
, expr
);
1135 if (TREE_CODE (t
) == INTEGER_CST
)
1137 if (TREE_OVERFLOW (t
))
1139 TREE_OVERFLOW (t
) = 0;
1141 /* No warning for converting 0x80000000 to int. */
1142 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
1143 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1144 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1145 /* If EXPR fits in the unsigned version of TYPE,
1146 don't warn unless pedantic. */
1148 || TREE_UNSIGNED (type
)
1149 || ! int_fits_type_p (expr
, unsigned_type (type
)))
1150 warning ("overflow in implicit constant conversion");
1153 unsigned_conversion_warning (t
, expr
);
1159 c_expand_expr_stmt (expr
)
1162 /* Do default conversion if safe and possibly important,
1163 in case within ({...}). */
1164 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
&& lvalue_p (expr
))
1165 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1166 expr
= default_conversion (expr
);
1168 if (TREE_TYPE (expr
) != error_mark_node
1169 && TYPE_SIZE (TREE_TYPE (expr
)) == 0
1170 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1171 error ("expression statement has incomplete type");
1173 expand_expr_stmt (expr
);
1176 /* Validate the expression after `case' and apply default promotions. */
1179 check_case_value (value
)
1182 if (value
== NULL_TREE
)
1185 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1186 STRIP_TYPE_NOPS (value
);
1188 if (TREE_CODE (value
) != INTEGER_CST
1189 && value
!= error_mark_node
)
1191 error ("case label does not reduce to an integer constant");
1192 value
= error_mark_node
;
1195 /* Promote char or short to int. */
1196 value
= default_conversion (value
);
1198 constant_expression_warning (value
);
1203 /* Return an integer type with BITS bits of precision,
1204 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1207 type_for_size (bits
, unsignedp
)
1211 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1212 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1214 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1215 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1217 if (bits
== TYPE_PRECISION (integer_type_node
))
1218 return unsignedp
? unsigned_type_node
: integer_type_node
;
1220 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1221 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1223 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1224 return (unsignedp
? long_long_unsigned_type_node
1225 : long_long_integer_type_node
);
1227 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1228 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1230 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1231 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1233 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1234 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1236 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1237 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1242 /* Return a data type that has machine mode MODE.
1243 If the mode is an integer,
1244 then UNSIGNEDP selects between signed and unsigned types. */
1247 type_for_mode (mode
, unsignedp
)
1248 enum machine_mode mode
;
1251 if (mode
== TYPE_MODE (signed_char_type_node
))
1252 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1254 if (mode
== TYPE_MODE (short_integer_type_node
))
1255 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1257 if (mode
== TYPE_MODE (integer_type_node
))
1258 return unsignedp
? unsigned_type_node
: integer_type_node
;
1260 if (mode
== TYPE_MODE (long_integer_type_node
))
1261 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1263 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1264 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1266 if (mode
== TYPE_MODE (intQI_type_node
))
1267 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1269 if (mode
== TYPE_MODE (intHI_type_node
))
1270 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1272 if (mode
== TYPE_MODE (intSI_type_node
))
1273 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1275 if (mode
== TYPE_MODE (intDI_type_node
))
1276 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1278 if (mode
== TYPE_MODE (float_type_node
))
1279 return float_type_node
;
1281 if (mode
== TYPE_MODE (double_type_node
))
1282 return double_type_node
;
1284 if (mode
== TYPE_MODE (long_double_type_node
))
1285 return long_double_type_node
;
1287 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1288 return build_pointer_type (char_type_node
);
1290 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1291 return build_pointer_type (integer_type_node
);
1296 /* Print an error message for invalid operands to arith operation CODE.
1297 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1300 binary_op_error (code
)
1301 enum tree_code code
;
1303 register char *opname
= "unknown";
1308 error ("invalid truth-value expression");
1312 opname
= "+"; break;
1314 opname
= "-"; break;
1316 opname
= "*"; break;
1318 opname
= "max"; break;
1320 opname
= "min"; break;
1322 opname
= "=="; break;
1324 opname
= "!="; break;
1326 opname
= "<="; break;
1328 opname
= ">="; break;
1330 opname
= "<"; break;
1332 opname
= ">"; break;
1334 opname
= "<<"; break;
1336 opname
= ">>"; break;
1337 case TRUNC_MOD_EXPR
:
1338 case FLOOR_MOD_EXPR
:
1339 opname
= "%"; break;
1340 case TRUNC_DIV_EXPR
:
1341 case FLOOR_DIV_EXPR
:
1342 opname
= "/"; break;
1344 opname
= "&"; break;
1346 opname
= "|"; break;
1347 case TRUTH_ANDIF_EXPR
:
1348 opname
= "&&"; break;
1349 case TRUTH_ORIF_EXPR
:
1350 opname
= "||"; break;
1352 opname
= "^"; break;
1355 opname
= "rotate"; break;
1357 error ("invalid operands to binary %s", opname
);
1360 /* Subroutine of build_binary_op, used for comparison operations.
1361 See if the operands have both been converted from subword integer types
1362 and, if so, perhaps change them both back to their original type.
1363 This function is also responsible for converting the two operands
1364 to the proper common type for comparison.
1366 The arguments of this function are all pointers to local variables
1367 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1368 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1370 If this function returns nonzero, it means that the comparison has
1371 a constant value. What this function returns is an expression for
1375 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
1376 tree
*op0_ptr
, *op1_ptr
;
1378 enum tree_code
*rescode_ptr
;
1381 tree op0
= *op0_ptr
;
1382 tree op1
= *op1_ptr
;
1383 int unsignedp0
, unsignedp1
;
1385 tree primop0
, primop1
;
1386 enum tree_code code
= *rescode_ptr
;
1388 /* Throw away any conversions to wider types
1389 already present in the operands. */
1391 primop0
= get_narrower (op0
, &unsignedp0
);
1392 primop1
= get_narrower (op1
, &unsignedp1
);
1394 /* Handle the case that OP0 does not *contain* a conversion
1395 but it *requires* conversion to FINAL_TYPE. */
1397 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
1398 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
1399 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
1400 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
1402 /* If one of the operands must be floated, we cannot optimize. */
1403 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
1404 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
1406 /* If first arg is constant, swap the args (changing operation
1407 so value is preserved), for canonicalization. */
1409 if (TREE_CONSTANT (primop0
))
1411 register tree tem
= primop0
;
1412 register int temi
= unsignedp0
;
1420 unsignedp0
= unsignedp1
;
1441 *rescode_ptr
= code
;
1444 /* If comparing an integer against a constant more bits wide,
1445 maybe we can deduce a value of 1 or 0 independent of the data.
1446 Or else truncate the constant now
1447 rather than extend the variable at run time.
1449 This is only interesting if the constant is the wider arg.
1450 Also, it is not safe if the constant is unsigned and the
1451 variable arg is signed, since in this case the variable
1452 would be sign-extended and then regarded as unsigned.
1453 Our technique fails in this case because the lowest/highest
1454 possible unsigned results don't follow naturally from the
1455 lowest/highest possible values of the variable operand.
1456 For just EQ_EXPR and NE_EXPR there is another technique that
1457 could be used: see if the constant can be faithfully represented
1458 in the other operand's type, by truncating it and reextending it
1459 and see if that preserves the constant's value. */
1461 if (!real1
&& !real2
1462 && TREE_CODE (primop1
) == INTEGER_CST
1463 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
1465 int min_gt
, max_gt
, min_lt
, max_lt
;
1466 tree maxval
, minval
;
1467 /* 1 if comparison is nominally unsigned. */
1468 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
1471 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
1473 maxval
= TYPE_MAX_VALUE (type
);
1474 minval
= TYPE_MIN_VALUE (type
);
1476 if (unsignedp
&& !unsignedp0
)
1477 *restype_ptr
= signed_type (*restype_ptr
);
1479 if (TREE_TYPE (primop1
) != *restype_ptr
)
1480 primop1
= convert (*restype_ptr
, primop1
);
1481 if (type
!= *restype_ptr
)
1483 minval
= convert (*restype_ptr
, minval
);
1484 maxval
= convert (*restype_ptr
, maxval
);
1487 if (unsignedp
&& unsignedp0
)
1489 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
1490 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
1491 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
1492 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
1496 min_gt
= INT_CST_LT (primop1
, minval
);
1497 max_gt
= INT_CST_LT (primop1
, maxval
);
1498 min_lt
= INT_CST_LT (minval
, primop1
);
1499 max_lt
= INT_CST_LT (maxval
, primop1
);
1503 /* This used to be a switch, but Genix compiler can't handle that. */
1504 if (code
== NE_EXPR
)
1506 if (max_lt
|| min_gt
)
1507 val
= integer_one_node
;
1509 else if (code
== EQ_EXPR
)
1511 if (max_lt
|| min_gt
)
1512 val
= integer_zero_node
;
1514 else if (code
== LT_EXPR
)
1517 val
= integer_one_node
;
1519 val
= integer_zero_node
;
1521 else if (code
== GT_EXPR
)
1524 val
= integer_one_node
;
1526 val
= integer_zero_node
;
1528 else if (code
== LE_EXPR
)
1531 val
= integer_one_node
;
1533 val
= integer_zero_node
;
1535 else if (code
== GE_EXPR
)
1538 val
= integer_one_node
;
1540 val
= integer_zero_node
;
1543 /* If primop0 was sign-extended and unsigned comparison specd,
1544 we did a signed comparison above using the signed type bounds.
1545 But the comparison we output must be unsigned.
1547 Also, for inequalities, VAL is no good; but if the signed
1548 comparison had *any* fixed result, it follows that the
1549 unsigned comparison just tests the sign in reverse
1550 (positive values are LE, negative ones GE).
1551 So we can generate an unsigned comparison
1552 against an extreme value of the signed type. */
1554 if (unsignedp
&& !unsignedp0
)
1561 primop1
= TYPE_MIN_VALUE (type
);
1567 primop1
= TYPE_MAX_VALUE (type
);
1571 type
= unsigned_type (type
);
1574 if (!max_gt
&& !unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1576 /* This is the case of (char)x >?< 0x80, which people used to use
1577 expecting old C compilers to change the 0x80 into -0x80. */
1578 if (val
== integer_zero_node
)
1579 warning ("comparison is always 0 due to limited range of data type");
1580 if (val
== integer_one_node
)
1581 warning ("comparison is always 1 due to limited range of data type");
1584 if (!min_lt
&& unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1586 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1587 if (val
== integer_zero_node
)
1588 warning ("comparison is always 0 due to limited range of data type");
1589 if (val
== integer_one_node
)
1590 warning ("comparison is always 1 due to limited range of data type");
1595 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1596 if (TREE_SIDE_EFFECTS (primop0
))
1597 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
1601 /* Value is not predetermined, but do the comparison
1602 in the type of the operand that is not constant.
1603 TYPE is already properly set. */
1605 else if (real1
&& real2
1606 && (TYPE_PRECISION (TREE_TYPE (primop0
))
1607 == TYPE_PRECISION (TREE_TYPE (primop1
))))
1608 type
= TREE_TYPE (primop0
);
1610 /* If args' natural types are both narrower than nominal type
1611 and both extend in the same manner, compare them
1612 in the type of the wider arg.
1613 Otherwise must actually extend both to the nominal
1614 common type lest different ways of extending
1616 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1618 else if (unsignedp0
== unsignedp1
&& real1
== real2
1619 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
1620 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
1622 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
1623 type
= signed_or_unsigned_type (unsignedp0
1624 || TREE_UNSIGNED (*restype_ptr
),
1626 /* Make sure shorter operand is extended the right way
1627 to match the longer operand. */
1628 primop0
= convert (signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
)),
1630 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
1635 /* Here we must do the comparison on the nominal type
1636 using the args exactly as we received them. */
1637 type
= *restype_ptr
;
1641 if (!real1
&& !real2
&& integer_zerop (primop1
)
1642 && TREE_UNSIGNED (TREE_TYPE (primop0
)))
1649 warning ("unsigned value >= 0 is always 1");
1650 value
= integer_one_node
;
1655 warning ("unsigned value < 0 is always 0");
1656 value
= integer_zero_node
;
1661 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1662 if (TREE_SIDE_EFFECTS (primop0
))
1663 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1670 *op0_ptr
= convert (type
, primop0
);
1671 *op1_ptr
= convert (type
, primop1
);
1673 *restype_ptr
= integer_type_node
;
1678 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1679 or validate its data type for an `if' or `while' statement or ?..: exp.
1681 This preparation consists of taking the ordinary
1682 representation of an expression expr and producing a valid tree
1683 boolean expression describing whether expr is nonzero. We could
1684 simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
1685 but we optimize comparisons, &&, ||, and !.
1687 The resulting type should always be `integer_type_node'. */
1690 truthvalue_conversion (expr
)
1693 register enum tree_code code
;
1695 if (TREE_CODE (expr
) == ERROR_MARK
)
1698 #if 0 /* This appears to be wrong for C++. */
1699 /* These really should return error_mark_node after 2.4 is stable.
1700 But not all callers handle ERROR_MARK properly. */
1701 switch (TREE_CODE (TREE_TYPE (expr
)))
1704 error ("struct type value used where scalar is required");
1705 return integer_zero_node
;
1708 error ("union type value used where scalar is required");
1709 return integer_zero_node
;
1712 error ("array type value used where scalar is required");
1713 return integer_zero_node
;
1720 switch (TREE_CODE (expr
))
1722 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1723 or comparison expressions as truth values at this level. */
1726 /* A one-bit unsigned bit-field is already acceptable. */
1727 if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr
, 1)))
1728 && TREE_UNSIGNED (TREE_OPERAND (expr
, 1)))
1734 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1735 or comparison expressions as truth values at this level. */
1737 if (integer_zerop (TREE_OPERAND (expr
, 1)))
1738 return build_unary_op (TRUTH_NOT_EXPR
, TREE_OPERAND (expr
, 0), 0);
1740 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
1741 case TRUTH_ANDIF_EXPR
:
1742 case TRUTH_ORIF_EXPR
:
1743 case TRUTH_AND_EXPR
:
1745 case TRUTH_XOR_EXPR
:
1750 return integer_zerop (expr
) ? integer_zero_node
: integer_one_node
;
1753 return real_zerop (expr
) ? integer_zero_node
: integer_one_node
;
1756 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
1757 return build (COMPOUND_EXPR
, integer_type_node
,
1758 TREE_OPERAND (expr
, 0), integer_one_node
);
1760 return integer_one_node
;
1763 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
1764 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
1765 truthvalue_conversion (TREE_OPERAND (expr
, 0)),
1766 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
1773 /* These don't change whether an object is non-zero or zero. */
1774 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
1778 /* These don't change whether an object is zero or non-zero, but
1779 we can't ignore them if their second arg has side-effects. */
1780 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
1781 return build (COMPOUND_EXPR
, integer_type_node
, TREE_OPERAND (expr
, 1),
1782 truthvalue_conversion (TREE_OPERAND (expr
, 0)));
1784 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
1787 /* Distribute the conversion into the arms of a COND_EXPR. */
1788 return fold (build (COND_EXPR
, integer_type_node
, TREE_OPERAND (expr
, 0),
1789 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
1790 truthvalue_conversion (TREE_OPERAND (expr
, 2))));
1793 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
1794 since that affects how `default_conversion' will behave. */
1795 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
1796 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
1798 /* fall through... */
1800 /* If this is widening the argument, we can ignore it. */
1801 if (TYPE_PRECISION (TREE_TYPE (expr
))
1802 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
1803 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
1807 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
1809 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
1810 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
1812 /* fall through... */
1814 /* This and MINUS_EXPR can be changed into a comparison of the
1816 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
1817 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
1818 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
1819 TREE_OPERAND (expr
, 1), 1);
1820 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
1821 fold (build1 (NOP_EXPR
,
1822 TREE_TYPE (TREE_OPERAND (expr
, 0)),
1823 TREE_OPERAND (expr
, 1))), 1);
1826 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
1827 warning ("suggest parentheses around assignment used as truth value");
1831 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
1832 return (build_binary_op
1833 ((TREE_SIDE_EFFECTS (expr
)
1834 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
1835 truthvalue_conversion (build_unary_op (REALPART_EXPR
, expr
, 0)),
1836 truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, expr
, 0)),
1839 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
1842 /* Read the rest of a #-directive from input stream FINPUT.
1843 In normal use, the directive name and the white space after it
1844 have already been read, so they won't be included in the result.
1845 We allow for the fact that the directive line may contain
1846 a newline embedded within a character or string literal which forms
1847 a part of the directive.
1849 The value is a string in a reusable buffer. It remains valid
1850 only until the next time this function is called. */
1853 get_directive_line (finput
)
1854 register FILE *finput
;
1856 static char *directive_buffer
= NULL
;
1857 static unsigned buffer_length
= 0;
1859 register char *buffer_limit
;
1860 register int looking_for
= 0;
1861 register int char_escaped
= 0;
1863 if (buffer_length
== 0)
1865 directive_buffer
= (char *)xmalloc (128);
1866 buffer_length
= 128;
1869 buffer_limit
= &directive_buffer
[buffer_length
];
1871 for (p
= directive_buffer
; ; )
1875 /* Make buffer bigger if it is full. */
1876 if (p
>= buffer_limit
)
1878 register unsigned bytes_used
= (p
- directive_buffer
);
1882 = (char *)xrealloc (directive_buffer
, buffer_length
);
1883 p
= &directive_buffer
[bytes_used
];
1884 buffer_limit
= &directive_buffer
[buffer_length
];
1889 /* Discard initial whitespace. */
1890 if ((c
== ' ' || c
== '\t') && p
== directive_buffer
)
1893 /* Detect the end of the directive. */
1894 if (c
== '\n' && looking_for
== 0)
1903 return directive_buffer
;
1905 /* Handle string and character constant syntax. */
1908 if (looking_for
== c
&& !char_escaped
)
1909 looking_for
= 0; /* Found terminator... stop looking. */
1912 if (c
== '\'' || c
== '"')
1913 looking_for
= c
; /* Don't stop buffering until we see another
1914 another one of these (or an EOF). */
1916 /* Handle backslash. */
1917 char_escaped
= (c
== '\\' && ! char_escaped
);
1921 /* Make a variant type in the proper way for C/C++, propagating qualifiers
1922 down to the element type of an array. */
1925 c_build_type_variant (type
, constp
, volatilep
)
1927 int constp
, volatilep
;
1929 if (TREE_CODE (type
) == ARRAY_TYPE
)
1931 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
1933 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
1934 type
= build_array_type (c_build_type_variant (TREE_TYPE (type
),
1936 TYPE_DOMAIN (type
));
1937 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
1940 return build_type_variant (type
, constp
, volatilep
);