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,
70 or if we want to give warnings for large objects, make a bigger one. */
71 vlen
= strlen (value
) + 1;
72 type
= char_array_type_node
;
73 if (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TREE_TYPE (type
))) < vlen
75 type
= build_array_type (char_type_node
,
76 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
;
209 tree a
, name
, args
, type
, new_attr
;
211 type
= TREE_TYPE (decl
);
213 new_attr
= TYPE_ATTRIBUTES (type
);
215 for (a
= attributes
; a
; a
= TREE_CHAIN (a
))
216 if (!(name
= TREE_VALUE (a
)))
218 else if (name
== get_identifier ("packed"))
220 if (TREE_CODE (decl
) == FIELD_DECL
)
221 DECL_PACKED (decl
) = 1;
222 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
223 used for DECL_REGISTER. It wouldn't mean anything anyway. */
225 warning_with_decl (decl
, "`packed' attribute ignore");
228 else if (TREE_VALUE (a
) == get_identifier ("noreturn")
229 || TREE_VALUE (a
) == get_identifier ("volatile"))
231 if (TREE_CODE (decl
) == FUNCTION_DECL
)
232 TREE_THIS_VOLATILE (decl
) = 1;
233 else if (TREE_CODE (type
) == POINTER_TYPE
234 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
235 TREE_TYPE (decl
) = type
237 (build_type_variant (TREE_TYPE (type
),
238 TREE_READONLY (TREE_TYPE (type
)), 1));
240 warning_with_decl (decl
, "`%s' attribute ignored",
241 IDENTIFIER_POINTER (TREE_VALUE (a
)));
243 else if (TREE_VALUE (a
) == get_identifier ("const"))
245 if (TREE_CODE (decl
) == FUNCTION_DECL
)
246 TREE_READONLY (decl
) = 1;
247 else if (TREE_CODE (type
) == POINTER_TYPE
248 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
249 TREE_TYPE (decl
) = type
251 (build_type_variant (TREE_TYPE (type
), 1,
252 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
254 warning_with_decl (decl
, "`const' attribute ignored");
256 else if (TREE_VALUE (a
) == get_identifier ("transparent_union"))
258 if (TREE_CODE (decl
) == PARM_DECL
259 && TREE_CODE (type
) == UNION_TYPE
260 && TYPE_MODE (type
) == DECL_MODE (TYPE_FIELDS (type
)))
261 DECL_TRANSPARENT_UNION (decl
) = 1;
262 else if (TREE_CODE (decl
) == TYPE_DECL
263 && TREE_CODE (type
) == UNION_TYPE
264 && TYPE_MODE (type
) == DECL_MODE (TYPE_FIELDS (type
)))
265 TYPE_TRANSPARENT_UNION (type
) = 1;
267 warning_with_decl (decl
, "`transparent_union' attribute ignored");
269 else if (TREE_CODE (name
) != TREE_LIST
)
271 #ifdef VALID_MACHINE_ATTRIBUTE
272 if (VALID_MACHINE_ATTRIBUTE (type
, new_attr
, name
))
274 register tree atlist
;
276 for (atlist
= new_attr
; atlist
; atlist
= TREE_CHAIN (atlist
))
277 if (TREE_VALUE (atlist
) == name
)
280 new_attr
= tree_cons (NULL_TREE
, name
, new_attr
);
285 warning ("`%s' attribute directive ignored",
286 IDENTIFIER_POINTER (name
));
288 else if ( args
= TREE_CHAIN(name
),
289 !strcmp (IDENTIFIER_POINTER (name
= TREE_PURPOSE (name
)), "mode")
290 && list_length (args
) == 1
291 && TREE_CODE (TREE_VALUE (args
)) == IDENTIFIER_NODE
)
295 = IDENTIFIER_POINTER (TREE_VALUE (args
));
297 /* Give this decl a type with the specified mode. */
298 for (i
= 0; i
< NUM_MACHINE_MODES
; i
++)
299 if (!strcmp (specified_name
, GET_MODE_NAME (i
)))
302 = type_for_mode (i
, TREE_UNSIGNED (type
));
305 TREE_TYPE (decl
) = type
= typefm
;
306 DECL_SIZE (decl
) = 0;
307 layout_decl (decl
, 0);
310 error ("no data type for mode `%s'", specified_name
);
313 if (i
== NUM_MACHINE_MODES
)
314 error_with_decl (decl
, "unknown machine mode `%s'", specified_name
);
316 else if (!strcmp (IDENTIFIER_POINTER (name
), "section")
317 && list_length (args
) == 1
318 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
320 #ifdef ASM_OUTPUT_SECTION_NAME
321 if (TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
323 if (TREE_CODE (decl
) == VAR_DECL
&& current_function_decl
!= NULL_TREE
)
324 error_with_decl (decl
,
325 "section attribute cannot be specified for local variables");
326 /* The decl may have already been given a section attribute from
327 a previous declaration. Ensure they match. */
328 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
329 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
330 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
331 error_with_decl (decl
,
332 "section of `%s' conflicts with previous declaration");
334 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
337 error_with_decl (decl
,
338 "section attribute not allowed for `%s'");
340 error_with_decl (decl
, "section attributes are not supported for this target");
343 else if (!strcmp (IDENTIFIER_POINTER (name
), "aligned")
344 && list_length (args
) == 1
345 && TREE_CODE (TREE_VALUE (args
)) == INTEGER_CST
)
347 tree align_expr
= TREE_VALUE (args
);
350 /* Strip any NOPs of any kind. */
351 while (TREE_CODE (align_expr
) == NOP_EXPR
352 || TREE_CODE (align_expr
) == CONVERT_EXPR
353 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
354 align_expr
= TREE_OPERAND (align_expr
, 0);
356 if (TREE_CODE (align_expr
) != INTEGER_CST
)
358 error_with_decl (decl
,
359 "requested alignment of `%s' is not a constant");
363 align
= TREE_INT_CST_LOW (align_expr
) * BITS_PER_UNIT
;
365 if (exact_log2 (align
) == -1)
366 error_with_decl (decl
,
367 "requested alignment of `%s' is not a power of 2");
368 else if (TREE_CODE (decl
) != VAR_DECL
369 && TREE_CODE (decl
) != FIELD_DECL
)
370 error_with_decl (decl
,
371 "alignment specified for `%s'");
373 DECL_ALIGN (decl
) = align
;
375 else if (!strcmp (IDENTIFIER_POINTER (name
), "format")
376 && list_length (args
) == 3
377 && TREE_CODE (TREE_VALUE (args
)) == IDENTIFIER_NODE
378 && TREE_CODE (TREE_VALUE (TREE_CHAIN (args
))) == INTEGER_CST
379 && TREE_CODE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args
)))) == INTEGER_CST
)
381 tree format_type
= TREE_VALUE (args
);
382 tree format_num_expr
= TREE_VALUE (TREE_CHAIN (args
));
383 tree first_arg_num_expr
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args
)));
390 if (TREE_CODE (decl
) != FUNCTION_DECL
)
392 error_with_decl (decl
,
393 "argument format specified for non-function `%s'");
397 if (!strcmp (IDENTIFIER_POINTER (format_type
), "printf"))
399 else if (!strcmp (IDENTIFIER_POINTER (format_type
), "scanf"))
403 error_with_decl (decl
, "unrecognized format specifier for `%s'");
407 /* Strip any conversions from the string index and first arg number
408 and verify they are constants. */
409 while (TREE_CODE (format_num_expr
) == NOP_EXPR
410 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
411 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
412 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
414 while (TREE_CODE (first_arg_num_expr
) == NOP_EXPR
415 || TREE_CODE (first_arg_num_expr
) == CONVERT_EXPR
416 || TREE_CODE (first_arg_num_expr
) == NON_LVALUE_EXPR
)
417 first_arg_num_expr
= TREE_OPERAND (first_arg_num_expr
, 0);
419 if (TREE_CODE (format_num_expr
) != INTEGER_CST
420 || TREE_CODE (first_arg_num_expr
) != INTEGER_CST
)
422 error_with_decl (decl
,
423 "format string for `%s' has non-constant operand number");
427 format_num
= TREE_INT_CST_LOW (format_num_expr
);
428 first_arg_num
= TREE_INT_CST_LOW (first_arg_num_expr
);
429 if (first_arg_num
!= 0 && first_arg_num
<= format_num
)
431 error_with_decl (decl
,
432 "format string arg follows the args to be formatted, for `%s'");
436 /* If a parameter list is specified, verify that the format_num
437 argument is actually a string, in case the format attribute
439 argument
= TYPE_ARG_TYPES (type
);
442 for (arg_num
= 1; ; ++arg_num
)
444 if (argument
== 0 || arg_num
== format_num
)
446 argument
= TREE_CHAIN (argument
);
449 || TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
450 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument
)))
453 error_with_decl (decl
,
454 "format string arg not a string type, for `%s'");
457 if (first_arg_num
!= 0)
459 /* Verify that first_arg_num points to the last arg, the ... */
461 arg_num
++, argument
= TREE_CHAIN (argument
);
462 if (arg_num
!= first_arg_num
)
464 error_with_decl (decl
,
465 "args to be formatted is not ..., for `%s'");
471 record_function_format (DECL_NAME (decl
), DECL_ASSEMBLER_NAME (decl
),
472 is_scan
, format_num
, first_arg_num
);
475 warning ("`%s' attribute directive ignored",
476 IDENTIFIER_POINTER (name
));
478 TREE_TYPE (decl
) = build_type_attribute_variant (type
, new_attr
);
481 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
484 #define T_I &integer_type_node
485 #define T_L &long_integer_type_node
486 #define T_S &short_integer_type_node
487 #define T_UI &unsigned_type_node
488 #define T_UL &long_unsigned_type_node
489 #define T_US &short_unsigned_type_node
490 #define T_F &float_type_node
491 #define T_D &double_type_node
492 #define T_LD &long_double_type_node
493 #define T_C &char_type_node
494 #define T_V &void_type_node
495 #define T_W &wchar_type_node
496 #define T_ST &sizetype
501 /* Type of argument if no length modifier is used. */
503 /* Type of argument if length modifier for shortening is used.
504 If NULL, then this modifier is not allowed. */
506 /* Type of argument if length modifier `l' is used.
507 If NULL, then this modifier is not allowed. */
509 /* Type of argument if length modifier `L' is used.
510 If NULL, then this modifier is not allowed. */
512 /* List of other modifier characters allowed with these options. */
516 static format_char_info print_char_table
[] = {
517 { "di", 0, T_I
, T_I
, T_L
, NULL
, "-wp0 +" },
518 { "oxX", 0, T_UI
, T_UI
, T_UL
, NULL
, "-wp0#" },
519 { "u", 0, T_UI
, T_UI
, T_UL
, NULL
, "-wp0" },
520 /* Two GNU extensions. */
521 { "Z", 0, T_ST
, NULL
, NULL
, NULL
, "-wp0" },
522 { "m", 0, T_UI
, T_UI
, T_UL
, NULL
, "-wp" },
523 { "feEgG", 0, T_D
, NULL
, NULL
, T_LD
, "-wp0 +#" },
524 { "c", 0, T_I
, NULL
, T_W
, NULL
, "-w" },
525 { "C", 0, T_W
, NULL
, NULL
, NULL
, "-w" },
526 { "s", 1, T_C
, NULL
, T_W
, NULL
, "-wp" },
527 { "S", 1, T_W
, NULL
, NULL
, NULL
, "-wp" },
528 { "p", 1, T_V
, NULL
, NULL
, NULL
, "-w" },
529 { "n", 1, T_I
, T_S
, T_L
, NULL
, "" },
533 static format_char_info scan_char_table
[] = {
534 { "di", 1, T_I
, T_S
, T_L
, NULL
, "*" },
535 { "ouxX", 1, T_UI
, T_US
, T_UL
, NULL
, "*" },
536 { "efgEG", 1, T_F
, NULL
, T_D
, T_LD
, "*" },
537 { "sc", 1, T_C
, NULL
, T_W
, NULL
, "*a" },
538 { "[", 1, T_C
, NULL
, NULL
, NULL
, "*a" },
539 { "C", 1, T_W
, NULL
, NULL
, NULL
, "*" },
540 { "S", 1, T_W
, NULL
, NULL
, NULL
, "*" },
541 { "p", 2, T_V
, NULL
, NULL
, NULL
, "*" },
542 { "n", 1, T_I
, T_S
, T_L
, NULL
, "" },
546 typedef struct function_format_info
{
547 struct function_format_info
*next
; /* next structure on the list */
548 tree name
; /* identifier such as "printf" */
549 tree assembler_name
; /* optional mangled identifier (for C++) */
550 int is_scan
; /* TRUE if *scanf */
551 int format_num
; /* number of format argument */
552 int first_arg_num
; /* number of first arg (zero for varargs) */
553 } function_format_info
;
555 static function_format_info
*function_format_list
= NULL
;
557 static void check_format_info
PROTO((function_format_info
*, tree
));
559 /* Initialize the table of functions to perform format checking on.
560 The ANSI functions are always checked (whether <stdio.h> is
561 included or not), since it is common to call printf without
562 including <stdio.h>. There shouldn't be a problem with this,
563 since ANSI reserves these function names whether you include the
564 header file or not. In any case, the checking is harmless. */
567 init_function_format_info ()
569 record_function_format (get_identifier ("printf"), NULL_TREE
, 0, 1, 2);
570 record_function_format (get_identifier ("fprintf"), NULL_TREE
, 0, 2, 3);
571 record_function_format (get_identifier ("sprintf"), NULL_TREE
, 0, 2, 3);
572 record_function_format (get_identifier ("scanf"), NULL_TREE
, 1, 1, 2);
573 record_function_format (get_identifier ("fscanf"), NULL_TREE
, 1, 2, 3);
574 record_function_format (get_identifier ("sscanf"), NULL_TREE
, 1, 2, 3);
575 record_function_format (get_identifier ("vprintf"), NULL_TREE
, 0, 1, 0);
576 record_function_format (get_identifier ("vfprintf"), NULL_TREE
, 0, 2, 0);
577 record_function_format (get_identifier ("vsprintf"), NULL_TREE
, 0, 2, 0);
580 /* Record information for argument format checking. FUNCTION_IDENT is
581 the identifier node for the name of the function to check (its decl
582 need not exist yet). IS_SCAN is true for scanf-type format checking;
583 false indicates printf-style format checking. FORMAT_NUM is the number
584 of the argument which is the format control string (starting from 1).
585 FIRST_ARG_NUM is the number of the first actual argument to check
586 against teh format string, or zero if no checking is not be done
587 (e.g. for varargs such as vfprintf). */
590 record_function_format (name
, assembler_name
, is_scan
,
591 format_num
, first_arg_num
)
598 function_format_info
*info
;
600 /* Re-use existing structure if it's there. */
602 for (info
= function_format_list
; info
; info
= info
->next
)
604 if (info
->name
== name
&& info
->assembler_name
== assembler_name
)
609 info
= (function_format_info
*) xmalloc (sizeof (function_format_info
));
610 info
->next
= function_format_list
;
611 function_format_list
= info
;
614 info
->assembler_name
= assembler_name
;
617 info
->is_scan
= is_scan
;
618 info
->format_num
= format_num
;
619 info
->first_arg_num
= first_arg_num
;
622 static char tfaff
[] = "too few arguments for format";
624 /* Check the argument list of a call to printf, scanf, etc.
625 NAME is the function identifier.
626 ASSEMBLER_NAME is the function's assembler identifier.
627 (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
628 PARAMS is the list of argument values. */
631 check_function_format (name
, assembler_name
, params
)
636 function_format_info
*info
;
638 /* See if this function is a format function. */
639 for (info
= function_format_list
; info
; info
= info
->next
)
641 if (info
->assembler_name
642 ? (info
->assembler_name
== assembler_name
)
643 : (info
->name
== name
))
646 check_format_info (info
, params
);
652 /* Check the argument list of a call to printf, scanf, etc.
653 INFO points to the function_format_info structure.
654 PARAMS is the list of argument values. */
657 check_format_info (info
, params
)
658 function_format_info
*info
;
663 int suppressed
, wide
, precise
;
671 tree first_fillin_param
;
673 format_char_info
*fci
;
674 static char message
[132];
676 int has_operand_number
= 0;
678 /* Skip to format argument. If the argument isn't available, there's
679 no work for us to do; prototype checking will catch the problem. */
680 for (arg_num
= 1; ; ++arg_num
)
684 if (arg_num
== info
->format_num
)
686 params
= TREE_CHAIN (params
);
688 format_tree
= TREE_VALUE (params
);
689 params
= TREE_CHAIN (params
);
690 if (format_tree
== 0)
692 /* We can only check the format if it's a string constant. */
693 while (TREE_CODE (format_tree
) == NOP_EXPR
)
694 format_tree
= TREE_OPERAND (format_tree
, 0); /* strip coercion */
695 if (format_tree
== null_pointer_node
)
697 warning ("null format string");
700 if (TREE_CODE (format_tree
) != ADDR_EXPR
)
702 format_tree
= TREE_OPERAND (format_tree
, 0);
703 if (TREE_CODE (format_tree
) != STRING_CST
)
705 format_chars
= TREE_STRING_POINTER (format_tree
);
706 format_length
= TREE_STRING_LENGTH (format_tree
);
707 if (format_length
<= 1)
708 warning ("zero-length format string");
709 if (format_chars
[--format_length
] != 0)
711 warning ("unterminated format string");
714 /* Skip to first argument to check. */
715 while (arg_num
+ 1 < info
->first_arg_num
)
719 params
= TREE_CHAIN (params
);
723 first_fillin_param
= params
;
727 if (*format_chars
== 0)
729 if (format_chars
- TREE_STRING_POINTER (format_tree
) != format_length
)
730 warning ("embedded `\\0' in format");
731 if (info
->first_arg_num
!= 0 && params
!= 0 && ! has_operand_number
)
732 warning ("too many arguments for format");
735 if (*format_chars
++ != '%')
737 if (*format_chars
== 0)
739 warning ("spurious trailing `%%' in format");
742 if (*format_chars
== '%')
748 suppressed
= wide
= precise
= FALSE
;
751 suppressed
= *format_chars
== '*';
754 while (isdigit (*format_chars
))
759 /* See if we have a number followed by a dollar sign. If we do,
760 it is an operand number, so set PARAMS to that operand. */
761 if (*format_chars
>= '0' && *format_chars
<= '9')
763 char *p
= format_chars
;
765 while (*p
>= '0' && *p
++ <= '9')
770 int opnum
= atoi (format_chars
);
772 params
= first_fillin_param
;
773 format_chars
= p
+ 1;
774 has_operand_number
= 1;
776 for (i
= 1; i
< opnum
&& params
!= 0; i
++)
777 params
= TREE_CHAIN (params
);
779 if (opnum
== 0 || params
== 0)
781 warning ("operand number out of range in format");
787 while (*format_chars
!= 0 && index (" +#0-", *format_chars
) != 0)
789 if (index (flag_chars
, *format_chars
) != 0)
791 sprintf (message
, "repeated `%c' flag in format",
795 i
= strlen (flag_chars
);
796 flag_chars
[i
++] = *format_chars
++;
799 /* "If the space and + flags both appear,
800 the space flag will be ignored." */
801 if (index (flag_chars
, ' ') != 0
802 && index (flag_chars
, '+') != 0)
803 warning ("use of both ` ' and `+' flags in format");
804 /* "If the 0 and - flags both appear,
805 the 0 flag will be ignored." */
806 if (index (flag_chars
, '0') != 0
807 && index (flag_chars
, '-') != 0)
808 warning ("use of both `0' and `-' flags in format");
809 if (*format_chars
== '*')
812 /* "...a field width...may be indicated by an asterisk.
813 In this case, an int argument supplies the field width..." */
820 if (info
->first_arg_num
!= 0)
822 cur_param
= TREE_VALUE (params
);
823 params
= TREE_CHAIN (params
);
825 /* size_t is generally not valid here.
826 It will work on most machines, because size_t and int
827 have the same mode. But might as well warn anyway,
828 since it will fail on other machines. */
829 if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
830 != integer_type_node
)
832 (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
833 != unsigned_type_node
))
836 "field width is not type int (arg %d)",
844 while (isdigit (*format_chars
))
850 if (*format_chars
== '.')
854 if (*format_chars
!= '*' && !isdigit (*format_chars
))
855 warning ("`.' not followed by `*' or digit in format");
856 /* "...a...precision...may be indicated by an asterisk.
857 In this case, an int argument supplies the...precision." */
858 if (*format_chars
== '*')
860 if (info
->first_arg_num
!= 0)
868 cur_param
= TREE_VALUE (params
);
869 params
= TREE_CHAIN (params
);
871 if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
872 != integer_type_node
)
875 "field width is not type int (arg %d)",
883 while (isdigit (*format_chars
))
888 if (*format_chars
== 'h' || *format_chars
== 'l' || *format_chars
== 'L')
889 length_char
= *format_chars
++;
893 if (*format_chars
== 'a')
898 if (suppressed
&& length_char
!= 0)
901 "use of `*' and `%c' together in format",
905 format_char
= *format_chars
;
906 if (format_char
== 0)
908 warning ("conversion lacks type at end of format");
912 fci
= info
->is_scan
? scan_char_table
: print_char_table
;
913 while (fci
->format_chars
!= 0
914 && index (fci
->format_chars
, format_char
) == 0)
916 if (fci
->format_chars
== 0)
918 if (format_char
>= 040 && format_char
< 0177)
920 "unknown conversion type character `%c' in format",
924 "unknown conversion type character 0x%x in format",
929 if (wide
&& index (fci
->flag_chars
, 'w') == 0)
931 sprintf (message
, "width used with `%c' format",
935 if (precise
&& index (fci
->flag_chars
, 'p') == 0)
937 sprintf (message
, "precision used with `%c' format",
941 if (aflag
&& index (fci
->flag_chars
, 'a') == 0)
943 sprintf (message
, "`a' flag used with `%c' format",
947 if (info
->is_scan
&& format_char
== '[')
949 /* Skip over scan set, in case it happens to have '%' in it. */
950 if (*format_chars
== '^')
952 /* Find closing bracket; if one is hit immediately, then
953 it's part of the scan set rather than a terminator. */
954 if (*format_chars
== ']')
956 while (*format_chars
&& *format_chars
!= ']')
958 if (*format_chars
!= ']')
959 /* The end of the format string was reached. */
960 warning ("no closing `]' for `%%[' format");
964 if (index (fci
->flag_chars
, '*') == 0)
967 "suppression of `%c' conversion in format",
973 for (i
= 0; flag_chars
[i
] != 0; ++i
)
975 if (index (fci
->flag_chars
, flag_chars
[i
]) == 0)
977 sprintf (message
, "flag `%c' used with type `%c'",
978 flag_chars
[i
], format_char
);
982 if (precise
&& index (flag_chars
, '0') != 0
983 && (format_char
== 'd' || format_char
== 'i'
984 || format_char
== 'o' || format_char
== 'u'
985 || format_char
== 'x' || format_char
== 'x'))
988 "precision and `0' flag not both allowed with `%c' format",
994 default: wanted_type
= fci
->nolen
? *(fci
->nolen
) : 0; break;
995 case 'h': wanted_type
= fci
->hlen
? *(fci
->hlen
) : 0; break;
996 case 'l': wanted_type
= fci
->llen
? *(fci
->llen
) : 0; break;
997 case 'L': wanted_type
= fci
->bigllen
? *(fci
->bigllen
) : 0; break;
999 if (wanted_type
== 0)
1002 "use of `%c' length character with `%c' type character",
1003 length_char
, format_char
);
1008 ** XXX -- should kvetch about stuff such as
1012 ** scanf ("%d", &i);
1016 /* Finally. . .check type of argument against desired type! */
1017 if (info
->first_arg_num
== 0)
1024 cur_param
= TREE_VALUE (params
);
1025 params
= TREE_CHAIN (params
);
1027 cur_type
= TREE_TYPE (cur_param
);
1029 /* Check the types of any additional pointer arguments
1030 that precede the "real" argument. */
1031 for (i
= 0; i
< fci
->pointer_count
; ++i
)
1033 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
1035 cur_type
= TREE_TYPE (cur_type
);
1039 "format argument is not a %s (arg %d)",
1040 ((fci
->pointer_count
== 1) ? "pointer" : "pointer to a pointer"),
1046 /* Check the type of the "real" argument, if there's a type we want. */
1047 if (i
== fci
->pointer_count
&& wanted_type
!= 0
1048 && wanted_type
!= TYPE_MAIN_VARIANT (cur_type
)
1049 /* If we want `void *', allow any pointer type.
1050 (Anything else would already have got a warning.) */
1051 && ! (wanted_type
== void_type_node
1052 && fci
->pointer_count
> 0)
1053 /* Don't warn about differences merely in signedness. */
1054 && !(TREE_CODE (wanted_type
) == INTEGER_TYPE
1055 && TREE_CODE (TYPE_MAIN_VARIANT (cur_type
)) == INTEGER_TYPE
1056 && (TREE_UNSIGNED (wanted_type
)
1057 ? wanted_type
== (cur_type
= unsigned_type (cur_type
))
1058 : wanted_type
== (cur_type
= signed_type (cur_type
))))
1059 /* Likewise, "signed char", "unsigned char" and "char" are
1060 equivalent but the above test won't consider them equivalent. */
1061 && ! (wanted_type
== char_type_node
1062 && (TYPE_MAIN_VARIANT (cur_type
) == signed_char_type_node
1063 || TYPE_MAIN_VARIANT (cur_type
) == unsigned_char_type_node
)))
1065 register char *this;
1066 register char *that
;
1068 this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type
)));
1070 if (TREE_CODE (cur_type
) != ERROR_MARK
1071 && TYPE_NAME (cur_type
) != 0
1072 && TREE_CODE (cur_type
) != INTEGER_TYPE
1073 && !(TREE_CODE (cur_type
) == POINTER_TYPE
1074 && TREE_CODE (TREE_TYPE (cur_type
)) == INTEGER_TYPE
))
1076 if (TREE_CODE (TYPE_NAME (cur_type
)) == TYPE_DECL
1077 && DECL_NAME (TYPE_NAME (cur_type
)) != 0)
1078 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type
)));
1080 that
= IDENTIFIER_POINTER (TYPE_NAME (cur_type
));
1083 /* A nameless type can't possibly match what the format wants.
1084 So there will be a warning for it.
1085 Make up a string to describe vaguely what it is. */
1088 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
1091 that
= "different type";
1094 /* Make the warning better in case of mismatch of int vs long. */
1095 if (TREE_CODE (cur_type
) == INTEGER_TYPE
1096 && TREE_CODE (wanted_type
) == INTEGER_TYPE
1097 && TYPE_PRECISION (cur_type
) == TYPE_PRECISION (wanted_type
)
1098 && TYPE_NAME (cur_type
) != 0
1099 && TREE_CODE (TYPE_NAME (cur_type
)) == TYPE_DECL
)
1100 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type
)));
1102 if (strcmp (this, that
) != 0)
1104 sprintf (message
, "%s format, %s arg (arg %d)",
1105 this, that
, arg_num
);
1112 /* Print a warning if a constant expression had overflow in folding.
1113 Invoke this function on every expression that the language
1114 requires to be a constant expression.
1115 Note the ANSI C standard says it is erroneous for a
1116 constant expression to overflow. */
1119 constant_expression_warning (value
)
1122 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1123 || TREE_CODE (value
) == COMPLEX_CST
)
1124 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
1125 pedwarn ("overflow in constant expression");
1128 /* Print a warning if an expression had overflow in folding.
1129 Invoke this function on every expression that
1130 (1) appears in the source code, and
1131 (2) might be a constant expression that overflowed, and
1132 (3) is not already checked by convert_and_check;
1133 however, do not invoke this function on operands of explicit casts. */
1136 overflow_warning (value
)
1139 if ((TREE_CODE (value
) == INTEGER_CST
1140 || (TREE_CODE (value
) == COMPLEX_CST
1141 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
1142 && TREE_OVERFLOW (value
))
1144 TREE_OVERFLOW (value
) = 0;
1145 warning ("integer overflow in expression");
1147 else if ((TREE_CODE (value
) == REAL_CST
1148 || (TREE_CODE (value
) == COMPLEX_CST
1149 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
1150 && TREE_OVERFLOW (value
))
1152 TREE_OVERFLOW (value
) = 0;
1153 warning ("floating-pointer overflow in expression");
1157 /* Print a warning if a large constant is truncated to unsigned,
1158 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1159 Invoke this function on every expression that might be implicitly
1160 converted to an unsigned type. */
1163 unsigned_conversion_warning (result
, operand
)
1164 tree result
, operand
;
1166 if (TREE_CODE (operand
) == INTEGER_CST
1167 && TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
1168 && TREE_UNSIGNED (TREE_TYPE (result
))
1169 && !int_fits_type_p (operand
, TREE_TYPE (result
)))
1171 if (!int_fits_type_p (operand
, signed_type (TREE_TYPE (result
))))
1172 /* This detects cases like converting -129 or 256 to unsigned char. */
1173 warning ("large integer implicitly truncated to unsigned type");
1174 else if (warn_conversion
)
1175 warning ("negative integer implicitly converted to unsigned type");
1179 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1180 Invoke this function on every expression that is converted implicitly,
1181 i.e. because of language rules and not because of an explicit cast. */
1184 convert_and_check (type
, expr
)
1187 tree t
= convert (type
, expr
);
1188 if (TREE_CODE (t
) == INTEGER_CST
)
1190 if (TREE_OVERFLOW (t
))
1192 TREE_OVERFLOW (t
) = 0;
1194 /* No warning for converting 0x80000000 to int. */
1195 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
1196 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1197 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1198 /* If EXPR fits in the unsigned version of TYPE,
1199 don't warn unless pedantic. */
1201 || TREE_UNSIGNED (type
)
1202 || ! int_fits_type_p (expr
, unsigned_type (type
)))
1203 warning ("overflow in implicit constant conversion");
1206 unsigned_conversion_warning (t
, expr
);
1212 c_expand_expr_stmt (expr
)
1215 /* Do default conversion if safe and possibly important,
1216 in case within ({...}). */
1217 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
&& lvalue_p (expr
))
1218 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1219 expr
= default_conversion (expr
);
1221 if (TREE_TYPE (expr
) != error_mark_node
1222 && TYPE_SIZE (TREE_TYPE (expr
)) == 0
1223 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1224 error ("expression statement has incomplete type");
1226 expand_expr_stmt (expr
);
1229 /* Validate the expression after `case' and apply default promotions. */
1232 check_case_value (value
)
1235 if (value
== NULL_TREE
)
1238 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1239 STRIP_TYPE_NOPS (value
);
1241 if (TREE_CODE (value
) != INTEGER_CST
1242 && value
!= error_mark_node
)
1244 error ("case label does not reduce to an integer constant");
1245 value
= error_mark_node
;
1248 /* Promote char or short to int. */
1249 value
= default_conversion (value
);
1251 constant_expression_warning (value
);
1256 /* Return an integer type with BITS bits of precision,
1257 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1260 type_for_size (bits
, unsignedp
)
1264 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1265 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1267 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1268 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1270 if (bits
== TYPE_PRECISION (integer_type_node
))
1271 return unsignedp
? unsigned_type_node
: integer_type_node
;
1273 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1274 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1276 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1277 return (unsignedp
? long_long_unsigned_type_node
1278 : long_long_integer_type_node
);
1280 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1281 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1283 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1284 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1286 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1287 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1289 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1290 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1295 /* Return a data type that has machine mode MODE.
1296 If the mode is an integer,
1297 then UNSIGNEDP selects between signed and unsigned types. */
1300 type_for_mode (mode
, unsignedp
)
1301 enum machine_mode mode
;
1304 if (mode
== TYPE_MODE (signed_char_type_node
))
1305 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1307 if (mode
== TYPE_MODE (short_integer_type_node
))
1308 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1310 if (mode
== TYPE_MODE (integer_type_node
))
1311 return unsignedp
? unsigned_type_node
: integer_type_node
;
1313 if (mode
== TYPE_MODE (long_integer_type_node
))
1314 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1316 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1317 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1319 if (mode
== TYPE_MODE (intQI_type_node
))
1320 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1322 if (mode
== TYPE_MODE (intHI_type_node
))
1323 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1325 if (mode
== TYPE_MODE (intSI_type_node
))
1326 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1328 if (mode
== TYPE_MODE (intDI_type_node
))
1329 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1331 if (mode
== TYPE_MODE (float_type_node
))
1332 return float_type_node
;
1334 if (mode
== TYPE_MODE (double_type_node
))
1335 return double_type_node
;
1337 if (mode
== TYPE_MODE (long_double_type_node
))
1338 return long_double_type_node
;
1340 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1341 return build_pointer_type (char_type_node
);
1343 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1344 return build_pointer_type (integer_type_node
);
1349 /* Print an error message for invalid operands to arith operation CODE.
1350 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1353 binary_op_error (code
)
1354 enum tree_code code
;
1356 register char *opname
= "unknown";
1361 error ("invalid truth-value expression");
1365 opname
= "+"; break;
1367 opname
= "-"; break;
1369 opname
= "*"; break;
1371 opname
= "max"; break;
1373 opname
= "min"; break;
1375 opname
= "=="; break;
1377 opname
= "!="; break;
1379 opname
= "<="; break;
1381 opname
= ">="; break;
1383 opname
= "<"; break;
1385 opname
= ">"; break;
1387 opname
= "<<"; break;
1389 opname
= ">>"; break;
1390 case TRUNC_MOD_EXPR
:
1391 case FLOOR_MOD_EXPR
:
1392 opname
= "%"; break;
1393 case TRUNC_DIV_EXPR
:
1394 case FLOOR_DIV_EXPR
:
1395 opname
= "/"; break;
1397 opname
= "&"; break;
1399 opname
= "|"; break;
1400 case TRUTH_ANDIF_EXPR
:
1401 opname
= "&&"; break;
1402 case TRUTH_ORIF_EXPR
:
1403 opname
= "||"; break;
1405 opname
= "^"; break;
1408 opname
= "rotate"; break;
1410 error ("invalid operands to binary %s", opname
);
1413 /* Subroutine of build_binary_op, used for comparison operations.
1414 See if the operands have both been converted from subword integer types
1415 and, if so, perhaps change them both back to their original type.
1416 This function is also responsible for converting the two operands
1417 to the proper common type for comparison.
1419 The arguments of this function are all pointers to local variables
1420 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1421 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1423 If this function returns nonzero, it means that the comparison has
1424 a constant value. What this function returns is an expression for
1428 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
1429 tree
*op0_ptr
, *op1_ptr
;
1431 enum tree_code
*rescode_ptr
;
1434 tree op0
= *op0_ptr
;
1435 tree op1
= *op1_ptr
;
1436 int unsignedp0
, unsignedp1
;
1438 tree primop0
, primop1
;
1439 enum tree_code code
= *rescode_ptr
;
1441 /* Throw away any conversions to wider types
1442 already present in the operands. */
1444 primop0
= get_narrower (op0
, &unsignedp0
);
1445 primop1
= get_narrower (op1
, &unsignedp1
);
1447 /* Handle the case that OP0 does not *contain* a conversion
1448 but it *requires* conversion to FINAL_TYPE. */
1450 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
1451 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
1452 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
1453 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
1455 /* If one of the operands must be floated, we cannot optimize. */
1456 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
1457 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
1459 /* If first arg is constant, swap the args (changing operation
1460 so value is preserved), for canonicalization. Don't do this if
1461 the second arg is 0. */
1463 if (TREE_CONSTANT (primop0
)
1464 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
1466 register tree tem
= primop0
;
1467 register int temi
= unsignedp0
;
1475 unsignedp0
= unsignedp1
;
1496 *rescode_ptr
= code
;
1499 /* If comparing an integer against a constant more bits wide,
1500 maybe we can deduce a value of 1 or 0 independent of the data.
1501 Or else truncate the constant now
1502 rather than extend the variable at run time.
1504 This is only interesting if the constant is the wider arg.
1505 Also, it is not safe if the constant is unsigned and the
1506 variable arg is signed, since in this case the variable
1507 would be sign-extended and then regarded as unsigned.
1508 Our technique fails in this case because the lowest/highest
1509 possible unsigned results don't follow naturally from the
1510 lowest/highest possible values of the variable operand.
1511 For just EQ_EXPR and NE_EXPR there is another technique that
1512 could be used: see if the constant can be faithfully represented
1513 in the other operand's type, by truncating it and reextending it
1514 and see if that preserves the constant's value. */
1516 if (!real1
&& !real2
1517 && TREE_CODE (primop1
) == INTEGER_CST
1518 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
1520 int min_gt
, max_gt
, min_lt
, max_lt
;
1521 tree maxval
, minval
;
1522 /* 1 if comparison is nominally unsigned. */
1523 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
1526 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
1528 maxval
= TYPE_MAX_VALUE (type
);
1529 minval
= TYPE_MIN_VALUE (type
);
1531 if (unsignedp
&& !unsignedp0
)
1532 *restype_ptr
= signed_type (*restype_ptr
);
1534 if (TREE_TYPE (primop1
) != *restype_ptr
)
1535 primop1
= convert (*restype_ptr
, primop1
);
1536 if (type
!= *restype_ptr
)
1538 minval
= convert (*restype_ptr
, minval
);
1539 maxval
= convert (*restype_ptr
, maxval
);
1542 if (unsignedp
&& unsignedp0
)
1544 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
1545 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
1546 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
1547 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
1551 min_gt
= INT_CST_LT (primop1
, minval
);
1552 max_gt
= INT_CST_LT (primop1
, maxval
);
1553 min_lt
= INT_CST_LT (minval
, primop1
);
1554 max_lt
= INT_CST_LT (maxval
, primop1
);
1558 /* This used to be a switch, but Genix compiler can't handle that. */
1559 if (code
== NE_EXPR
)
1561 if (max_lt
|| min_gt
)
1562 val
= integer_one_node
;
1564 else if (code
== EQ_EXPR
)
1566 if (max_lt
|| min_gt
)
1567 val
= integer_zero_node
;
1569 else if (code
== LT_EXPR
)
1572 val
= integer_one_node
;
1574 val
= integer_zero_node
;
1576 else if (code
== GT_EXPR
)
1579 val
= integer_one_node
;
1581 val
= integer_zero_node
;
1583 else if (code
== LE_EXPR
)
1586 val
= integer_one_node
;
1588 val
= integer_zero_node
;
1590 else if (code
== GE_EXPR
)
1593 val
= integer_one_node
;
1595 val
= integer_zero_node
;
1598 /* If primop0 was sign-extended and unsigned comparison specd,
1599 we did a signed comparison above using the signed type bounds.
1600 But the comparison we output must be unsigned.
1602 Also, for inequalities, VAL is no good; but if the signed
1603 comparison had *any* fixed result, it follows that the
1604 unsigned comparison just tests the sign in reverse
1605 (positive values are LE, negative ones GE).
1606 So we can generate an unsigned comparison
1607 against an extreme value of the signed type. */
1609 if (unsignedp
&& !unsignedp0
)
1616 primop1
= TYPE_MIN_VALUE (type
);
1622 primop1
= TYPE_MAX_VALUE (type
);
1626 type
= unsigned_type (type
);
1629 if (!max_gt
&& !unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1631 /* This is the case of (char)x >?< 0x80, which people used to use
1632 expecting old C compilers to change the 0x80 into -0x80. */
1633 if (val
== integer_zero_node
)
1634 warning ("comparison is always 0 due to limited range of data type");
1635 if (val
== integer_one_node
)
1636 warning ("comparison is always 1 due to limited range of data type");
1639 if (!min_lt
&& unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1641 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1642 if (val
== integer_zero_node
)
1643 warning ("comparison is always 0 due to limited range of data type");
1644 if (val
== integer_one_node
)
1645 warning ("comparison is always 1 due to limited range of data type");
1650 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1651 if (TREE_SIDE_EFFECTS (primop0
))
1652 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
1656 /* Value is not predetermined, but do the comparison
1657 in the type of the operand that is not constant.
1658 TYPE is already properly set. */
1660 else if (real1
&& real2
1661 && (TYPE_PRECISION (TREE_TYPE (primop0
))
1662 == TYPE_PRECISION (TREE_TYPE (primop1
))))
1663 type
= TREE_TYPE (primop0
);
1665 /* If args' natural types are both narrower than nominal type
1666 and both extend in the same manner, compare them
1667 in the type of the wider arg.
1668 Otherwise must actually extend both to the nominal
1669 common type lest different ways of extending
1671 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1673 else if (unsignedp0
== unsignedp1
&& real1
== real2
1674 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
1675 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
1677 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
1678 type
= signed_or_unsigned_type (unsignedp0
1679 || TREE_UNSIGNED (*restype_ptr
),
1681 /* Make sure shorter operand is extended the right way
1682 to match the longer operand. */
1683 primop0
= convert (signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
)),
1685 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
1690 /* Here we must do the comparison on the nominal type
1691 using the args exactly as we received them. */
1692 type
= *restype_ptr
;
1696 if (!real1
&& !real2
&& integer_zerop (primop1
)
1697 && TREE_UNSIGNED (*restype_ptr
))
1703 /* All unsigned values are >= 0, so we warn if extra warnings
1704 are requested. However, if OP0 is a constant that is
1705 >= 0, the signedness of the comparison isn't an issue,
1706 so suppress the warning. */
1708 && ! (TREE_CODE (primop0
) == INTEGER_CST
1709 && ! TREE_OVERFLOW (convert (signed_type (type
),
1711 warning ("unsigned value >= 0 is always 1");
1712 value
= integer_one_node
;
1717 && ! (TREE_CODE (primop0
) == INTEGER_CST
1718 && ! TREE_OVERFLOW (convert (signed_type (type
),
1720 warning ("unsigned value < 0 is always 0");
1721 value
= integer_zero_node
;
1726 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1727 if (TREE_SIDE_EFFECTS (primop0
))
1728 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1735 *op0_ptr
= convert (type
, primop0
);
1736 *op1_ptr
= convert (type
, primop1
);
1738 *restype_ptr
= integer_type_node
;
1743 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1744 or validate its data type for an `if' or `while' statement or ?..: exp.
1746 This preparation consists of taking the ordinary
1747 representation of an expression expr and producing a valid tree
1748 boolean expression describing whether expr is nonzero. We could
1749 simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
1750 but we optimize comparisons, &&, ||, and !.
1752 The resulting type should always be `integer_type_node'. */
1755 truthvalue_conversion (expr
)
1758 if (TREE_CODE (expr
) == ERROR_MARK
)
1761 #if 0 /* This appears to be wrong for C++. */
1762 /* These really should return error_mark_node after 2.4 is stable.
1763 But not all callers handle ERROR_MARK properly. */
1764 switch (TREE_CODE (TREE_TYPE (expr
)))
1767 error ("struct type value used where scalar is required");
1768 return integer_zero_node
;
1771 error ("union type value used where scalar is required");
1772 return integer_zero_node
;
1775 error ("array type value used where scalar is required");
1776 return integer_zero_node
;
1783 switch (TREE_CODE (expr
))
1785 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1786 or comparison expressions as truth values at this level. */
1789 /* A one-bit unsigned bit-field is already acceptable. */
1790 if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr
, 1)))
1791 && TREE_UNSIGNED (TREE_OPERAND (expr
, 1)))
1797 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1798 or comparison expressions as truth values at this level. */
1800 if (integer_zerop (TREE_OPERAND (expr
, 1)))
1801 return build_unary_op (TRUTH_NOT_EXPR
, TREE_OPERAND (expr
, 0), 0);
1803 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
1804 case TRUTH_ANDIF_EXPR
:
1805 case TRUTH_ORIF_EXPR
:
1806 case TRUTH_AND_EXPR
:
1808 case TRUTH_XOR_EXPR
:
1809 return convert (integer_type_node
, expr
);
1815 return integer_zerop (expr
) ? integer_zero_node
: integer_one_node
;
1818 return real_zerop (expr
) ? integer_zero_node
: integer_one_node
;
1821 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
1822 return build (COMPOUND_EXPR
, integer_type_node
,
1823 TREE_OPERAND (expr
, 0), integer_one_node
);
1825 return integer_one_node
;
1828 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
1829 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
1830 truthvalue_conversion (TREE_OPERAND (expr
, 0)),
1831 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
1838 /* These don't change whether an object is non-zero or zero. */
1839 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
1843 /* These don't change whether an object is zero or non-zero, but
1844 we can't ignore them if their second arg has side-effects. */
1845 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
1846 return build (COMPOUND_EXPR
, integer_type_node
, TREE_OPERAND (expr
, 1),
1847 truthvalue_conversion (TREE_OPERAND (expr
, 0)));
1849 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
1852 /* Distribute the conversion into the arms of a COND_EXPR. */
1853 return fold (build (COND_EXPR
, integer_type_node
, TREE_OPERAND (expr
, 0),
1854 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
1855 truthvalue_conversion (TREE_OPERAND (expr
, 2))));
1858 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
1859 since that affects how `default_conversion' will behave. */
1860 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
1861 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
1863 /* fall through... */
1865 /* If this is widening the argument, we can ignore it. */
1866 if (TYPE_PRECISION (TREE_TYPE (expr
))
1867 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
1868 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
1872 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
1874 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
1875 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
1877 /* fall through... */
1879 /* This and MINUS_EXPR can be changed into a comparison of the
1881 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
1882 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
1883 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
1884 TREE_OPERAND (expr
, 1), 1);
1885 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
1886 fold (build1 (NOP_EXPR
,
1887 TREE_TYPE (TREE_OPERAND (expr
, 0)),
1888 TREE_OPERAND (expr
, 1))), 1);
1891 if (integer_onep (TREE_OPERAND (expr
, 1)))
1895 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
1896 warning ("suggest parentheses around assignment used as truth value");
1900 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
1901 return (build_binary_op
1902 ((TREE_SIDE_EFFECTS (expr
)
1903 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
1904 truthvalue_conversion (build_unary_op (REALPART_EXPR
, expr
, 0)),
1905 truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, expr
, 0)),
1908 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
1911 /* Read the rest of a #-directive from input stream FINPUT.
1912 In normal use, the directive name and the white space after it
1913 have already been read, so they won't be included in the result.
1914 We allow for the fact that the directive line may contain
1915 a newline embedded within a character or string literal which forms
1916 a part of the directive.
1918 The value is a string in a reusable buffer. It remains valid
1919 only until the next time this function is called. */
1922 get_directive_line (finput
)
1923 register FILE *finput
;
1925 static char *directive_buffer
= NULL
;
1926 static unsigned buffer_length
= 0;
1928 register char *buffer_limit
;
1929 register int looking_for
= 0;
1930 register int char_escaped
= 0;
1932 if (buffer_length
== 0)
1934 directive_buffer
= (char *)xmalloc (128);
1935 buffer_length
= 128;
1938 buffer_limit
= &directive_buffer
[buffer_length
];
1940 for (p
= directive_buffer
; ; )
1944 /* Make buffer bigger if it is full. */
1945 if (p
>= buffer_limit
)
1947 register unsigned bytes_used
= (p
- directive_buffer
);
1951 = (char *)xrealloc (directive_buffer
, buffer_length
);
1952 p
= &directive_buffer
[bytes_used
];
1953 buffer_limit
= &directive_buffer
[buffer_length
];
1958 /* Discard initial whitespace. */
1959 if ((c
== ' ' || c
== '\t') && p
== directive_buffer
)
1962 /* Detect the end of the directive. */
1963 if (c
== '\n' && looking_for
== 0)
1972 return directive_buffer
;
1974 /* Handle string and character constant syntax. */
1977 if (looking_for
== c
&& !char_escaped
)
1978 looking_for
= 0; /* Found terminator... stop looking. */
1981 if (c
== '\'' || c
== '"')
1982 looking_for
= c
; /* Don't stop buffering until we see another
1983 another one of these (or an EOF). */
1985 /* Handle backslash. */
1986 char_escaped
= (c
== '\\' && ! char_escaped
);
1990 /* Make a variant type in the proper way for C/C++, propagating qualifiers
1991 down to the element type of an array. */
1994 c_build_type_variant (type
, constp
, volatilep
)
1996 int constp
, volatilep
;
1998 if (TREE_CODE (type
) == ARRAY_TYPE
)
2000 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
2002 push_obstacks (TYPE_OBSTACK (real_main_variant
),
2003 TYPE_OBSTACK (real_main_variant
));
2004 type
= build_array_type (c_build_type_variant (TREE_TYPE (type
),
2006 TYPE_DOMAIN (type
));
2008 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
2009 make a copy. (TYPE might have come from the hash table and
2010 REAL_MAIN_VARIANT might be in some function's obstack.) */
2012 if (TYPE_OBSTACK (type
) != TYPE_OBSTACK (real_main_variant
))
2014 type
= copy_node (type
);
2015 TYPE_POINTER_TO (type
) = TYPE_REFERENCE_TO (type
) = 0;
2018 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
2021 return build_type_variant (type
, constp
, volatilep
);