1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995 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 and PREFIX_ATTRIBUTES
203 and install them in DECL. PREFIX_ATTRIBUTES can appear after the
204 declaration specifiers and declaration modifiers but before the
205 declaration proper. */
208 decl_attributes (decl, attributes, prefix_attributes)
209 tree decl, attributes, prefix_attributes;
211 tree a, name, args, type;
213 type = TREE_TYPE (decl);
214 attributes = chainon (prefix_attributes, attributes);
216 for (a = attributes; a; a = TREE_CHAIN (a))
217 if (!(name = TREE_VALUE (a)))
219 else if (name == get_identifier ("packed")
220 || name == get_identifier ("__packed__"))
222 if (TREE_CODE (decl) == FIELD_DECL)
223 DECL_PACKED (decl) = 1;
224 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
225 used for DECL_REGISTER. It wouldn't mean anything anyway. */
227 warning_with_decl (decl, "`packed' attribute ignored");
229 else if (name == get_identifier ("noreturn")
230 || name == get_identifier ("__noreturn__")
231 || name == get_identifier ("volatile")
232 || name == get_identifier ("__volatile__"))
234 if (TREE_CODE (decl) == FUNCTION_DECL)
235 TREE_THIS_VOLATILE (decl) = 1;
236 else if (TREE_CODE (type) == POINTER_TYPE
237 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
238 TREE_TYPE (decl) = type
240 (build_type_variant (TREE_TYPE (type),
241 TREE_READONLY (TREE_TYPE (type)), 1));
243 warning_with_decl (decl,
244 (IDENTIFIER_POINTER (name)[0] == 'n'
245 || IDENTIFIER_POINTER (name)[2] == 'n')
246 ? "`noreturn' attribute ignored"
247 : "`volatile' attribute ignored");
249 else if (name == get_identifier ("const")
250 || name == get_identifier ("__const__"))
252 if (TREE_CODE (decl) == FUNCTION_DECL)
253 TREE_READONLY (decl) = 1;
254 else if (TREE_CODE (type) == POINTER_TYPE
255 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
256 TREE_TYPE (decl) = type
258 (build_type_variant (TREE_TYPE (type), 1,
259 TREE_THIS_VOLATILE (TREE_TYPE (type))));
261 warning_with_decl (decl, "`const' attribute ignored");
263 else if (name == get_identifier ("transparent_union")
264 || name == get_identifier ("__transparent_union__"))
266 if (TREE_CODE (decl) == PARM_DECL
267 && TREE_CODE (type) == UNION_TYPE
268 && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))
269 DECL_TRANSPARENT_UNION (decl) = 1;
270 else if (TREE_CODE (decl) == TYPE_DECL
271 && TREE_CODE (type) == UNION_TYPE
272 && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))
273 TYPE_TRANSPARENT_UNION (type) = 1;
275 warning_with_decl (decl, "`transparent_union' attribute ignored");
277 else if (name == get_identifier ("constructor")
278 || name == get_identifier ("__constructor__"))
280 if (TREE_CODE (decl) != FUNCTION_DECL
281 || TREE_CODE (TREE_TYPE (decl)) != FUNCTION_TYPE
282 || decl_function_context (decl))
284 error_with_decl (decl,
285 "`constructor' attribute meaningless for non-function %s");
288 DECL_STATIC_CONSTRUCTOR (decl) = 1;
290 else if (name == get_identifier ("destructor")
291 || name == get_identifier ("__destructor__"))
293 if (TREE_CODE (decl) != FUNCTION_DECL
294 || TREE_CODE (TREE_TYPE (decl)) != FUNCTION_TYPE
295 || decl_function_context (decl))
297 error_with_decl (decl,
298 "`destructor' attribute meaningless for non-function %s");
301 DECL_STATIC_DESTRUCTOR (decl) = 1;
303 else if ( args = TREE_CHAIN (name),
304 (!strcmp (IDENTIFIER_POINTER (name = TREE_PURPOSE (name)), "mode")
305 || !strcmp (IDENTIFIER_POINTER (name), "__mode__"))
306 && list_length (args) == 1
307 && TREE_CODE (TREE_VALUE (args)) == IDENTIFIER_NODE)
310 char *specified_name = IDENTIFIER_POINTER (TREE_VALUE (args));
311 enum machine_mode mode = VOIDmode;
314 /* Give this decl a type with the specified mode.
315 First check for the special modes. */
316 if (! strcmp (specified_name, "byte")
317 || ! strcmp (specified_name, "__byte__"))
319 else if (!strcmp (specified_name, "word")
320 || ! strcmp (specified_name, "__word__"))
322 else if (! strcmp (specified_name, "pointer")
323 || !strcmp (specified_name, "__pointer__"))
326 for (i = 0; i < NUM_MACHINE_MODES; i++)
327 if (!strcmp (specified_name, GET_MODE_NAME (i)))
328 mode = (enum machine_mode) i;
330 if (mode == VOIDmode)
331 error ("unknown machine mode `%s'", specified_name);
332 else if ((typefm = type_for_mode (mode, TREE_UNSIGNED (type))) == 0)
333 error ("no data type for mode `%s'", specified_name);
336 TREE_TYPE (decl) = type = typefm;
337 DECL_SIZE (decl) = 0;
338 layout_decl (decl, 0);
341 else if ((!strcmp (IDENTIFIER_POINTER (name), "section")
342 || !strcmp (IDENTIFIER_POINTER (name), "__section__"))
343 && list_length (args) == 1
344 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
346 #ifdef ASM_OUTPUT_SECTION_NAME
347 if (TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
349 if (TREE_CODE (decl) == VAR_DECL
350 && current_function_decl != NULL_TREE)
351 error_with_decl (decl,
352 "section attribute cannot be specified for local variables");
353 /* The decl may have already been given a section attribute from
354 a previous declaration. Ensure they match. */
355 else if (DECL_SECTION_NAME (decl) != NULL_TREE
356 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
357 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
358 error_with_decl (decl,
359 "section of `%s' conflicts with previous declaration");
361 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
364 error_with_decl (decl,
365 "section attribute not allowed for `%s'");
367 error_with_decl (decl, "section attributes are not supported for this target");
370 else if ((!strcmp (IDENTIFIER_POINTER (name), "aligned")
371 || !strcmp (IDENTIFIER_POINTER (name), "__aligned__"))
372 && list_length (args) == 1
373 && TREE_CODE (TREE_VALUE (args)) == INTEGER_CST)
375 tree align_expr = TREE_VALUE (args);
378 /* Strip any NOPs of any kind. */
379 while (TREE_CODE (align_expr) == NOP_EXPR
380 || TREE_CODE (align_expr) == CONVERT_EXPR
381 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
382 align_expr = TREE_OPERAND (align_expr, 0);
384 if (TREE_CODE (align_expr) != INTEGER_CST)
386 error_with_decl (decl,
387 "requested alignment of `%s' is not a constant");
391 align = TREE_INT_CST_LOW (align_expr) * BITS_PER_UNIT;
393 if (exact_log2 (align) == -1)
394 error_with_decl (decl,
395 "requested alignment of `%s' is not a power of 2");
396 else if (TREE_CODE (decl) == TYPE_DECL)
397 TYPE_ALIGN (TREE_TYPE (decl)) = align;
398 else if (TREE_CODE (decl) != VAR_DECL
399 && TREE_CODE (decl) != FIELD_DECL)
400 error_with_decl (decl,
401 "alignment may not be specified for `%s'");
403 DECL_ALIGN (decl) = align;
405 else if ((!strcmp (IDENTIFIER_POINTER (name), "format")
406 || !strcmp (IDENTIFIER_POINTER (name), "__format__"))
407 && list_length (args) == 3
408 && TREE_CODE (TREE_VALUE (args)) == IDENTIFIER_NODE
409 && TREE_CODE (TREE_VALUE (TREE_CHAIN (args))) == INTEGER_CST
410 && TREE_CODE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args))))
413 tree format_type = TREE_VALUE (args);
414 tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
415 tree first_arg_num_expr = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
422 if (TREE_CODE (decl) != FUNCTION_DECL)
424 error_with_decl (decl,
425 "argument format specified for non-function `%s'");
429 if (!strcmp (IDENTIFIER_POINTER (format_type), "printf")
430 || !strcmp (IDENTIFIER_POINTER (format_type), "__printf__"))
432 else if (!strcmp (IDENTIFIER_POINTER (format_type), "scanf")
433 || !strcmp (IDENTIFIER_POINTER (format_type), "__scanf__"))
437 error_with_decl (decl, "unrecognized format specifier for `%s'");
441 /* Strip any conversions from the string index and first arg number
442 and verify they are constants. */
443 while (TREE_CODE (format_num_expr) == NOP_EXPR
444 || TREE_CODE (format_num_expr) == CONVERT_EXPR
445 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
446 format_num_expr = TREE_OPERAND (format_num_expr, 0);
448 while (TREE_CODE (first_arg_num_expr) == NOP_EXPR
449 || TREE_CODE (first_arg_num_expr) == CONVERT_EXPR
450 || TREE_CODE (first_arg_num_expr) == NON_LVALUE_EXPR)
451 first_arg_num_expr = TREE_OPERAND (first_arg_num_expr, 0);
453 if (TREE_CODE (format_num_expr) != INTEGER_CST
454 || TREE_CODE (first_arg_num_expr) != INTEGER_CST)
456 error_with_decl (decl,
457 "format string for `%s' has non-constant operand number");
461 format_num = TREE_INT_CST_LOW (format_num_expr);
462 first_arg_num = TREE_INT_CST_LOW (first_arg_num_expr);
463 if (first_arg_num != 0 && first_arg_num <= format_num)
465 error_with_decl (decl,
466 "format string arg follows the args to be formatted, for `%s'");
470 /* If a parameter list is specified, verify that the format_num
471 argument is actually a string, in case the format attribute
473 argument = TYPE_ARG_TYPES (type);
476 for (arg_num = 1; ; ++arg_num)
478 if (argument == 0 || arg_num == format_num)
480 argument = TREE_CHAIN (argument);
483 || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
484 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
487 error_with_decl (decl,
488 "format string arg not a string type, for `%s'");
491 if (first_arg_num != 0)
493 /* Verify that first_arg_num points to the last arg, the ... */
495 arg_num++, argument = TREE_CHAIN (argument);
496 if (arg_num != first_arg_num)
498 error_with_decl (decl,
499 "args to be formatted is not ..., for `%s'");
505 record_function_format (DECL_NAME (decl), DECL_ASSEMBLER_NAME (decl),
506 is_scan, format_num, first_arg_num);
508 else if (valid_machine_attribute (name, decl, type))
511 warning ("`%s' attribute directive ignored",
512 IDENTIFIER_POINTER (name));
516 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
519 #define T_I &integer_type_node
520 #define T_L &long_integer_type_node
521 #define T_LL &long_long_integer_type_node
522 #define T_S &short_integer_type_node
523 #define T_UI &unsigned_type_node
524 #define T_UL &long_unsigned_type_node
525 #define T_ULL &long_long_unsigned_type_node
526 #define T_US &short_unsigned_type_node
527 #define T_F &float_type_node
528 #define T_D &double_type_node
529 #define T_LD &long_double_type_node
530 #define T_C &char_type_node
531 #define T_V &void_type_node
532 #define T_W &wchar_type_node
533 #define T_ST &sizetype
538 /* Type of argument if no length modifier is used. */
540 /* Type of argument if length modifier for shortening is used.
541 If NULL, then this modifier is not allowed. */
543 /* Type of argument if length modifier `l' is used.
544 If NULL, then this modifier is not allowed. */
546 /* Type of argument if length modifier `q' or `ll' is used.
547 If NULL, then this modifier is not allowed. */
549 /* Type of argument if length modifier `L' is used.
550 If NULL, then this modifier is not allowed. */
552 /* List of other modifier characters allowed with these options. */
556 static format_char_info print_char_table[] = {
557 { "di", 0, T_I, T_I, T_L, T_LL, T_LL, "-wp0 +" },
558 { "oxX", 0, T_UI, T_UI, T_UL, T_ULL, T_ULL, "-wp0#" },
559 { "u", 0, T_UI, T_UI, T_UL, T_ULL, T_ULL, "-wp0" },
560 /* Two GNU extensions. */
561 { "Z", 0, T_ST, NULL, NULL, NULL, NULL, "-wp0" },
562 { "m", 0, T_UI, T_UI, T_UL, NULL, NULL, "-wp" },
563 { "feEgG", 0, T_D, NULL, NULL, NULL, T_LD, "-wp0 +#" },
564 { "c", 0, T_I, NULL, T_W, NULL, NULL, "-w" },
565 { "C", 0, T_W, NULL, NULL, NULL, NULL, "-w" },
566 { "s", 1, T_C, NULL, T_W, NULL, NULL, "-wp" },
567 { "S", 1, T_W, NULL, NULL, NULL, NULL, "-wp" },
568 { "p", 1, T_V, NULL, NULL, NULL, NULL, "-w" },
569 { "n", 1, T_I, T_S, T_L, T_LL, NULL, "" },
573 static format_char_info scan_char_table[] = {
574 { "di", 1, T_I, T_S, T_L, T_LL, T_LL, "*" },
575 { "ouxX", 1, T_UI, T_US, T_UL, T_ULL, T_ULL, "*" },
576 { "efgEG", 1, T_F, NULL, T_D, NULL, T_LD, "*" },
577 { "sc", 1, T_C, NULL, T_W, NULL, NULL, "*a" },
578 { "[", 1, T_C, NULL, NULL, NULL, NULL, "*a" },
579 { "C", 1, T_W, NULL, NULL, NULL, NULL, "*" },
580 { "S", 1, T_W, NULL, NULL, NULL, NULL, "*" },
581 { "p", 2, T_V, NULL, NULL, NULL, NULL, "*" },
582 { "n", 1, T_I, T_S, T_L, T_LL, NULL, "" },
586 typedef struct function_format_info {
587 struct function_format_info *next; /* next structure on the list */
588 tree name; /* identifier such as "printf" */
589 tree assembler_name; /* optional mangled identifier (for C++) */
590 int is_scan; /* TRUE if *scanf */
591 int format_num; /* number of format argument */
592 int first_arg_num; /* number of first arg (zero for varargs) */
593 } function_format_info;
595 static function_format_info *function_format_list = NULL;
597 static void check_format_info PROTO((function_format_info *, tree));
599 /* Initialize the table of functions to perform format checking on.
600 The ANSI functions are always checked (whether <stdio.h> is
601 included or not), since it is common to call printf without
602 including <stdio.h>. There shouldn't be a problem with this,
603 since ANSI reserves these function names whether you include the
604 header file or not. In any case, the checking is harmless. */
607 init_function_format_info ()
609 record_function_format (get_identifier ("printf"), NULL_TREE, 0, 1, 2);
610 record_function_format (get_identifier ("fprintf"), NULL_TREE, 0, 2, 3);
611 record_function_format (get_identifier ("sprintf"), NULL_TREE, 0, 2, 3);
612 record_function_format (get_identifier ("scanf"), NULL_TREE, 1, 1, 2);
613 record_function_format (get_identifier ("fscanf"), NULL_TREE, 1, 2, 3);
614 record_function_format (get_identifier ("sscanf"), NULL_TREE, 1, 2, 3);
615 record_function_format (get_identifier ("vprintf"), NULL_TREE, 0, 1, 0);
616 record_function_format (get_identifier ("vfprintf"), NULL_TREE, 0, 2, 0);
617 record_function_format (get_identifier ("vsprintf"), NULL_TREE, 0, 2, 0);
620 /* Record information for argument format checking. FUNCTION_IDENT is
621 the identifier node for the name of the function to check (its decl
622 need not exist yet). IS_SCAN is true for scanf-type format checking;
623 false indicates printf-style format checking. FORMAT_NUM is the number
624 of the argument which is the format control string (starting from 1).
625 FIRST_ARG_NUM is the number of the first actual argument to check
626 against teh format string, or zero if no checking is not be done
627 (e.g. for varargs such as vfprintf). */
630 record_function_format (name, assembler_name, is_scan,
631 format_num, first_arg_num)
638 function_format_info *info;
640 /* Re-use existing structure if it's there. */
642 for (info = function_format_list; info; info = info->next)
644 if (info->name == name && info->assembler_name == assembler_name)
649 info = (function_format_info *) xmalloc (sizeof (function_format_info));
650 info->next = function_format_list;
651 function_format_list = info;
654 info->assembler_name = assembler_name;
657 info->is_scan = is_scan;
658 info->format_num = format_num;
659 info->first_arg_num = first_arg_num;
662 static char tfaff[] = "too few arguments for format";
664 /* Check the argument list of a call to printf, scanf, etc.
665 NAME is the function identifier.
666 ASSEMBLER_NAME is the function's assembler identifier.
667 (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
668 PARAMS is the list of argument values. */
671 check_function_format (name, assembler_name, params)
676 function_format_info *info;
678 /* See if this function is a format function. */
679 for (info = function_format_list; info; info = info->next)
681 if (info->assembler_name
682 ? (info->assembler_name == assembler_name)
683 : (info->name == name))
686 check_format_info (info, params);
692 /* Check the argument list of a call to printf, scanf, etc.
693 INFO points to the function_format_info structure.
694 PARAMS is the list of argument values. */
697 check_format_info (info, params)
698 function_format_info *info;
703 int suppressed, wide, precise;
711 tree first_fillin_param;
713 format_char_info *fci;
714 static char message[132];
716 int has_operand_number = 0;
718 /* Skip to format argument. If the argument isn't available, there's
719 no work for us to do; prototype checking will catch the problem. */
720 for (arg_num = 1; ; ++arg_num)
724 if (arg_num == info->format_num)
726 params = TREE_CHAIN (params);
728 format_tree = TREE_VALUE (params);
729 params = TREE_CHAIN (params);
730 if (format_tree == 0)
732 /* We can only check the format if it's a string constant. */
733 while (TREE_CODE (format_tree) == NOP_EXPR)
734 format_tree = TREE_OPERAND (format_tree, 0); /* strip coercion */
735 if (format_tree == null_pointer_node)
737 warning ("null format string");
740 if (TREE_CODE (format_tree) != ADDR_EXPR)
742 format_tree = TREE_OPERAND (format_tree, 0);
743 if (TREE_CODE (format_tree) != STRING_CST)
745 format_chars = TREE_STRING_POINTER (format_tree);
746 format_length = TREE_STRING_LENGTH (format_tree);
747 if (format_length <= 1)
748 warning ("zero-length format string");
749 if (format_chars[--format_length] != 0)
751 warning ("unterminated format string");
754 /* Skip to first argument to check. */
755 while (arg_num + 1 < info->first_arg_num)
759 params = TREE_CHAIN (params);
763 first_fillin_param = params;
767 if (*format_chars == 0)
769 if (format_chars - TREE_STRING_POINTER (format_tree) != format_length)
770 warning ("embedded `\\0' in format");
771 if (info->first_arg_num != 0 && params != 0 && ! has_operand_number)
772 warning ("too many arguments for format");
775 if (*format_chars++ != '%')
777 if (*format_chars == 0)
779 warning ("spurious trailing `%%' in format");
782 if (*format_chars == '%')
788 suppressed = wide = precise = FALSE;
791 suppressed = *format_chars == '*';
794 while (isdigit (*format_chars))
799 /* See if we have a number followed by a dollar sign. If we do,
800 it is an operand number, so set PARAMS to that operand. */
801 if (*format_chars >= '0' && *format_chars <= '9')
803 char *p = format_chars;
805 while (*p >= '0' && *p++ <= '9')
810 int opnum = atoi (format_chars);
812 params = first_fillin_param;
813 format_chars = p + 1;
814 has_operand_number = 1;
816 for (i = 1; i < opnum && params != 0; i++)
817 params = TREE_CHAIN (params);
819 if (opnum == 0 || params == 0)
821 warning ("operand number out of range in format");
827 while (*format_chars != 0 && index (" +#0-", *format_chars) != 0)
829 if (index (flag_chars, *format_chars) != 0)
831 sprintf (message, "repeated `%c' flag in format",
835 i = strlen (flag_chars);
836 flag_chars[i++] = *format_chars++;
839 /* "If the space and + flags both appear,
840 the space flag will be ignored." */
841 if (index (flag_chars, ' ') != 0
842 && index (flag_chars, '+') != 0)
843 warning ("use of both ` ' and `+' flags in format");
844 /* "If the 0 and - flags both appear,
845 the 0 flag will be ignored." */
846 if (index (flag_chars, '0') != 0
847 && index (flag_chars, '-') != 0)
848 warning ("use of both `0' and `-' flags in format");
849 if (*format_chars == '*')
852 /* "...a field width...may be indicated by an asterisk.
853 In this case, an int argument supplies the field width..." */
860 if (info->first_arg_num != 0)
862 cur_param = TREE_VALUE (params);
863 params = TREE_CHAIN (params);
865 /* size_t is generally not valid here.
866 It will work on most machines, because size_t and int
867 have the same mode. But might as well warn anyway,
868 since it will fail on other machines. */
869 if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
870 != integer_type_node)
872 (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
873 != unsigned_type_node))
876 "field width is not type int (arg %d)",
884 while (isdigit (*format_chars))
890 if (*format_chars == '.')
894 if (*format_chars != '*' && !isdigit (*format_chars))
895 warning ("`.' not followed by `*' or digit in format");
896 /* "...a...precision...may be indicated by an asterisk.
897 In this case, an int argument supplies the...precision." */
898 if (*format_chars == '*')
900 if (info->first_arg_num != 0)
908 cur_param = TREE_VALUE (params);
909 params = TREE_CHAIN (params);
911 if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
912 != integer_type_node)
915 "field width is not type int (arg %d)",
923 while (isdigit (*format_chars))
928 if (*format_chars == 'h' || *format_chars == 'l' || *format_chars == 'q' ||
929 *format_chars == 'L')
930 length_char = *format_chars++;
933 if (length_char == 'l' && *format_chars == 'l')
934 length_char = 'q', format_chars++;
936 if (*format_chars == 'a')
941 if (suppressed && length_char != 0)
944 "use of `*' and `%c' together in format",
948 format_char = *format_chars;
949 if (format_char == 0)
951 warning ("conversion lacks type at end of format");
955 fci = info->is_scan ? scan_char_table : print_char_table;
956 while (fci->format_chars != 0
957 && index (fci->format_chars, format_char) == 0)
959 if (fci->format_chars == 0)
961 if (format_char >= 040 && format_char < 0177)
963 "unknown conversion type character `%c' in format",
967 "unknown conversion type character 0x%x in format",
972 if (wide && index (fci->flag_chars, 'w') == 0)
974 sprintf (message, "width used with `%c' format",
978 if (precise && index (fci->flag_chars, 'p') == 0)
980 sprintf (message, "precision used with `%c' format",
984 if (aflag && index (fci->flag_chars, 'a') == 0)
986 sprintf (message, "`a' flag used with `%c' format",
990 if (info->is_scan && format_char == '[')
992 /* Skip over scan set, in case it happens to have '%' in it. */
993 if (*format_chars == '^')
995 /* Find closing bracket; if one is hit immediately, then
996 it's part of the scan set rather than a terminator. */
997 if (*format_chars == ']')
999 while (*format_chars && *format_chars != ']')
1001 if (*format_chars != ']')
1002 /* The end of the format string was reached. */
1003 warning ("no closing `]' for `%%[' format");
1007 if (index (fci->flag_chars, '*') == 0)
1010 "suppression of `%c' conversion in format",
1016 for (i = 0; flag_chars[i] != 0; ++i)
1018 if (index (fci->flag_chars, flag_chars[i]) == 0)
1020 sprintf (message, "flag `%c' used with type `%c'",
1021 flag_chars[i], format_char);
1025 if (precise && index (flag_chars, '0') != 0
1026 && (format_char == 'd' || format_char == 'i'
1027 || format_char == 'o' || format_char == 'u'
1028 || format_char == 'x' || format_char == 'x'))
1031 "precision and `0' flag not both allowed with `%c' format",
1035 switch (length_char)
1037 default: wanted_type = fci->nolen ? *(fci->nolen) : 0; break;
1038 case 'h': wanted_type = fci->hlen ? *(fci->hlen) : 0; break;
1039 case 'l': wanted_type = fci->llen ? *(fci->llen) : 0; break;
1040 case 'q': wanted_type = fci->qlen ? *(fci->qlen) : 0; break;
1041 case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break;
1043 if (wanted_type == 0)
1046 "use of `%c' length character with `%c' type character",
1047 length_char, format_char);
1052 ** XXX -- should kvetch about stuff such as
1056 ** scanf ("%d", &i);
1060 /* Finally. . .check type of argument against desired type! */
1061 if (info->first_arg_num == 0)
1068 cur_param = TREE_VALUE (params);
1069 params = TREE_CHAIN (params);
1071 cur_type = TREE_TYPE (cur_param);
1073 /* Check the types of any additional pointer arguments
1074 that precede the "real" argument. */
1075 for (i = 0; i < fci->pointer_count; ++i)
1077 if (TREE_CODE (cur_type) == POINTER_TYPE)
1079 cur_type = TREE_TYPE (cur_type);
1083 "format argument is not a %s (arg %d)",
1084 ((fci->pointer_count == 1) ? "pointer" : "pointer to a pointer"),
1090 /* Check the type of the "real" argument, if there's a type we want. */
1091 if (i == fci->pointer_count && wanted_type != 0
1092 && wanted_type != TYPE_MAIN_VARIANT (cur_type)
1093 /* If we want `void *', allow any pointer type.
1094 (Anything else would already have got a warning.) */
1095 && ! (wanted_type == void_type_node
1096 && fci->pointer_count > 0)
1097 /* Don't warn about differences merely in signedness. */
1098 && !(TREE_CODE (wanted_type) == INTEGER_TYPE
1099 && TREE_CODE (TYPE_MAIN_VARIANT (cur_type)) == INTEGER_TYPE
1100 && (TREE_UNSIGNED (wanted_type)
1101 ? wanted_type == (cur_type = unsigned_type (cur_type))
1102 : wanted_type == (cur_type = signed_type (cur_type))))
1103 /* Likewise, "signed char", "unsigned char" and "char" are
1104 equivalent but the above test won't consider them equivalent. */
1105 && ! (wanted_type == char_type_node
1106 && (TYPE_MAIN_VARIANT (cur_type) == signed_char_type_node
1107 || TYPE_MAIN_VARIANT (cur_type) == unsigned_char_type_node)))
1109 register char *this;
1110 register char *that;
1112 this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type)));
1114 if (TREE_CODE (cur_type) != ERROR_MARK
1115 && TYPE_NAME (cur_type) != 0
1116 && TREE_CODE (cur_type) != INTEGER_TYPE
1117 && !(TREE_CODE (cur_type) == POINTER_TYPE
1118 && TREE_CODE (TREE_TYPE (cur_type)) == INTEGER_TYPE))
1120 if (TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL
1121 && DECL_NAME (TYPE_NAME (cur_type)) != 0)
1122 that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
1124 that = IDENTIFIER_POINTER (TYPE_NAME (cur_type));
1127 /* A nameless type can't possibly match what the format wants.
1128 So there will be a warning for it.
1129 Make up a string to describe vaguely what it is. */
1132 if (TREE_CODE (cur_type) == POINTER_TYPE)
1135 that = "different type";
1138 /* Make the warning better in case of mismatch of int vs long. */
1139 if (TREE_CODE (cur_type) == INTEGER_TYPE
1140 && TREE_CODE (wanted_type) == INTEGER_TYPE
1141 && TYPE_PRECISION (cur_type) == TYPE_PRECISION (wanted_type)
1142 && TYPE_NAME (cur_type) != 0
1143 && TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL)
1144 that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
1146 if (strcmp (this, that) != 0)
1148 sprintf (message, "%s format, %s arg (arg %d)",
1149 this, that, arg_num);
1156 /* Print a warning if a constant expression had overflow in folding.
1157 Invoke this function on every expression that the language
1158 requires to be a constant expression.
1159 Note the ANSI C standard says it is erroneous for a
1160 constant expression to overflow. */
1163 constant_expression_warning (value)
1166 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1167 || TREE_CODE (value) == COMPLEX_CST)
1168 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1169 pedwarn ("overflow in constant expression");
1172 /* Print a warning if an expression had overflow in folding.
1173 Invoke this function on every expression that
1174 (1) appears in the source code, and
1175 (2) might be a constant expression that overflowed, and
1176 (3) is not already checked by convert_and_check;
1177 however, do not invoke this function on operands of explicit casts. */
1180 overflow_warning (value)
1183 if ((TREE_CODE (value) == INTEGER_CST
1184 || (TREE_CODE (value) == COMPLEX_CST
1185 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1186 && TREE_OVERFLOW (value))
1188 TREE_OVERFLOW (value) = 0;
1189 warning ("integer overflow in expression");
1191 else if ((TREE_CODE (value) == REAL_CST
1192 || (TREE_CODE (value) == COMPLEX_CST
1193 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1194 && TREE_OVERFLOW (value))
1196 TREE_OVERFLOW (value) = 0;
1197 warning ("floating-pointer overflow in expression");
1201 /* Print a warning if a large constant is truncated to unsigned,
1202 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1203 Invoke this function on every expression that might be implicitly
1204 converted to an unsigned type. */
1207 unsigned_conversion_warning (result, operand)
1208 tree result, operand;
1210 if (TREE_CODE (operand) == INTEGER_CST
1211 && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
1212 && TREE_UNSIGNED (TREE_TYPE (result))
1213 && !int_fits_type_p (operand, TREE_TYPE (result)))
1215 if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
1216 /* This detects cases like converting -129 or 256 to unsigned char. */
1217 warning ("large integer implicitly truncated to unsigned type");
1218 else if (warn_conversion)
1219 warning ("negative integer implicitly converted to unsigned type");
1223 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1224 Invoke this function on every expression that is converted implicitly,
1225 i.e. because of language rules and not because of an explicit cast. */
1228 convert_and_check (type, expr)
1231 tree t = convert (type, expr);
1232 if (TREE_CODE (t) == INTEGER_CST)
1234 if (TREE_OVERFLOW (t))
1236 TREE_OVERFLOW (t) = 0;
1238 /* No warning for converting 0x80000000 to int. */
1239 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1240 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1241 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1242 /* If EXPR fits in the unsigned version of TYPE,
1243 don't warn unless pedantic. */
1245 || TREE_UNSIGNED (type)
1246 || ! int_fits_type_p (expr, unsigned_type (type)))
1247 warning ("overflow in implicit constant conversion");
1250 unsigned_conversion_warning (t, expr);
1256 c_expand_expr_stmt (expr)
1259 /* Do default conversion if safe and possibly important,
1260 in case within ({...}). */
1261 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
1262 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1263 expr = default_conversion (expr);
1265 if (TREE_TYPE (expr) != error_mark_node
1266 && TYPE_SIZE (TREE_TYPE (expr)) == 0
1267 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1268 error ("expression statement has incomplete type");
1270 expand_expr_stmt (expr);
1273 /* Validate the expression after `case' and apply default promotions. */
1276 check_case_value (value)
1279 if (value == NULL_TREE)
1282 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1283 STRIP_TYPE_NOPS (value);
1285 if (TREE_CODE (value) != INTEGER_CST
1286 && value != error_mark_node)
1288 error ("case label does not reduce to an integer constant");
1289 value = error_mark_node;
1292 /* Promote char or short to int. */
1293 value = default_conversion (value);
1295 constant_expression_warning (value);
1300 /* Return an integer type with BITS bits of precision,
1301 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1304 type_for_size (bits, unsignedp)
1308 if (bits == TYPE_PRECISION (integer_type_node))
1309 return unsignedp ? unsigned_type_node : integer_type_node;
1311 if (bits == TYPE_PRECISION (signed_char_type_node))
1312 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1314 if (bits == TYPE_PRECISION (short_integer_type_node))
1315 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1317 if (bits == TYPE_PRECISION (long_integer_type_node))
1318 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1320 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1321 return (unsignedp ? long_long_unsigned_type_node
1322 : long_long_integer_type_node);
1324 if (bits <= TYPE_PRECISION (intQI_type_node))
1325 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1327 if (bits <= TYPE_PRECISION (intHI_type_node))
1328 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1330 if (bits <= TYPE_PRECISION (intSI_type_node))
1331 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1333 if (bits <= TYPE_PRECISION (intDI_type_node))
1334 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1339 /* Return a data type that has machine mode MODE.
1340 If the mode is an integer,
1341 then UNSIGNEDP selects between signed and unsigned types. */
1344 type_for_mode (mode, unsignedp)
1345 enum machine_mode mode;
1348 if (mode == TYPE_MODE (integer_type_node))
1349 return unsignedp ? unsigned_type_node : integer_type_node;
1351 if (mode == TYPE_MODE (signed_char_type_node))
1352 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1354 if (mode == TYPE_MODE (short_integer_type_node))
1355 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1357 if (mode == TYPE_MODE (long_integer_type_node))
1358 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1360 if (mode == TYPE_MODE (long_long_integer_type_node))
1361 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1363 if (mode == TYPE_MODE (intQI_type_node))
1364 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1366 if (mode == TYPE_MODE (intHI_type_node))
1367 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1369 if (mode == TYPE_MODE (intSI_type_node))
1370 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1372 if (mode == TYPE_MODE (intDI_type_node))
1373 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1375 if (mode == TYPE_MODE (float_type_node))
1376 return float_type_node;
1378 if (mode == TYPE_MODE (double_type_node))
1379 return double_type_node;
1381 if (mode == TYPE_MODE (long_double_type_node))
1382 return long_double_type_node;
1384 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1385 return build_pointer_type (char_type_node);
1387 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1388 return build_pointer_type (integer_type_node);
1393 /* Return the minimum number of bits needed to represent VALUE in a
1394 signed or unsigned type, UNSIGNEDP says which. */
1397 min_precision (value, unsignedp)
1403 /* If the value is negative, compute its negative minus 1. The latter
1404 adjustment is because the absolute value of the largest negative value
1405 is one larger than the largest positive value. This is equivalent to
1406 a bit-wise negation, so use that operation instead. */
1408 if (tree_int_cst_sgn (value) < 0)
1409 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1411 /* Return the number of bits needed, taking into account the fact
1412 that we need one more bit for a signed than unsigned type. */
1414 if (integer_zerop (value))
1416 else if (TREE_INT_CST_HIGH (value) != 0)
1417 log = HOST_BITS_PER_WIDE_INT + floor_log2 (TREE_INT_CST_HIGH (value));
1419 log = floor_log2 (TREE_INT_CST_LOW (value));
1421 return log + 1 + ! unsignedp;
1424 /* Print an error message for invalid operands to arith operation CODE.
1425 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1428 binary_op_error (code)
1429 enum tree_code code;
1431 register char *opname = "unknown";
1436 error ("invalid truth-value expression");
1440 opname = "+"; break;
1442 opname = "-"; break;
1444 opname = "*"; break;
1446 opname = "max"; break;
1448 opname = "min"; break;
1450 opname = "=="; break;
1452 opname = "!="; break;
1454 opname = "<="; break;
1456 opname = ">="; break;
1458 opname = "<"; break;
1460 opname = ">"; break;
1462 opname = "<<"; break;
1464 opname = ">>"; break;
1465 case TRUNC_MOD_EXPR:
1466 case FLOOR_MOD_EXPR:
1467 opname = "%"; break;
1468 case TRUNC_DIV_EXPR:
1469 case FLOOR_DIV_EXPR:
1470 opname = "/"; break;
1472 opname = "&"; break;
1474 opname = "|"; break;
1475 case TRUTH_ANDIF_EXPR:
1476 opname = "&&"; break;
1477 case TRUTH_ORIF_EXPR:
1478 opname = "||"; break;
1480 opname = "^"; break;
1483 opname = "rotate"; break;
1485 error ("invalid operands to binary %s", opname);
1488 /* Subroutine of build_binary_op, used for comparison operations.
1489 See if the operands have both been converted from subword integer types
1490 and, if so, perhaps change them both back to their original type.
1491 This function is also responsible for converting the two operands
1492 to the proper common type for comparison.
1494 The arguments of this function are all pointers to local variables
1495 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1496 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1498 If this function returns nonzero, it means that the comparison has
1499 a constant value. What this function returns is an expression for
1503 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
1504 tree *op0_ptr, *op1_ptr;
1506 enum tree_code *rescode_ptr;
1509 tree op0 = *op0_ptr;
1510 tree op1 = *op1_ptr;
1511 int unsignedp0, unsignedp1;
1513 tree primop0, primop1;
1514 enum tree_code code = *rescode_ptr;
1516 /* Throw away any conversions to wider types
1517 already present in the operands. */
1519 primop0 = get_narrower (op0, &unsignedp0);
1520 primop1 = get_narrower (op1, &unsignedp1);
1522 /* Handle the case that OP0 does not *contain* a conversion
1523 but it *requires* conversion to FINAL_TYPE. */
1525 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1526 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
1527 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1528 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
1530 /* If one of the operands must be floated, we cannot optimize. */
1531 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1532 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1534 /* If first arg is constant, swap the args (changing operation
1535 so value is preserved), for canonicalization. Don't do this if
1536 the second arg is 0. */
1538 if (TREE_CONSTANT (primop0)
1539 && ! integer_zerop (primop1) && ! real_zerop (primop1))
1541 register tree tem = primop0;
1542 register int temi = unsignedp0;
1550 unsignedp0 = unsignedp1;
1571 *rescode_ptr = code;
1574 /* If comparing an integer against a constant more bits wide,
1575 maybe we can deduce a value of 1 or 0 independent of the data.
1576 Or else truncate the constant now
1577 rather than extend the variable at run time.
1579 This is only interesting if the constant is the wider arg.
1580 Also, it is not safe if the constant is unsigned and the
1581 variable arg is signed, since in this case the variable
1582 would be sign-extended and then regarded as unsigned.
1583 Our technique fails in this case because the lowest/highest
1584 possible unsigned results don't follow naturally from the
1585 lowest/highest possible values of the variable operand.
1586 For just EQ_EXPR and NE_EXPR there is another technique that
1587 could be used: see if the constant can be faithfully represented
1588 in the other operand's type, by truncating it and reextending it
1589 and see if that preserves the constant's value. */
1591 if (!real1 && !real2
1592 && TREE_CODE (primop1) == INTEGER_CST
1593 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1595 int min_gt, max_gt, min_lt, max_lt;
1596 tree maxval, minval;
1597 /* 1 if comparison is nominally unsigned. */
1598 int unsignedp = TREE_UNSIGNED (*restype_ptr);
1601 type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
1603 maxval = TYPE_MAX_VALUE (type);
1604 minval = TYPE_MIN_VALUE (type);
1606 if (unsignedp && !unsignedp0)
1607 *restype_ptr = signed_type (*restype_ptr);
1609 if (TREE_TYPE (primop1) != *restype_ptr)
1610 primop1 = convert (*restype_ptr, primop1);
1611 if (type != *restype_ptr)
1613 minval = convert (*restype_ptr, minval);
1614 maxval = convert (*restype_ptr, maxval);
1617 if (unsignedp && unsignedp0)
1619 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
1620 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
1621 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
1622 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
1626 min_gt = INT_CST_LT (primop1, minval);
1627 max_gt = INT_CST_LT (primop1, maxval);
1628 min_lt = INT_CST_LT (minval, primop1);
1629 max_lt = INT_CST_LT (maxval, primop1);
1633 /* This used to be a switch, but Genix compiler can't handle that. */
1634 if (code == NE_EXPR)
1636 if (max_lt || min_gt)
1637 val = boolean_true_node;
1639 else if (code == EQ_EXPR)
1641 if (max_lt || min_gt)
1642 val = boolean_false_node;
1644 else if (code == LT_EXPR)
1647 val = boolean_true_node;
1649 val = boolean_false_node;
1651 else if (code == GT_EXPR)
1654 val = boolean_true_node;
1656 val = boolean_false_node;
1658 else if (code == LE_EXPR)
1661 val = boolean_true_node;
1663 val = boolean_false_node;
1665 else if (code == GE_EXPR)
1668 val = boolean_true_node;
1670 val = boolean_false_node;
1673 /* If primop0 was sign-extended and unsigned comparison specd,
1674 we did a signed comparison above using the signed type bounds.
1675 But the comparison we output must be unsigned.
1677 Also, for inequalities, VAL is no good; but if the signed
1678 comparison had *any* fixed result, it follows that the
1679 unsigned comparison just tests the sign in reverse
1680 (positive values are LE, negative ones GE).
1681 So we can generate an unsigned comparison
1682 against an extreme value of the signed type. */
1684 if (unsignedp && !unsignedp0)
1691 primop1 = TYPE_MIN_VALUE (type);
1697 primop1 = TYPE_MAX_VALUE (type);
1701 type = unsigned_type (type);
1704 if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1706 /* This is the case of (char)x >?< 0x80, which people used to use
1707 expecting old C compilers to change the 0x80 into -0x80. */
1708 if (val == boolean_false_node)
1709 warning ("comparison is always 0 due to limited range of data type");
1710 if (val == boolean_true_node)
1711 warning ("comparison is always 1 due to limited range of data type");
1714 if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1716 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1717 if (val == boolean_false_node)
1718 warning ("comparison is always 0 due to limited range of data type");
1719 if (val == boolean_true_node)
1720 warning ("comparison is always 1 due to limited range of data type");
1725 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1726 if (TREE_SIDE_EFFECTS (primop0))
1727 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
1731 /* Value is not predetermined, but do the comparison
1732 in the type of the operand that is not constant.
1733 TYPE is already properly set. */
1735 else if (real1 && real2
1736 && (TYPE_PRECISION (TREE_TYPE (primop0))
1737 == TYPE_PRECISION (TREE_TYPE (primop1))))
1738 type = TREE_TYPE (primop0);
1740 /* If args' natural types are both narrower than nominal type
1741 and both extend in the same manner, compare them
1742 in the type of the wider arg.
1743 Otherwise must actually extend both to the nominal
1744 common type lest different ways of extending
1746 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1748 else if (unsignedp0 == unsignedp1 && real1 == real2
1749 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
1750 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
1752 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
1753 type = signed_or_unsigned_type (unsignedp0
1754 || TREE_UNSIGNED (*restype_ptr),
1756 /* Make sure shorter operand is extended the right way
1757 to match the longer operand. */
1758 primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
1760 primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
1765 /* Here we must do the comparison on the nominal type
1766 using the args exactly as we received them. */
1767 type = *restype_ptr;
1771 if (!real1 && !real2 && integer_zerop (primop1)
1772 && TREE_UNSIGNED (*restype_ptr))
1778 /* All unsigned values are >= 0, so we warn if extra warnings
1779 are requested. However, if OP0 is a constant that is
1780 >= 0, the signedness of the comparison isn't an issue,
1781 so suppress the warning. */
1783 && ! (TREE_CODE (primop0) == INTEGER_CST
1784 && ! TREE_OVERFLOW (convert (signed_type (type),
1786 warning ("unsigned value >= 0 is always 1");
1787 value = boolean_true_node;
1792 && ! (TREE_CODE (primop0) == INTEGER_CST
1793 && ! TREE_OVERFLOW (convert (signed_type (type),
1795 warning ("unsigned value < 0 is always 0");
1796 value = boolean_false_node;
1801 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1802 if (TREE_SIDE_EFFECTS (primop0))
1803 return build (COMPOUND_EXPR, TREE_TYPE (value),
1810 *op0_ptr = convert (type, primop0);
1811 *op1_ptr = convert (type, primop1);
1813 *restype_ptr = boolean_type_node;
1818 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1819 or validate its data type for an `if' or `while' statement or ?..: exp.
1821 This preparation consists of taking the ordinary
1822 representation of an expression expr and producing a valid tree
1823 boolean expression describing whether expr is nonzero. We could
1824 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
1825 but we optimize comparisons, &&, ||, and !.
1827 The resulting type should always be `boolean_type_node'. */
1830 truthvalue_conversion (expr)
1833 if (TREE_CODE (expr) == ERROR_MARK)
1836 #if 0 /* This appears to be wrong for C++. */
1837 /* These really should return error_mark_node after 2.4 is stable.
1838 But not all callers handle ERROR_MARK properly. */
1839 switch (TREE_CODE (TREE_TYPE (expr)))
1842 error ("struct type value used where scalar is required");
1843 return boolean_false_node;
1846 error ("union type value used where scalar is required");
1847 return boolean_false_node;
1850 error ("array type value used where scalar is required");
1851 return boolean_false_node;
1858 switch (TREE_CODE (expr))
1860 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1861 or comparison expressions as truth values at this level. */
1864 /* A one-bit unsigned bit-field is already acceptable. */
1865 if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1)))
1866 && TREE_UNSIGNED (TREE_OPERAND (expr, 1)))
1872 /* It is simpler and generates better code to have only TRUTH_*_EXPR
1873 or comparison expressions as truth values at this level. */
1875 if (integer_zerop (TREE_OPERAND (expr, 1)))
1876 return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0);
1878 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
1879 case TRUTH_ANDIF_EXPR:
1880 case TRUTH_ORIF_EXPR:
1881 case TRUTH_AND_EXPR:
1883 case TRUTH_XOR_EXPR:
1884 TREE_TYPE (expr) = boolean_type_node;
1891 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
1894 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
1897 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
1898 return build (COMPOUND_EXPR, boolean_type_node,
1899 TREE_OPERAND (expr, 0), boolean_true_node);
1901 return boolean_true_node;
1904 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
1905 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
1906 truthvalue_conversion (TREE_OPERAND (expr, 0)),
1907 truthvalue_conversion (TREE_OPERAND (expr, 1)),
1914 /* These don't change whether an object is non-zero or zero. */
1915 return truthvalue_conversion (TREE_OPERAND (expr, 0));
1919 /* These don't change whether an object is zero or non-zero, but
1920 we can't ignore them if their second arg has side-effects. */
1921 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
1922 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
1923 truthvalue_conversion (TREE_OPERAND (expr, 0)));
1925 return truthvalue_conversion (TREE_OPERAND (expr, 0));
1928 /* Distribute the conversion into the arms of a COND_EXPR. */
1929 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
1930 truthvalue_conversion (TREE_OPERAND (expr, 1)),
1931 truthvalue_conversion (TREE_OPERAND (expr, 2))));
1934 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
1935 since that affects how `default_conversion' will behave. */
1936 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
1937 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
1939 /* fall through... */
1941 /* If this is widening the argument, we can ignore it. */
1942 if (TYPE_PRECISION (TREE_TYPE (expr))
1943 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
1944 return truthvalue_conversion (TREE_OPERAND (expr, 0));
1948 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
1950 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
1951 && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
1953 /* fall through... */
1955 /* This and MINUS_EXPR can be changed into a comparison of the
1957 if (TREE_TYPE (TREE_OPERAND (expr, 0))
1958 == TREE_TYPE (TREE_OPERAND (expr, 1)))
1959 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
1960 TREE_OPERAND (expr, 1), 1);
1961 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
1962 fold (build1 (NOP_EXPR,
1963 TREE_TYPE (TREE_OPERAND (expr, 0)),
1964 TREE_OPERAND (expr, 1))), 1);
1967 if (integer_onep (TREE_OPERAND (expr, 1)))
1971 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
1972 warning ("suggest parentheses around assignment used as truth value");
1976 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
1977 return (build_binary_op
1978 ((TREE_SIDE_EFFECTS (expr)
1979 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
1980 truthvalue_conversion (build_unary_op (REALPART_EXPR, expr, 0)),
1981 truthvalue_conversion (build_unary_op (IMAGPART_EXPR, expr, 0)),
1984 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
1987 /* Read the rest of a #-directive from input stream FINPUT.
1988 In normal use, the directive name and the white space after it
1989 have already been read, so they won't be included in the result.
1990 We allow for the fact that the directive line may contain
1991 a newline embedded within a character or string literal which forms
1992 a part of the directive.
1994 The value is a string in a reusable buffer. It remains valid
1995 only until the next time this function is called. */
1998 get_directive_line (finput)
1999 register FILE *finput;
2001 static char *directive_buffer = NULL;
2002 static unsigned buffer_length = 0;
2004 register char *buffer_limit;
2005 register int looking_for = 0;
2006 register int char_escaped = 0;
2008 if (buffer_length == 0)
2010 directive_buffer = (char *)xmalloc (128);
2011 buffer_length = 128;
2014 buffer_limit = &directive_buffer[buffer_length];
2016 for (p = directive_buffer; ; )
2020 /* Make buffer bigger if it is full. */
2021 if (p >= buffer_limit)
2023 register unsigned bytes_used = (p - directive_buffer);
2027 = (char *)xrealloc (directive_buffer, buffer_length);
2028 p = &directive_buffer[bytes_used];
2029 buffer_limit = &directive_buffer[buffer_length];
2034 /* Discard initial whitespace. */
2035 if ((c == ' ' || c == '\t') && p == directive_buffer)
2038 /* Detect the end of the directive. */
2039 if (c == '\n' && looking_for == 0)
2048 return directive_buffer;
2050 /* Handle string and character constant syntax. */
2053 if (looking_for == c && !char_escaped)
2054 looking_for = 0; /* Found terminator... stop looking. */
2057 if (c == '\'' || c == '"')
2058 looking_for = c; /* Don't stop buffering until we see another
2059 another one of these (or an EOF). */
2061 /* Handle backslash. */
2062 char_escaped = (c == '\\' && ! char_escaped);
2066 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2067 down to the element type of an array. */
2070 c_build_type_variant (type, constp, volatilep)
2072 int constp, volatilep;
2074 if (TREE_CODE (type) == ARRAY_TYPE)
2076 tree real_main_variant = TYPE_MAIN_VARIANT (type);
2078 push_obstacks (TYPE_OBSTACK (real_main_variant),
2079 TYPE_OBSTACK (real_main_variant));
2080 type = build_array_type (c_build_type_variant (TREE_TYPE (type),
2082 TYPE_DOMAIN (type));
2084 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
2085 make a copy. (TYPE might have come from the hash table and
2086 REAL_MAIN_VARIANT might be in some function's obstack.) */
2088 if (TYPE_OBSTACK (type) != TYPE_OBSTACK (real_main_variant))
2090 type = copy_node (type);
2091 TYPE_POINTER_TO (type) = TYPE_REFERENCE_TO (type) = 0;
2094 TYPE_MAIN_VARIANT (type) = real_main_variant;
2097 return build_type_variant (type, constp, volatilep);