1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
35 #include "diagnostic.h"
42 #undef WCHAR_TYPE_SIZE
43 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
45 /* The following symbols are subsumed in the c_global_trees array, and
46 listed here individually for documentation purposes.
48 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
50 tree short_integer_type_node;
51 tree long_integer_type_node;
52 tree long_long_integer_type_node;
54 tree short_unsigned_type_node;
55 tree long_unsigned_type_node;
56 tree long_long_unsigned_type_node;
58 tree boolean_type_node;
59 tree boolean_false_node;
60 tree boolean_true_node;
62 tree ptrdiff_type_node;
64 tree unsigned_char_type_node;
65 tree signed_char_type_node;
67 tree signed_wchar_type_node;
68 tree unsigned_wchar_type_node;
71 tree double_type_node;
72 tree long_double_type_node;
74 tree complex_integer_type_node;
75 tree complex_float_type_node;
76 tree complex_double_type_node;
77 tree complex_long_double_type_node;
85 tree unsigned_intQI_type_node;
86 tree unsigned_intHI_type_node;
87 tree unsigned_intSI_type_node;
88 tree unsigned_intDI_type_node;
89 tree unsigned_intTI_type_node;
91 tree widest_integer_literal_type_node;
92 tree widest_unsigned_literal_type_node;
94 Nodes for types `void *' and `const void *'.
96 tree ptr_type_node, const_ptr_type_node;
98 Nodes for types `char *' and `const char *'.
100 tree string_type_node, const_string_type_node;
102 Type `char[SOMENUMBER]'.
103 Used when an array of char is needed and the size is irrelevant.
105 tree char_array_type_node;
107 Type `int[SOMENUMBER]' or something like it.
108 Used when an array of int needed and the size is irrelevant.
110 tree int_array_type_node;
112 Type `wchar_t[SOMENUMBER]' or something like it.
113 Used when a wide string literal is created.
115 tree wchar_array_type_node;
117 Type `int ()' -- used for implicit declaration of functions.
119 tree default_function_type;
121 Function types `int (int)', etc.
127 tree ptr_ftype_sizetype;
129 A VOID_TYPE node, packaged in a TREE_LIST.
133 The identifiers __FUNCTION__, __PRETTY_FUNCTION__, and __func__.
135 tree function_id_node;
136 tree pretty_function_id_node;
141 tree c_global_trees[CTI_MAX];
143 /* Nonzero means don't recognize the non-ANSI builtin functions. */
147 /* Nonzero means don't recognize the non-ANSI builtin functions.
150 int flag_no_nonansi_builtin;
152 /* Nonzero means warn about possible violations of sequence point rules. */
154 int warn_sequence_point;
156 /* The elements of `ridpointers' are identifier nodes for the reserved
157 type names and storage classes. It is indexed by a RID_... value. */
160 tree (*make_fname_decl) PARAMS ((tree, const char *, int));
162 /* If non-NULL, the address of a language-specific function that
163 returns 1 for language-specific statement codes. */
164 int (*lang_statement_code_p) PARAMS ((enum tree_code));
166 /* If non-NULL, the address of a language-specific function that takes
167 any action required right before expand_function_end is called. */
168 void (*lang_expand_function_end) PARAMS ((void));
170 /* If this variable is defined to a non-NULL value, it will be called
171 after the file has been completely parsed. */
172 void (*back_end_hook) PARAMS ((tree));
174 /* Nonzero means the expression being parsed will never be evaluated.
175 This is a count, since unevaluated expressions can nest. */
178 enum attrs {A_PACKED, A_NOCOMMON, A_COMMON, A_NORETURN, A_CONST, A_T_UNION,
179 A_NO_CHECK_MEMORY_USAGE, A_NO_INSTRUMENT_FUNCTION,
180 A_CONSTRUCTOR, A_DESTRUCTOR, A_MODE, A_SECTION, A_ALIGNED,
181 A_UNUSED, A_FORMAT, A_FORMAT_ARG, A_WEAK, A_ALIAS, A_MALLOC,
182 A_NO_LIMIT_STACK, A_PURE};
184 enum format_type { printf_format_type, scanf_format_type,
185 strftime_format_type };
187 static void add_attribute PARAMS ((enum attrs, const char *,
189 static void init_attributes PARAMS ((void));
190 static void record_function_format PARAMS ((tree, tree, enum format_type,
192 static void record_international_format PARAMS ((tree, tree, int));
193 static int default_valid_lang_attribute PARAMS ((tree, tree, tree, tree));
195 /* Keep a stack of if statements. We record the number of compound
196 statements seen up to the if keyword, as well as the line number
197 and file of the if. If a potentially ambiguous else is seen, that
198 fact is recorded; the warning is issued when we can be sure that
199 the enclosing if statement does not have an else branch. */
209 static if_elt *if_stack;
211 /* Amount of space in the if statement stack. */
212 static int if_stack_space = 0;
215 static int if_stack_pointer = 0;
217 /* Record the start of an if-then, and record the start of it
218 for ambiguous else detection. */
221 c_expand_start_cond (cond, compstmt_count)
227 /* Make sure there is enough space on the stack. */
228 if (if_stack_space == 0)
231 if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
233 else if (if_stack_space == if_stack_pointer)
235 if_stack_space += 10;
236 if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
239 if_stmt = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
240 IF_COND (if_stmt) = cond;
243 /* Record this if statement. */
244 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
245 if_stack[if_stack_pointer].file = input_filename;
246 if_stack[if_stack_pointer].line = lineno;
247 if_stack[if_stack_pointer].needs_warning = 0;
248 if_stack[if_stack_pointer].if_stmt = if_stmt;
252 /* Called after the then-clause for an if-statement is processed. */
257 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
258 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
261 /* Record the end of an if-then. Optionally warn if a nested
262 if statement had an ambiguous else clause. */
268 if (if_stack[if_stack_pointer].needs_warning)
269 warning_with_file_and_line (if_stack[if_stack_pointer].file,
270 if_stack[if_stack_pointer].line,
271 "suggest explicit braces to avoid ambiguous `else'");
272 last_expr_type = NULL_TREE;
275 /* Called between the then-clause and the else-clause
276 of an if-then-else. */
279 c_expand_start_else ()
281 /* An ambiguous else warning must be generated for the enclosing if
282 statement, unless we see an else branch for that one, too. */
284 && if_stack_pointer > 1
285 && (if_stack[if_stack_pointer - 1].compstmt_count
286 == if_stack[if_stack_pointer - 2].compstmt_count))
287 if_stack[if_stack_pointer - 2].needs_warning = 1;
289 /* Even if a nested if statement had an else branch, it can't be
290 ambiguous if this one also has an else. So don't warn in that
291 case. Also don't warn for any if statements nested in this else. */
292 if_stack[if_stack_pointer - 1].needs_warning = 0;
293 if_stack[if_stack_pointer - 1].compstmt_count--;
296 /* Called after the else-clause for an if-statement is processed. */
301 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
302 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
305 /* Make bindings for __FUNCTION__, __PRETTY_FUNCTION__, and __func__. */
308 declare_function_name ()
310 const char *name, *printable_name;
312 if (current_function_decl == NULL)
315 printable_name = "top level";
319 /* Allow functions to be nameless (such as artificial ones). */
320 if (DECL_NAME (current_function_decl))
321 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
324 printable_name = (*decl_printable_name) (current_function_decl, 2);
326 /* ISO C99 defines __func__, which is a variable, not a string
327 constant, and which is not a defined symbol at file scope. */
328 (*make_fname_decl) (func_id_node, name, 0);
331 (*make_fname_decl) (function_id_node, name, 0);
332 (*make_fname_decl) (pretty_function_id_node, printable_name, 1);
335 /* Given a chain of STRING_CST nodes,
336 concatenate them into one STRING_CST
337 and give it a suitable array-of-chars data type. */
340 combine_strings (strings)
343 register tree value, t;
344 register int length = 1;
347 int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
349 const int nchars_max = flag_isoc99 ? 4095 : 509;
351 if (TREE_CHAIN (strings))
353 /* More than one in the chain, so concatenate. */
354 register char *p, *q;
356 /* Don't include the \0 at the end of each substring,
357 except for the last one.
358 Count wide strings and ordinary strings separately. */
359 for (t = strings; t; t = TREE_CHAIN (t))
361 if (TREE_TYPE (t) == wchar_array_type_node)
363 wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
367 length += (TREE_STRING_LENGTH (t) - 1);
370 /* If anything is wide, the non-wides will be converted,
371 which makes them take more space. */
373 length = length * wchar_bytes + wide_length;
375 p = ggc_alloc_string (NULL, length);
377 /* Copy the individual strings into the new combined string.
378 If the combined string is wide, convert the chars to ints
379 for any individual strings that are not wide. */
382 for (t = strings; t; t = TREE_CHAIN (t))
384 int len = (TREE_STRING_LENGTH (t)
385 - ((TREE_TYPE (t) == wchar_array_type_node)
387 if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
389 memcpy (q, TREE_STRING_POINTER (t), len);
395 for (i = 0; i < len; i++)
397 if (WCHAR_TYPE_SIZE == HOST_BITS_PER_SHORT)
398 ((short *) q)[i] = TREE_STRING_POINTER (t)[i];
400 ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
402 q += len * wchar_bytes;
408 for (i = 0; i < wchar_bytes; i++)
414 value = make_node (STRING_CST);
415 TREE_STRING_POINTER (value) = p;
416 TREE_STRING_LENGTH (value) = length;
421 length = TREE_STRING_LENGTH (value);
422 if (TREE_TYPE (value) == wchar_array_type_node)
426 /* Compute the number of elements, for the array type. */
427 nchars = wide_flag ? length / wchar_bytes : length;
429 if (pedantic && nchars > nchars_max && c_language == clk_c)
430 pedwarn ("string length `%d' is greater than the minimum length `%d' ISO C%d is required to support",
431 nchars, nchars_max, flag_isoc99 ? 99 : 89);
433 /* Create the array type for the string constant.
434 -Wwrite-strings says make the string constant an array of const char
435 so that copying it to a non-const pointer will get a warning.
436 For C++, this is the standard behavior. */
437 if (flag_const_strings
438 && (! flag_traditional && ! flag_writable_strings))
441 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
444 = build_array_type (elements,
445 build_index_type (build_int_2 (nchars - 1, 0)));
449 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
450 build_index_type (build_int_2 (nchars - 1, 0)));
452 TREE_CONSTANT (value) = 1;
453 TREE_READONLY (value) = ! flag_writable_strings;
454 TREE_STATIC (value) = 1;
458 /* To speed up processing of attributes, we maintain an array of
459 IDENTIFIER_NODES and the corresponding attribute types. */
461 /* Array to hold attribute information. */
463 static struct {enum attrs id; tree name; int min, max, decl_req;} attrtab[50];
465 static int attrtab_idx = 0;
467 /* Add an entry to the attribute table above. */
470 add_attribute (id, string, min_len, max_len, decl_req)
473 int min_len, max_len;
478 attrtab[attrtab_idx].id = id;
479 attrtab[attrtab_idx].name = get_identifier (string);
480 attrtab[attrtab_idx].min = min_len;
481 attrtab[attrtab_idx].max = max_len;
482 attrtab[attrtab_idx++].decl_req = decl_req;
484 sprintf (buf, "__%s__", string);
486 attrtab[attrtab_idx].id = id;
487 attrtab[attrtab_idx].name = get_identifier (buf);
488 attrtab[attrtab_idx].min = min_len;
489 attrtab[attrtab_idx].max = max_len;
490 attrtab[attrtab_idx++].decl_req = decl_req;
493 /* Initialize attribute table. */
498 add_attribute (A_PACKED, "packed", 0, 0, 0);
499 add_attribute (A_NOCOMMON, "nocommon", 0, 0, 1);
500 add_attribute (A_COMMON, "common", 0, 0, 1);
501 add_attribute (A_NORETURN, "noreturn", 0, 0, 1);
502 add_attribute (A_NORETURN, "volatile", 0, 0, 1);
503 add_attribute (A_UNUSED, "unused", 0, 0, 0);
504 add_attribute (A_CONST, "const", 0, 0, 1);
505 add_attribute (A_T_UNION, "transparent_union", 0, 0, 0);
506 add_attribute (A_CONSTRUCTOR, "constructor", 0, 0, 1);
507 add_attribute (A_DESTRUCTOR, "destructor", 0, 0, 1);
508 add_attribute (A_MODE, "mode", 1, 1, 1);
509 add_attribute (A_SECTION, "section", 1, 1, 1);
510 add_attribute (A_ALIGNED, "aligned", 0, 1, 0);
511 add_attribute (A_FORMAT, "format", 3, 3, 1);
512 add_attribute (A_FORMAT_ARG, "format_arg", 1, 1, 1);
513 add_attribute (A_WEAK, "weak", 0, 0, 1);
514 add_attribute (A_ALIAS, "alias", 1, 1, 1);
515 add_attribute (A_NO_INSTRUMENT_FUNCTION, "no_instrument_function", 0, 0, 1);
516 add_attribute (A_NO_CHECK_MEMORY_USAGE, "no_check_memory_usage", 0, 0, 1);
517 add_attribute (A_MALLOC, "malloc", 0, 0, 1);
518 add_attribute (A_NO_LIMIT_STACK, "no_stack_limit", 0, 0, 1);
519 add_attribute (A_PURE, "pure", 0, 0, 1);
522 /* Default implementation of valid_lang_attribute, below. By default, there
523 are no language-specific attributes. */
526 default_valid_lang_attribute (attr_name, attr_args, decl, type)
527 tree attr_name ATTRIBUTE_UNUSED;
528 tree attr_args ATTRIBUTE_UNUSED;
529 tree decl ATTRIBUTE_UNUSED;
530 tree type ATTRIBUTE_UNUSED;
535 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid language-specific
536 attribute for either declaration DECL or type TYPE and 0 otherwise. */
538 int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree))
539 = default_valid_lang_attribute;
541 /* Process the attributes listed in ATTRIBUTES and PREFIX_ATTRIBUTES
542 and install them in NODE, which is either a DECL (including a TYPE_DECL)
543 or a TYPE. PREFIX_ATTRIBUTES can appear after the declaration specifiers
544 and declaration modifiers but before the declaration proper. */
547 decl_attributes (node, attributes, prefix_attributes)
548 tree node, attributes, prefix_attributes;
550 tree decl = 0, type = 0;
554 if (attrtab_idx == 0)
560 type = TREE_TYPE (decl);
561 is_type = TREE_CODE (node) == TYPE_DECL;
563 else if (TYPE_P (node))
564 type = node, is_type = 1;
566 #ifdef PRAGMA_INSERT_ATTRIBUTES
567 /* If the code in c-pragma.c wants to insert some attributes then
568 allow it to do so. Do this before allowing machine back ends to
569 insert attributes, so that they have the opportunity to override
570 anything done here. */
571 PRAGMA_INSERT_ATTRIBUTES (node, & attributes, & prefix_attributes);
574 #ifdef INSERT_ATTRIBUTES
575 INSERT_ATTRIBUTES (node, & attributes, & prefix_attributes);
578 attributes = chainon (prefix_attributes, attributes);
580 for (a = attributes; a; a = TREE_CHAIN (a))
582 tree name = TREE_PURPOSE (a);
583 tree args = TREE_VALUE (a);
587 for (i = 0; i < attrtab_idx; i++)
588 if (attrtab[i].name == name)
591 if (i == attrtab_idx)
593 if (! valid_machine_attribute (name, args, decl, type)
594 && ! (* valid_lang_attribute) (name, args, decl, type))
595 warning ("`%s' attribute directive ignored",
596 IDENTIFIER_POINTER (name));
598 type = TREE_TYPE (decl);
601 else if (attrtab[i].decl_req && decl == 0)
603 warning ("`%s' attribute does not apply to types",
604 IDENTIFIER_POINTER (name));
607 else if (list_length (args) < attrtab[i].min
608 || list_length (args) > attrtab[i].max)
610 error ("wrong number of arguments specified for `%s' attribute",
611 IDENTIFIER_POINTER (name));
620 TYPE_PACKED (type) = 1;
621 else if (TREE_CODE (decl) == FIELD_DECL)
622 DECL_PACKED (decl) = 1;
623 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
624 used for DECL_REGISTER. It wouldn't mean anything anyway. */
626 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
630 if (TREE_CODE (decl) == VAR_DECL)
631 DECL_COMMON (decl) = 0;
633 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
637 if (TREE_CODE (decl) == VAR_DECL)
638 DECL_COMMON (decl) = 1;
640 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
644 if (TREE_CODE (decl) == FUNCTION_DECL)
645 TREE_THIS_VOLATILE (decl) = 1;
646 else if (TREE_CODE (type) == POINTER_TYPE
647 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
648 TREE_TYPE (decl) = type
650 (build_type_variant (TREE_TYPE (type),
651 TREE_READONLY (TREE_TYPE (type)), 1));
653 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
657 if (TREE_CODE (decl) == FUNCTION_DECL)
658 DECL_IS_MALLOC (decl) = 1;
659 /* ??? TODO: Support types. */
661 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
667 TREE_USED (decl) = 1;
669 TREE_USED (type) = 1;
670 else if (TREE_CODE (decl) == PARM_DECL
671 || TREE_CODE (decl) == VAR_DECL
672 || TREE_CODE (decl) == FUNCTION_DECL
673 || TREE_CODE (decl) == LABEL_DECL)
674 TREE_USED (decl) = 1;
676 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
680 if (TREE_CODE (decl) == FUNCTION_DECL)
681 TREE_READONLY (decl) = 1;
682 else if (TREE_CODE (type) == POINTER_TYPE
683 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
684 TREE_TYPE (decl) = type
686 (build_type_variant (TREE_TYPE (type), 1,
687 TREE_THIS_VOLATILE (TREE_TYPE (type))));
689 warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name));
693 if (TREE_CODE (decl) == FUNCTION_DECL)
694 DECL_IS_PURE (decl) = 1;
695 /* ??? TODO: Support types. */
697 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
703 && TREE_CODE (type) == UNION_TYPE
705 || (TYPE_FIELDS (type) != 0
706 && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))))
707 TYPE_TRANSPARENT_UNION (type) = 1;
708 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
709 && TREE_CODE (type) == UNION_TYPE
710 && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))
711 DECL_TRANSPARENT_UNION (decl) = 1;
713 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
717 if (TREE_CODE (decl) == FUNCTION_DECL
718 && TREE_CODE (type) == FUNCTION_TYPE
719 && decl_function_context (decl) == 0)
721 DECL_STATIC_CONSTRUCTOR (decl) = 1;
722 TREE_USED (decl) = 1;
725 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
729 if (TREE_CODE (decl) == FUNCTION_DECL
730 && TREE_CODE (type) == FUNCTION_TYPE
731 && decl_function_context (decl) == 0)
733 DECL_STATIC_DESTRUCTOR (decl) = 1;
734 TREE_USED (decl) = 1;
737 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
741 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
742 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
746 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
747 int len = strlen (p);
748 enum machine_mode mode = VOIDmode;
751 if (len > 4 && p[0] == '_' && p[1] == '_'
752 && p[len - 1] == '_' && p[len - 2] == '_')
754 char *newp = (char *) alloca (len - 1);
756 strcpy (newp, &p[2]);
757 newp[len - 4] = '\0';
761 /* Give this decl a type with the specified mode.
762 First check for the special modes. */
763 if (! strcmp (p, "byte"))
765 else if (!strcmp (p, "word"))
767 else if (! strcmp (p, "pointer"))
770 for (j = 0; j < NUM_MACHINE_MODES; j++)
771 if (!strcmp (p, GET_MODE_NAME (j)))
772 mode = (enum machine_mode) j;
774 if (mode == VOIDmode)
775 error ("unknown machine mode `%s'", p);
776 else if (0 == (typefm = type_for_mode (mode,
777 TREE_UNSIGNED (type))))
778 error ("no data type for mode `%s'", p);
781 if (TYPE_PRECISION (typefm) > (TREE_UNSIGNED (type)
782 ? TYPE_PRECISION(uintmax_type_node)
783 : TYPE_PRECISION(intmax_type_node))
785 pedwarn ("type with more precision than %s",
786 TREE_UNSIGNED (type) ? "uintmax_t" : "intmax_t");
787 TREE_TYPE (decl) = type = typefm;
788 DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
789 layout_decl (decl, 0);
795 #ifdef ASM_OUTPUT_SECTION_NAME
796 if ((TREE_CODE (decl) == FUNCTION_DECL
797 || TREE_CODE (decl) == VAR_DECL)
798 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
800 if (TREE_CODE (decl) == VAR_DECL
801 && current_function_decl != NULL_TREE
802 && ! TREE_STATIC (decl))
803 error_with_decl (decl,
804 "section attribute cannot be specified for local variables");
805 /* The decl may have already been given a section attribute from
806 a previous declaration. Ensure they match. */
807 else if (DECL_SECTION_NAME (decl) != NULL_TREE
808 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
809 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
810 error_with_decl (node,
811 "section of `%s' conflicts with previous declaration");
813 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
816 error_with_decl (node,
817 "section attribute not allowed for `%s'");
819 error_with_decl (node,
820 "section attributes are not supported for this target");
827 = (args ? TREE_VALUE (args)
828 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
831 /* Strip any NOPs of any kind. */
832 while (TREE_CODE (align_expr) == NOP_EXPR
833 || TREE_CODE (align_expr) == CONVERT_EXPR
834 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
835 align_expr = TREE_OPERAND (align_expr, 0);
837 if (TREE_CODE (align_expr) != INTEGER_CST)
839 error ("requested alignment is not a constant");
843 if ((i = tree_log2 (align_expr)) == -1)
844 error ("requested alignment is not a power of 2");
845 else if (i > HOST_BITS_PER_INT - 2)
846 error ("requested alignment is too large");
849 /* If we have a TYPE_DECL, then copy the type, so that we
850 don't accidentally modify a builtin type. See pushdecl. */
851 if (decl && TREE_TYPE (decl) != error_mark_node
852 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
854 tree tt = TREE_TYPE (decl);
855 DECL_ORIGINAL_TYPE (decl) = tt;
856 tt = build_type_copy (tt);
857 TYPE_NAME (tt) = decl;
858 TREE_USED (tt) = TREE_USED (decl);
859 TREE_TYPE (decl) = tt;
863 TYPE_ALIGN (type) = (1 << i) * BITS_PER_UNIT;
864 TYPE_USER_ALIGN (type) = 1;
866 else if (TREE_CODE (decl) != VAR_DECL
867 && TREE_CODE (decl) != FIELD_DECL)
868 error_with_decl (decl,
869 "alignment may not be specified for `%s'");
872 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
873 DECL_USER_ALIGN (decl) = 1;
880 tree format_type_id = TREE_VALUE (args);
881 tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
882 tree first_arg_num_expr
883 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
884 unsigned HOST_WIDE_INT format_num, first_arg_num;
885 enum format_type format_type;
887 unsigned int arg_num;
889 if (TREE_CODE (decl) != FUNCTION_DECL)
891 error_with_decl (decl,
892 "argument format specified for non-function `%s'");
896 if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
898 error ("unrecognized format specifier");
903 const char *p = IDENTIFIER_POINTER (format_type_id);
905 if (!strcmp (p, "printf") || !strcmp (p, "__printf__"))
906 format_type = printf_format_type;
907 else if (!strcmp (p, "scanf") || !strcmp (p, "__scanf__"))
908 format_type = scanf_format_type;
909 else if (!strcmp (p, "strftime")
910 || !strcmp (p, "__strftime__"))
911 format_type = strftime_format_type;
914 warning ("`%s' is an unrecognized format function type", p);
919 /* Strip any conversions from the string index and first arg number
920 and verify they are constants. */
921 while (TREE_CODE (format_num_expr) == NOP_EXPR
922 || TREE_CODE (format_num_expr) == CONVERT_EXPR
923 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
924 format_num_expr = TREE_OPERAND (format_num_expr, 0);
926 while (TREE_CODE (first_arg_num_expr) == NOP_EXPR
927 || TREE_CODE (first_arg_num_expr) == CONVERT_EXPR
928 || TREE_CODE (first_arg_num_expr) == NON_LVALUE_EXPR)
929 first_arg_num_expr = TREE_OPERAND (first_arg_num_expr, 0);
931 if (TREE_CODE (format_num_expr) != INTEGER_CST
932 || TREE_INT_CST_HIGH (format_num_expr) != 0
933 || TREE_CODE (first_arg_num_expr) != INTEGER_CST
934 || TREE_INT_CST_HIGH (first_arg_num_expr) != 0)
936 error ("format string has invalid operand number");
940 format_num = TREE_INT_CST_LOW (format_num_expr);
941 first_arg_num = TREE_INT_CST_LOW (first_arg_num_expr);
942 if (first_arg_num != 0 && first_arg_num <= format_num)
944 error ("format string arg follows the args to be formatted");
948 /* If a parameter list is specified, verify that the format_num
949 argument is actually a string, in case the format attribute
951 argument = TYPE_ARG_TYPES (type);
954 for (arg_num = 1; argument != 0 && arg_num != format_num;
955 ++arg_num, argument = TREE_CHAIN (argument))
959 || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
960 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
963 error ("format string arg not a string type");
967 else if (first_arg_num != 0)
969 /* Verify that first_arg_num points to the last arg,
972 arg_num++, argument = TREE_CHAIN (argument);
974 if (arg_num != first_arg_num)
976 error ("args to be formatted is not '...'");
982 if (format_type == strftime_format_type && first_arg_num != 0)
984 error ("strftime formats cannot format arguments");
988 record_function_format (DECL_NAME (decl),
989 DECL_ASSEMBLER_NAME (decl),
990 format_type, format_num, first_arg_num);
996 tree format_num_expr = TREE_VALUE (args);
997 unsigned HOST_WIDE_INT format_num;
998 unsigned int arg_num;
1001 if (TREE_CODE (decl) != FUNCTION_DECL)
1003 error_with_decl (decl,
1004 "argument format specified for non-function `%s'");
1008 /* Strip any conversions from the first arg number and verify it
1010 while (TREE_CODE (format_num_expr) == NOP_EXPR
1011 || TREE_CODE (format_num_expr) == CONVERT_EXPR
1012 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
1013 format_num_expr = TREE_OPERAND (format_num_expr, 0);
1015 if (TREE_CODE (format_num_expr) != INTEGER_CST
1016 || TREE_INT_CST_HIGH (format_num_expr) != 0)
1018 error ("format string has invalid operand number");
1022 format_num = TREE_INT_CST_LOW (format_num_expr);
1024 /* If a parameter list is specified, verify that the format_num
1025 argument is actually a string, in case the format attribute
1027 argument = TYPE_ARG_TYPES (type);
1030 for (arg_num = 1; argument != 0 && arg_num != format_num;
1031 ++arg_num, argument = TREE_CHAIN (argument))
1035 || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
1036 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
1039 error ("format string arg not a string type");
1044 if (TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) != POINTER_TYPE
1045 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (TREE_TYPE (decl))))
1048 error ("function does not return string type");
1052 record_international_format (DECL_NAME (decl),
1053 DECL_ASSEMBLER_NAME (decl),
1059 declare_weak (decl);
1063 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
1064 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
1065 error_with_decl (decl,
1066 "`%s' defined both normally and as an alias");
1067 else if (decl_function_context (decl) == 0)
1071 id = TREE_VALUE (args);
1072 if (TREE_CODE (id) != STRING_CST)
1074 error ("alias arg not a string");
1077 id = get_identifier (TREE_STRING_POINTER (id));
1078 /* This counts as a use of the object pointed to. */
1081 if (TREE_CODE (decl) == FUNCTION_DECL)
1082 DECL_INITIAL (decl) = error_mark_node;
1084 DECL_EXTERNAL (decl) = 0;
1085 assemble_alias (decl, id);
1088 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
1091 case A_NO_CHECK_MEMORY_USAGE:
1092 if (TREE_CODE (decl) != FUNCTION_DECL)
1094 error_with_decl (decl,
1095 "`%s' attribute applies only to functions",
1096 IDENTIFIER_POINTER (name));
1098 else if (DECL_INITIAL (decl))
1100 error_with_decl (decl,
1101 "can't set `%s' attribute after definition",
1102 IDENTIFIER_POINTER (name));
1105 DECL_NO_CHECK_MEMORY_USAGE (decl) = 1;
1108 case A_NO_INSTRUMENT_FUNCTION:
1109 if (TREE_CODE (decl) != FUNCTION_DECL)
1111 error_with_decl (decl,
1112 "`%s' attribute applies only to functions",
1113 IDENTIFIER_POINTER (name));
1115 else if (DECL_INITIAL (decl))
1117 error_with_decl (decl,
1118 "can't set `%s' attribute after definition",
1119 IDENTIFIER_POINTER (name));
1122 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1125 case A_NO_LIMIT_STACK:
1126 if (TREE_CODE (decl) != FUNCTION_DECL)
1128 error_with_decl (decl,
1129 "`%s' attribute applies only to functions",
1130 IDENTIFIER_POINTER (name));
1132 else if (DECL_INITIAL (decl))
1134 error_with_decl (decl,
1135 "can't set `%s' attribute after definition",
1136 IDENTIFIER_POINTER (name));
1139 DECL_NO_LIMIT_STACK (decl) = 1;
1145 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
1146 lists. SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
1148 The head of the declspec list is stored in DECLSPECS.
1149 The head of the attribute list is stored in PREFIX_ATTRIBUTES.
1151 Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
1152 the list elements. We drop the containing TREE_LIST nodes and link the
1153 resulting attributes together the way decl_attributes expects them. */
1156 split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
1158 tree *declspecs, *prefix_attributes;
1160 tree t, s, a, next, specs, attrs;
1162 /* This can happen after an __extension__ in pedantic mode. */
1163 if (specs_attrs != NULL_TREE
1164 && TREE_CODE (specs_attrs) == INTEGER_CST)
1166 *declspecs = NULL_TREE;
1167 *prefix_attributes = NULL_TREE;
1171 /* This can happen in c++ (eg: decl: typespec initdecls ';'). */
1172 if (specs_attrs != NULL_TREE
1173 && TREE_CODE (specs_attrs) != TREE_LIST)
1175 *declspecs = specs_attrs;
1176 *prefix_attributes = NULL_TREE;
1180 /* Remember to keep the lists in the same order, element-wise. */
1182 specs = s = NULL_TREE;
1183 attrs = a = NULL_TREE;
1184 for (t = specs_attrs; t; t = next)
1186 next = TREE_CHAIN (t);
1187 /* Declspecs have a non-NULL TREE_VALUE. */
1188 if (TREE_VALUE (t) != NULL_TREE)
1190 if (specs == NULL_TREE)
1200 if (attrs == NULL_TREE)
1201 attrs = a = TREE_PURPOSE (t);
1204 TREE_CHAIN (a) = TREE_PURPOSE (t);
1205 a = TREE_PURPOSE (t);
1207 /* More attrs can be linked here, move A to the end. */
1208 while (TREE_CHAIN (a) != NULL_TREE)
1213 /* Terminate the lists. */
1215 TREE_CHAIN (s) = NULL_TREE;
1217 TREE_CHAIN (a) = NULL_TREE;
1221 *prefix_attributes = attrs;
1224 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
1225 This function is used by the parser when a rule will accept attributes
1226 in a particular position, but we don't want to support that just yet.
1228 A warning is issued for every ignored attribute. */
1231 strip_attrs (specs_attrs)
1236 split_specs_attrs (specs_attrs, &specs, &attrs);
1240 warning ("`%s' attribute ignored",
1241 IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
1242 attrs = TREE_CHAIN (attrs);
1248 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
1249 a parameter list. */
1251 /* The meaningfully distinct length modifiers for format checking recognised
1268 /* The standard versions in which various format features appeared. */
1269 enum format_std_version
1277 /* The C standard version C++ is treated as equivalent to
1278 or inheriting from, for the purpose of format features supported. */
1279 #define CPLUSPLUS_STD_VER STD_C89
1280 /* The C standard version we are checking formats against when pedantic. */
1281 #define C_STD_VER (c_language == clk_cplusplus \
1282 ? CPLUSPLUS_STD_VER \
1285 : (flag_isoc94 ? STD_C94 : STD_C89)))
1286 /* The name to give to the standard version we are warning about when
1287 pedantic. FEATURE_VER is the version in which the feature warned out
1288 appeared, which is higher than C_STD_VER. */
1289 #define C_STD_NAME(FEATURE_VER) (c_language == clk_cplusplus \
1291 : ((FEATURE_VER) == STD_EXT \
1295 /* Flags that may apply to a particular kind of format checked by GCC. */
1298 /* This format converts arguments of types determined by the
1300 FMT_FLAG_ARG_CONVERT = 1,
1301 /* The scanf allocation 'a' kludge applies to this format kind. */
1302 FMT_FLAG_SCANF_A_KLUDGE = 2,
1303 /* A % during parsing a specifier is allowed to be a modified % rather
1304 that indicating the format is broken and we are out-of-sync. */
1305 FMT_FLAG_FANCY_PERCENT_OK = 4,
1306 /* With $ operand numbers, it is OK to reference the same argument more
1308 FMT_FLAG_DOLLAR_MULTIPLE = 8
1309 /* Not included here: details of whether width or precision may occur
1310 (controlled by width_char and precision_char); details of whether
1311 '*' can be used for these (width_type and precision_type); details
1312 of whether length modifiers can occur (length_char_specs); details
1313 of when $ operand numbers are allowed (always, for the formats
1314 supported, if arguments are converted). */
1318 /* Structure describing a length modifier supported in format checking, and
1319 possibly a doubled version such as "hh". */
1322 /* Name of the single-character length modifier. */
1324 /* Index into a format_char_info.types array. */
1325 enum format_lengths index;
1326 /* Standard version this length appears in. */
1327 enum format_std_version std;
1328 /* Same, if the modifier can be repeated, or NULL if it can't. */
1329 const char *double_name;
1330 enum format_lengths double_index;
1331 enum format_std_version double_std;
1332 } format_length_info;
1335 /* Structure desribing the combination of a conversion specifier
1336 (or a set of specifiers which act identically) and a length modifier. */
1339 /* The standard version this combination of length and type appeared in.
1340 This is only relevant if greater than those for length and type
1341 individually; otherwise it is ignored. */
1342 enum format_std_version std;
1343 /* The name to use for the type, if different from that generated internally
1344 (e.g., "signed size_t"). */
1346 /* The type itself. */
1348 } format_type_detail;
1351 /* Macros to fill out tables of these. */
1352 #define BADLEN { 0, NULL, NULL }
1353 #define NOLENGTHS { BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
1356 /* Structure desribing a format conversion specifier (or a set of specifiers
1357 which act identically), and the length modifiers used with it. */
1360 const char *format_chars;
1362 enum format_std_version std;
1363 /* Types accepted for each length modifier. */
1364 format_type_detail types[FMT_LEN_MAX];
1365 /* List of other modifier characters allowed with these specifiers.
1366 This lists flags, and additionally "w" for width, "p" for precision,
1367 "a" for scanf "a" allocation extension (not applicable in C99 mode),
1368 "*" for scanf suppression, and "E" and "O" for those strftime
1370 const char *flag_chars;
1371 /* List of additional flags describing these conversion specifiers.
1372 "c" for generic character pointers being allowed, "2" for strftime
1373 two digit year formats, "3" for strftime formats giving two digit
1374 years in some locales, "4" for "2" which becomes "3" with an "E" modifier,
1375 "o" if use of strftime "O" is a GNU extension beyond C99,
1376 "W" if the argument is a pointer which is dereferenced and written into,
1377 "i" for printf integer formats where the '0' flag is ignored with
1378 precision, and "[" for the starting character of a scanf scanset. */
1383 /* Structure describing a flag accepted by some kind of format. */
1386 /* The flag character in question (0 for end of array). */
1388 /* Zero if this entry describes the flag character in general, or a
1389 non-zero character that may be found in flags2 if it describes the
1390 flag when used with certain formats only. If the latter, only
1391 the first such entry found that applies to the current conversion
1392 specifier is used; the values of `name' and `long_name' it supplies
1393 will be used, if non-NULL and the standard version is higher than
1394 the unpredicated one, for any pedantic warning. For example, 'o'
1395 for strftime formats (meaning 'O' is an extension over C99). */
1397 /* The name to use for this flag in diagnostic messages. For example,
1398 N_("`0' flag"), N_("field width"). */
1400 /* Long name for this flag in diagnostic messages; currently only used for
1401 "ISO C does not support ...". For example, N_("the `I' printf flag"). */
1402 const char *long_name;
1403 /* The standard version in which it appeared. */
1404 enum format_std_version std;
1408 /* Structure describing a combination of flags that is bad for some kind
1412 /* The first flag character in question (0 for end of array). */
1414 /* The second flag character. */
1416 /* Non-zero if the message should say that the first flag is ignored with
1417 the second, zero if the combination should simply be objected to. */
1419 /* Zero if this entry applies whenever this flag combination occurs,
1420 a non-zero character from flags2 if it only applies in some
1421 circumstances (e.g. 'i' for printf formats ignoring 0 with precision). */
1426 /* Structure describing a particular kind of format processed by GCC. */
1429 /* The name of this kind of format, for use in diagnostics. */
1431 /* Specifications of the length modifiers accepted; possibly NULL. */
1432 const format_length_info *length_char_specs;
1433 /* Details of the conversion specification characters accepted. */
1434 const format_char_info *conversion_specs;
1435 /* String listing the flag characters that are accepted. */
1436 const char *flag_chars;
1437 /* String listing modifier characters (strftime) accepted. May be NULL. */
1438 const char *modifier_chars;
1439 /* Details of the flag characters, including pseudo-flags. */
1440 const format_flag_spec *flag_specs;
1441 /* Details of bad combinations of flags. */
1442 const format_flag_pair *bad_flag_pairs;
1443 /* Flags applicable to this kind of format. */
1445 /* Flag character to treat a width as, or 0 if width not used. */
1447 /* Flag character to treat a precision as, or 0 if precision not used. */
1449 /* If a flag character has the effect of suppressing the conversion of
1450 an argument ('*' in scanf), that flag character, otherwise 0. */
1451 int suppression_char;
1452 /* Flag character to treat a length modifier as (ignored if length
1453 modifiers not used). Need not be placed in flag_chars for conversion
1454 specifiers, but is used to check for bad combinations such as length
1455 modifier with assignment suppression in scanf. */
1456 int length_code_char;
1457 /* Pointer to type of argument expected if '*' is used for a width,
1458 or NULL if '*' not used for widths. */
1460 /* Pointer to type of argument expected if '*' is used for a precision,
1461 or NULL if '*' not used for precisions. */
1462 tree *precision_type;
1466 /* Structure describing details of a type expected in format checking,
1467 and the type to check against it. */
1468 typedef struct format_wanted_type
1470 /* The type wanted. */
1472 /* The name of this type to use in diagnostics. */
1473 const char *wanted_type_name;
1474 /* The level of indirection through pointers at which this type occurs. */
1476 /* Whether, when pointer_count is 1, to allow any character type when
1477 pedantic, rather than just the character or void type specified. */
1478 int char_lenient_flag;
1479 /* Whether the argument, dereferenced once, is written into and so the
1480 argument must not be a pointer to a const-qualified type. */
1481 int writing_in_flag;
1482 /* If warnings should be of the form "field precision is not type int",
1483 the name to use (in this case "field precision"), otherwise NULL,
1484 for "%s format, %s arg" type messages. If (in an extension), this
1485 is a pointer type, wanted_type_name should be set to include the
1486 terminating '*' characters of the type name to give a correct
1489 /* The actual parameter to check against the wanted type. */
1491 /* The argument number of that parameter. */
1493 /* The next type to check for this format conversion, or NULL if none. */
1494 struct format_wanted_type *next;
1495 } format_wanted_type;
1498 static const format_length_info printf_length_specs[] =
1500 { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
1501 { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C99 },
1502 { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
1503 { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
1504 { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
1505 { "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 },
1506 { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
1507 { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
1508 { NULL, 0, 0, NULL, 0, 0 }
1512 /* This differs from printf_length_specs only in that "Z" is not accepted. */
1513 static const format_length_info scanf_length_specs[] =
1515 { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
1516 { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C99 },
1517 { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
1518 { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
1519 { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
1520 { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
1521 { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
1522 { NULL, 0, 0, NULL, 0, 0 }
1526 static const format_flag_spec printf_flag_specs[] =
1528 { ' ', 0, N_("` ' flag"), N_("the ` ' printf flag"), STD_C89 },
1529 { '+', 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89 },
1530 { '#', 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89 },
1531 { '0', 0, N_("`0' flag"), N_("the `0' printf flag"), STD_C89 },
1532 { '-', 0, N_("`-' flag"), N_("the `-' printf flag"), STD_C89 },
1533 { '\'', 0, N_("`'' flag"), N_("the `'' printf flag"), STD_EXT },
1534 { 'I', 0, N_("`I' flag"), N_("the `I' printf flag"), STD_EXT },
1535 { 'w', 0, N_("field width"), N_("field width in printf format"), STD_C89 },
1536 { 'p', 0, N_("precision"), N_("precision in printf format"), STD_C89 },
1537 { 'L', 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
1538 { 0, 0, NULL, NULL, 0 }
1542 static const format_flag_pair printf_flag_pairs[] =
1546 { '0', 'p', 1, 'i' },
1551 static const format_flag_spec scanf_flag_specs[] =
1553 { '*', 0, N_("assignment suppression"), N_("assignment suppression"), STD_C89 },
1554 { 'a', 0, N_("`a' flag"), N_("the `a' scanf flag"), STD_EXT },
1555 { 'w', 0, N_("field width"), N_("field width in scanf format"), STD_C89 },
1556 { 'L', 0, N_("length modifier"), N_("length modifier in scanf format"), STD_C89 },
1557 { '\'', 0, N_("`'' flag"), N_("the `'' scanf flag"), STD_EXT },
1558 { 'I', 0, N_("`I' flag"), N_("the `I' scanf flag"), STD_EXT },
1559 { 0, 0, NULL, NULL, 0 }
1563 static const format_flag_pair scanf_flag_pairs[] =
1570 static const format_flag_spec strftime_flag_specs[] =
1572 { '_', 0, N_("`_' flag"), N_("the `_' strftime flag"), STD_EXT },
1573 { '-', 0, N_("`-' flag"), N_("the `-' strftime flag"), STD_EXT },
1574 { '0', 0, N_("`0' flag"), N_("the `0' strftime flag"), STD_EXT },
1575 { '^', 0, N_("`^' flag"), N_("the `^' strftime flag"), STD_EXT },
1576 { '#', 0, N_("`#' flag"), N_("the `#' strftime flag"), STD_EXT },
1577 { 'w', 0, N_("field width"), N_("field width in strftime format"), STD_EXT },
1578 { 'E', 0, N_("`E' modifier"), N_("the `E' strftime modifier"), STD_C99 },
1579 { 'O', 0, N_("`O' modifier"), N_("the `O' strftime modifier"), STD_C99 },
1580 { 'O', 'o', NULL, N_("the `O' modifier"), STD_EXT },
1581 { 0, 0, NULL, NULL, 0 }
1585 static const format_flag_pair strftime_flag_pairs[] =
1596 #define T_I &integer_type_node
1597 #define T89_I { STD_C89, NULL, T_I }
1598 #define T99_I { STD_C99, NULL, T_I }
1599 #define T_L &long_integer_type_node
1600 #define T89_L { STD_C89, NULL, T_L }
1601 #define T_LL &long_long_integer_type_node
1602 #define T99_LL { STD_C99, NULL, T_LL }
1603 #define TEX_LL { STD_EXT, NULL, T_LL }
1604 #define T_S &short_integer_type_node
1605 #define T89_S { STD_C89, NULL, T_S }
1606 #define T_UI &unsigned_type_node
1607 #define T89_UI { STD_C89, NULL, T_UI }
1608 #define T99_UI { STD_C99, NULL, T_UI }
1609 #define T_UL &long_unsigned_type_node
1610 #define T89_UL { STD_C89, NULL, T_UL }
1611 #define T_ULL &long_long_unsigned_type_node
1612 #define T99_ULL { STD_C99, NULL, T_ULL }
1613 #define TEX_ULL { STD_EXT, NULL, T_ULL }
1614 #define T_US &short_unsigned_type_node
1615 #define T89_US { STD_C89, NULL, T_US }
1616 #define T_F &float_type_node
1617 #define T89_F { STD_C89, NULL, T_F }
1618 #define T99_F { STD_C99, NULL, T_F }
1619 #define T_D &double_type_node
1620 #define T89_D { STD_C89, NULL, T_D }
1621 #define T99_D { STD_C99, NULL, T_D }
1622 #define T_LD &long_double_type_node
1623 #define T89_LD { STD_C89, NULL, T_LD }
1624 #define T99_LD { STD_C99, NULL, T_LD }
1625 #define T_C &char_type_node
1626 #define T89_C { STD_C89, NULL, T_C }
1627 #define T_SC &signed_char_type_node
1628 #define T99_SC { STD_C99, NULL, T_SC }
1629 #define T_UC &unsigned_char_type_node
1630 #define T99_UC { STD_C99, NULL, T_UC }
1631 #define T_V &void_type_node
1632 #define T89_V { STD_C89, NULL, T_V }
1633 #define T_W &wchar_type_node
1634 #define T94_W { STD_C94, "wchar_t", T_W }
1635 #define TEX_W { STD_EXT, "wchar_t", T_W }
1636 #define T_WI &wint_type_node
1637 #define T94_WI { STD_C94, "wint_t", T_WI }
1638 #define TEX_WI { STD_EXT, "wint_t", T_WI }
1639 #define T_ST &c_size_type_node
1640 #define T99_ST { STD_C99, "size_t", T_ST }
1641 #define T_SST &signed_size_type_node
1642 #define T99_SST { STD_C99, "signed size_t", T_SST }
1643 #define T_PD &ptrdiff_type_node
1644 #define T99_PD { STD_C99, "ptrdiff_t", T_PD }
1645 #define T_UPD &unsigned_ptrdiff_type_node
1646 #define T99_UPD { STD_C99, "unsigned ptrdiff_t", T_UPD }
1647 #define T_IM &intmax_type_node
1648 #define T99_IM { STD_C99, "intmax_t", T_IM }
1649 #define T_UIM &uintmax_type_node
1650 #define T99_UIM { STD_C99, "uintmax_t", T_UIM }
1652 static const format_char_info print_char_table[] =
1654 /* C89 conversion specifiers. */
1655 { "di", 0, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T99_LL, TEX_LL, T99_SST, T99_PD, T99_IM }, "-wp0 +'I", "i" },
1656 { "oxX", 0, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T99_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "-wp0#", "i" },
1657 { "u", 0, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T99_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "-wp0'I", "i" },
1658 { "fgG", 0, STD_C89, { T89_D, BADLEN, BADLEN, T99_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#'", "" },
1659 { "eE", 0, STD_C89, { T89_D, BADLEN, BADLEN, T99_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#", "" },
1660 { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, T94_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "" },
1661 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "c" },
1662 { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "c" },
1663 { "n", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T99_LL, BADLEN, T99_SST, T99_PD, T99_IM }, "", "W" },
1664 /* C99 conversion specifiers. */
1665 { "F", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#'", "" },
1666 { "aA", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#", "" },
1667 /* X/Open conversion specifiers. */
1668 { "C", 0, STD_EXT, { TEX_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "" },
1669 { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "" },
1670 /* GNU conversion specifiers. */
1671 { "m", 0, STD_EXT, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "" },
1672 { NULL, 0, 0, NOLENGTHS, NULL, NULL }
1675 static const format_char_info scan_char_table[] =
1677 /* C89 conversion specifiers. */
1678 { "di", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T99_LL, TEX_LL, T99_SST, T99_PD, T99_IM }, "*w'I", "W" },
1679 { "u", 1, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T99_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "*w'I", "W" },
1680 { "oxX", 1, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T99_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "*w", "W" },
1681 { "efgEG", 1, STD_C89, { T89_F, BADLEN, BADLEN, T89_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "*w'", "W" },
1682 { "c", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "cW" },
1683 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "cW" },
1684 { "[", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "cW[" },
1685 { "p", 2, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W" },
1686 { "n", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T99_LL, BADLEN, T99_SST, T99_PD, T99_IM }, "", "W" },
1687 /* C99 conversion specifiers. */
1688 { "FaA", 1, STD_C99, { T99_F, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "*w'", "W" },
1689 /* X/Open conversion specifiers. */
1690 { "C", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W" },
1691 { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "W" },
1692 { NULL, 0, 0, NOLENGTHS, NULL, NULL }
1695 static format_char_info time_char_table[] =
1697 /* C89 conversion specifiers. */
1698 { "ABZab", 0, STD_C89, NOLENGTHS, "^#", "" },
1699 { "cx", 0, STD_C89, NOLENGTHS, "E", "3" },
1700 { "HIMSUWdmw", 0, STD_C89, NOLENGTHS, "-_0Ow", "" },
1701 { "j", 0, STD_C89, NOLENGTHS, "-_0Ow", "o" },
1702 { "p", 0, STD_C89, NOLENGTHS, "#", "" },
1703 { "X", 0, STD_C89, NOLENGTHS, "E", "" },
1704 { "y", 0, STD_C89, NOLENGTHS, "EO-_0w", "4" },
1705 { "Y", 0, STD_C89, NOLENGTHS, "-_0EOw", "o" },
1706 { "%", 0, STD_C89, NOLENGTHS, "", "" },
1707 /* C99 conversion specifiers. */
1708 { "C", 0, STD_C99, NOLENGTHS, "-_0EOw", "o" },
1709 { "D", 0, STD_C99, NOLENGTHS, "", "2" },
1710 { "eVu", 0, STD_C99, NOLENGTHS, "-_0Ow", "" },
1711 { "FRTnrt", 0, STD_C99, NOLENGTHS, "", "" },
1712 { "g", 0, STD_C99, NOLENGTHS, "O-_0w", "2o" },
1713 { "G", 0, STD_C99, NOLENGTHS, "-_0Ow", "o" },
1714 { "h", 0, STD_C99, NOLENGTHS, "^#", "" },
1715 { "z", 0, STD_C99, NOLENGTHS, "O", "o" },
1716 /* GNU conversion specifiers. */
1717 { "kls", 0, STD_EXT, NOLENGTHS, "-_0Ow", "" },
1718 { "P", 0, STD_EXT, NOLENGTHS, "", "" },
1719 { NULL, 0, 0, NOLENGTHS, NULL, NULL }
1723 /* This must be in the same order as enum format_type. */
1724 static const format_kind_info format_types[] =
1726 { "printf", printf_length_specs, print_char_table, " +#0-'I", NULL,
1727 printf_flag_specs, printf_flag_pairs,
1728 FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE, 'w', 'p', 0, 'L',
1729 &integer_type_node, &integer_type_node
1731 { "scanf", scanf_length_specs, scan_char_table, "*'I", NULL,
1732 scanf_flag_specs, scanf_flag_pairs,
1733 FMT_FLAG_ARG_CONVERT|FMT_FLAG_SCANF_A_KLUDGE, 'w', 0, '*', 'L',
1736 { "strftime", NULL, time_char_table, "_-0^#", "EO",
1737 strftime_flag_specs, strftime_flag_pairs,
1738 FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0,
1744 typedef struct function_format_info
1746 struct function_format_info *next; /* next structure on the list */
1747 tree name; /* identifier such as "printf" */
1748 tree assembler_name; /* optional mangled identifier (for C++) */
1749 enum format_type format_type; /* type of format (printf, scanf, etc.) */
1750 int format_num; /* number of format argument */
1751 int first_arg_num; /* number of first arg (zero for varargs) */
1752 } function_format_info;
1754 static function_format_info *function_format_list = NULL;
1756 typedef struct international_format_info
1758 struct international_format_info *next; /* next structure on the list */
1759 tree name; /* identifier such as "gettext" */
1760 tree assembler_name; /* optional mangled identifier (for C++) */
1761 int format_num; /* number of format argument */
1762 } international_format_info;
1764 static international_format_info *international_format_list = NULL;
1766 /* Structure detailing the results of checking a format function call
1767 where the format expression may be a conditional expression with
1768 many leaves resulting from nested conditional expressions. */
1771 /* Number of leaves of the format argument that could not be checked
1772 as they were not string literals. */
1773 int number_non_literal;
1774 /* Number of leaves of the format argument that were null pointers or
1775 string literals, but had extra format arguments. */
1776 int number_extra_args;
1777 /* Number of leaves of the format argument that were null pointers or
1778 string literals, but had extra format arguments and used $ operand
1780 int number_dollar_extra_args;
1781 /* Number of leaves of the format argument that were wide string
1784 /* Number of leaves of the format argument that were empty strings. */
1786 /* Number of leaves of the format argument that were unterminated
1788 int number_unterminated;
1789 /* Number of leaves of the format argument that were not counted above. */
1791 } format_check_results;
1793 static void check_format_info PARAMS ((int *, function_format_info *, tree));
1794 static void check_format_info_recurse PARAMS ((int *, format_check_results *,
1795 function_format_info *, tree,
1797 static void check_format_info_main PARAMS ((int *, format_check_results *,
1798 function_format_info *,
1799 const char *, int, tree, int));
1800 static void status_warning PARAMS ((int *, const char *, ...))
1803 static void init_dollar_format_checking PARAMS ((int, tree));
1804 static int maybe_read_dollar_number PARAMS ((int *, const char **, int,
1806 const format_kind_info *));
1807 static void finish_dollar_format_checking PARAMS ((int *, format_check_results *));
1809 static const format_flag_spec *get_flag_spec PARAMS ((const format_flag_spec *,
1810 int, const char *));
1812 static void check_format_types PARAMS ((int *, format_wanted_type *));
1813 static int is_valid_printf_arglist PARAMS ((tree));
1814 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1815 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1816 enum expand_modifier, int));
1818 /* Initialize the table of functions to perform format checking on.
1819 The ISO C functions are always checked (whether <stdio.h> is
1820 included or not), since it is common to call printf without
1821 including <stdio.h>. There shouldn't be a problem with this,
1822 since ISO C reserves these function names whether you include the
1823 header file or not. In any case, the checking is harmless. With
1824 -ffreestanding, these default attributes are disabled, and must be
1825 specified manually if desired.
1827 Also initialize the name of function that modify the format string for
1828 internationalization purposes. */
1831 init_function_format_info ()
1835 /* Functions from ISO/IEC 9899:1990. */
1836 record_function_format (get_identifier ("printf"), NULL_TREE,
1837 printf_format_type, 1, 2);
1838 record_function_format (get_identifier ("__builtin_printf"), NULL_TREE,
1839 printf_format_type, 1, 2);
1840 record_function_format (get_identifier ("fprintf"), NULL_TREE,
1841 printf_format_type, 2, 3);
1842 record_function_format (get_identifier ("sprintf"), NULL_TREE,
1843 printf_format_type, 2, 3);
1844 record_function_format (get_identifier ("scanf"), NULL_TREE,
1845 scanf_format_type, 1, 2);
1846 record_function_format (get_identifier ("fscanf"), NULL_TREE,
1847 scanf_format_type, 2, 3);
1848 record_function_format (get_identifier ("sscanf"), NULL_TREE,
1849 scanf_format_type, 2, 3);
1850 record_function_format (get_identifier ("vprintf"), NULL_TREE,
1851 printf_format_type, 1, 0);
1852 record_function_format (get_identifier ("vfprintf"), NULL_TREE,
1853 printf_format_type, 2, 0);
1854 record_function_format (get_identifier ("vsprintf"), NULL_TREE,
1855 printf_format_type, 2, 0);
1856 record_function_format (get_identifier ("strftime"), NULL_TREE,
1857 strftime_format_type, 3, 0);
1860 if (flag_hosted && flag_isoc99)
1862 /* ISO C99 adds the snprintf and vscanf family functions. */
1863 record_function_format (get_identifier ("snprintf"), NULL_TREE,
1864 printf_format_type, 3, 4);
1865 record_function_format (get_identifier ("vsnprintf"), NULL_TREE,
1866 printf_format_type, 3, 0);
1867 record_function_format (get_identifier ("vscanf"), NULL_TREE,
1868 scanf_format_type, 1, 0);
1869 record_function_format (get_identifier ("vfscanf"), NULL_TREE,
1870 scanf_format_type, 2, 0);
1871 record_function_format (get_identifier ("vsscanf"), NULL_TREE,
1872 scanf_format_type, 2, 0);
1875 if (flag_hosted && flag_noniso_default_format_attributes)
1877 /* Uniforum/GNU gettext functions, not in ISO C. */
1878 record_international_format (get_identifier ("gettext"), NULL_TREE, 1);
1879 record_international_format (get_identifier ("dgettext"), NULL_TREE, 2);
1880 record_international_format (get_identifier ("dcgettext"), NULL_TREE, 2);
1884 /* Record information for argument format checking. FUNCTION_IDENT is
1885 the identifier node for the name of the function to check (its decl
1886 need not exist yet).
1887 FORMAT_TYPE specifies the type of format checking. FORMAT_NUM is the number
1888 of the argument which is the format control string (starting from 1).
1889 FIRST_ARG_NUM is the number of the first actual argument to check
1890 against the format string, or zero if no checking is not be done
1891 (e.g. for varargs such as vfprintf). */
1894 record_function_format (name, assembler_name, format_type,
1895 format_num, first_arg_num)
1897 tree assembler_name;
1898 enum format_type format_type;
1902 function_format_info *info;
1904 /* Re-use existing structure if it's there. */
1906 for (info = function_format_list; info; info = info->next)
1908 if (info->name == name && info->assembler_name == assembler_name)
1913 info = (function_format_info *) xmalloc (sizeof (function_format_info));
1914 info->next = function_format_list;
1915 function_format_list = info;
1918 info->assembler_name = assembler_name;
1921 info->format_type = format_type;
1922 info->format_num = format_num;
1923 info->first_arg_num = first_arg_num;
1926 /* Record information for the names of function that modify the format
1927 argument to format functions. FUNCTION_IDENT is the identifier node for
1928 the name of the function (its decl need not exist yet) and FORMAT_NUM is
1929 the number of the argument which is the format control string (starting
1933 record_international_format (name, assembler_name, format_num)
1935 tree assembler_name;
1938 international_format_info *info;
1940 /* Re-use existing structure if it's there. */
1942 for (info = international_format_list; info; info = info->next)
1944 if (info->name == name && info->assembler_name == assembler_name)
1951 = (international_format_info *)
1952 xmalloc (sizeof (international_format_info));
1953 info->next = international_format_list;
1954 international_format_list = info;
1957 info->assembler_name = assembler_name;
1960 info->format_num = format_num;
1963 /* Check the argument list of a call to printf, scanf, etc.
1964 NAME is the function identifier.
1965 ASSEMBLER_NAME is the function's assembler identifier.
1966 (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
1967 PARAMS is the list of argument values. Also, if -Wmissing-format-attribute,
1968 warn for calls to vprintf or vscanf in functions with no such format
1969 attribute themselves. */
1972 check_function_format (status, name, assembler_name, params)
1975 tree assembler_name;
1978 function_format_info *info;
1980 /* See if this function is a format function. */
1981 for (info = function_format_list; info; info = info->next)
1983 if (info->assembler_name
1984 ? (info->assembler_name == assembler_name)
1985 : (info->name == name))
1987 /* Yup; check it. */
1988 check_format_info (status, info, params);
1989 if (warn_missing_format_attribute && info->first_arg_num == 0
1990 && (format_types[info->format_type].flags & FMT_FLAG_ARG_CONVERT))
1992 function_format_info *info2;
1993 for (info2 = function_format_list; info2; info2 = info2->next)
1994 if ((info2->assembler_name
1995 ? (info2->assembler_name == DECL_ASSEMBLER_NAME (current_function_decl))
1996 : (info2->name == DECL_NAME (current_function_decl)))
1997 && info2->format_type == info->format_type)
2000 warning ("function might be possible candidate for `%s' format attribute",
2001 format_types[info->format_type].name);
2008 /* This function replaces `warning' inside the printf format checking
2009 functions. If the `status' parameter is non-NULL, then it is
2010 dereferenced and set to 1 whenever a warning is caught. Otherwise
2011 it warns as usual by replicating the innards of the warning
2012 function from diagnostic.c. */
2014 status_warning VPARAMS ((int *status, const char *msgid, ...))
2016 #ifndef ANSI_PROTOTYPES
2021 diagnostic_context dc;
2027 VA_START (ap, msgid);
2029 #ifndef ANSI_PROTOTYPES
2030 status = va_arg (ap, int *);
2031 msgid = va_arg (ap, const char *);
2034 /* This duplicates the warning function behavior. */
2035 set_diagnostic_context
2036 (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 1);
2037 report_diagnostic (&dc);
2043 /* Variables used by the checking of $ operand number formats. */
2044 static char *dollar_arguments_used = NULL;
2045 static int dollar_arguments_alloc = 0;
2046 static int dollar_arguments_count;
2047 static int dollar_first_arg_num;
2048 static int dollar_max_arg_used;
2049 static int dollar_format_warned;
2051 /* Initialize the checking for a format string that may contain $
2052 parameter number specifications; we will need to keep track of whether
2053 each parameter has been used. FIRST_ARG_NUM is the number of the first
2054 argument that is a parameter to the format, or 0 for a vprintf-style
2055 function; PARAMS is the list of arguments starting at this argument. */
2058 init_dollar_format_checking (first_arg_num, params)
2062 dollar_first_arg_num = first_arg_num;
2063 dollar_arguments_count = 0;
2064 dollar_max_arg_used = 0;
2065 dollar_format_warned = 0;
2066 if (first_arg_num > 0)
2070 dollar_arguments_count++;
2071 params = TREE_CHAIN (params);
2074 if (dollar_arguments_alloc < dollar_arguments_count)
2076 if (dollar_arguments_used)
2077 free (dollar_arguments_used);
2078 dollar_arguments_alloc = dollar_arguments_count;
2079 dollar_arguments_used = xmalloc (dollar_arguments_alloc);
2081 if (dollar_arguments_alloc)
2082 memset (dollar_arguments_used, 0, dollar_arguments_alloc);
2086 /* Look for a decimal number followed by a $ in *FORMAT. If DOLLAR_NEEDED
2087 is set, it is an error if one is not found; otherwise, it is OK. If
2088 such a number is found, check whether it is within range and mark that
2089 numbered operand as being used for later checking. Returns the operand
2090 number if found and within range, zero if no such number was found and
2091 this is OK, or -1 on error. PARAMS points to the first operand of the
2092 format; PARAM_PTR is made to point to the parameter referred to. If
2093 a $ format is found, *FORMAT is updated to point just after it. */
2096 maybe_read_dollar_number (status, format, dollar_needed, params, param_ptr,
2099 const char **format;
2103 const format_kind_info *fki;
2107 const char *fcp = *format;
2108 if (*fcp < '0' || *fcp > '9')
2112 status_warning (status, "missing $ operand number in format");
2120 while (*fcp >= '0' && *fcp <= '9')
2123 nargnum = 10 * argnum + (*fcp - '0');
2124 if (nargnum < 0 || nargnum / 10 != argnum)
2133 status_warning (status, "missing $ operand number in format");
2140 if (pedantic && !dollar_format_warned)
2142 status_warning (status,
2143 "%s does not support %%n$ operand number formats",
2144 C_STD_NAME (STD_EXT));
2145 dollar_format_warned = 1;
2147 if (overflow_flag || argnum == 0
2148 || (dollar_first_arg_num && argnum > dollar_arguments_count))
2150 status_warning (status, "operand number out of range in format");
2153 if (argnum > dollar_max_arg_used)
2154 dollar_max_arg_used = argnum;
2155 /* For vprintf-style functions we may need to allocate more memory to
2156 track which arguments are used. */
2157 while (dollar_arguments_alloc < dollar_max_arg_used)
2160 nalloc = 2 * dollar_arguments_alloc + 16;
2161 dollar_arguments_used = xrealloc (dollar_arguments_used, nalloc);
2162 memset (dollar_arguments_used + dollar_arguments_alloc, 0,
2163 nalloc - dollar_arguments_alloc);
2164 dollar_arguments_alloc = nalloc;
2166 if (!(fki->flags & FMT_FLAG_DOLLAR_MULTIPLE)
2167 && dollar_arguments_used[argnum - 1] == 1)
2169 dollar_arguments_used[argnum - 1] = 2;
2170 status_warning (status,
2171 "format argument %d used more than once in %s format",
2175 dollar_arguments_used[argnum - 1] = 1;
2176 if (dollar_first_arg_num)
2179 *param_ptr = params;
2180 for (i = 1; i < argnum && *param_ptr != 0; i++)
2181 *param_ptr = TREE_CHAIN (*param_ptr);
2183 if (*param_ptr == 0)
2185 /* This case shouldn't be caught here. */
2195 /* Finish the checking for a format string that used $ operand number formats
2196 instead of non-$ formats. We check for unused operands before used ones
2197 (a serious error, since the implementation of the format function
2198 can't know what types to pass to va_arg to find the later arguments).
2199 and for unused operands at the end of the format (if we know how many
2200 arguments the format had, so not for vprintf). If there were operand
2201 numbers out of range on a non-vprintf-style format, we won't have reached
2205 finish_dollar_format_checking (status, res)
2207 format_check_results *res;
2210 for (i = 0; i < dollar_max_arg_used; i++)
2212 if (!dollar_arguments_used[i])
2213 status_warning (status, "format argument %d unused before used argument %d in $-style format",
2214 i + 1, dollar_max_arg_used);
2216 if (dollar_first_arg_num && dollar_max_arg_used < dollar_arguments_count)
2218 res->number_other--;
2219 res->number_dollar_extra_args++;
2224 /* Retrieve the specification for a format flag. SPEC contains the
2225 specifications for format flags for the applicable kind of format.
2226 FLAG is the flag in question. If PREDICATES is NULL, the basic
2227 spec for that flag must be retrieved and this function aborts if
2228 it cannot be found. If PREDICATES is not NULL, it is a string listing
2229 possible predicates for the spec entry; if an entry predicated on any
2230 of these is found, it is returned, otherwise NULL is returned. */
2232 static const format_flag_spec *
2233 get_flag_spec (spec, flag, predicates)
2234 const format_flag_spec *spec;
2236 const char *predicates;
2239 for (i = 0; spec[i].flag_char != 0; i++)
2241 if (spec[i].flag_char != flag)
2243 if (predicates != NULL)
2245 if (spec[i].predicate != 0
2246 && strchr (predicates, spec[i].predicate) != 0)
2249 else if (spec[i].predicate == 0)
2252 if (predicates == NULL)
2259 /* Check the argument list of a call to printf, scanf, etc.
2260 INFO points to the function_format_info structure.
2261 PARAMS is the list of argument values. */
2264 check_format_info (status, info, params)
2266 function_format_info *info;
2271 format_check_results res;
2272 /* Skip to format argument. If the argument isn't available, there's
2273 no work for us to do; prototype checking will catch the problem. */
2274 for (arg_num = 1; ; ++arg_num)
2278 if (arg_num == info->format_num)
2280 params = TREE_CHAIN (params);
2282 format_tree = TREE_VALUE (params);
2283 params = TREE_CHAIN (params);
2284 if (format_tree == 0)
2287 res.number_non_literal = 0;
2288 res.number_extra_args = 0;
2289 res.number_dollar_extra_args = 0;
2290 res.number_wide = 0;
2291 res.number_empty = 0;
2292 res.number_unterminated = 0;
2293 res.number_other = 0;
2295 check_format_info_recurse (status, &res, info, format_tree, params, arg_num);
2297 if (res.number_non_literal > 0)
2299 /* Functions taking a va_list normally pass a non-literal format
2300 string. These functions typically are declared with
2301 first_arg_num == 0, so avoid warning in those cases. */
2302 if (info->first_arg_num != 0 && warn_format > 1)
2303 status_warning (status, "format not a string literal, argument types not checked");
2306 /* If there were extra arguments to the format, normally warn. However,
2307 the standard does say extra arguments are ignored, so in the specific
2308 case where we have multiple leaves (conditional expressions or
2309 ngettext) allow extra arguments if at least one leaf didn't have extra
2310 arguments, but was otherwise OK (either non-literal or checked OK).
2311 If the format is an empty string, this should be counted similarly to the
2312 case of extra format arguments. */
2313 if (res.number_extra_args > 0 && res.number_non_literal == 0
2314 && res.number_other == 0)
2315 status_warning (status, "too many arguments for format");
2316 if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
2317 && res.number_other == 0)
2318 status_warning (status, "unused arguments in $-style format");
2319 if (res.number_empty > 0 && res.number_non_literal == 0
2320 && res.number_other == 0)
2321 status_warning (status, "zero-length format string");
2323 if (res.number_wide > 0)
2324 status_warning (status, "format is a wide character string");
2326 if (res.number_unterminated > 0)
2327 status_warning (status, "unterminated format string");
2331 /* Recursively check a call to a format function. FORMAT_TREE is the
2332 format parameter, which may be a conditional expression in which
2333 both halves should be checked. ARG_NUM is the number of the
2334 format argument; PARAMS points just after it in the argument list. */
2337 check_format_info_recurse (status, res, info, format_tree, params, arg_num)
2339 format_check_results *res;
2340 function_format_info *info;
2346 const char *format_chars;
2347 tree array_size = 0;
2350 if (TREE_CODE (format_tree) == NOP_EXPR)
2352 /* Strip coercion. */
2353 check_format_info_recurse (status, res, info,
2354 TREE_OPERAND (format_tree, 0), params,
2359 if (TREE_CODE (format_tree) == CALL_EXPR
2360 && TREE_CODE (TREE_OPERAND (format_tree, 0)) == ADDR_EXPR
2361 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0))
2364 tree function = TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0);
2366 /* See if this is a call to a known internationalization function
2367 that modifies the format arg. */
2368 international_format_info *iinfo;
2370 for (iinfo = international_format_list; iinfo; iinfo = iinfo->next)
2371 if (iinfo->assembler_name
2372 ? (iinfo->assembler_name == DECL_ASSEMBLER_NAME (function))
2373 : (iinfo->name == DECL_NAME (function)))
2378 for (inner_args = TREE_OPERAND (format_tree, 1), i = 1;
2380 inner_args = TREE_CHAIN (inner_args), i++)
2381 if (i == iinfo->format_num)
2383 /* FIXME: with Marc Espie's __attribute__((nonnull))
2384 patch in GCC, we will have chained attributes,
2385 and be able to handle functions like ngettext
2386 with multiple format_arg attributes properly. */
2387 check_format_info_recurse (status, res, info,
2388 TREE_VALUE (inner_args), params,
2395 if (TREE_CODE (format_tree) == COND_EXPR)
2397 /* Check both halves of the conditional expression. */
2398 check_format_info_recurse (status, res, info,
2399 TREE_OPERAND (format_tree, 1), params,
2401 check_format_info_recurse (status, res, info,
2402 TREE_OPERAND (format_tree, 2), params,
2407 if (integer_zerop (format_tree))
2409 /* FIXME: this warning should go away once Marc Espie's
2410 __attribute__((nonnull)) patch is in. Instead, checking for
2411 nonnull attributes should probably change this function to act
2412 specially if info == NULL and add a res->number_null entry for
2413 that case, or maybe add a function pointer to be called at
2414 the end instead of hardcoding check_format_info_main. */
2415 status_warning (status, "null format string");
2417 /* Skip to first argument to check, so we can see if this format
2418 has any arguments (it shouldn't). */
2419 while (arg_num + 1 < info->first_arg_num)
2423 params = TREE_CHAIN (params);
2428 res->number_other++;
2430 res->number_extra_args++;
2435 if (TREE_CODE (format_tree) != ADDR_EXPR)
2437 res->number_non_literal++;
2440 format_tree = TREE_OPERAND (format_tree, 0);
2441 if (TREE_CODE (format_tree) == VAR_DECL
2442 && TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE
2443 && (array_init = decl_constant_value (format_tree)) != format_tree
2444 && TREE_CODE (array_init) == STRING_CST)
2446 /* Extract the string constant initializer. Note that this may include
2447 a trailing NUL character that is not in the array (e.g.
2448 const char a[3] = "foo";). */
2449 array_size = DECL_SIZE_UNIT (format_tree);
2450 format_tree = array_init;
2452 if (TREE_CODE (format_tree) != STRING_CST)
2454 res->number_non_literal++;
2457 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree))) != char_type_node)
2462 format_chars = TREE_STRING_POINTER (format_tree);
2463 format_length = TREE_STRING_LENGTH (format_tree);
2464 if (array_size != 0)
2466 /* Variable length arrays can't be initialized. */
2467 if (TREE_CODE (array_size) != INTEGER_CST)
2469 if (host_integerp (array_size, 0))
2471 HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size);
2472 if (array_size_value > 0
2473 && array_size_value == (int) array_size_value
2474 && format_length > array_size_value)
2475 format_length = array_size_value;
2478 if (format_length < 1)
2480 res->number_unterminated++;
2483 if (format_length == 1)
2485 res->number_empty++;
2488 if (format_chars[--format_length] != 0)
2490 res->number_unterminated++;
2494 /* Skip to first argument to check. */
2495 while (arg_num + 1 < info->first_arg_num)
2499 params = TREE_CHAIN (params);
2502 /* Provisionally increment res->number_other; check_format_info_main
2503 will decrement it if it finds there are extra arguments, but this way
2504 need not adjust it for every return. */
2505 res->number_other++;
2506 check_format_info_main (status, res, info, format_chars, format_length,
2511 /* Do the main part of checking a call to a format function. FORMAT_CHARS
2512 is the NUL-terminated format string (which at this point may contain
2513 internal NUL characters); FORMAT_LENGTH is its length (excluding the
2514 terminating NUL character). ARG_NUM is one less than the number of
2515 the first format argument to check; PARAMS points to that format
2516 argument in the list of arguments. */
2519 check_format_info_main (status, res, info, format_chars, format_length,
2522 format_check_results *res;
2523 function_format_info *info;
2524 const char *format_chars;
2529 const char *orig_format_chars = format_chars;
2530 tree first_fillin_param = params;
2532 const format_kind_info *fki = &format_types[info->format_type];
2533 const format_flag_spec *flag_specs = fki->flag_specs;
2534 const format_flag_pair *bad_flag_pairs = fki->bad_flag_pairs;
2536 /* -1 if no conversions taking an operand have been found; 0 if one has
2537 and it didn't use $; 1 if $ formats are in use. */
2538 int has_operand_number = -1;
2540 init_dollar_format_checking (info->first_arg_num, first_fillin_param);
2545 int suppressed = FALSE;
2546 const char *length_chars = NULL;
2547 enum format_lengths length_chars_val = FMT_LEN_none;
2548 enum format_std_version length_chars_std = STD_C89;
2552 int main_arg_num = 0;
2553 tree main_arg_params = 0;
2554 enum format_std_version wanted_type_std;
2555 const char *wanted_type_name;
2556 format_wanted_type width_wanted_type;
2557 format_wanted_type precision_wanted_type;
2558 format_wanted_type main_wanted_type;
2559 format_wanted_type *first_wanted_type = NULL;
2560 format_wanted_type *last_wanted_type = NULL;
2561 const format_length_info *fli = NULL;
2562 const format_char_info *fci = NULL;
2563 char flag_chars[256];
2565 if (*format_chars == 0)
2567 if (format_chars - orig_format_chars != format_length)
2568 status_warning (status, "embedded `\\0' in format");
2569 if (info->first_arg_num != 0 && params != 0
2570 && has_operand_number <= 0)
2572 res->number_other--;
2573 res->number_extra_args++;
2575 if (has_operand_number > 0)
2576 finish_dollar_format_checking (status, res);
2579 if (*format_chars++ != '%')
2581 if (*format_chars == 0)
2583 status_warning (status, "spurious trailing `%%' in format");
2586 if (*format_chars == '%')
2593 if ((fki->flags & FMT_FLAG_ARG_CONVERT) && has_operand_number != 0)
2595 /* Possibly read a $ operand number at the start of the format.
2596 If one was previously used, one is required here. If one
2597 is not used here, we can't immediately conclude this is a
2598 format without them, since it could be printf %m or scanf %*. */
2600 opnum = maybe_read_dollar_number (status, &format_chars, 0,
2602 &main_arg_params, fki);
2607 has_operand_number = 1;
2608 main_arg_num = opnum + info->first_arg_num - 1;
2612 /* Read any format flags, but do not yet validate them beyond removing
2613 duplicates, since in general validation depends on the rest of
2615 while (*format_chars != 0
2616 && strchr (fki->flag_chars, *format_chars) != 0)
2618 if (strchr (flag_chars, *format_chars) != 0)
2620 const format_flag_spec *s = get_flag_spec (flag_specs,
2621 *format_chars, NULL);
2622 status_warning (status, "repeated %s in format", _(s->name));
2626 i = strlen (flag_chars);
2627 flag_chars[i++] = *format_chars;
2633 /* Read any format width, possibly * or *m$. */
2634 if (fki->width_char != 0)
2636 if (fki->width_type != NULL && *format_chars == '*')
2638 i = strlen (flag_chars);
2639 flag_chars[i++] = fki->width_char;
2641 /* "...a field width...may be indicated by an asterisk.
2642 In this case, an int argument supplies the field width..." */
2646 status_warning (status, "too few arguments for format");
2649 if (has_operand_number != 0)
2652 opnum = maybe_read_dollar_number (status, &format_chars,
2653 has_operand_number == 1,
2660 has_operand_number = 1;
2661 arg_num = opnum + info->first_arg_num - 1;
2664 has_operand_number = 0;
2666 if (info->first_arg_num != 0)
2668 cur_param = TREE_VALUE (params);
2669 if (has_operand_number <= 0)
2671 params = TREE_CHAIN (params);
2674 width_wanted_type.wanted_type = *fki->width_type;
2675 width_wanted_type.wanted_type_name = NULL;
2676 width_wanted_type.pointer_count = 0;
2677 width_wanted_type.char_lenient_flag = 0;
2678 width_wanted_type.writing_in_flag = 0;
2679 width_wanted_type.name = _("field width");
2680 width_wanted_type.param = cur_param;
2681 width_wanted_type.arg_num = arg_num;
2682 width_wanted_type.next = NULL;
2683 if (last_wanted_type != 0)
2684 last_wanted_type->next = &width_wanted_type;
2685 if (first_wanted_type == 0)
2686 first_wanted_type = &width_wanted_type;
2687 last_wanted_type = &width_wanted_type;
2692 /* Possibly read a numeric width. If the width is zero,
2693 we complain; for scanf this is bad according to the
2694 standard, and for printf and strftime it cannot occur
2695 because 0 is a flag. */
2696 int non_zero_width_char = FALSE;
2697 int found_width = FALSE;
2698 while (ISDIGIT (*format_chars))
2701 if (*format_chars != '0')
2702 non_zero_width_char = TRUE;
2705 if (found_width && !non_zero_width_char)
2706 status_warning (status, "zero width in %s format",
2710 i = strlen (flag_chars);
2711 flag_chars[i++] = fki->width_char;
2717 /* Read any format precision, possibly * or *m$. */
2718 if (fki->precision_char != 0 && *format_chars == '.')
2721 i = strlen (flag_chars);
2722 flag_chars[i++] = fki->precision_char;
2724 if (fki->precision_type != NULL && *format_chars == '*')
2726 /* "...a...precision...may be indicated by an asterisk.
2727 In this case, an int argument supplies the...precision." */
2729 if (has_operand_number != 0)
2732 opnum = maybe_read_dollar_number (status, &format_chars,
2733 has_operand_number == 1,
2740 has_operand_number = 1;
2741 arg_num = opnum + info->first_arg_num - 1;
2744 has_operand_number = 0;
2746 if (info->first_arg_num != 0)
2750 status_warning (status, "too few arguments for format");
2753 cur_param = TREE_VALUE (params);
2754 if (has_operand_number <= 0)
2756 params = TREE_CHAIN (params);
2759 precision_wanted_type.wanted_type = *fki->precision_type;
2760 precision_wanted_type.wanted_type_name = NULL;
2761 precision_wanted_type.pointer_count = 0;
2762 precision_wanted_type.char_lenient_flag = 0;
2763 precision_wanted_type.writing_in_flag = 0;
2764 precision_wanted_type.name = _("field precision");
2765 precision_wanted_type.param = cur_param;
2766 precision_wanted_type.arg_num = arg_num;
2767 precision_wanted_type.next = NULL;
2768 if (last_wanted_type != 0)
2769 last_wanted_type->next = &precision_wanted_type;
2770 if (first_wanted_type == 0)
2771 first_wanted_type = &precision_wanted_type;
2772 last_wanted_type = &precision_wanted_type;
2777 while (ISDIGIT (*format_chars))
2782 /* Read any length modifier, if this kind of format has them. */
2783 fli = fki->length_char_specs;
2784 length_chars = NULL;
2785 length_chars_val = FMT_LEN_none;
2786 length_chars_std = STD_C89;
2789 while (fli->name != 0 && fli->name[0] != *format_chars)
2794 if (fli->double_name != 0 && fli->name[0] == *format_chars)
2797 length_chars = fli->double_name;
2798 length_chars_val = fli->double_index;
2799 length_chars_std = fli->double_std;
2803 length_chars = fli->name;
2804 length_chars_val = fli->index;
2805 length_chars_std = fli->std;
2807 i = strlen (flag_chars);
2808 flag_chars[i++] = fki->length_code_char;
2813 /* Warn if the length modifier is non-standard. */
2814 if (length_chars_std > C_STD_VER)
2815 status_warning (status, "%s does not support the `%s' %s length modifier",
2816 C_STD_NAME (length_chars_std), length_chars,
2821 /* Read any modifier (strftime E/O). */
2822 if (fki->modifier_chars != NULL)
2824 while (*format_chars != 0
2825 && strchr (fki->modifier_chars, *format_chars) != 0)
2827 if (strchr (flag_chars, *format_chars) != 0)
2829 const format_flag_spec *s = get_flag_spec (flag_specs,
2830 *format_chars, NULL);
2831 status_warning (status, "repeated %s in format", _(s->name));
2835 i = strlen (flag_chars);
2836 flag_chars[i++] = *format_chars;
2843 /* Handle the scanf allocation kludge. */
2844 if (fki->flags & FMT_FLAG_SCANF_A_KLUDGE)
2846 if (*format_chars == 'a' && !flag_isoc99)
2848 if (format_chars[1] == 's' || format_chars[1] == 'S'
2849 || format_chars[1] == '[')
2851 /* `a' is used as a flag. */
2852 i = strlen (flag_chars);
2853 flag_chars[i++] = 'a';
2860 format_char = *format_chars;
2861 if (format_char == 0
2862 || (!(fki->flags & FMT_FLAG_FANCY_PERCENT_OK) && format_char == '%'))
2864 status_warning (status, "conversion lacks type at end of format");
2868 fci = fki->conversion_specs;
2869 while (fci->format_chars != 0
2870 && strchr (fci->format_chars, format_char) == 0)
2872 if (fci->format_chars == 0)
2874 if (ISGRAPH(format_char))
2875 status_warning (status, "unknown conversion type character `%c' in format",
2878 status_warning (status, "unknown conversion type character 0x%x in format",
2884 if (fci->std > C_STD_VER)
2885 status_warning (status, "%s does not support the `%%%c' %s format",
2886 C_STD_NAME (fci->std), format_char, fki->name);
2889 /* Validate the individual flags used, removing any that are invalid. */
2892 for (i = 0; flag_chars[i] != 0; i++)
2894 const format_flag_spec *s = get_flag_spec (flag_specs,
2895 flag_chars[i], NULL);
2896 flag_chars[i - d] = flag_chars[i];
2897 if (flag_chars[i] == fki->length_code_char)
2899 if (strchr (fci->flag_chars, flag_chars[i]) == 0)
2901 status_warning (status, "%s used with `%%%c' %s format",
2902 _(s->name), format_char, fki->name);
2908 const format_flag_spec *t;
2909 if (s->std > C_STD_VER)
2910 status_warning (status, "%s does not support %s",
2911 C_STD_NAME (s->std), _(s->long_name));
2912 t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2);
2913 if (t != NULL && t->std > s->std)
2915 const char *long_name = (t->long_name != NULL
2918 if (t->std > C_STD_VER)
2919 status_warning (status, "%s does not support %s with the `%%%c' %s format",
2920 C_STD_NAME (t->std), _(long_name),
2921 format_char, fki->name);
2925 flag_chars[i - d] = 0;
2928 if ((fki->flags & FMT_FLAG_SCANF_A_KLUDGE)
2929 && strchr (flag_chars, 'a') != 0)
2932 if (fki->suppression_char
2933 && strchr (flag_chars, fki->suppression_char) != 0)
2936 /* Validate the pairs of flags used. */
2937 for (i = 0; bad_flag_pairs[i].flag_char1 != 0; i++)
2939 const format_flag_spec *s, *t;
2940 if (strchr (flag_chars, bad_flag_pairs[i].flag_char1) == 0)
2942 if (strchr (flag_chars, bad_flag_pairs[i].flag_char2) == 0)
2944 if (bad_flag_pairs[i].predicate != 0
2945 && strchr (fci->flags2, bad_flag_pairs[i].predicate) == 0)
2947 s = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char1, NULL);
2948 t = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char2, NULL);
2949 if (bad_flag_pairs[i].ignored)
2951 if (bad_flag_pairs[i].predicate != 0)
2952 status_warning (status, "%s ignored with %s and `%%%c' %s format",
2953 _(s->name), _(t->name), format_char,
2956 status_warning (status, "%s ignored with %s in %s format",
2957 _(s->name), _(t->name), fki->name);
2961 if (bad_flag_pairs[i].predicate != 0)
2962 status_warning (status, "use of %s and %s together with `%%%c' %s format",
2963 _(s->name), _(t->name), format_char,
2966 status_warning (status, "use of %s and %s together in %s format",
2967 _(s->name), _(t->name), fki->name);
2971 /* Give Y2K warnings. */
2974 if (strchr (fci->flags2, '4') != 0)
2975 if (strchr (flag_chars, 'E') != 0)
2979 else if (strchr (fci->flags2, '3') != 0)
2981 else if (strchr (fci->flags2, '2') != 0)
2984 status_warning (status, "`%%%c' yields only last 2 digits of year in some locales",
2986 else if (y2k_level == 2)
2987 status_warning (status, "`%%%c' yields only last 2 digits of year", format_char);
2990 if (strchr (fci->flags2, '[') != 0)
2992 /* Skip over scan set, in case it happens to have '%' in it. */
2993 if (*format_chars == '^')
2995 /* Find closing bracket; if one is hit immediately, then
2996 it's part of the scan set rather than a terminator. */
2997 if (*format_chars == ']')
2999 while (*format_chars && *format_chars != ']')
3001 if (*format_chars != ']')
3002 /* The end of the format string was reached. */
3003 status_warning (status, "no closing `]' for `%%[' format");
3007 wanted_type_name = 0;
3008 if (fki->flags & FMT_FLAG_ARG_CONVERT)
3010 wanted_type = (fci->types[length_chars_val].type
3011 ? *fci->types[length_chars_val].type : 0);
3012 wanted_type_name = fci->types[length_chars_val].name;
3013 wanted_type_std = fci->types[length_chars_val].std;
3014 if (wanted_type == 0)
3016 status_warning (status, "use of `%s' length modifier with `%c' type character",
3017 length_chars, format_char);
3018 /* Heuristic: skip one argument when an invalid length/type
3019 combination is encountered. */
3023 status_warning (status, "too few arguments for format");
3026 params = TREE_CHAIN (params);
3030 /* Warn if non-standard, provided it is more non-standard
3031 than the length and type characters that may already
3032 have been warned for. */
3033 && wanted_type_std > length_chars_std
3034 && wanted_type_std > fci->std)
3036 if (wanted_type_std > C_STD_VER)
3037 status_warning (status, "%s does not support the `%%%s%c' %s format",
3038 C_STD_NAME (wanted_type_std), length_chars,
3039 format_char, fki->name);
3043 /* Finally. . .check type of argument against desired type! */
3044 if (info->first_arg_num == 0)
3046 if ((fci->pointer_count == 0 && wanted_type == void_type_node)
3049 if (main_arg_num != 0)
3052 status_warning (status, "operand number specified with suppressed assignment");
3054 status_warning (status, "operand number specified for format taking no argument");
3059 if (main_arg_num != 0)
3061 arg_num = main_arg_num;
3062 params = main_arg_params;
3067 if (has_operand_number > 0)
3069 status_warning (status, "missing $ operand number in format");
3073 has_operand_number = 0;
3076 status_warning (status, "too few arguments for format");
3080 cur_param = TREE_VALUE (params);
3081 params = TREE_CHAIN (params);
3082 main_wanted_type.wanted_type = wanted_type;
3083 main_wanted_type.wanted_type_name = wanted_type_name;
3084 main_wanted_type.pointer_count = fci->pointer_count + aflag;
3085 main_wanted_type.char_lenient_flag = 0;
3086 if (strchr (fci->flags2, 'c') != 0)
3087 main_wanted_type.char_lenient_flag = 1;
3088 main_wanted_type.writing_in_flag = 0;
3089 if (strchr (fci->flags2, 'W') != 0)
3090 main_wanted_type.writing_in_flag = 1;
3091 main_wanted_type.name = NULL;
3092 main_wanted_type.param = cur_param;
3093 main_wanted_type.arg_num = arg_num;
3094 main_wanted_type.next = NULL;
3095 if (last_wanted_type != 0)
3096 last_wanted_type->next = &main_wanted_type;
3097 if (first_wanted_type == 0)
3098 first_wanted_type = &main_wanted_type;
3099 last_wanted_type = &main_wanted_type;
3102 if (first_wanted_type != 0)
3103 check_format_types (status, first_wanted_type);
3109 /* Check the argument types from a single format conversion (possibly
3110 including width and precision arguments). */
3112 check_format_types (status, types)
3114 format_wanted_type *types;
3116 for (; types != 0; types = types->next)
3126 cur_param = types->param;
3127 cur_type = TREE_TYPE (cur_param);
3128 if (cur_type == error_mark_node)
3131 wanted_type = types->wanted_type;
3132 arg_num = types->arg_num;
3134 /* The following should not occur here. */
3135 if (wanted_type == 0)
3137 if (wanted_type == void_type_node && types->pointer_count == 0)
3140 if (types->pointer_count == 0)
3142 promoted_type = simple_type_promotes_to (wanted_type);
3143 if (promoted_type != NULL_TREE)
3144 wanted_type = promoted_type;
3147 STRIP_NOPS (cur_param);
3149 /* Check the types of any additional pointer arguments
3150 that precede the "real" argument. */
3151 for (i = 0; i < types->pointer_count; ++i)
3153 if (TREE_CODE (cur_type) == POINTER_TYPE)
3155 cur_type = TREE_TYPE (cur_type);
3156 if (cur_type == error_mark_node)
3159 /* Check for writing through a NULL pointer. */
3160 if (types->writing_in_flag
3163 && integer_zerop (cur_param))
3164 status_warning (status,
3165 "writing through null pointer (arg %d)",
3168 if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
3169 cur_param = TREE_OPERAND (cur_param, 0);
3173 /* See if this is an attempt to write into a const type with
3174 scanf or with printf "%n". Note: the writing in happens
3175 at the first indirection only, if for example
3176 void * const * is passed to scanf %p; passing
3177 const void ** is simply passing an incompatible type. */
3178 if (types->writing_in_flag
3180 && (TYPE_READONLY (cur_type)
3182 && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
3183 || (DECL_P (cur_param)
3184 && TREE_READONLY (cur_param))))))
3185 status_warning (status, "writing into constant object (arg %d)", arg_num);
3187 /* If there are extra type qualifiers beyond the first
3188 indirection, then this makes the types technically
3192 && (TYPE_READONLY (cur_type)
3193 || TYPE_VOLATILE (cur_type)
3194 || TYPE_RESTRICT (cur_type)))
3195 status_warning (status, "extra type qualifiers in format argument (arg %d)",
3201 if (types->pointer_count == 1)
3202 status_warning (status, "format argument is not a pointer (arg %d)", arg_num);
3204 status_warning (status, "format argument is not a pointer to a pointer (arg %d)", arg_num);
3209 if (i < types->pointer_count)
3212 orig_cur_type = cur_type;
3213 cur_type = TYPE_MAIN_VARIANT (cur_type);
3215 /* Check whether the argument type is a character type. This leniency
3216 only applies to certain formats, flagged with 'c'.
3218 if (types->char_lenient_flag)
3219 char_type_flag = (cur_type == char_type_node
3220 || cur_type == signed_char_type_node
3221 || cur_type == unsigned_char_type_node);
3223 /* Check the type of the "real" argument, if there's a type we want. */
3224 if (wanted_type == cur_type)
3226 /* If we want `void *', allow any pointer type.
3227 (Anything else would already have got a warning.)
3228 With -pedantic, only allow pointers to void and to character
3230 if (wanted_type == void_type_node
3231 && (!pedantic || (i == 1 && char_type_flag)))
3233 /* Don't warn about differences merely in signedness, unless
3234 -pedantic. With -pedantic, warn if the type is a pointer
3235 target and not a character type, and for character types at
3236 a second level of indirection. */
3237 if (TREE_CODE (wanted_type) == INTEGER_TYPE
3238 && TREE_CODE (cur_type) == INTEGER_TYPE
3239 && (! pedantic || i == 0 || (i == 1 && char_type_flag))
3240 && (TREE_UNSIGNED (wanted_type)
3241 ? wanted_type == unsigned_type (cur_type)
3242 : wanted_type == signed_type (cur_type)))
3244 /* Likewise, "signed char", "unsigned char" and "char" are
3245 equivalent but the above test won't consider them equivalent. */
3246 if (wanted_type == char_type_node
3247 && (! pedantic || i < 2)
3250 /* Now we have a type mismatch. */
3252 register const char *this;
3253 register const char *that;
3255 this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type)));
3257 if (TYPE_NAME (orig_cur_type) != 0
3258 && TREE_CODE (orig_cur_type) != INTEGER_TYPE
3259 && !(TREE_CODE (orig_cur_type) == POINTER_TYPE
3260 && TREE_CODE (TREE_TYPE (orig_cur_type)) == INTEGER_TYPE))
3262 if (TREE_CODE (TYPE_NAME (orig_cur_type)) == TYPE_DECL
3263 && DECL_NAME (TYPE_NAME (orig_cur_type)) != 0)
3264 that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type)));
3266 that = IDENTIFIER_POINTER (TYPE_NAME (orig_cur_type));
3269 /* A nameless type can't possibly match what the format wants.
3270 So there will be a warning for it.
3271 Make up a string to describe vaguely what it is. */
3274 if (TREE_CODE (orig_cur_type) == POINTER_TYPE)
3277 that = "different type";
3280 /* Make the warning better in case of mismatch of int vs long. */
3281 if (TREE_CODE (orig_cur_type) == INTEGER_TYPE
3282 && TREE_CODE (wanted_type) == INTEGER_TYPE
3283 && TYPE_PRECISION (orig_cur_type) == TYPE_PRECISION (wanted_type)
3284 && TYPE_NAME (orig_cur_type) != 0
3285 && TREE_CODE (TYPE_NAME (orig_cur_type)) == TYPE_DECL)
3286 that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type)));
3288 if (strcmp (this, that) != 0)
3290 /* There may be a better name for the format, e.g. size_t,
3291 but we should allow for programs with a perverse typedef
3292 making size_t something other than what the compiler
3294 if (types->wanted_type_name != 0
3295 && strcmp (types->wanted_type_name, that) != 0)
3296 this = types->wanted_type_name;
3297 if (types->name != 0)
3298 status_warning (status, "%s is not type %s (arg %d)", types->name, this,
3301 status_warning (status, "%s format, %s arg (arg %d)", this, that, arg_num);
3307 /* Print a warning if a constant expression had overflow in folding.
3308 Invoke this function on every expression that the language
3309 requires to be a constant expression.
3310 Note the ANSI C standard says it is erroneous for a
3311 constant expression to overflow. */
3314 constant_expression_warning (value)
3317 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
3318 || TREE_CODE (value) == COMPLEX_CST)
3319 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
3320 pedwarn ("overflow in constant expression");
3323 /* Print a warning if an expression had overflow in folding.
3324 Invoke this function on every expression that
3325 (1) appears in the source code, and
3326 (2) might be a constant expression that overflowed, and
3327 (3) is not already checked by convert_and_check;
3328 however, do not invoke this function on operands of explicit casts. */
3331 overflow_warning (value)
3334 if ((TREE_CODE (value) == INTEGER_CST
3335 || (TREE_CODE (value) == COMPLEX_CST
3336 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
3337 && TREE_OVERFLOW (value))
3339 TREE_OVERFLOW (value) = 0;
3340 if (skip_evaluation == 0)
3341 warning ("integer overflow in expression");
3343 else if ((TREE_CODE (value) == REAL_CST
3344 || (TREE_CODE (value) == COMPLEX_CST
3345 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
3346 && TREE_OVERFLOW (value))
3348 TREE_OVERFLOW (value) = 0;
3349 if (skip_evaluation == 0)
3350 warning ("floating point overflow in expression");
3354 /* Print a warning if a large constant is truncated to unsigned,
3355 or if -Wconversion is used and a constant < 0 is converted to unsigned.
3356 Invoke this function on every expression that might be implicitly
3357 converted to an unsigned type. */
3360 unsigned_conversion_warning (result, operand)
3361 tree result, operand;
3363 if (TREE_CODE (operand) == INTEGER_CST
3364 && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
3365 && TREE_UNSIGNED (TREE_TYPE (result))
3366 && skip_evaluation == 0
3367 && !int_fits_type_p (operand, TREE_TYPE (result)))
3369 if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
3370 /* This detects cases like converting -129 or 256 to unsigned char. */
3371 warning ("large integer implicitly truncated to unsigned type");
3372 else if (warn_conversion)
3373 warning ("negative integer implicitly converted to unsigned type");
3377 /* Convert EXPR to TYPE, warning about conversion problems with constants.
3378 Invoke this function on every expression that is converted implicitly,
3379 i.e. because of language rules and not because of an explicit cast. */
3382 convert_and_check (type, expr)
3385 tree t = convert (type, expr);
3386 if (TREE_CODE (t) == INTEGER_CST)
3388 if (TREE_OVERFLOW (t))
3390 TREE_OVERFLOW (t) = 0;
3392 /* Do not diagnose overflow in a constant expression merely
3393 because a conversion overflowed. */
3394 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
3396 /* No warning for converting 0x80000000 to int. */
3397 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
3398 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
3399 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
3400 /* If EXPR fits in the unsigned version of TYPE,
3401 don't warn unless pedantic. */
3403 || TREE_UNSIGNED (type)
3404 || ! int_fits_type_p (expr, unsigned_type (type)))
3405 && skip_evaluation == 0)
3406 warning ("overflow in implicit constant conversion");
3409 unsigned_conversion_warning (t, expr);
3414 /* Describe a reversed version of a normal tree, so that we can get to the
3415 parent of each node. */
3418 /* All reverse_tree structures for a given tree are chained through this
3420 struct reverse_tree *next;
3421 /* The parent of this node. */
3422 struct reverse_tree *parent;
3423 /* The actual tree node. */
3425 /* The operand number this node corresponds to in the parent. */
3427 /* Describe whether this expression is written to or read. */
3431 /* A list of all reverse_tree structures for a given expression, built by
3432 build_reverse_tree. */
3433 static struct reverse_tree *reverse_list;
3434 /* The maximum depth of a tree, computed by build_reverse_tree. */
3435 static int reverse_max_depth;
3437 static void build_reverse_tree PARAMS ((tree, struct reverse_tree *, int, int,
3439 static struct reverse_tree *common_ancestor PARAMS ((struct reverse_tree *,
3440 struct reverse_tree *,
3441 struct reverse_tree **,
3442 struct reverse_tree **));
3443 static int modify_ok PARAMS ((struct reverse_tree *, struct reverse_tree *));
3444 static void verify_sequence_points PARAMS ((tree));
3446 /* Recursively process an expression, X, building a reverse tree while
3447 descending and recording OPERANDNO, READ, and WRITE in the created
3448 structures. DEPTH is used to compute reverse_max_depth.
3449 FIXME: if walk_tree gets moved out of the C++ front end, this should
3450 probably use walk_tree. */
3453 build_reverse_tree (x, parent, operandno, read, write, depth)
3455 struct reverse_tree *parent;
3456 int operandno, read, write, depth;
3458 struct reverse_tree *node;
3460 if (x == 0 || x == error_mark_node)
3463 node = (struct reverse_tree *) xmalloc (sizeof (struct reverse_tree));
3465 node->parent = parent;
3468 node->write = write;
3469 node->operandno = operandno;
3470 node->next = reverse_list;
3471 reverse_list = node;
3472 if (depth > reverse_max_depth)
3473 reverse_max_depth = depth;
3475 switch (TREE_CODE (x))
3477 case PREDECREMENT_EXPR:
3478 case PREINCREMENT_EXPR:
3479 case POSTDECREMENT_EXPR:
3480 case POSTINCREMENT_EXPR:
3481 build_reverse_tree (TREE_OPERAND (x, 0), node, 0, 1, 1, depth + 1);
3485 build_reverse_tree (TREE_OPERAND (x, 0), node, 0, 1, 0, depth + 1);
3486 x = TREE_OPERAND (x, 1);
3489 build_reverse_tree (TREE_VALUE (x), node, 1, 1, 0, depth + 1);
3495 /* Scan all the list, e.g. indices of multi dimensional array. */
3498 build_reverse_tree (TREE_VALUE (x), node, 0, 1, 0, depth + 1);
3504 build_reverse_tree (TREE_OPERAND (x, 0), node, 0, 0, 1, depth + 1);
3505 build_reverse_tree (TREE_OPERAND (x, 1), node, 1, 1, 0, depth + 1);
3509 switch (TREE_CODE_CLASS (TREE_CODE (x)))
3521 int max = first_rtl_op (TREE_CODE (x));
3522 for (lp = 0; lp < max; lp++)
3523 build_reverse_tree (TREE_OPERAND (x, lp), node, lp, 1, 0,
3534 /* Given nodes P1 and P2 as well as enough scratch space pointed to by TMP1
3535 and TMP2, find the common ancestor of P1 and P2. */
3537 static struct reverse_tree *
3538 common_ancestor (p1, p2, tmp1, tmp2)
3539 struct reverse_tree *p1, *p2;
3540 struct reverse_tree **tmp1, **tmp2;
3542 struct reverse_tree *t1 = p1;
3543 struct reverse_tree *t2 = p2;
3546 /* First, check if we're actually looking at the same expression twice,
3547 which can happen if it's wrapped in a SAVE_EXPR - in this case there's
3548 no chance of conflict. */
3549 while (t1 && t2 && t1->x == t2->x)
3551 if (TREE_CODE (t1->x) == SAVE_EXPR)
3557 for (i = 0; p1; i++, p1 = p1->parent)
3559 for (j = 0; p2; j++, p2 = p2->parent)
3561 while (tmp1[i - 1] == tmp2[j - 1])
3567 /* Subroutine of verify_sequence_points to check whether a node T corresponding
3568 to a MODIFY_EXPR invokes undefined behaviour. OTHER occurs somewhere in the
3569 RHS, and an identical expression is the LHS of T.
3570 For MODIFY_EXPRs, some special cases apply when testing for undefined
3571 behaviour if one of the expressions we found is the LHS of the MODIFY_EXPR.
3572 If the other expression is just a use, then there's no undefined behaviour.
3573 Likewise, if the other expression is wrapped inside another expression that
3574 will force a sequence point, then there's no undefined behaviour either. */
3577 modify_ok (t, other)
3578 struct reverse_tree *t, *other;
3580 struct reverse_tree *p;
3585 /* See if there's an intervening sequence point. */
3586 for (p = other; p->parent != t; p = p->parent)
3588 if ((TREE_CODE (p->parent->x) == COMPOUND_EXPR
3589 || TREE_CODE (p->parent->x) == TRUTH_ANDIF_EXPR
3590 || TREE_CODE (p->parent->x) == TRUTH_ORIF_EXPR
3591 || TREE_CODE (p->parent->x) == COND_EXPR)
3592 && p->operandno == 0)
3594 if (TREE_CODE (p->parent->x) == SAVE_EXPR)
3596 if (TREE_CODE (p->parent->x) == CALL_EXPR
3597 && p->operandno != 0)
3603 /* Try to warn for undefined behaviour in EXPR due to missing sequence
3607 verify_sequence_points (expr)
3610 struct reverse_tree **tmp1, **tmp2;
3611 struct reverse_tree *p;
3614 reverse_max_depth = 0;
3615 build_reverse_tree (expr, NULL, 0, 1, 0, 1);
3617 tmp1 = (struct reverse_tree **) xmalloc (sizeof (struct reverse_tree *)
3618 * reverse_max_depth);
3619 tmp2 = (struct reverse_tree **) xmalloc (sizeof (struct reverse_tree *)
3620 * reverse_max_depth);
3622 /* Search for multiple occurrences of the same variable, where either both
3623 occurrences are writes, or one is a read and a write. If we can't prove
3624 that these are ordered by a sequence point, warn that the expression is
3626 for (p = reverse_list; p; p = p->next)
3628 struct reverse_tree *p2;
3629 if (TREE_CODE (p->x) != VAR_DECL && TREE_CODE (p->x) != PARM_DECL)
3631 for (p2 = p->next; p2; p2 = p2->next)
3633 if ((TREE_CODE (p2->x) == VAR_DECL || TREE_CODE (p2->x) == PARM_DECL)
3634 && DECL_NAME (p->x) == DECL_NAME (p2->x)
3635 && (p->write || p2->write))
3637 struct reverse_tree *t = common_ancestor (p, p2, tmp1, tmp2);
3640 || TREE_CODE (t->x) == COMPOUND_EXPR
3641 || TREE_CODE (t->x) == TRUTH_ANDIF_EXPR
3642 || TREE_CODE (t->x) == TRUTH_ORIF_EXPR
3643 || TREE_CODE (t->x) == COND_EXPR)
3645 if (TREE_CODE (t->x) == MODIFY_EXPR
3647 && modify_ok (t, p2))
3649 if (TREE_CODE (t->x) == MODIFY_EXPR
3651 && modify_ok (t, p))
3654 warning ("operation on `%s' may be undefined",
3655 IDENTIFIER_POINTER (DECL_NAME (p->x)));
3661 while (reverse_list)
3663 struct reverse_tree *p = reverse_list;
3664 reverse_list = p->next;
3672 c_expand_expr_stmt (expr)
3675 /* Do default conversion if safe and possibly important,
3676 in case within ({...}). */
3677 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
3678 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
3679 expr = default_conversion (expr);
3681 if (warn_sequence_point)
3682 verify_sequence_points (expr);
3684 if (TREE_TYPE (expr) != error_mark_node
3685 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
3686 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
3687 error ("expression statement has incomplete type");
3689 last_expr_type = TREE_TYPE (expr);
3690 add_stmt (build_stmt (EXPR_STMT, expr));
3693 /* Validate the expression after `case' and apply default promotions. */
3696 check_case_value (value)
3699 if (value == NULL_TREE)
3702 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3703 STRIP_TYPE_NOPS (value);
3704 /* In C++, the following is allowed:
3707 switch (...) { case i: ... }
3709 So, we try to reduce the VALUE to a constant that way. */
3710 if (c_language == clk_cplusplus)
3712 value = decl_constant_value (value);
3713 STRIP_TYPE_NOPS (value);
3714 value = fold (value);
3717 if (TREE_CODE (value) != INTEGER_CST
3718 && value != error_mark_node)
3720 error ("case label does not reduce to an integer constant");
3721 value = error_mark_node;
3724 /* Promote char or short to int. */
3725 value = default_conversion (value);
3727 constant_expression_warning (value);
3732 /* Return an integer type with BITS bits of precision,
3733 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
3736 type_for_size (bits, unsignedp)
3740 if (bits == TYPE_PRECISION (integer_type_node))
3741 return unsignedp ? unsigned_type_node : integer_type_node;
3743 if (bits == TYPE_PRECISION (signed_char_type_node))
3744 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3746 if (bits == TYPE_PRECISION (short_integer_type_node))
3747 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3749 if (bits == TYPE_PRECISION (long_integer_type_node))
3750 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3752 if (bits == TYPE_PRECISION (long_long_integer_type_node))
3753 return (unsignedp ? long_long_unsigned_type_node
3754 : long_long_integer_type_node);
3756 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
3757 return (unsignedp ? widest_unsigned_literal_type_node
3758 : widest_integer_literal_type_node);
3760 if (bits <= TYPE_PRECISION (intQI_type_node))
3761 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3763 if (bits <= TYPE_PRECISION (intHI_type_node))
3764 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3766 if (bits <= TYPE_PRECISION (intSI_type_node))
3767 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3769 if (bits <= TYPE_PRECISION (intDI_type_node))
3770 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3775 /* Return a data type that has machine mode MODE.
3776 If the mode is an integer,
3777 then UNSIGNEDP selects between signed and unsigned types. */
3780 type_for_mode (mode, unsignedp)
3781 enum machine_mode mode;
3784 if (mode == TYPE_MODE (integer_type_node))
3785 return unsignedp ? unsigned_type_node : integer_type_node;
3787 if (mode == TYPE_MODE (signed_char_type_node))
3788 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3790 if (mode == TYPE_MODE (short_integer_type_node))
3791 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3793 if (mode == TYPE_MODE (long_integer_type_node))
3794 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3796 if (mode == TYPE_MODE (long_long_integer_type_node))
3797 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3799 if (mode == TYPE_MODE (widest_integer_literal_type_node))
3800 return unsignedp ? widest_unsigned_literal_type_node
3801 : widest_integer_literal_type_node;
3803 if (mode == TYPE_MODE (intQI_type_node))
3804 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3806 if (mode == TYPE_MODE (intHI_type_node))
3807 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3809 if (mode == TYPE_MODE (intSI_type_node))
3810 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3812 if (mode == TYPE_MODE (intDI_type_node))
3813 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3815 #if HOST_BITS_PER_WIDE_INT >= 64
3816 if (mode == TYPE_MODE (intTI_type_node))
3817 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3820 if (mode == TYPE_MODE (float_type_node))
3821 return float_type_node;
3823 if (mode == TYPE_MODE (double_type_node))
3824 return double_type_node;
3826 if (mode == TYPE_MODE (long_double_type_node))
3827 return long_double_type_node;
3829 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
3830 return build_pointer_type (char_type_node);
3832 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
3833 return build_pointer_type (integer_type_node);
3835 #ifdef VECTOR_MODE_SUPPORTED_P
3836 if (mode == TYPE_MODE (V4SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
3837 return V4SF_type_node;
3838 if (mode == TYPE_MODE (V4SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
3839 return V4SI_type_node;
3840 if (mode == TYPE_MODE (V2SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
3841 return V2SI_type_node;
3842 if (mode == TYPE_MODE (V4HI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
3843 return V4HI_type_node;
3844 if (mode == TYPE_MODE (V8QI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
3845 return V8QI_type_node;
3851 /* Return an unsigned type the same as TYPE in other respects. */
3853 unsigned_type (type)
3856 tree type1 = TYPE_MAIN_VARIANT (type);
3857 if (type1 == signed_char_type_node || type1 == char_type_node)
3858 return unsigned_char_type_node;
3859 if (type1 == integer_type_node)
3860 return unsigned_type_node;
3861 if (type1 == short_integer_type_node)
3862 return short_unsigned_type_node;
3863 if (type1 == long_integer_type_node)
3864 return long_unsigned_type_node;
3865 if (type1 == long_long_integer_type_node)
3866 return long_long_unsigned_type_node;
3867 if (type1 == widest_integer_literal_type_node)
3868 return widest_unsigned_literal_type_node;
3869 #if HOST_BITS_PER_WIDE_INT >= 64
3870 if (type1 == intTI_type_node)
3871 return unsigned_intTI_type_node;
3873 if (type1 == intDI_type_node)
3874 return unsigned_intDI_type_node;
3875 if (type1 == intSI_type_node)
3876 return unsigned_intSI_type_node;
3877 if (type1 == intHI_type_node)
3878 return unsigned_intHI_type_node;
3879 if (type1 == intQI_type_node)
3880 return unsigned_intQI_type_node;
3882 return signed_or_unsigned_type (1, type);
3885 /* Return a signed type the same as TYPE in other respects. */
3891 tree type1 = TYPE_MAIN_VARIANT (type);
3892 if (type1 == unsigned_char_type_node || type1 == char_type_node)
3893 return signed_char_type_node;
3894 if (type1 == unsigned_type_node)
3895 return integer_type_node;
3896 if (type1 == short_unsigned_type_node)
3897 return short_integer_type_node;
3898 if (type1 == long_unsigned_type_node)
3899 return long_integer_type_node;
3900 if (type1 == long_long_unsigned_type_node)
3901 return long_long_integer_type_node;
3902 if (type1 == widest_unsigned_literal_type_node)
3903 return widest_integer_literal_type_node;
3904 #if HOST_BITS_PER_WIDE_INT >= 64
3905 if (type1 == unsigned_intTI_type_node)
3906 return intTI_type_node;
3908 if (type1 == unsigned_intDI_type_node)
3909 return intDI_type_node;
3910 if (type1 == unsigned_intSI_type_node)
3911 return intSI_type_node;
3912 if (type1 == unsigned_intHI_type_node)
3913 return intHI_type_node;
3914 if (type1 == unsigned_intQI_type_node)
3915 return intQI_type_node;
3917 return signed_or_unsigned_type (0, type);
3920 /* Return a type the same as TYPE except unsigned or
3921 signed according to UNSIGNEDP. */
3924 signed_or_unsigned_type (unsignedp, type)
3928 if (! INTEGRAL_TYPE_P (type)
3929 || TREE_UNSIGNED (type) == unsignedp)
3932 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
3933 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3934 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
3935 return unsignedp ? unsigned_type_node : integer_type_node;
3936 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
3937 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3938 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
3939 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3940 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
3941 return (unsignedp ? long_long_unsigned_type_node
3942 : long_long_integer_type_node);
3943 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
3944 return (unsignedp ? widest_unsigned_literal_type_node
3945 : widest_integer_literal_type_node);
3949 /* Return the minimum number of bits needed to represent VALUE in a
3950 signed or unsigned type, UNSIGNEDP says which. */
3953 min_precision (value, unsignedp)
3959 /* If the value is negative, compute its negative minus 1. The latter
3960 adjustment is because the absolute value of the largest negative value
3961 is one larger than the largest positive value. This is equivalent to
3962 a bit-wise negation, so use that operation instead. */
3964 if (tree_int_cst_sgn (value) < 0)
3965 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
3967 /* Return the number of bits needed, taking into account the fact
3968 that we need one more bit for a signed than unsigned type. */
3970 if (integer_zerop (value))
3973 log = tree_floor_log2 (value);
3975 return log + 1 + ! unsignedp;
3978 /* Print an error message for invalid operands to arith operation CODE.
3979 NOP_EXPR is used as a special case (see truthvalue_conversion). */
3982 binary_op_error (code)
3983 enum tree_code code;
3985 register const char *opname;
3990 error ("invalid truth-value expression");
3994 opname = "+"; break;
3996 opname = "-"; break;
3998 opname = "*"; break;
4000 opname = "max"; break;
4002 opname = "min"; break;
4004 opname = "=="; break;
4006 opname = "!="; break;
4008 opname = "<="; break;
4010 opname = ">="; break;
4012 opname = "<"; break;
4014 opname = ">"; break;
4016 opname = "<<"; break;
4018 opname = ">>"; break;
4019 case TRUNC_MOD_EXPR:
4020 case FLOOR_MOD_EXPR:
4021 opname = "%"; break;
4022 case TRUNC_DIV_EXPR:
4023 case FLOOR_DIV_EXPR:
4024 opname = "/"; break;
4026 opname = "&"; break;
4028 opname = "|"; break;
4029 case TRUTH_ANDIF_EXPR:
4030 opname = "&&"; break;
4031 case TRUTH_ORIF_EXPR:
4032 opname = "||"; break;
4034 opname = "^"; break;
4037 opname = "rotate"; break;
4039 opname = "unknown"; break;
4041 error ("invalid operands to binary %s", opname);
4044 /* Subroutine of build_binary_op, used for comparison operations.
4045 See if the operands have both been converted from subword integer types
4046 and, if so, perhaps change them both back to their original type.
4047 This function is also responsible for converting the two operands
4048 to the proper common type for comparison.
4050 The arguments of this function are all pointers to local variables
4051 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
4052 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
4054 If this function returns nonzero, it means that the comparison has
4055 a constant value. What this function returns is an expression for
4059 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
4060 tree *op0_ptr, *op1_ptr;
4062 enum tree_code *rescode_ptr;
4065 tree op0 = *op0_ptr;
4066 tree op1 = *op1_ptr;
4067 int unsignedp0, unsignedp1;
4069 tree primop0, primop1;
4070 enum tree_code code = *rescode_ptr;
4072 /* Throw away any conversions to wider types
4073 already present in the operands. */
4075 primop0 = get_narrower (op0, &unsignedp0);
4076 primop1 = get_narrower (op1, &unsignedp1);
4078 /* Handle the case that OP0 does not *contain* a conversion
4079 but it *requires* conversion to FINAL_TYPE. */
4081 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
4082 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
4083 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
4084 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
4086 /* If one of the operands must be floated, we cannot optimize. */
4087 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
4088 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
4090 /* If first arg is constant, swap the args (changing operation
4091 so value is preserved), for canonicalization. Don't do this if
4092 the second arg is 0. */
4094 if (TREE_CONSTANT (primop0)
4095 && ! integer_zerop (primop1) && ! real_zerop (primop1))
4097 register tree tem = primop0;
4098 register int temi = unsignedp0;
4106 unsignedp0 = unsignedp1;
4129 *rescode_ptr = code;
4132 /* If comparing an integer against a constant more bits wide,
4133 maybe we can deduce a value of 1 or 0 independent of the data.
4134 Or else truncate the constant now
4135 rather than extend the variable at run time.
4137 This is only interesting if the constant is the wider arg.
4138 Also, it is not safe if the constant is unsigned and the
4139 variable arg is signed, since in this case the variable
4140 would be sign-extended and then regarded as unsigned.
4141 Our technique fails in this case because the lowest/highest
4142 possible unsigned results don't follow naturally from the
4143 lowest/highest possible values of the variable operand.
4144 For just EQ_EXPR and NE_EXPR there is another technique that
4145 could be used: see if the constant can be faithfully represented
4146 in the other operand's type, by truncating it and reextending it
4147 and see if that preserves the constant's value. */
4149 if (!real1 && !real2
4150 && TREE_CODE (primop1) == INTEGER_CST
4151 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
4153 int min_gt, max_gt, min_lt, max_lt;
4154 tree maxval, minval;
4155 /* 1 if comparison is nominally unsigned. */
4156 int unsignedp = TREE_UNSIGNED (*restype_ptr);
4159 type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
4161 /* If TYPE is an enumeration, then we need to get its min/max
4162 values from it's underlying integral type, not the enumerated
4164 if (TREE_CODE (type) == ENUMERAL_TYPE)
4165 type = type_for_size (TYPE_PRECISION (type), unsignedp0);
4167 maxval = TYPE_MAX_VALUE (type);
4168 minval = TYPE_MIN_VALUE (type);
4170 if (unsignedp && !unsignedp0)
4171 *restype_ptr = signed_type (*restype_ptr);
4173 if (TREE_TYPE (primop1) != *restype_ptr)
4174 primop1 = convert (*restype_ptr, primop1);
4175 if (type != *restype_ptr)
4177 minval = convert (*restype_ptr, minval);
4178 maxval = convert (*restype_ptr, maxval);
4181 if (unsignedp && unsignedp0)
4183 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
4184 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
4185 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
4186 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
4190 min_gt = INT_CST_LT (primop1, minval);
4191 max_gt = INT_CST_LT (primop1, maxval);
4192 min_lt = INT_CST_LT (minval, primop1);
4193 max_lt = INT_CST_LT (maxval, primop1);
4197 /* This used to be a switch, but Genix compiler can't handle that. */
4198 if (code == NE_EXPR)
4200 if (max_lt || min_gt)
4201 val = boolean_true_node;
4203 else if (code == EQ_EXPR)
4205 if (max_lt || min_gt)
4206 val = boolean_false_node;
4208 else if (code == LT_EXPR)
4211 val = boolean_true_node;
4213 val = boolean_false_node;
4215 else if (code == GT_EXPR)
4218 val = boolean_true_node;
4220 val = boolean_false_node;
4222 else if (code == LE_EXPR)
4225 val = boolean_true_node;
4227 val = boolean_false_node;
4229 else if (code == GE_EXPR)
4232 val = boolean_true_node;
4234 val = boolean_false_node;
4237 /* If primop0 was sign-extended and unsigned comparison specd,
4238 we did a signed comparison above using the signed type bounds.
4239 But the comparison we output must be unsigned.
4241 Also, for inequalities, VAL is no good; but if the signed
4242 comparison had *any* fixed result, it follows that the
4243 unsigned comparison just tests the sign in reverse
4244 (positive values are LE, negative ones GE).
4245 So we can generate an unsigned comparison
4246 against an extreme value of the signed type. */
4248 if (unsignedp && !unsignedp0)
4255 primop1 = TYPE_MIN_VALUE (type);
4261 primop1 = TYPE_MAX_VALUE (type);
4268 type = unsigned_type (type);
4271 if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
4273 /* This is the case of (char)x >?< 0x80, which people used to use
4274 expecting old C compilers to change the 0x80 into -0x80. */
4275 if (val == boolean_false_node)
4276 warning ("comparison is always false due to limited range of data type");
4277 if (val == boolean_true_node)
4278 warning ("comparison is always true due to limited range of data type");
4281 if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
4283 /* This is the case of (unsigned char)x >?< -1 or < 0. */
4284 if (val == boolean_false_node)
4285 warning ("comparison is always false due to limited range of data type");
4286 if (val == boolean_true_node)
4287 warning ("comparison is always true due to limited range of data type");
4292 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
4293 if (TREE_SIDE_EFFECTS (primop0))
4294 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
4298 /* Value is not predetermined, but do the comparison
4299 in the type of the operand that is not constant.
4300 TYPE is already properly set. */
4302 else if (real1 && real2
4303 && (TYPE_PRECISION (TREE_TYPE (primop0))
4304 == TYPE_PRECISION (TREE_TYPE (primop1))))
4305 type = TREE_TYPE (primop0);
4307 /* If args' natural types are both narrower than nominal type
4308 and both extend in the same manner, compare them
4309 in the type of the wider arg.
4310 Otherwise must actually extend both to the nominal
4311 common type lest different ways of extending
4313 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
4315 else if (unsignedp0 == unsignedp1 && real1 == real2
4316 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
4317 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
4319 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
4320 type = signed_or_unsigned_type (unsignedp0
4321 || TREE_UNSIGNED (*restype_ptr),
4323 /* Make sure shorter operand is extended the right way
4324 to match the longer operand. */
4325 primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
4327 primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
4332 /* Here we must do the comparison on the nominal type
4333 using the args exactly as we received them. */
4334 type = *restype_ptr;
4338 if (!real1 && !real2 && integer_zerop (primop1)
4339 && TREE_UNSIGNED (*restype_ptr))
4345 /* All unsigned values are >= 0, so we warn if extra warnings
4346 are requested. However, if OP0 is a constant that is
4347 >= 0, the signedness of the comparison isn't an issue,
4348 so suppress the warning. */
4349 if (extra_warnings && !in_system_header
4350 && ! (TREE_CODE (primop0) == INTEGER_CST
4351 && ! TREE_OVERFLOW (convert (signed_type (type),
4353 warning ("comparison of unsigned expression >= 0 is always true");
4354 value = boolean_true_node;
4358 if (extra_warnings && !in_system_header
4359 && ! (TREE_CODE (primop0) == INTEGER_CST
4360 && ! TREE_OVERFLOW (convert (signed_type (type),
4362 warning ("comparison of unsigned expression < 0 is always false");
4363 value = boolean_false_node;
4372 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
4373 if (TREE_SIDE_EFFECTS (primop0))
4374 return build (COMPOUND_EXPR, TREE_TYPE (value),
4381 *op0_ptr = convert (type, primop0);
4382 *op1_ptr = convert (type, primop1);
4384 *restype_ptr = boolean_type_node;
4389 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
4390 or validate its data type for an `if' or `while' statement or ?..: exp.
4392 This preparation consists of taking the ordinary
4393 representation of an expression expr and producing a valid tree
4394 boolean expression describing whether expr is nonzero. We could
4395 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
4396 but we optimize comparisons, &&, ||, and !.
4398 The resulting type should always be `boolean_type_node'. */
4401 truthvalue_conversion (expr)
4404 if (TREE_CODE (expr) == ERROR_MARK)
4407 #if 0 /* This appears to be wrong for C++. */
4408 /* These really should return error_mark_node after 2.4 is stable.
4409 But not all callers handle ERROR_MARK properly. */
4410 switch (TREE_CODE (TREE_TYPE (expr)))
4413 error ("struct type value used where scalar is required");
4414 return boolean_false_node;
4417 error ("union type value used where scalar is required");
4418 return boolean_false_node;
4421 error ("array type value used where scalar is required");
4422 return boolean_false_node;
4429 switch (TREE_CODE (expr))
4432 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
4433 case TRUTH_ANDIF_EXPR:
4434 case TRUTH_ORIF_EXPR:
4435 case TRUTH_AND_EXPR:
4437 case TRUTH_XOR_EXPR:
4438 case TRUTH_NOT_EXPR:
4439 TREE_TYPE (expr) = boolean_type_node;
4446 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
4449 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
4452 /* If we are taking the address of a external decl, it might be zero
4453 if it is weak, so we cannot optimize. */
4454 if (DECL_P (TREE_OPERAND (expr, 0))
4455 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
4458 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
4459 return build (COMPOUND_EXPR, boolean_type_node,
4460 TREE_OPERAND (expr, 0), boolean_true_node);
4462 return boolean_true_node;
4465 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
4466 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4467 truthvalue_conversion (TREE_OPERAND (expr, 0)),
4468 truthvalue_conversion (TREE_OPERAND (expr, 1)),
4475 /* These don't change whether an object is non-zero or zero. */
4476 return truthvalue_conversion (TREE_OPERAND (expr, 0));
4480 /* These don't change whether an object is zero or non-zero, but
4481 we can't ignore them if their second arg has side-effects. */
4482 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
4483 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
4484 truthvalue_conversion (TREE_OPERAND (expr, 0)));
4486 return truthvalue_conversion (TREE_OPERAND (expr, 0));
4489 /* Distribute the conversion into the arms of a COND_EXPR. */
4490 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
4491 truthvalue_conversion (TREE_OPERAND (expr, 1)),
4492 truthvalue_conversion (TREE_OPERAND (expr, 2))));
4495 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4496 since that affects how `default_conversion' will behave. */
4497 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
4498 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
4500 /* fall through... */
4502 /* If this is widening the argument, we can ignore it. */
4503 if (TYPE_PRECISION (TREE_TYPE (expr))
4504 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
4505 return truthvalue_conversion (TREE_OPERAND (expr, 0));
4509 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
4511 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
4512 && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
4514 /* fall through... */
4516 /* This and MINUS_EXPR can be changed into a comparison of the
4518 if (TREE_TYPE (TREE_OPERAND (expr, 0))
4519 == TREE_TYPE (TREE_OPERAND (expr, 1)))
4520 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
4521 TREE_OPERAND (expr, 1), 1);
4522 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
4523 fold (build1 (NOP_EXPR,
4524 TREE_TYPE (TREE_OPERAND (expr, 0)),
4525 TREE_OPERAND (expr, 1))), 1);
4528 if (integer_onep (TREE_OPERAND (expr, 1))
4529 && TREE_TYPE (expr) != boolean_type_node)
4530 /* Using convert here would cause infinite recursion. */
4531 return build1 (NOP_EXPR, boolean_type_node, expr);
4535 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
4536 warning ("suggest parentheses around assignment used as truth value");
4543 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
4545 tree tem = save_expr (expr);
4546 return (build_binary_op
4547 ((TREE_SIDE_EFFECTS (expr)
4548 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4549 truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
4550 truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
4554 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
4558 /* Read the rest of a #-directive from input stream FINPUT.
4559 In normal use, the directive name and the white space after it
4560 have already been read, so they won't be included in the result.
4561 We allow for the fact that the directive line may contain
4562 a newline embedded within a character or string literal which forms
4563 a part of the directive.
4565 The value is a string in a reusable buffer. It remains valid
4566 only until the next time this function is called.
4568 The terminating character ('\n' or EOF) is left in FINPUT for the
4569 caller to re-read. */
4572 get_directive_line (finput)
4573 register FILE *finput;
4575 static char *directive_buffer = NULL;
4576 static unsigned buffer_length = 0;
4578 register char *buffer_limit;
4579 register int looking_for = 0;
4580 register int char_escaped = 0;
4582 if (buffer_length == 0)
4584 directive_buffer = (char *)xmalloc (128);
4585 buffer_length = 128;
4588 buffer_limit = &directive_buffer[buffer_length];
4590 for (p = directive_buffer; ; )
4594 /* Make buffer bigger if it is full. */
4595 if (p >= buffer_limit)
4597 register unsigned bytes_used = (p - directive_buffer);
4601 = (char *)xrealloc (directive_buffer, buffer_length);
4602 p = &directive_buffer[bytes_used];
4603 buffer_limit = &directive_buffer[buffer_length];
4608 /* Discard initial whitespace. */
4609 if ((c == ' ' || c == '\t') && p == directive_buffer)
4612 /* Detect the end of the directive. */
4613 if (looking_for == 0
4614 && (c == '\n' || c == EOF))
4623 return directive_buffer;
4625 /* Handle string and character constant syntax. */
4628 if (looking_for == c && !char_escaped)
4629 looking_for = 0; /* Found terminator... stop looking. */
4632 if (c == '\'' || c == '"')
4633 looking_for = c; /* Don't stop buffering until we see another
4634 one of these (or an EOF). */
4636 /* Handle backslash. */
4637 char_escaped = (c == '\\' && ! char_escaped);
4640 #endif /* USE_CPPLIB */
4642 /* Make a variant type in the proper way for C/C++, propagating qualifiers
4643 down to the element type of an array. */
4646 c_build_qualified_type (type, type_quals)
4650 /* A restrict-qualified pointer type must be a pointer to object or
4651 incomplete type. Note that the use of POINTER_TYPE_P also allows
4652 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
4653 the C++ front-end also use POINTER_TYPE for pointer-to-member
4654 values, so even though it should be illegal to use `restrict'
4655 with such an entity we don't flag that here. Thus, special case
4656 code for that case is required in the C++ front-end. */
4657 if ((type_quals & TYPE_QUAL_RESTRICT)
4658 && (!POINTER_TYPE_P (type)
4659 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
4661 error ("invalid use of `restrict'");
4662 type_quals &= ~TYPE_QUAL_RESTRICT;
4665 if (TREE_CODE (type) == ARRAY_TYPE)
4666 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
4668 TYPE_DOMAIN (type));
4669 return build_qualified_type (type, type_quals);
4672 /* Apply the TYPE_QUALS to the new DECL. */
4675 c_apply_type_quals_to_decl (type_quals, decl)
4679 if ((type_quals & TYPE_QUAL_CONST)
4680 || (TREE_TYPE (decl)
4681 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
4682 TREE_READONLY (decl) = 1;
4683 if (type_quals & TYPE_QUAL_VOLATILE)
4685 TREE_SIDE_EFFECTS (decl) = 1;
4686 TREE_THIS_VOLATILE (decl) = 1;
4688 if (type_quals & TYPE_QUAL_RESTRICT)
4690 if (!TREE_TYPE (decl)
4691 || !POINTER_TYPE_P (TREE_TYPE (decl))
4692 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
4693 error ("invalid use of `restrict'");
4694 else if (flag_strict_aliasing)
4696 /* No two restricted pointers can point at the same thing.
4697 However, a restricted pointer can point at the same thing
4698 as an unrestricted pointer, if that unrestricted pointer
4699 is based on the restricted pointer. So, we make the
4700 alias set for the restricted pointer a subset of the
4701 alias set for the type pointed to by the type of the
4704 HOST_WIDE_INT pointed_to_alias_set
4705 = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
4707 if (pointed_to_alias_set == 0)
4708 /* It's not legal to make a subset of alias set zero. */
4712 DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
4713 record_alias_subset (pointed_to_alias_set,
4714 DECL_POINTER_ALIAS_SET (decl));
4721 /* Return the typed-based alias set for T, which may be an expression
4722 or a type. Return -1 if we don't do anything special. */
4725 lang_get_alias_set (t)
4730 /* Permit type-punning when accessing a union, provided the access
4731 is directly through the union. For example, this code does not
4732 permit taking the address of a union member and then storing
4733 through it. Even the type-punning allowed here is a GCC
4734 extension, albeit a common and useful one; the C standard says
4735 that such accesses have implementation-defined behavior. */
4737 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4738 u = TREE_OPERAND (u, 0))
4739 if (TREE_CODE (u) == COMPONENT_REF
4740 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4743 /* If this is a char *, the ANSI C standard says it can alias
4744 anything. Note that all references need do this. */
4745 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
4746 && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
4747 && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
4750 /* That's all the expressions we handle specially. */
4754 /* The C standard specifically allows aliasing between signed and
4755 unsigned variants of the same type. We treat the signed
4756 variant as canonical. */
4757 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
4759 tree t1 = signed_type (t);
4761 /* t1 == t can happen for boolean nodes which are always unsigned. */
4763 return get_alias_set (t1);
4765 else if (POINTER_TYPE_P (t))
4769 /* Unfortunately, there is no canonical form of a pointer type.
4770 In particular, if we have `typedef int I', then `int *', and
4771 `I *' are different types. So, we have to pick a canonical
4772 representative. We do this below.
4774 Technically, this approach is actually more conservative that
4775 it needs to be. In particular, `const int *' and `int *'
4776 chould be in different alias sets, according to the C and C++
4777 standard, since their types are not the same, and so,
4778 technically, an `int **' and `const int **' cannot point at
4781 But, the standard is wrong. In particular, this code is
4786 const int* const* cipp = &ip;
4788 And, it doesn't make sense for that to be legal unless you
4789 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
4790 the pointed-to types. This issue has been reported to the
4792 t1 = TYPE_MAIN_VARIANT (TREE_TYPE (t));
4793 t1 = ((TREE_CODE (t) == POINTER_TYPE)
4794 ? build_pointer_type (t1) : build_reference_type (t1));
4796 return get_alias_set (t1);
4798 /* It's not yet safe to use alias sets for classes in C++ because
4799 the TYPE_FIELDs list for a class doesn't mention base classes. */
4800 else if (c_language == clk_cplusplus && AGGREGATE_TYPE_P (t))
4806 /* Build tree nodes and builtin functions common to both C and C++ language
4810 c_common_nodes_and_builtins ()
4813 tree memcpy_ftype, memset_ftype, strlen_ftype;
4814 tree bzero_ftype, bcmp_ftype, puts_ftype, printf_ftype;
4815 tree endlink, int_endlink, double_endlink, unsigned_endlink;
4816 tree sizetype_endlink;
4817 tree ptr_ftype, ptr_ftype_unsigned;
4818 tree void_ftype_any, void_ftype_int, int_ftype_any, sizet_ftype_any;
4819 tree double_ftype_double, double_ftype_double_double;
4820 tree float_ftype_float, ldouble_ftype_ldouble;
4821 tree int_ftype_cptr_cptr_sizet;
4822 tree int_ftype_string_string, string_ftype_ptr_ptr;
4823 tree string_ftype_string_int, string_ftype_string_string;
4824 tree long_ftype_long;
4825 tree longlong_ftype_longlong;
4826 /* Either char* or void*. */
4827 tree traditional_ptr_type_node;
4828 /* Either const char* or const void*. */
4829 tree traditional_cptr_type_node;
4830 tree traditional_len_type_node;
4831 tree traditional_len_endlink;
4832 tree va_list_ref_type_node;
4833 tree va_list_arg_type_node;
4835 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
4836 va_list_type_node));
4838 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
4839 ptrdiff_type_node));
4841 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
4844 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4846 va_list_arg_type_node = va_list_ref_type_node =
4847 build_pointer_type (TREE_TYPE (va_list_type_node));
4851 va_list_arg_type_node = va_list_type_node;
4852 va_list_ref_type_node = build_reference_type (va_list_type_node);
4855 endlink = void_list_node;
4856 int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
4857 double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
4858 unsigned_endlink = tree_cons (NULL_TREE, unsigned_type_node, endlink);
4860 ptr_ftype = build_function_type (ptr_type_node, NULL_TREE);
4861 ptr_ftype_unsigned = build_function_type (ptr_type_node, unsigned_endlink);
4862 sizetype_endlink = tree_cons (NULL_TREE, TYPE_DOMAIN (sizetype), endlink);
4863 /* We realloc here because sizetype could be int or unsigned. S'ok. */
4864 ptr_ftype_sizetype = build_function_type (ptr_type_node, sizetype_endlink);
4866 sizet_ftype_any = build_function_type (sizetype, NULL_TREE);
4867 int_ftype_any = build_function_type (integer_type_node, NULL_TREE);
4868 void_ftype_any = build_function_type (void_type_node, NULL_TREE);
4869 void_ftype = build_function_type (void_type_node, endlink);
4870 void_ftype_int = build_function_type (void_type_node, int_endlink);
4872 = build_function_type (void_type_node,
4873 tree_cons (NULL_TREE, ptr_type_node, endlink));
4876 = build_function_type (float_type_node,
4877 tree_cons (NULL_TREE, float_type_node, endlink));
4880 = build_function_type (double_type_node, double_endlink);
4882 ldouble_ftype_ldouble
4883 = build_function_type (long_double_type_node,
4884 tree_cons (NULL_TREE, long_double_type_node,
4887 double_ftype_double_double
4888 = build_function_type (double_type_node,
4889 tree_cons (NULL_TREE, double_type_node,
4893 = build_function_type (integer_type_node, int_endlink);
4896 = build_function_type (long_integer_type_node,
4897 tree_cons (NULL_TREE, long_integer_type_node,
4900 longlong_ftype_longlong
4901 = build_function_type (long_long_integer_type_node,
4902 tree_cons (NULL_TREE, long_long_integer_type_node,
4905 int_ftype_cptr_cptr_sizet
4906 = build_function_type (integer_type_node,
4907 tree_cons (NULL_TREE, const_ptr_type_node,
4908 tree_cons (NULL_TREE, const_ptr_type_node,
4909 tree_cons (NULL_TREE,
4913 void_zero_node = build_int_2 (0, 0);
4914 TREE_TYPE (void_zero_node) = void_type_node;
4916 /* Prototype for strcpy. */
4917 string_ftype_ptr_ptr
4918 = build_function_type (string_type_node,
4919 tree_cons (NULL_TREE, string_type_node,
4920 tree_cons (NULL_TREE,
4921 const_string_type_node,
4924 traditional_len_type_node = ((flag_traditional &&
4925 c_language != clk_cplusplus)
4926 ? integer_type_node : sizetype);
4927 traditional_len_endlink = tree_cons (NULL_TREE, traditional_len_type_node,
4930 /* Prototype for strcmp. */
4931 int_ftype_string_string
4932 = build_function_type (integer_type_node,
4933 tree_cons (NULL_TREE, const_string_type_node,
4934 tree_cons (NULL_TREE,
4935 const_string_type_node,
4938 /* Prototype for strstr, strpbrk, etc. */
4939 string_ftype_string_string
4940 = build_function_type (string_type_node,
4941 tree_cons (NULL_TREE, const_string_type_node,
4942 tree_cons (NULL_TREE,
4943 const_string_type_node,
4946 /* Prototype for strchr. */
4947 string_ftype_string_int
4948 = build_function_type (string_type_node,
4949 tree_cons (NULL_TREE, const_string_type_node,
4950 tree_cons (NULL_TREE,
4954 /* Prototype for strlen. */
4956 = build_function_type (traditional_len_type_node,
4957 tree_cons (NULL_TREE, const_string_type_node,
4960 traditional_ptr_type_node = ((flag_traditional &&
4961 c_language != clk_cplusplus)
4962 ? string_type_node : ptr_type_node);
4963 traditional_cptr_type_node = ((flag_traditional &&
4964 c_language != clk_cplusplus)
4965 ? const_string_type_node : const_ptr_type_node);
4967 /* Prototype for memcpy. */
4969 = build_function_type (traditional_ptr_type_node,
4970 tree_cons (NULL_TREE, ptr_type_node,
4971 tree_cons (NULL_TREE, const_ptr_type_node,
4972 sizetype_endlink)));
4974 /* Prototype for memset. */
4976 = build_function_type (traditional_ptr_type_node,
4977 tree_cons (NULL_TREE, ptr_type_node,
4978 tree_cons (NULL_TREE, integer_type_node,
4979 tree_cons (NULL_TREE,
4983 /* Prototype for bzero. */
4985 = build_function_type (void_type_node,
4986 tree_cons (NULL_TREE, traditional_ptr_type_node,
4987 traditional_len_endlink));
4989 /* Prototype for bcmp. */
4991 = build_function_type (integer_type_node,
4992 tree_cons (NULL_TREE, traditional_cptr_type_node,
4993 tree_cons (NULL_TREE,
4994 traditional_cptr_type_node,
4995 traditional_len_endlink)));
4997 /* Prototype for puts. */
4999 = build_function_type (integer_type_node,
5000 tree_cons (NULL_TREE, const_string_type_node,
5003 /* Prototype for printf. */
5005 = build_function_type (integer_type_node,
5006 tree_cons (NULL_TREE, const_string_type_node,
5009 builtin_function ("__builtin_constant_p", default_function_type,
5010 BUILT_IN_CONSTANT_P, BUILT_IN_NORMAL, NULL_PTR);
5012 builtin_function ("__builtin_return_address", ptr_ftype_unsigned,
5013 BUILT_IN_RETURN_ADDRESS, BUILT_IN_NORMAL, NULL_PTR);
5015 builtin_function ("__builtin_frame_address", ptr_ftype_unsigned,
5016 BUILT_IN_FRAME_ADDRESS, BUILT_IN_NORMAL, NULL_PTR);
5018 builtin_function ("__builtin_alloca", ptr_ftype_sizetype,
5019 BUILT_IN_ALLOCA, BUILT_IN_NORMAL, "alloca");
5020 builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS,
5021 BUILT_IN_NORMAL, NULL_PTR);
5022 /* Define alloca, ffs as builtins.
5023 Declare _exit just to mark it as volatile. */
5024 if (! flag_no_builtin && ! flag_no_nonansi_builtin)
5027 temp = builtin_function ("alloca", ptr_ftype_sizetype,
5028 BUILT_IN_ALLOCA, BUILT_IN_NORMAL, NULL_PTR);
5029 /* Suppress error if redefined as a non-function. */
5030 DECL_BUILT_IN_NONANSI (temp) = 1;
5032 temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS,
5033 BUILT_IN_NORMAL, NULL_PTR);
5034 /* Suppress error if redefined as a non-function. */
5035 DECL_BUILT_IN_NONANSI (temp) = 1;
5036 temp = builtin_function ("_exit", void_ftype_int,
5037 0, NOT_BUILT_IN, NULL_PTR);
5038 TREE_THIS_VOLATILE (temp) = 1;
5039 TREE_SIDE_EFFECTS (temp) = 1;
5040 /* Suppress error if redefined as a non-function. */
5041 DECL_BUILT_IN_NONANSI (temp) = 1;
5043 /* The system prototypes for these functions have many
5044 variations, so don't specify parameters to avoid conflicts.
5045 The expand_* functions check the argument types anyway. */
5046 temp = builtin_function ("bzero", void_ftype_any,
5047 BUILT_IN_BZERO, BUILT_IN_NORMAL, NULL_PTR);
5048 DECL_BUILT_IN_NONANSI (temp) = 1;
5049 temp = builtin_function ("bcmp", int_ftype_any,
5050 BUILT_IN_BCMP, BUILT_IN_NORMAL, NULL_PTR);
5051 DECL_BUILT_IN_NONANSI (temp) = 1;
5054 builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS,
5055 BUILT_IN_NORMAL, NULL_PTR);
5056 builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
5057 BUILT_IN_NORMAL, NULL_PTR);
5058 builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
5059 BUILT_IN_NORMAL, NULL_PTR);
5060 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
5061 BUILT_IN_NORMAL, NULL_PTR);
5062 builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS,
5063 BUILT_IN_NORMAL, NULL_PTR);
5064 builtin_function ("__builtin_llabs", longlong_ftype_longlong, BUILT_IN_LLABS,
5065 BUILT_IN_NORMAL, NULL_PTR);
5066 builtin_function ("__builtin_saveregs", ptr_ftype, BUILT_IN_SAVEREGS,
5067 BUILT_IN_NORMAL, NULL_PTR);
5068 builtin_function ("__builtin_classify_type", default_function_type,
5069 BUILT_IN_CLASSIFY_TYPE, BUILT_IN_NORMAL, NULL_PTR);
5070 builtin_function ("__builtin_next_arg", ptr_ftype, BUILT_IN_NEXT_ARG,
5071 BUILT_IN_NORMAL, NULL_PTR);
5072 builtin_function ("__builtin_args_info", int_ftype_int, BUILT_IN_ARGS_INFO,
5073 BUILT_IN_NORMAL, NULL_PTR);
5074 builtin_function ("__builtin_setjmp",
5075 build_function_type (integer_type_node,
5076 tree_cons (NULL_TREE, ptr_type_node,
5078 BUILT_IN_SETJMP, BUILT_IN_NORMAL, NULL_PTR);
5079 builtin_function ("__builtin_longjmp",
5080 build_function_type (void_type_node,
5081 tree_cons (NULL_TREE, ptr_type_node,
5082 tree_cons (NULL_TREE,
5085 BUILT_IN_LONGJMP, BUILT_IN_NORMAL, NULL_PTR);
5086 builtin_function ("__builtin_trap", void_ftype, BUILT_IN_TRAP,
5087 BUILT_IN_NORMAL, NULL_PTR);
5089 /* ISO C99 IEEE Unordered compares. */
5090 builtin_function ("__builtin_isgreater", default_function_type,
5091 BUILT_IN_ISGREATER, BUILT_IN_NORMAL, NULL_PTR);
5092 builtin_function ("__builtin_isgreaterequal", default_function_type,
5093 BUILT_IN_ISGREATEREQUAL, BUILT_IN_NORMAL, NULL_PTR);
5094 builtin_function ("__builtin_isless", default_function_type,
5095 BUILT_IN_ISLESS, BUILT_IN_NORMAL, NULL_PTR);
5096 builtin_function ("__builtin_islessequal", default_function_type,
5097 BUILT_IN_ISLESSEQUAL, BUILT_IN_NORMAL, NULL_PTR);
5098 builtin_function ("__builtin_islessgreater", default_function_type,
5099 BUILT_IN_ISLESSGREATER, BUILT_IN_NORMAL, NULL_PTR);
5100 builtin_function ("__builtin_isunordered", default_function_type,
5101 BUILT_IN_ISUNORDERED, BUILT_IN_NORMAL, NULL_PTR);
5103 /* Untyped call and return. */
5104 builtin_function ("__builtin_apply_args", ptr_ftype,
5105 BUILT_IN_APPLY_ARGS, BUILT_IN_NORMAL, NULL_PTR);
5107 temp = tree_cons (NULL_TREE,
5108 build_pointer_type (build_function_type (void_type_node,
5110 tree_cons (NULL_TREE,
5112 tree_cons (NULL_TREE,
5115 builtin_function ("__builtin_apply",
5116 build_function_type (ptr_type_node, temp),
5117 BUILT_IN_APPLY, BUILT_IN_NORMAL, NULL_PTR);
5118 builtin_function ("__builtin_return", void_ftype_ptr,
5119 BUILT_IN_RETURN, BUILT_IN_NORMAL, NULL_PTR);
5121 /* Support for varargs.h and stdarg.h. */
5122 builtin_function ("__builtin_varargs_start",
5123 build_function_type (void_type_node,
5124 tree_cons (NULL_TREE,
5125 va_list_ref_type_node,
5127 BUILT_IN_VARARGS_START, BUILT_IN_NORMAL, NULL_PTR);
5129 builtin_function ("__builtin_stdarg_start",
5130 build_function_type (void_type_node,
5131 tree_cons (NULL_TREE,
5132 va_list_ref_type_node,
5134 BUILT_IN_STDARG_START, BUILT_IN_NORMAL, NULL_PTR);
5136 builtin_function ("__builtin_va_end",
5137 build_function_type (void_type_node,
5138 tree_cons (NULL_TREE,
5139 va_list_ref_type_node,
5141 BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL_PTR);
5143 builtin_function ("__builtin_va_copy",
5144 build_function_type (void_type_node,
5145 tree_cons (NULL_TREE,
5146 va_list_ref_type_node,
5147 tree_cons (NULL_TREE,
5148 va_list_arg_type_node,
5150 BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL_PTR);
5152 /* ??? Ought to be `T __builtin_expect(T, T)' for any type T. */
5153 builtin_function ("__builtin_expect",
5154 build_function_type (long_integer_type_node,
5155 tree_cons (NULL_TREE,
5156 long_integer_type_node,
5157 tree_cons (NULL_TREE,
5158 long_integer_type_node,
5160 BUILT_IN_EXPECT, BUILT_IN_NORMAL, NULL_PTR);
5162 /* Currently under experimentation. */
5163 builtin_function ("__builtin_memcpy", memcpy_ftype, BUILT_IN_MEMCPY,
5164 BUILT_IN_NORMAL, "memcpy");
5165 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
5166 BUILT_IN_MEMCMP, BUILT_IN_NORMAL, "memcmp");
5167 builtin_function ("__builtin_memset", memset_ftype,
5168 BUILT_IN_MEMSET, BUILT_IN_NORMAL, "memset");
5169 builtin_function ("__builtin_bzero", bzero_ftype,
5170 BUILT_IN_BZERO, BUILT_IN_NORMAL, "bzero");
5171 builtin_function ("__builtin_bcmp", bcmp_ftype,
5172 BUILT_IN_BCMP, BUILT_IN_NORMAL, "bcmp");
5173 builtin_function ("__builtin_strcmp", int_ftype_string_string,
5174 BUILT_IN_STRCMP, BUILT_IN_NORMAL, "strcmp");
5175 builtin_function ("__builtin_strstr", string_ftype_string_string,
5176 BUILT_IN_STRSTR, BUILT_IN_NORMAL, "strstr");
5177 builtin_function ("__builtin_strpbrk", string_ftype_string_string,
5178 BUILT_IN_STRPBRK, BUILT_IN_NORMAL, "strpbrk");
5179 built_in_decls[BUILT_IN_STRCHR] =
5180 builtin_function ("__builtin_strchr", string_ftype_string_int,
5181 BUILT_IN_STRCHR, BUILT_IN_NORMAL, "strchr");
5182 builtin_function ("__builtin_strrchr", string_ftype_string_int,
5183 BUILT_IN_STRRCHR, BUILT_IN_NORMAL, "strrchr");
5184 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
5185 BUILT_IN_STRCPY, BUILT_IN_NORMAL, "strcpy");
5186 builtin_function ("__builtin_strlen", strlen_ftype,
5187 BUILT_IN_STRLEN, BUILT_IN_NORMAL, "strlen");
5188 builtin_function ("__builtin_sqrtf", float_ftype_float,
5189 BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrtf");
5190 builtin_function ("__builtin_fsqrt", double_ftype_double,
5191 BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrt");
5192 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
5193 BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrtl");
5194 builtin_function ("__builtin_sinf", float_ftype_float,
5195 BUILT_IN_SIN, BUILT_IN_NORMAL, "sinf");
5196 builtin_function ("__builtin_sin", double_ftype_double,
5197 BUILT_IN_SIN, BUILT_IN_NORMAL, "sin");
5198 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
5199 BUILT_IN_SIN, BUILT_IN_NORMAL, "sinl");
5200 builtin_function ("__builtin_cosf", float_ftype_float,
5201 BUILT_IN_COS, BUILT_IN_NORMAL, "cosf");
5202 builtin_function ("__builtin_cos", double_ftype_double,
5203 BUILT_IN_COS, BUILT_IN_NORMAL, "cos");
5204 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
5205 BUILT_IN_COS, BUILT_IN_NORMAL, "cosl");
5206 built_in_decls[BUILT_IN_PUTCHAR] =
5207 builtin_function ("__builtin_putchar", int_ftype_int,
5208 BUILT_IN_PUTCHAR, BUILT_IN_NORMAL, "putchar");
5209 built_in_decls[BUILT_IN_PUTS] =
5210 builtin_function ("__builtin_puts", puts_ftype,
5211 BUILT_IN_PUTS, BUILT_IN_NORMAL, "puts");
5212 builtin_function ("__builtin_printf", printf_ftype,
5213 BUILT_IN_PRINTF, BUILT_IN_FRONTEND, "printf");
5214 /* We declare these without argument so that the initial declaration
5215 for these identifiers is a builtin. That allows us to redeclare
5216 them later with argument without worrying about the explicit
5217 declarations in stdio.h being taken as the initial declaration.
5218 Also, save the _DECL for these so we can use them later. */
5219 built_in_decls[BUILT_IN_FWRITE] =
5220 builtin_function ("__builtin_fwrite", sizet_ftype_any,
5221 BUILT_IN_FWRITE, BUILT_IN_NORMAL, "fwrite");
5222 built_in_decls[BUILT_IN_FPUTC] =
5223 builtin_function ("__builtin_fputc", int_ftype_any,
5224 BUILT_IN_FPUTC, BUILT_IN_NORMAL, "fputc");
5225 built_in_decls[BUILT_IN_FPUTS] =
5226 builtin_function ("__builtin_fputs", int_ftype_any,
5227 BUILT_IN_FPUTS, BUILT_IN_NORMAL, "fputs");
5229 if (! flag_no_builtin)
5231 builtin_function ("abs", int_ftype_int, BUILT_IN_ABS,
5232 BUILT_IN_NORMAL, NULL_PTR);
5233 builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS,
5234 BUILT_IN_NORMAL, NULL_PTR);
5235 builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS,
5236 BUILT_IN_NORMAL, NULL_PTR);
5237 builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
5238 BUILT_IN_NORMAL, NULL_PTR);
5239 builtin_function ("labs", long_ftype_long, BUILT_IN_LABS,
5240 BUILT_IN_NORMAL, NULL_PTR);
5241 if (flag_isoc99 || ! flag_no_nonansi_builtin)
5242 builtin_function ("llabs", longlong_ftype_longlong, BUILT_IN_LLABS,
5243 BUILT_IN_NORMAL, NULL_PTR);
5244 builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY,
5245 BUILT_IN_NORMAL, NULL_PTR);
5246 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
5247 BUILT_IN_NORMAL, NULL_PTR);
5248 builtin_function ("memset", memset_ftype, BUILT_IN_MEMSET,
5249 BUILT_IN_NORMAL, NULL_PTR);
5250 builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
5251 BUILT_IN_NORMAL, NULL_PTR);
5252 builtin_function ("strstr", string_ftype_string_string, BUILT_IN_STRSTR,
5253 BUILT_IN_NORMAL, NULL_PTR);
5254 builtin_function ("strchr", string_ftype_string_int, BUILT_IN_STRCHR,
5255 BUILT_IN_NORMAL, NULL_PTR);
5256 builtin_function ("strrchr", string_ftype_string_int, BUILT_IN_STRRCHR,
5257 BUILT_IN_NORMAL, NULL_PTR);
5258 builtin_function ("strpbrk", string_ftype_string_string, BUILT_IN_STRPBRK,
5259 BUILT_IN_NORMAL, NULL_PTR);
5260 builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
5261 BUILT_IN_NORMAL, NULL_PTR);
5262 builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN,
5263 BUILT_IN_NORMAL, NULL_PTR);
5264 builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT,
5265 BUILT_IN_NORMAL, NULL_PTR);
5266 builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT,
5267 BUILT_IN_NORMAL, NULL_PTR);
5268 builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
5269 BUILT_IN_NORMAL, NULL_PTR);
5270 builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN,
5271 BUILT_IN_NORMAL, NULL_PTR);
5272 builtin_function ("sin", double_ftype_double, BUILT_IN_SIN,
5273 BUILT_IN_NORMAL, NULL_PTR);
5274 builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN,
5275 BUILT_IN_NORMAL, NULL_PTR);
5276 builtin_function ("cosf", float_ftype_float, BUILT_IN_COS,
5277 BUILT_IN_NORMAL, NULL_PTR);
5278 builtin_function ("cos", double_ftype_double, BUILT_IN_COS,
5279 BUILT_IN_NORMAL, NULL_PTR);
5280 builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS,
5281 BUILT_IN_NORMAL, NULL_PTR);
5282 builtin_function ("printf", printf_ftype, BUILT_IN_PRINTF,
5283 BUILT_IN_FRONTEND, NULL_PTR);
5284 /* We declare these without argument so that the initial
5285 declaration for these identifiers is a builtin. That allows
5286 us to redeclare them later with argument without worrying
5287 about the explicit declarations in stdio.h being taken as the
5288 initial declaration. */
5289 builtin_function ("fputc", int_ftype_any, BUILT_IN_FPUTC,
5290 BUILT_IN_NORMAL, NULL_PTR);
5291 builtin_function ("fputs", int_ftype_any, BUILT_IN_FPUTS,
5292 BUILT_IN_NORMAL, NULL_PTR);
5294 /* Declare these functions volatile
5295 to avoid spurious "control drops through" warnings. */
5296 temp = builtin_function ("abort",
5297 ((c_language == clk_cplusplus)
5298 ? void_ftype : void_ftype_any),
5299 0, NOT_BUILT_IN, NULL_PTR);
5300 TREE_THIS_VOLATILE (temp) = 1;
5301 TREE_SIDE_EFFECTS (temp) = 1;
5303 temp = builtin_function ("exit",
5304 ((c_language == clk_cplusplus)
5305 ? void_ftype_int : void_ftype_any),
5306 0, NOT_BUILT_IN, NULL_PTR);
5307 TREE_THIS_VOLATILE (temp) = 1;
5308 TREE_SIDE_EFFECTS (temp) = 1;
5312 /* Support for these has not been written in either expand_builtin
5313 or build_function_call. */
5314 builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV,
5315 BUILT_IN_NORMAL, NULL_PTR);
5316 builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV,
5317 BUILT_IN_NORMAL, NULL_PTR);
5318 builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
5319 BUILT_IN_NORMAL, NULL_PTR);
5320 builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
5321 BUILT_IN_NORMAL, NULL_PTR);
5322 builtin_function ("__builtin_fmod", double_ftype_double_double,
5323 BUILT_IN_FMOD, BUILT_IN_NORMAL, NULL_PTR);
5324 builtin_function ("__builtin_frem", double_ftype_double_double,
5325 BUILT_IN_FREM, BUILT_IN_NORMAL, NULL_PTR);
5326 builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
5327 BUILT_IN_NORMAL, NULL_PTR);
5328 builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
5329 BUILT_IN_NORMAL, NULL_PTR);
5332 main_identifier_node = get_identifier ("main");
5334 /* ??? Perhaps there's a better place to do this. But it is related
5335 to __builtin_va_arg, so it isn't that off-the-wall. */
5336 lang_type_promotes_to = simple_type_promotes_to;
5340 build_va_arg (expr, type)
5343 return build1 (VA_ARG_EXPR, type, expr);
5346 /* Given a type, apply default promotions wrt unnamed function arguments
5347 and return the new type. Return NULL_TREE if no change. */
5348 /* ??? There is a function of the same name in the C++ front end that
5349 does something similar, but is more thorough and does not return NULL
5350 if no change. We could perhaps share code, but it would make the
5351 self_promoting_type property harder to identify. */
5354 simple_type_promotes_to (type)
5357 if (TYPE_MAIN_VARIANT (type) == float_type_node)
5358 return double_type_node;
5360 if (C_PROMOTING_INTEGER_TYPE_P (type))
5362 /* Traditionally, unsignedness is preserved in default promotions.
5363 Also preserve unsignedness if not really getting any wider. */
5364 if (TREE_UNSIGNED (type)
5365 && (flag_traditional
5366 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
5367 return unsigned_type_node;
5368 return integer_type_node;
5374 /* Return 1 if PARMS specifies a fixed number of parameters
5375 and none of their types is affected by default promotions. */
5378 self_promoting_args_p (parms)
5382 for (t = parms; t; t = TREE_CHAIN (t))
5384 register tree type = TREE_VALUE (t);
5386 if (TREE_CHAIN (t) == 0 && type != void_type_node)
5392 if (TYPE_MAIN_VARIANT (type) == float_type_node)
5395 if (C_PROMOTING_INTEGER_TYPE_P (type))
5401 /* Recognize certain built-in functions so we can make tree-codes
5402 other than CALL_EXPR. We do this when it enables fold-const.c
5403 to do something useful. */
5404 /* ??? By rights this should go in builtins.c, but only C and C++
5405 implement build_{binary,unary}_op. Not exactly sure what bits
5406 of functionality are actually needed from those functions, or
5407 where the similar functionality exists in the other front ends. */
5410 expand_tree_builtin (function, params, coerced_params)
5411 tree function, params, coerced_params;
5413 enum tree_code code;
5415 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
5418 switch (DECL_FUNCTION_CODE (function))
5422 case BUILT_IN_LLABS:
5424 if (coerced_params == 0)
5425 return integer_zero_node;
5426 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
5428 case BUILT_IN_ISGREATER:
5429 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
5435 case BUILT_IN_ISGREATEREQUAL:
5436 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
5442 case BUILT_IN_ISLESS:
5443 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
5449 case BUILT_IN_ISLESSEQUAL:
5450 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
5456 case BUILT_IN_ISLESSGREATER:
5457 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
5463 case BUILT_IN_ISUNORDERED:
5464 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
5465 return integer_zero_node;
5466 code = UNORDERED_EXPR;
5474 || TREE_CHAIN (params) == 0)
5476 error ("too few arguments to function `%s'",
5477 IDENTIFIER_POINTER (DECL_NAME (function)));
5478 return error_mark_node;
5480 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
5482 error ("too many arguments to function `%s'",
5483 IDENTIFIER_POINTER (DECL_NAME (function)));
5484 return error_mark_node;
5487 arg0 = TREE_VALUE (params);
5488 arg1 = TREE_VALUE (TREE_CHAIN (params));
5489 arg0 = build_binary_op (code, arg0, arg1, 0);
5490 if (code != UNORDERED_EXPR)
5491 arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
5503 /* Returns non-zero if CODE is the code for a statement. */
5506 statement_code_p (code)
5507 enum tree_code code;
5530 if (lang_statement_code_p)
5531 return (*lang_statement_code_p) (code);
5536 /* Walk the statemen tree, rooted at *tp. Apply FUNC to all the
5537 sub-trees of *TP in a pre-order traversal. FUNC is called with the
5538 DATA and the address of each sub-tree. If FUNC returns a non-NULL
5539 value, the traversal is aborted, and the value returned by FUNC is
5540 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
5541 the node being visited are not walked.
5543 We don't need a without_duplicates variant of this one because the
5544 statement tree is a tree, not a graph. */
5547 walk_stmt_tree (tp, func, data)
5552 enum tree_code code;
5557 #define WALK_SUBTREE(NODE) \
5560 result = walk_stmt_tree (&(NODE), func, data); \
5566 /* Skip empty subtrees. */
5570 /* Skip subtrees below non-statement nodes. */
5571 if (!statement_code_p (TREE_CODE (*tp)))
5574 /* Call the function. */
5576 result = (*func) (tp, &walk_subtrees, data);
5578 /* If we found something, return it. */
5582 /* Even if we didn't, FUNC may have decided that there was nothing
5583 interesting below this point in the tree. */
5587 /* FUNC may have modified the tree, recheck that we're looking at a
5589 code = TREE_CODE (*tp);
5590 if (!statement_code_p (code))
5593 /* Walk over all the sub-trees of this operand. Statement nodes never
5594 contain RTL, and we needn't worry about TARGET_EXPRs. */
5595 len = TREE_CODE_LENGTH (code);
5597 /* Go through the subtrees. We need to do this in forward order so
5598 that the scope of a FOR_EXPR is handled properly. */
5599 for (i = 0; i < len; ++i)
5600 WALK_SUBTREE (TREE_OPERAND (*tp, i));
5602 /* Finally visit the chain. This can be tail-recursion optimized if
5603 we write it this way. */
5604 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
5609 /* Used to compare case labels. K1 and K2 are actually tree nodes
5610 representing case labels, or NULL_TREE for a `default' label.
5611 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5612 K2, and 0 if K1 and K2 are equal. */
5615 case_compare (k1, k2)
5619 /* Consider a NULL key (such as arises with a `default' label) to be
5620 smaller than anything else. */
5626 return tree_int_cst_compare ((tree) k1, (tree) k2);
5629 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
5630 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
5631 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
5632 case label was declared using the usual C/C++ syntax, rather than
5633 the GNU case range extension. CASES is a tree containing all the
5634 case ranges processed so far; COND is the condition for the
5635 switch-statement itself. Returns the CASE_LABEL created, or
5636 ERROR_MARK_NODE if no CASE_LABEL is created. */
5639 c_add_case_label (cases, cond, low_value, high_value)
5648 splay_tree_node node;
5650 /* Create the LABEL_DECL itself. */
5651 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5652 DECL_CONTEXT (label) = current_function_decl;
5654 /* If there was an error processing the switch condition, bail now
5655 before we get more confused. */
5656 if (!cond || cond == error_mark_node)
5658 /* Add a label anyhow so that the back-end doesn't think that
5659 the beginning of the switch is unreachable. */
5661 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
5662 return error_mark_node;
5665 if ((low_value && TREE_TYPE (low_value)
5666 && POINTER_TYPE_P (TREE_TYPE (low_value)))
5667 || (high_value && TREE_TYPE (high_value)
5668 && POINTER_TYPE_P (TREE_TYPE (high_value))))
5669 error ("pointers are not permitted as case values");
5671 /* Case ranges are a GNU extension. */
5672 if (high_value && pedantic)
5674 if (c_language == clk_cplusplus)
5675 pedwarn ("ISO C++ forbids range expressions in switch statements");
5677 pedwarn ("ISO C forbids range expressions in switch statements");
5680 type = TREE_TYPE (cond);
5683 low_value = check_case_value (low_value);
5684 low_value = convert_and_check (type, low_value);
5688 high_value = check_case_value (high_value);
5689 high_value = convert_and_check (type, high_value);
5692 /* If an error has occurred, bail out now. */
5693 if (low_value == error_mark_node || high_value == error_mark_node)
5696 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
5697 return error_mark_node;
5700 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5701 really a case range, even though it was written that way. Remove
5702 the HIGH_VALUE to simplify later processing. */
5703 if (tree_int_cst_equal (low_value, high_value))
5704 high_value = NULL_TREE;
5705 if (low_value && high_value
5706 && !tree_int_cst_lt (low_value, high_value))
5707 warning ("empty range specified");
5709 /* Look up the LOW_VALUE in the table of case labels we already
5711 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5712 /* If there was not an exact match, check for overlapping ranges.
5713 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5714 that's a `default' label and the only overlap is an exact match. */
5715 if (!node && (low_value || high_value))
5717 splay_tree_node low_bound;
5718 splay_tree_node high_bound;
5720 /* Even though there wasn't an exact match, there might be an
5721 overlap between this case range and another case range.
5722 Since we've (inductively) not allowed any overlapping case
5723 ranges, we simply need to find the greatest low case label
5724 that is smaller that LOW_VALUE, and the smallest low case
5725 label that is greater than LOW_VALUE. If there is an overlap
5726 it will occur in one of these two ranges. */
5727 low_bound = splay_tree_predecessor (cases,
5728 (splay_tree_key) low_value);
5729 high_bound = splay_tree_successor (cases,
5730 (splay_tree_key) low_value);
5732 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5733 the LOW_VALUE, so there is no need to check unless the
5734 LOW_BOUND is in fact itself a case range. */
5736 && CASE_HIGH ((tree) low_bound->value)
5737 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5740 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5741 range is bigger than the low end of the current range, so we
5742 are only interested if the current range is a real range, and
5743 not an ordinary case label. */
5746 && (tree_int_cst_compare ((tree) high_bound->key,
5751 /* If there was an overlap, issue an error. */
5754 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
5758 error ("duplicate (or overlapping) case value");
5759 error_with_decl (duplicate,
5760 "this is the first entry overlapping that value");
5764 error ("duplicate case value") ;
5765 error_with_decl (duplicate, "previously used here");
5769 error ("multiple default labels in one switch");
5770 error_with_decl (duplicate, "this is the first default label");
5773 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
5776 /* Add a CASE_LABEL to the statement-tree. */
5777 case_label = add_stmt (build_case_label (low_value, high_value, label));
5778 /* Register this case label in the splay tree. */
5779 splay_tree_insert (cases,
5780 (splay_tree_key) low_value,
5781 (splay_tree_value) case_label);
5786 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
5787 parameter allows this function to be used as a GC-marking
5794 stmt_tree st = (stmt_tree) p;
5796 ggc_mark_tree (st->x_last_stmt);
5797 ggc_mark_tree (st->x_last_expr_type);
5800 /* Mark LD for GC. */
5803 c_mark_lang_decl (c)
5804 struct c_lang_decl *c;
5806 ggc_mark_tree (c->saved_tree);
5809 /* Mark F for GC. */
5812 mark_c_language_function (f)
5813 struct language_function *f;
5818 mark_stmt_tree (&f->x_stmt_tree);
5819 ggc_mark_tree (f->x_scope_stmt_stack);
5822 /* Hook used by expand_expr to expand language-specific tree codes. */
5825 c_expand_expr (exp, target, tmode, modifier)
5828 enum machine_mode tmode;
5829 enum expand_modifier modifier;
5831 switch (TREE_CODE (exp))
5838 /* Since expand_expr_stmt calls free_temp_slots after every
5839 expression statement, we must call push_temp_slots here.
5840 Otherwise, any temporaries in use now would be considered
5841 out-of-scope after the first EXPR_STMT from within the
5844 rtl_expr = expand_start_stmt_expr ();
5845 expand_stmt (STMT_EXPR_STMT (exp));
5846 expand_end_stmt_expr (rtl_expr);
5847 result = expand_expr (rtl_expr, target, tmode, modifier);
5855 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
5856 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
5858 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
5859 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
5860 == BUILT_IN_FRONTEND))
5861 return c_expand_builtin (exp, target, tmode, modifier);
5875 /* Hook used by safe_from_p to handle language-specific tree codes. */
5878 c_safe_from_p (target, exp)
5882 /* We can see statements here when processing the body of a
5883 statement-expression. For a declaration statement declaring a
5884 variable, look at the variable's initializer. */
5885 if (TREE_CODE (exp) == DECL_STMT)
5887 tree decl = DECL_STMT_DECL (exp);
5889 if (TREE_CODE (decl) == VAR_DECL
5890 && DECL_INITIAL (decl)
5891 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
5895 /* For any statement, we must follow the statement-chain. */
5896 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
5897 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
5899 /* Assume everything else is safe. */
5903 /* Tree code classes. */
5905 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
5907 static char c_tree_code_type[] = {
5909 #include "c-common.def"
5913 /* Table indexed by tree code giving number of expression
5914 operands beyond the fixed part of the node structure.
5915 Not used for types or decls. */
5917 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
5919 static int c_tree_code_length[] = {
5921 #include "c-common.def"
5925 /* Names of tree components.
5926 Used for printing out the tree and error messages. */
5927 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
5929 static const char *c_tree_code_name[] = {
5931 #include "c-common.def"
5935 /* Adds the tree codes specific to the C front end to the list of all
5941 memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
5943 (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
5944 memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
5946 (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
5947 memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
5949 (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
5952 #define CALLED_AS_BUILT_IN(NODE) \
5953 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
5956 c_expand_builtin (exp, target, tmode, modifier)
5959 enum machine_mode tmode;
5960 enum expand_modifier modifier;
5962 tree type = TREE_TYPE (exp);
5963 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
5964 tree arglist = TREE_OPERAND (exp, 1);
5965 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5966 enum tree_code code = TREE_CODE (exp);
5967 const int ignore = (target == const0_rtx
5968 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
5969 || code == CONVERT_EXPR || code == REFERENCE_EXPR
5970 || code == COND_EXPR)
5971 && TREE_CODE (type) == VOID_TYPE));
5973 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
5974 return expand_call (exp, target, ignore);
5978 case BUILT_IN_PRINTF:
5979 target = c_expand_builtin_printf (arglist, target, tmode,
5985 default: /* just do library call, if unknown builtin */
5986 error ("built-in function `%s' not currently supported",
5987 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
5990 /* The switch statement above can drop through to cause the function
5991 to be called normally. */
5992 return expand_call (exp, target, ignore);
5995 /* Check an arglist to *printf for problems. The arglist should start
5996 at the format specifier, with the remaining arguments immediately
5999 is_valid_printf_arglist (arglist)
6002 /* Save this value so we can restore it later. */
6003 const int SAVE_pedantic = pedantic;
6004 int diagnostic_occurred = 0;
6006 /* Set this to a known value so the user setting won't affect code
6009 /* Check to make sure there are no format specifier errors. */
6010 check_function_format (&diagnostic_occurred,
6011 maybe_get_identifier("printf"),
6012 NULL_TREE, arglist);
6014 /* Restore the value of `pedantic'. */
6015 pedantic = SAVE_pedantic;
6017 /* If calling `check_function_format_ptr' produces a warning, we
6018 return false, otherwise we return true. */
6019 return ! diagnostic_occurred;
6022 /* If the arguments passed to printf are suitable for optimizations,
6023 we attempt to transform the call. */
6025 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore)
6028 enum machine_mode tmode;
6029 enum expand_modifier modifier;
6032 tree fn_putchar = built_in_decls[BUILT_IN_PUTCHAR],
6033 fn_puts = built_in_decls[BUILT_IN_PUTS];
6034 tree fn, format_arg, stripped_string;
6036 /* If the return value is used, or the replacement _DECL isn't
6037 initialized, don't do the transformation. */
6038 if (!ignore || !fn_putchar || !fn_puts)
6041 /* Verify the required arguments in the original call. */
6043 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
6046 /* Check the specifier vs. the parameters. */
6047 if (!is_valid_printf_arglist (arglist))
6050 format_arg = TREE_VALUE (arglist);
6051 stripped_string = format_arg;
6052 STRIP_NOPS (stripped_string);
6053 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
6054 stripped_string = TREE_OPERAND (stripped_string, 0);
6056 /* If the format specifier isn't a STRING_CST, punt. */
6057 if (TREE_CODE (stripped_string) != STRING_CST)
6060 /* OK! We can attempt optimization. */
6062 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
6063 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
6065 arglist = TREE_CHAIN (arglist);
6068 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
6069 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
6071 arglist = TREE_CHAIN (arglist);
6076 /* We can't handle anything else with % args or %% ... yet. */
6077 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
6080 /* If the resulting constant string has a length of 1, call
6081 putchar. Note, TREE_STRING_LENGTH includes the terminating
6082 NULL in its count. */
6083 if (TREE_STRING_LENGTH (stripped_string) == 2)
6085 /* Given printf("c"), (where c is any one character,)
6086 convert "c"[0] to an int and pass that to the replacement
6088 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
6089 arglist = build_tree_list (NULL_TREE, arglist);
6093 /* If the resulting constant was "string\n", call
6094 __builtin_puts("string"). Ensure "string" has at least one
6095 character besides the trailing \n. Note, TREE_STRING_LENGTH
6096 includes the terminating NULL in its count. */
6097 else if (TREE_STRING_LENGTH (stripped_string) > 2
6098 && TREE_STRING_POINTER (stripped_string)
6099 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
6101 /* Create a NULL-terminated string that's one char shorter
6102 than the original, stripping off the trailing '\n'. */
6103 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
6104 char *newstr = (char *) alloca (newlen);
6105 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
6106 newstr[newlen - 1] = 0;
6108 arglist = combine_strings (build_string (newlen, newstr));
6109 arglist = build_tree_list (NULL_TREE, arglist);
6113 /* We'd like to arrange to call fputs(string) here, but we
6114 need stdout and don't have a way to get it ... yet. */
6118 return expand_expr (build_function_call (fn, arglist),
6119 (ignore ? const0_rtx : target),