1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
34 #include "tree-inline.h"
35 #include "diagnostic.h"
40 #include "langhooks.h"
41 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
43 cpp_reader *parse_in; /* Declared in c-pragma.h. */
45 /* We let tm.h override the types used here, to handle trivial differences
46 such as the choice of unsigned int or long unsigned int for size_t.
47 When machines start needing nontrivial differences in the size type,
48 it would be best to do something here to figure out automatically
49 from other information what type to use. */
52 #define SIZE_TYPE "long unsigned int"
56 #define WCHAR_TYPE "int"
59 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
60 #define MODIFIED_WCHAR_TYPE \
61 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
64 #define PTRDIFF_TYPE "long int"
68 #define WINT_TYPE "unsigned int"
72 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
74 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
80 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
82 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
83 ? "long unsigned int" \
84 : "long long unsigned int"))
87 #ifndef STDC_0_IN_SYSTEM_HEADERS
88 #define STDC_0_IN_SYSTEM_HEADERS 0
91 #ifndef REGISTER_PREFIX
92 #define REGISTER_PREFIX ""
95 /* The variant of the C language being processed. */
97 enum c_language_kind c_language;
99 /* The following symbols are subsumed in the c_global_trees array, and
100 listed here individually for documentation purposes.
102 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
104 tree short_integer_type_node;
105 tree long_integer_type_node;
106 tree long_long_integer_type_node;
108 tree short_unsigned_type_node;
109 tree long_unsigned_type_node;
110 tree long_long_unsigned_type_node;
112 tree boolean_type_node;
113 tree boolean_false_node;
114 tree boolean_true_node;
116 tree ptrdiff_type_node;
118 tree unsigned_char_type_node;
119 tree signed_char_type_node;
120 tree wchar_type_node;
121 tree signed_wchar_type_node;
122 tree unsigned_wchar_type_node;
124 tree float_type_node;
125 tree double_type_node;
126 tree long_double_type_node;
128 tree complex_integer_type_node;
129 tree complex_float_type_node;
130 tree complex_double_type_node;
131 tree complex_long_double_type_node;
133 tree intQI_type_node;
134 tree intHI_type_node;
135 tree intSI_type_node;
136 tree intDI_type_node;
137 tree intTI_type_node;
139 tree unsigned_intQI_type_node;
140 tree unsigned_intHI_type_node;
141 tree unsigned_intSI_type_node;
142 tree unsigned_intDI_type_node;
143 tree unsigned_intTI_type_node;
145 tree widest_integer_literal_type_node;
146 tree widest_unsigned_literal_type_node;
148 Nodes for types `void *' and `const void *'.
150 tree ptr_type_node, const_ptr_type_node;
152 Nodes for types `char *' and `const char *'.
154 tree string_type_node, const_string_type_node;
156 Type `char[SOMENUMBER]'.
157 Used when an array of char is needed and the size is irrelevant.
159 tree char_array_type_node;
161 Type `int[SOMENUMBER]' or something like it.
162 Used when an array of int needed and the size is irrelevant.
164 tree int_array_type_node;
166 Type `wchar_t[SOMENUMBER]' or something like it.
167 Used when a wide string literal is created.
169 tree wchar_array_type_node;
171 Type `int ()' -- used for implicit declaration of functions.
173 tree default_function_type;
175 A VOID_TYPE node, packaged in a TREE_LIST.
179 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
180 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
181 VAR_DECLS, but C++ does.)
183 tree function_name_decl_node;
184 tree pretty_function_name_decl_node;
185 tree c99_function_name_decl_node;
187 Stack of nested function name VAR_DECLs.
189 tree saved_function_name_decls;
193 tree c_global_trees[CTI_MAX];
195 /* Switches common to the C front ends. */
197 /* Nonzero if prepreprocessing only. */
198 int flag_preprocess_only;
200 /* Nonzero if an ISO standard was selected. It rejects macros in the
204 /* Nonzero if -undef was given. It suppresses target built-in macros
208 /* Nonzero means don't recognize the non-ANSI builtin functions. */
212 /* Nonzero means don't recognize the non-ANSI builtin functions.
215 int flag_no_nonansi_builtin;
217 /* Nonzero means give `double' the same size as `float'. */
219 int flag_short_double;
221 /* Nonzero means give `wchar_t' the same size as `short'. */
223 int flag_short_wchar;
225 /* Nonzero means allow Microsoft extensions without warnings or errors. */
226 int flag_ms_extensions;
228 /* Nonzero means don't recognize the keyword `asm'. */
232 /* Nonzero means give string constants the type `const char *', as mandated
235 int flag_const_strings;
237 /* Nonzero means `$' can be in an identifier. */
239 #ifndef DOLLARS_IN_IDENTIFIERS
240 #define DOLLARS_IN_IDENTIFIERS 1
242 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
244 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
246 int flag_signed_bitfields = 1;
247 int explicit_flag_signed_bitfields;
249 /* Nonzero means warn about pointer casts that can drop a type qualifier
250 from the pointer target type. */
254 /* Warn about functions which might be candidates for format attributes. */
256 int warn_missing_format_attribute;
258 /* Nonzero means warn about sizeof(function) or addition/subtraction
259 of function pointers. */
261 int warn_pointer_arith;
263 /* Nonzero means warn for any global function def
264 without separate previous prototype decl. */
266 int warn_missing_prototypes;
268 /* Warn if adding () is suggested. */
270 int warn_parentheses;
272 /* Warn if initializer is not completely bracketed. */
274 int warn_missing_braces;
276 /* Warn about comparison of signed and unsigned values.
277 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
279 int warn_sign_compare;
281 /* Nonzero means warn about usage of long long when `-pedantic'. */
283 int warn_long_long = 1;
285 /* Nonzero means warn about deprecated conversion from string constant to
288 int warn_write_strings;
290 /* Nonzero means warn about multiple (redundant) decls for the same single
291 variable or function. */
293 int warn_redundant_decls;
295 /* Warn about testing equality of floating point numbers. */
297 int warn_float_equal;
299 /* Warn about a subscript that has type char. */
301 int warn_char_subscripts;
303 /* Warn if a type conversion is done that might have confusing results. */
307 /* Warn about #pragma directives that are not recognised. */
309 int warn_unknown_pragmas; /* Tri state variable. */
311 /* Nonzero means warn about use of multicharacter literals. */
313 int warn_multichar = 1;
315 /* Warn about format/argument anomalies in calls to formatted I/O functions
316 (*printf, *scanf, strftime, strfmon, etc.). */
320 /* Warn about Y2K problems with strftime formats. */
324 /* Warn about excess arguments to formats. */
326 int warn_format_extra_args;
328 /* Warn about zero-length formats. */
330 int warn_format_zero_length;
332 /* Warn about non-literal format arguments. */
334 int warn_format_nonliteral;
336 /* Warn about possible security problems with calls to format functions. */
338 int warn_format_security;
341 /* C/ObjC language option variables. */
344 /* Nonzero means message about use of implicit function declarations;
345 1 means warning; 2 means error. */
347 int mesg_implicit_function_declaration = -1;
349 /* Nonzero means allow type mismatches in conditional expressions;
350 just make their values `void'. */
352 int flag_cond_mismatch;
354 /* Nonzero means enable C89 Amendment 1 features. */
358 /* Nonzero means use the ISO C99 dialect of C. */
362 /* Nonzero means that we have builtin functions, and main is an int */
366 /* Nonzero means add default format_arg attributes for functions not
369 int flag_noniso_default_format_attributes = 1;
371 /* Nonzero means warn when casting a function call to a type that does
372 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
373 when there is no previous declaration of sqrt or malloc. */
375 int warn_bad_function_cast;
377 /* Warn about traditional constructs whose meanings changed in ANSI C. */
379 int warn_traditional;
381 /* Nonzero means warn for non-prototype function decls
382 or non-prototyped defs without previous prototype. */
384 int warn_strict_prototypes;
386 /* Nonzero means warn for any global function def
387 without separate previous decl. */
389 int warn_missing_declarations;
391 /* Nonzero means warn about declarations of objects not at
392 file-scope level and about *all* declarations of functions (whether
393 or static) not at file-scope level. Note that we exclude
394 implicit function declarations. To get warnings about those, use
397 int warn_nested_externs;
399 /* Warn if main is suspicious. */
403 /* Nonzero means warn about possible violations of sequence point rules. */
405 int warn_sequence_point;
407 /* Nonzero means to warn about compile-time division by zero. */
408 int warn_div_by_zero = 1;
410 /* Nonzero means warn about use of implicit int. */
412 int warn_implicit_int;
414 /* Warn about NULL being passed to argument slots marked as requiring
420 /* ObjC language option variables. */
423 /* Open and close the file for outputting class declarations, if
426 int flag_gen_declaration;
428 /* Generate code for GNU or NeXT runtime environment. */
430 #ifdef NEXT_OBJC_RUNTIME
431 int flag_next_runtime = 1;
433 int flag_next_runtime = 0;
436 /* Tells the compiler that this is a special run. Do not perform any
437 compiling, instead we are to test some platform dependent features
438 and output a C header file with appropriate definitions. */
440 int print_struct_values;
442 /* ???. Undocumented. */
444 const char *constant_string_class_name;
446 /* Warn if multiple methods are seen for the same selector, but with
447 different argument types. */
451 /* Warn if methods required by a protocol are not implemented in the
452 class adopting it. When turned off, methods inherited to that
453 class are also considered implemented. */
455 int warn_protocol = 1;
458 /* C++ language option variables. */
461 /* Nonzero means don't recognize any extension keywords. */
463 int flag_no_gnu_keywords;
465 /* Nonzero means do emit exported implementations of functions even if
466 they can be inlined. */
468 int flag_implement_inlines = 1;
470 /* Nonzero means do emit exported implementations of templates, instead of
471 multiple static copies in each file that needs a definition. */
473 int flag_external_templates;
475 /* Nonzero means that the decision to emit or not emit the implementation of a
476 template depends on where the template is instantiated, rather than where
479 int flag_alt_external_templates;
481 /* Nonzero means that implicit instantiations will be emitted if needed. */
483 int flag_implicit_templates = 1;
485 /* Nonzero means that implicit instantiations of inline templates will be
486 emitted if needed, even if instantiations of non-inline templates
489 int flag_implicit_inline_templates = 1;
491 /* Nonzero means generate separate instantiation control files and
492 juggle them at link time. */
494 int flag_use_repository;
496 /* Nonzero if we want to issue diagnostics that the standard says are not
499 int flag_optional_diags = 1;
501 /* Nonzero means we should attempt to elide constructors when possible. */
503 int flag_elide_constructors = 1;
505 /* Nonzero means that member functions defined in class scope are
506 inline by default. */
508 int flag_default_inline = 1;
510 /* Controls whether compiler generates 'type descriptor' that give
511 run-time type information. */
515 /* Nonzero if we want to conserve space in the .o files. We do this
516 by putting uninitialized data and runtime initialized data into
517 .common instead of .data at the expense of not flagging multiple
520 int flag_conserve_space;
522 /* Nonzero if we want to obey access control semantics. */
524 int flag_access_control = 1;
526 /* Nonzero if we want to check the return value of new and avoid calling
527 constructors if it is a null pointer. */
531 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
532 initialization variables.
533 0: Old rules, set by -fno-for-scope.
534 2: New ISO rules, set by -ffor-scope.
535 1: Try to implement new ISO rules, but with backup compatibility
536 (and warnings). This is the default, for now. */
538 int flag_new_for_scope = 1;
540 /* Nonzero if we want to emit defined symbols with common-like linkage as
541 weak symbols where possible, in order to conform to C++ semantics.
542 Otherwise, emit them as local symbols. */
546 /* Nonzero to use __cxa_atexit, rather than atexit, to register
547 destructors for local statics and global objects. */
549 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
551 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
555 /* Nonzero means make the default pedwarns warnings instead of errors.
556 The value of this flag is ignored if -pedantic is specified. */
560 /* Nonzero means to implement standard semantics for exception
561 specifications, calling unexpected if an exception is thrown that
562 doesn't match the specification. Zero means to treat them as
563 assertions and optimize accordingly, but not check them. */
565 int flag_enforce_eh_specs = 1;
567 /* Nonzero means warn about implicit declarations. */
569 int warn_implicit = 1;
571 /* Nonzero means warn when all ctors or dtors are private, and the class
574 int warn_ctor_dtor_privacy = 1;
576 /* Non-zero means warn in function declared in derived class has the
577 same name as a virtual in the base class, but fails to match the
578 type signature of any virtual function in the base class. */
580 int warn_overloaded_virtual;
582 /* Non-zero means warn when declaring a class that has a non virtual
583 destructor, when it really ought to have a virtual one. */
587 /* Non-zero means warn when the compiler will reorder code. */
591 /* Non-zero means warn when synthesis behavior differs from Cfront's. */
595 /* Non-zero means warn when we convert a pointer to member function
596 into a pointer to (void or function). */
598 int warn_pmf2ptr = 1;
600 /* Nonzero means warn about violation of some Effective C++ style rules. */
604 /* Nonzero means warn where overload resolution chooses a promotion from
605 unsigned to signed over a conversion to an unsigned of the same size. */
609 /* Nonzero means warn when an old-style cast is used. */
611 int warn_old_style_cast;
613 /* Nonzero means warn when non-templatized friend functions are
614 declared within a template */
616 int warn_nontemplate_friend = 1;
618 /* Nonzero means complain about deprecated features. */
620 int warn_deprecated = 1;
622 /* Maximum template instantiation depth. This limit is rather
623 arbitrary, but it exists to limit the time it takes to notice
624 infinite template instantiations. */
626 int max_tinst_depth = 500;
630 /* The elements of `ridpointers' are identifier nodes for the reserved
631 type names and storage classes. It is indexed by a RID_... value. */
634 tree (*make_fname_decl) PARAMS ((tree, int));
636 /* If non-NULL, the address of a language-specific function that
637 returns 1 for language-specific statement codes. */
638 int (*lang_statement_code_p) PARAMS ((enum tree_code));
640 /* If non-NULL, the address of a language-specific function that takes
641 any action required right before expand_function_end is called. */
642 void (*lang_expand_function_end) PARAMS ((void));
644 /* Nonzero means the expression being parsed will never be evaluated.
645 This is a count, since unevaluated expressions can nest. */
648 /* Information about how a function name is generated. */
651 tree *const decl; /* pointer to the VAR_DECL. */
652 const unsigned rid; /* RID number for the identifier. */
653 const int pretty; /* How pretty is it? */
656 /* The three ways of getting then name of the current function. */
658 const struct fname_var_t fname_vars[] =
660 /* C99 compliant __func__, must be first. */
661 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
662 /* GCC __FUNCTION__ compliant. */
663 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
664 /* GCC __PRETTY_FUNCTION__ compliant. */
665 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
669 static int constant_fits_type_p PARAMS ((tree, tree));
671 /* Keep a stack of if statements. We record the number of compound
672 statements seen up to the if keyword, as well as the line number
673 and file of the if. If a potentially ambiguous else is seen, that
674 fact is recorded; the warning is issued when we can be sure that
675 the enclosing if statement does not have an else branch. */
685 static if_elt *if_stack;
687 /* Amount of space in the if statement stack. */
688 static int if_stack_space = 0;
691 static int if_stack_pointer = 0;
693 static void cb_register_builtins PARAMS ((cpp_reader *));
695 static tree handle_packed_attribute PARAMS ((tree *, tree, tree, int,
697 static tree handle_nocommon_attribute PARAMS ((tree *, tree, tree, int,
699 static tree handle_common_attribute PARAMS ((tree *, tree, tree, int,
701 static tree handle_noreturn_attribute PARAMS ((tree *, tree, tree, int,
703 static tree handle_noinline_attribute PARAMS ((tree *, tree, tree, int,
705 static tree handle_always_inline_attribute PARAMS ((tree *, tree, tree, int,
707 static tree handle_used_attribute PARAMS ((tree *, tree, tree, int,
709 static tree handle_unused_attribute PARAMS ((tree *, tree, tree, int,
711 static tree handle_const_attribute PARAMS ((tree *, tree, tree, int,
713 static tree handle_transparent_union_attribute PARAMS ((tree *, tree, tree,
715 static tree handle_constructor_attribute PARAMS ((tree *, tree, tree, int,
717 static tree handle_destructor_attribute PARAMS ((tree *, tree, tree, int,
719 static tree handle_mode_attribute PARAMS ((tree *, tree, tree, int,
721 static tree handle_section_attribute PARAMS ((tree *, tree, tree, int,
723 static tree handle_aligned_attribute PARAMS ((tree *, tree, tree, int,
725 static tree handle_weak_attribute PARAMS ((tree *, tree, tree, int,
727 static tree handle_alias_attribute PARAMS ((tree *, tree, tree, int,
729 static tree handle_visibility_attribute PARAMS ((tree *, tree, tree, int,
731 static tree handle_no_instrument_function_attribute PARAMS ((tree *, tree,
734 static tree handle_malloc_attribute PARAMS ((tree *, tree, tree, int,
736 static tree handle_no_limit_stack_attribute PARAMS ((tree *, tree, tree, int,
738 static tree handle_pure_attribute PARAMS ((tree *, tree, tree, int,
740 static tree handle_deprecated_attribute PARAMS ((tree *, tree, tree, int,
742 static tree handle_vector_size_attribute PARAMS ((tree *, tree, tree, int,
744 static tree handle_nonnull_attribute PARAMS ((tree *, tree, tree, int,
746 static tree handle_nothrow_attribute PARAMS ((tree *, tree, tree, int,
748 static tree vector_size_helper PARAMS ((tree, tree));
750 static void check_function_nonnull PARAMS ((tree, tree));
751 static void check_nonnull_arg PARAMS ((void *, tree,
752 unsigned HOST_WIDE_INT));
753 static bool nonnull_check_p PARAMS ((tree, unsigned HOST_WIDE_INT));
754 static bool get_nonnull_operand PARAMS ((tree,
755 unsigned HOST_WIDE_INT *));
756 void builtin_define_std PARAMS ((const char *));
757 static void builtin_define_with_value PARAMS ((const char *, const char *,
759 static void builtin_define_type_max PARAMS ((const char *, tree, int));
761 /* Table of machine-independent attributes common to all C-like languages. */
762 const struct attribute_spec c_common_attribute_table[] =
764 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
765 { "packed", 0, 0, false, false, false,
766 handle_packed_attribute },
767 { "nocommon", 0, 0, true, false, false,
768 handle_nocommon_attribute },
769 { "common", 0, 0, true, false, false,
770 handle_common_attribute },
771 /* FIXME: logically, noreturn attributes should be listed as
772 "false, true, true" and apply to function types. But implementing this
773 would require all the places in the compiler that use TREE_THIS_VOLATILE
774 on a decl to identify non-returning functions to be located and fixed
775 to check the function type instead. */
776 { "noreturn", 0, 0, true, false, false,
777 handle_noreturn_attribute },
778 { "volatile", 0, 0, true, false, false,
779 handle_noreturn_attribute },
780 { "noinline", 0, 0, true, false, false,
781 handle_noinline_attribute },
782 { "always_inline", 0, 0, true, false, false,
783 handle_always_inline_attribute },
784 { "used", 0, 0, true, false, false,
785 handle_used_attribute },
786 { "unused", 0, 0, false, false, false,
787 handle_unused_attribute },
788 /* The same comments as for noreturn attributes apply to const ones. */
789 { "const", 0, 0, true, false, false,
790 handle_const_attribute },
791 { "transparent_union", 0, 0, false, false, false,
792 handle_transparent_union_attribute },
793 { "constructor", 0, 0, true, false, false,
794 handle_constructor_attribute },
795 { "destructor", 0, 0, true, false, false,
796 handle_destructor_attribute },
797 { "mode", 1, 1, false, true, false,
798 handle_mode_attribute },
799 { "section", 1, 1, true, false, false,
800 handle_section_attribute },
801 { "aligned", 0, 1, false, false, false,
802 handle_aligned_attribute },
803 { "weak", 0, 0, true, false, false,
804 handle_weak_attribute },
805 { "alias", 1, 1, true, false, false,
806 handle_alias_attribute },
807 { "no_instrument_function", 0, 0, true, false, false,
808 handle_no_instrument_function_attribute },
809 { "malloc", 0, 0, true, false, false,
810 handle_malloc_attribute },
811 { "no_stack_limit", 0, 0, true, false, false,
812 handle_no_limit_stack_attribute },
813 { "pure", 0, 0, true, false, false,
814 handle_pure_attribute },
815 { "deprecated", 0, 0, false, false, false,
816 handle_deprecated_attribute },
817 { "vector_size", 1, 1, false, true, false,
818 handle_vector_size_attribute },
819 { "visibility", 1, 1, true, false, false,
820 handle_visibility_attribute },
821 { "nonnull", 0, -1, false, true, true,
822 handle_nonnull_attribute },
823 { "nothrow", 0, 0, true, false, false,
824 handle_nothrow_attribute },
825 { "may_alias", 0, 0, false, true, false, NULL },
826 { NULL, 0, 0, false, false, false, NULL }
829 /* Give the specifications for the format attributes, used by C and all
832 const struct attribute_spec c_common_format_attribute_table[] =
834 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
835 { "format", 3, 3, false, true, true,
836 handle_format_attribute },
837 { "format_arg", 1, 1, false, true, true,
838 handle_format_arg_attribute },
839 { NULL, 0, 0, false, false, false, NULL }
842 /* Record the start of an if-then, and record the start of it
843 for ambiguous else detection.
845 COND is the condition for the if-then statement.
847 IF_STMT is the statement node that has already been created for
848 this if-then statement. It is created before parsing the
849 condition to keep line number information accurate. */
852 c_expand_start_cond (cond, compstmt_count, if_stmt)
857 /* Make sure there is enough space on the stack. */
858 if (if_stack_space == 0)
861 if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
863 else if (if_stack_space == if_stack_pointer)
865 if_stack_space += 10;
866 if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
869 IF_COND (if_stmt) = cond;
872 /* Record this if statement. */
873 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
874 if_stack[if_stack_pointer].file = input_filename;
875 if_stack[if_stack_pointer].line = lineno;
876 if_stack[if_stack_pointer].needs_warning = 0;
877 if_stack[if_stack_pointer].if_stmt = if_stmt;
881 /* Called after the then-clause for an if-statement is processed. */
886 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
887 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
890 /* Record the end of an if-then. Optionally warn if a nested
891 if statement had an ambiguous else clause. */
897 if (if_stack[if_stack_pointer].needs_warning)
898 warning_with_file_and_line (if_stack[if_stack_pointer].file,
899 if_stack[if_stack_pointer].line,
900 "suggest explicit braces to avoid ambiguous `else'");
901 last_expr_type = NULL_TREE;
904 /* Called between the then-clause and the else-clause
905 of an if-then-else. */
908 c_expand_start_else ()
910 /* An ambiguous else warning must be generated for the enclosing if
911 statement, unless we see an else branch for that one, too. */
913 && if_stack_pointer > 1
914 && (if_stack[if_stack_pointer - 1].compstmt_count
915 == if_stack[if_stack_pointer - 2].compstmt_count))
916 if_stack[if_stack_pointer - 2].needs_warning = 1;
918 /* Even if a nested if statement had an else branch, it can't be
919 ambiguous if this one also has an else. So don't warn in that
920 case. Also don't warn for any if statements nested in this else. */
921 if_stack[if_stack_pointer - 1].needs_warning = 0;
922 if_stack[if_stack_pointer - 1].compstmt_count--;
925 /* Called after the else-clause for an if-statement is processed. */
930 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
931 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
934 /* Begin an if-statement. Returns a newly created IF_STMT if
937 Unlike the C++ front-end, we do not call add_stmt here; it is
938 probably safe to do so, but I am not very familiar with this
939 code so I am being extra careful not to change its behavior
940 beyond what is strictly necessary for correctness. */
946 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
950 /* Begin a while statement. Returns a newly created WHILE_STMT if
953 Unlike the C++ front-end, we do not call add_stmt here; it is
954 probably safe to do so, but I am not very familiar with this
955 code so I am being extra careful not to change its behavior
956 beyond what is strictly necessary for correctness. */
959 c_begin_while_stmt ()
962 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
967 c_finish_while_stmt_cond (cond, while_stmt)
971 WHILE_COND (while_stmt) = cond;
974 /* Push current bindings for the function name VAR_DECLS. */
980 tree saved = NULL_TREE;
982 for (ix = 0; fname_vars[ix].decl; ix++)
984 tree decl = *fname_vars[ix].decl;
988 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
989 *fname_vars[ix].decl = NULL_TREE;
992 if (saved || saved_function_name_decls)
993 /* Normally they'll have been NULL, so only push if we've got a
994 stack, or they are non-NULL. */
995 saved_function_name_decls = tree_cons (saved, NULL_TREE,
996 saved_function_name_decls);
999 /* Finish up the current bindings, adding them into the
1000 current function's statement tree. This is done by wrapping the
1001 function's body in a COMPOUND_STMT containing these decls too. This
1002 must be done _before_ finish_stmt_tree is called. If there is no
1003 current function, we must be at file scope and no statements are
1004 involved. Pop the previous bindings. */
1007 finish_fname_decls ()
1010 tree body = NULL_TREE;
1011 tree stack = saved_function_name_decls;
1013 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1014 body = chainon (TREE_VALUE (stack), body);
1018 /* They were called into existence, so add to statement tree. */
1019 body = chainon (body,
1020 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
1021 body = build_stmt (COMPOUND_STMT, body);
1023 COMPOUND_STMT_NO_SCOPE (body) = 1;
1024 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
1027 for (ix = 0; fname_vars[ix].decl; ix++)
1028 *fname_vars[ix].decl = NULL_TREE;
1032 /* We had saved values, restore them. */
1035 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1037 tree decl = TREE_PURPOSE (saved);
1038 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1040 *fname_vars[ix].decl = decl;
1042 stack = TREE_CHAIN (stack);
1044 saved_function_name_decls = stack;
1047 /* Return the text name of the current function, suitable prettified
1051 fname_as_string (pretty_p)
1054 const char *name = NULL;
1057 name = (current_function_decl
1058 ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
1060 else if (current_function_decl && DECL_NAME (current_function_decl))
1061 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
1067 /* Return the text name of the current function, formatted as
1068 required by the supplied RID value. */
1076 for (ix = 0; fname_vars[ix].decl; ix++)
1077 if (fname_vars[ix].rid == rid)
1079 return fname_as_string (fname_vars[ix].pretty);
1082 /* Return the VAR_DECL for a const char array naming the current
1083 function. If the VAR_DECL has not yet been created, create it
1084 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1085 ID is its name (unfortunately C and C++ hold the RID values of
1086 keywords in different places, so we can't derive RID from ID in
1087 this language independent code. */
1090 fname_decl (rid, id)
1095 tree decl = NULL_TREE;
1097 for (ix = 0; fname_vars[ix].decl; ix++)
1098 if (fname_vars[ix].rid == rid)
1101 decl = *fname_vars[ix].decl;
1104 tree saved_last_tree = last_tree;
1106 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1107 if (last_tree != saved_last_tree)
1109 /* We created some statement tree for the decl. This belongs
1110 at the start of the function, so remove it now and reinsert
1111 it after the function is complete. */
1112 tree stmts = TREE_CHAIN (saved_last_tree);
1114 TREE_CHAIN (saved_last_tree) = NULL_TREE;
1115 last_tree = saved_last_tree;
1116 saved_function_name_decls = tree_cons (decl, stmts,
1117 saved_function_name_decls);
1119 *fname_vars[ix].decl = decl;
1121 if (!ix && !current_function_decl)
1122 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
1127 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1130 fix_string_type (value)
1133 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1134 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1135 const int nchars_max = flag_isoc99 ? 4095 : 509;
1136 int length = TREE_STRING_LENGTH (value);
1139 /* Compute the number of elements, for the array type. */
1140 nchars = wide_flag ? length / wchar_bytes : length;
1142 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
1143 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1144 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1146 /* Create the array type for the string constant.
1147 -Wwrite-strings says make the string constant an array of const char
1148 so that copying it to a non-const pointer will get a warning.
1149 For C++, this is the standard behavior. */
1150 if (flag_const_strings && ! flag_writable_strings)
1153 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1156 = build_array_type (elements,
1157 build_index_type (build_int_2 (nchars - 1, 0)));
1161 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1162 build_index_type (build_int_2 (nchars - 1, 0)));
1164 TREE_CONSTANT (value) = 1;
1165 TREE_READONLY (value) = ! flag_writable_strings;
1166 TREE_STATIC (value) = 1;
1170 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1174 combine_strings (strings)
1175 varray_type strings;
1177 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1178 const int nstrings = VARRAY_ACTIVE_SIZE (strings);
1181 int wide_length = 0;
1186 /* Don't include the \0 at the end of each substring. Count wide
1187 strings and ordinary strings separately. */
1188 for (i = 0; i < nstrings; ++i)
1190 t = VARRAY_TREE (strings, i);
1192 if (TREE_TYPE (t) == wchar_array_type_node)
1194 wide_length += TREE_STRING_LENGTH (t) - wchar_bytes;
1199 length += (TREE_STRING_LENGTH (t) - 1);
1200 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
1201 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1205 /* If anything is wide, the non-wides will be converted,
1206 which makes them take more space. */
1208 length = length * wchar_bytes + wide_length;
1210 p = xmalloc (length);
1212 /* Copy the individual strings into the new combined string.
1213 If the combined string is wide, convert the chars to ints
1214 for any individual strings that are not wide. */
1217 for (i = 0; i < nstrings; ++i)
1221 t = VARRAY_TREE (strings, i);
1222 this_wide = TREE_TYPE (t) == wchar_array_type_node;
1223 len = TREE_STRING_LENGTH (t) - (this_wide ? wchar_bytes : 1);
1224 if (this_wide == wide_flag)
1226 memcpy (q, TREE_STRING_POINTER (t), len);
1231 const int nzeros = (TYPE_PRECISION (wchar_type_node)
1232 / BITS_PER_UNIT) - 1;
1235 if (BYTES_BIG_ENDIAN)
1237 for (k = 0; k < len; k++)
1239 for (j = 0; j < nzeros; j++)
1241 *q++ = TREE_STRING_POINTER (t)[k];
1246 for (k = 0; k < len; k++)
1248 *q++ = TREE_STRING_POINTER (t)[k];
1249 for (j = 0; j < nzeros; j++)
1256 /* Nul terminate the string. */
1259 for (i = 0; i < wchar_bytes; i++)
1265 value = build_string (length, p);
1269 TREE_TYPE (value) = wchar_array_type_node;
1271 TREE_TYPE (value) = char_array_type_node;
1276 static int is_valid_printf_arglist PARAMS ((tree));
1277 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1278 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1279 enum expand_modifier, int, int));
1280 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
1281 enum expand_modifier, int, int));
1283 /* Print a warning if a constant expression had overflow in folding.
1284 Invoke this function on every expression that the language
1285 requires to be a constant expression.
1286 Note the ANSI C standard says it is erroneous for a
1287 constant expression to overflow. */
1290 constant_expression_warning (value)
1293 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1294 || TREE_CODE (value) == VECTOR_CST
1295 || TREE_CODE (value) == COMPLEX_CST)
1296 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1297 pedwarn ("overflow in constant expression");
1300 /* Print a warning if an expression had overflow in folding.
1301 Invoke this function on every expression that
1302 (1) appears in the source code, and
1303 (2) might be a constant expression that overflowed, and
1304 (3) is not already checked by convert_and_check;
1305 however, do not invoke this function on operands of explicit casts. */
1308 overflow_warning (value)
1311 if ((TREE_CODE (value) == INTEGER_CST
1312 || (TREE_CODE (value) == COMPLEX_CST
1313 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1314 && TREE_OVERFLOW (value))
1316 TREE_OVERFLOW (value) = 0;
1317 if (skip_evaluation == 0)
1318 warning ("integer overflow in expression");
1320 else if ((TREE_CODE (value) == REAL_CST
1321 || (TREE_CODE (value) == COMPLEX_CST
1322 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1323 && TREE_OVERFLOW (value))
1325 TREE_OVERFLOW (value) = 0;
1326 if (skip_evaluation == 0)
1327 warning ("floating point overflow in expression");
1329 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1331 TREE_OVERFLOW (value) = 0;
1332 if (skip_evaluation == 0)
1333 warning ("vector overflow in expression");
1337 /* Print a warning if a large constant is truncated to unsigned,
1338 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1339 Invoke this function on every expression that might be implicitly
1340 converted to an unsigned type. */
1343 unsigned_conversion_warning (result, operand)
1344 tree result, operand;
1346 tree type = TREE_TYPE (result);
1348 if (TREE_CODE (operand) == INTEGER_CST
1349 && TREE_CODE (type) == INTEGER_TYPE
1350 && TREE_UNSIGNED (type)
1351 && skip_evaluation == 0
1352 && !int_fits_type_p (operand, type))
1354 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1355 /* This detects cases like converting -129 or 256 to unsigned char. */
1356 warning ("large integer implicitly truncated to unsigned type");
1357 else if (warn_conversion)
1358 warning ("negative integer implicitly converted to unsigned type");
1362 /* Nonzero if constant C has a value that is permissible
1363 for type TYPE (an INTEGER_TYPE). */
1366 constant_fits_type_p (c, type)
1369 if (TREE_CODE (c) == INTEGER_CST)
1370 return int_fits_type_p (c, type);
1372 c = convert (type, c);
1373 return !TREE_OVERFLOW (c);
1376 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1377 Invoke this function on every expression that is converted implicitly,
1378 i.e. because of language rules and not because of an explicit cast. */
1381 convert_and_check (type, expr)
1384 tree t = convert (type, expr);
1385 if (TREE_CODE (t) == INTEGER_CST)
1387 if (TREE_OVERFLOW (t))
1389 TREE_OVERFLOW (t) = 0;
1391 /* Do not diagnose overflow in a constant expression merely
1392 because a conversion overflowed. */
1393 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1395 /* No warning for converting 0x80000000 to int. */
1396 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1397 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1398 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1399 /* If EXPR fits in the unsigned version of TYPE,
1400 don't warn unless pedantic. */
1402 || TREE_UNSIGNED (type)
1403 || ! constant_fits_type_p (expr,
1404 c_common_unsigned_type (type)))
1405 && skip_evaluation == 0)
1406 warning ("overflow in implicit constant conversion");
1409 unsigned_conversion_warning (t, expr);
1414 /* A node in a list that describes references to variables (EXPR), which are
1415 either read accesses if WRITER is zero, or write accesses, in which case
1416 WRITER is the parent of EXPR. */
1423 /* Used to implement a cache the results of a call to verify_tree. We only
1424 use this for SAVE_EXPRs. */
1427 struct tlist_cache *next;
1428 struct tlist *cache_before_sp;
1429 struct tlist *cache_after_sp;
1433 /* Obstack to use when allocating tlist structures, and corresponding
1435 static struct obstack tlist_obstack;
1436 static char *tlist_firstobj = 0;
1438 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1440 static struct tlist *warned_ids;
1441 /* SAVE_EXPRs need special treatment. We process them only once and then
1442 cache the results. */
1443 static struct tlist_cache *save_expr_cache;
1445 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1446 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1447 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1448 static int warning_candidate_p PARAMS ((tree));
1449 static void warn_for_collisions PARAMS ((struct tlist *));
1450 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1451 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1452 static void verify_sequence_points PARAMS ((tree));
1454 /* Create a new struct tlist and fill in its fields. */
1455 static struct tlist *
1456 new_tlist (next, t, writer)
1462 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1469 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1470 is nonnull, we ignore any node we find which has a writer equal to it. */
1473 add_tlist (to, add, exclude_writer, copy)
1476 tree exclude_writer;
1481 struct tlist *next = add->next;
1484 if (! exclude_writer || add->writer != exclude_writer)
1485 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1490 /* Merge the nodes of ADD into TO. This merging process is done so that for
1491 each variable that already exists in TO, no new node is added; however if
1492 there is a write access recorded in ADD, and an occurrence on TO is only
1493 a read access, then the occurrence in TO will be modified to record the
1497 merge_tlist (to, add, copy)
1502 struct tlist **end = to;
1505 end = &(*end)->next;
1511 struct tlist *next = add->next;
1513 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1514 if (tmp2->expr == add->expr)
1518 tmp2->writer = add->writer;
1522 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1523 end = &(*end)->next;
1530 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1531 references in list LIST conflict with it, excluding reads if ONLY writers
1535 warn_for_collisions_1 (written, writer, list, only_writes)
1536 tree written, writer;
1542 /* Avoid duplicate warnings. */
1543 for (tmp = warned_ids; tmp; tmp = tmp->next)
1544 if (tmp->expr == written)
1549 if (list->expr == written
1550 && list->writer != writer
1551 && (! only_writes || list->writer))
1553 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1554 warning ("operation on `%s' may be undefined",
1555 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1561 /* Given a list LIST of references to variables, find whether any of these
1562 can cause conflicts due to missing sequence points. */
1565 warn_for_collisions (list)
1570 for (tmp = list; tmp; tmp = tmp->next)
1573 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1577 /* Return nonzero if X is a tree that can be verified by the sequence point
1580 warning_candidate_p (x)
1583 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1586 /* Walk the tree X, and record accesses to variables. If X is written by the
1587 parent tree, WRITER is the parent.
1588 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1589 expression or its only operand forces a sequence point, then everything up
1590 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1592 Once we return, we will have emitted warnings if any subexpression before
1593 such a sequence point could be undefined. On a higher level, however, the
1594 sequence point may not be relevant, and we'll merge the two lists.
1596 Example: (b++, a) + b;
1597 The call that processes the COMPOUND_EXPR will store the increment of B
1598 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1599 processes the PLUS_EXPR will need to merge the two lists so that
1600 eventually, all accesses end up on the same list (and we'll warn about the
1601 unordered subexpressions b++ and b.
1603 A note on merging. If we modify the former example so that our expression
1606 care must be taken not simply to add all three expressions into the final
1607 PNO_SP list. The function merge_tlist takes care of that by merging the
1608 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1609 way, so that no more than one access to B is recorded. */
1612 verify_tree (x, pbefore_sp, pno_sp, writer)
1614 struct tlist **pbefore_sp, **pno_sp;
1617 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1618 enum tree_code code;
1621 /* X may be NULL if it is the operand of an empty statement expression
1627 code = TREE_CODE (x);
1628 class = TREE_CODE_CLASS (code);
1630 if (warning_candidate_p (x))
1632 *pno_sp = new_tlist (*pno_sp, x, writer);
1642 case TRUTH_ANDIF_EXPR:
1643 case TRUTH_ORIF_EXPR:
1644 tmp_before = tmp_nosp = tmp_list3 = 0;
1645 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1646 warn_for_collisions (tmp_nosp);
1647 merge_tlist (pbefore_sp, tmp_before, 0);
1648 merge_tlist (pbefore_sp, tmp_nosp, 0);
1649 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1650 merge_tlist (pbefore_sp, tmp_list3, 0);
1654 tmp_before = tmp_list2 = 0;
1655 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1656 warn_for_collisions (tmp_list2);
1657 merge_tlist (pbefore_sp, tmp_before, 0);
1658 merge_tlist (pbefore_sp, tmp_list2, 1);
1660 tmp_list3 = tmp_nosp = 0;
1661 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1662 warn_for_collisions (tmp_nosp);
1663 merge_tlist (pbefore_sp, tmp_list3, 0);
1665 tmp_list3 = tmp_list2 = 0;
1666 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1667 warn_for_collisions (tmp_list2);
1668 merge_tlist (pbefore_sp, tmp_list3, 0);
1669 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1670 two first, to avoid warning for (a ? b++ : b++). */
1671 merge_tlist (&tmp_nosp, tmp_list2, 0);
1672 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1675 case PREDECREMENT_EXPR:
1676 case PREINCREMENT_EXPR:
1677 case POSTDECREMENT_EXPR:
1678 case POSTINCREMENT_EXPR:
1679 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1683 tmp_before = tmp_nosp = tmp_list3 = 0;
1684 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1685 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1686 /* Expressions inside the LHS are not ordered wrt. the sequence points
1687 in the RHS. Example:
1689 Despite the fact that the modification of "a" is in the before_sp
1690 list (tmp_before), it conflicts with the use of "a" in the LHS.
1691 We can handle this by adding the contents of tmp_list3
1692 to those of tmp_before, and redoing the collision warnings for that
1694 add_tlist (&tmp_before, tmp_list3, x, 1);
1695 warn_for_collisions (tmp_before);
1696 /* Exclude the LHS itself here; we first have to merge it into the
1697 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1698 didn't exclude the LHS, we'd get it twice, once as a read and once
1700 add_tlist (pno_sp, tmp_list3, x, 0);
1701 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1703 merge_tlist (pbefore_sp, tmp_before, 0);
1704 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1705 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1706 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1710 /* We need to warn about conflicts among arguments and conflicts between
1711 args and the function address. Side effects of the function address,
1712 however, are not ordered by the sequence point of the call. */
1713 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1714 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1715 if (TREE_OPERAND (x, 1))
1716 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1717 merge_tlist (&tmp_list3, tmp_list2, 0);
1718 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1719 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1720 warn_for_collisions (tmp_before);
1721 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1725 /* Scan all the list, e.g. indices of multi dimensional array. */
1728 tmp_before = tmp_nosp = 0;
1729 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1730 merge_tlist (&tmp_nosp, tmp_before, 0);
1731 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1738 struct tlist_cache *t;
1739 for (t = save_expr_cache; t; t = t->next)
1745 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1747 t->next = save_expr_cache;
1749 save_expr_cache = t;
1751 tmp_before = tmp_nosp = 0;
1752 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1753 warn_for_collisions (tmp_nosp);
1758 struct tlist *t = tmp_nosp;
1760 merge_tlist (&tmp_list3, t, 0);
1762 t->cache_before_sp = tmp_before;
1763 t->cache_after_sp = tmp_list3;
1765 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1766 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1775 if (first_rtl_op (code) == 0)
1777 x = TREE_OPERAND (x, 0);
1793 int max = first_rtl_op (TREE_CODE (x));
1794 for (lp = 0; lp < max; lp++)
1796 tmp_before = tmp_nosp = 0;
1797 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1798 merge_tlist (&tmp_nosp, tmp_before, 0);
1799 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1806 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1810 verify_sequence_points (expr)
1813 struct tlist *before_sp = 0, *after_sp = 0;
1816 save_expr_cache = 0;
1817 if (tlist_firstobj == 0)
1819 gcc_obstack_init (&tlist_obstack);
1820 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1823 verify_tree (expr, &before_sp, &after_sp, 0);
1824 warn_for_collisions (after_sp);
1825 obstack_free (&tlist_obstack, tlist_firstobj);
1829 c_expand_expr_stmt (expr)
1832 /* Do default conversion if safe and possibly important,
1833 in case within ({...}). */
1834 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1835 && (flag_isoc99 || lvalue_p (expr)))
1836 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1837 expr = default_conversion (expr);
1839 if (warn_sequence_point)
1840 verify_sequence_points (expr);
1842 if (TREE_TYPE (expr) != error_mark_node
1843 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1844 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1845 error ("expression statement has incomplete type");
1847 last_expr_type = TREE_TYPE (expr);
1848 return add_stmt (build_stmt (EXPR_STMT, expr));
1851 /* Validate the expression after `case' and apply default promotions. */
1854 check_case_value (value)
1857 if (value == NULL_TREE)
1860 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1861 STRIP_TYPE_NOPS (value);
1862 /* In C++, the following is allowed:
1865 switch (...) { case i: ... }
1867 So, we try to reduce the VALUE to a constant that way. */
1868 if (c_language == clk_cplusplus)
1870 value = decl_constant_value (value);
1871 STRIP_TYPE_NOPS (value);
1872 value = fold (value);
1875 if (TREE_CODE (value) != INTEGER_CST
1876 && value != error_mark_node)
1878 error ("case label does not reduce to an integer constant");
1879 value = error_mark_node;
1882 /* Promote char or short to int. */
1883 value = default_conversion (value);
1885 constant_expression_warning (value);
1890 /* Return an integer type with BITS bits of precision,
1891 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1894 c_common_type_for_size (bits, unsignedp)
1898 if (bits == TYPE_PRECISION (integer_type_node))
1899 return unsignedp ? unsigned_type_node : integer_type_node;
1901 if (bits == TYPE_PRECISION (signed_char_type_node))
1902 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1904 if (bits == TYPE_PRECISION (short_integer_type_node))
1905 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1907 if (bits == TYPE_PRECISION (long_integer_type_node))
1908 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1910 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1911 return (unsignedp ? long_long_unsigned_type_node
1912 : long_long_integer_type_node);
1914 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1915 return (unsignedp ? widest_unsigned_literal_type_node
1916 : widest_integer_literal_type_node);
1918 if (bits <= TYPE_PRECISION (intQI_type_node))
1919 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1921 if (bits <= TYPE_PRECISION (intHI_type_node))
1922 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1924 if (bits <= TYPE_PRECISION (intSI_type_node))
1925 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1927 if (bits <= TYPE_PRECISION (intDI_type_node))
1928 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1933 /* Return a data type that has machine mode MODE.
1934 If the mode is an integer,
1935 then UNSIGNEDP selects between signed and unsigned types. */
1938 c_common_type_for_mode (mode, unsignedp)
1939 enum machine_mode mode;
1942 if (mode == TYPE_MODE (integer_type_node))
1943 return unsignedp ? unsigned_type_node : integer_type_node;
1945 if (mode == TYPE_MODE (signed_char_type_node))
1946 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1948 if (mode == TYPE_MODE (short_integer_type_node))
1949 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1951 if (mode == TYPE_MODE (long_integer_type_node))
1952 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1954 if (mode == TYPE_MODE (long_long_integer_type_node))
1955 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1957 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1958 return unsignedp ? widest_unsigned_literal_type_node
1959 : widest_integer_literal_type_node;
1962 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1965 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1968 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1971 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1973 #if HOST_BITS_PER_WIDE_INT >= 64
1974 if (mode == TYPE_MODE (intTI_type_node))
1975 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1978 if (mode == TYPE_MODE (float_type_node))
1979 return float_type_node;
1981 if (mode == TYPE_MODE (double_type_node))
1982 return double_type_node;
1984 if (mode == TYPE_MODE (long_double_type_node))
1985 return long_double_type_node;
1987 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1988 return build_pointer_type (char_type_node);
1990 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1991 return build_pointer_type (integer_type_node);
1996 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1998 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
2000 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
2002 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
2004 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
2006 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
2008 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
2010 return V16SF_type_node;
2012 return V4SF_type_node;
2014 return V2SF_type_node;
2016 return V2DF_type_node;
2024 /* Return an unsigned type the same as TYPE in other respects. */
2026 c_common_unsigned_type (type)
2029 tree type1 = TYPE_MAIN_VARIANT (type);
2030 if (type1 == signed_char_type_node || type1 == char_type_node)
2031 return unsigned_char_type_node;
2032 if (type1 == integer_type_node)
2033 return unsigned_type_node;
2034 if (type1 == short_integer_type_node)
2035 return short_unsigned_type_node;
2036 if (type1 == long_integer_type_node)
2037 return long_unsigned_type_node;
2038 if (type1 == long_long_integer_type_node)
2039 return long_long_unsigned_type_node;
2040 if (type1 == widest_integer_literal_type_node)
2041 return widest_unsigned_literal_type_node;
2042 #if HOST_BITS_PER_WIDE_INT >= 64
2043 if (type1 == intTI_type_node)
2044 return unsigned_intTI_type_node;
2046 if (type1 == intDI_type_node)
2047 return unsigned_intDI_type_node;
2048 if (type1 == intSI_type_node)
2049 return unsigned_intSI_type_node;
2050 if (type1 == intHI_type_node)
2051 return unsigned_intHI_type_node;
2052 if (type1 == intQI_type_node)
2053 return unsigned_intQI_type_node;
2055 return c_common_signed_or_unsigned_type (1, type);
2058 /* Return a signed type the same as TYPE in other respects. */
2061 c_common_signed_type (type)
2064 tree type1 = TYPE_MAIN_VARIANT (type);
2065 if (type1 == unsigned_char_type_node || type1 == char_type_node)
2066 return signed_char_type_node;
2067 if (type1 == unsigned_type_node)
2068 return integer_type_node;
2069 if (type1 == short_unsigned_type_node)
2070 return short_integer_type_node;
2071 if (type1 == long_unsigned_type_node)
2072 return long_integer_type_node;
2073 if (type1 == long_long_unsigned_type_node)
2074 return long_long_integer_type_node;
2075 if (type1 == widest_unsigned_literal_type_node)
2076 return widest_integer_literal_type_node;
2077 #if HOST_BITS_PER_WIDE_INT >= 64
2078 if (type1 == unsigned_intTI_type_node)
2079 return intTI_type_node;
2081 if (type1 == unsigned_intDI_type_node)
2082 return intDI_type_node;
2083 if (type1 == unsigned_intSI_type_node)
2084 return intSI_type_node;
2085 if (type1 == unsigned_intHI_type_node)
2086 return intHI_type_node;
2087 if (type1 == unsigned_intQI_type_node)
2088 return intQI_type_node;
2090 return c_common_signed_or_unsigned_type (0, type);
2093 /* Return a type the same as TYPE except unsigned or
2094 signed according to UNSIGNEDP. */
2097 c_common_signed_or_unsigned_type (unsignedp, type)
2101 if (! INTEGRAL_TYPE_P (type)
2102 || TREE_UNSIGNED (type) == unsignedp)
2105 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2106 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2107 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2108 return unsignedp ? unsigned_type_node : integer_type_node;
2109 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2110 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2111 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2112 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2113 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2114 return (unsignedp ? long_long_unsigned_type_node
2115 : long_long_integer_type_node);
2116 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2117 return (unsignedp ? widest_unsigned_literal_type_node
2118 : widest_integer_literal_type_node);
2120 #if HOST_BITS_PER_WIDE_INT >= 64
2121 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
2122 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2124 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
2125 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2126 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
2127 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2128 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
2129 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2130 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
2131 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2136 /* Return the minimum number of bits needed to represent VALUE in a
2137 signed or unsigned type, UNSIGNEDP says which. */
2140 min_precision (value, unsignedp)
2146 /* If the value is negative, compute its negative minus 1. The latter
2147 adjustment is because the absolute value of the largest negative value
2148 is one larger than the largest positive value. This is equivalent to
2149 a bit-wise negation, so use that operation instead. */
2151 if (tree_int_cst_sgn (value) < 0)
2152 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2154 /* Return the number of bits needed, taking into account the fact
2155 that we need one more bit for a signed than unsigned type. */
2157 if (integer_zerop (value))
2160 log = tree_floor_log2 (value);
2162 return log + 1 + ! unsignedp;
2165 /* Print an error message for invalid operands to arith operation
2166 CODE. NOP_EXPR is used as a special case (see
2167 c_common_truthvalue_conversion). */
2170 binary_op_error (code)
2171 enum tree_code code;
2178 error ("invalid truth-value expression");
2182 opname = "+"; break;
2184 opname = "-"; break;
2186 opname = "*"; break;
2188 opname = "max"; break;
2190 opname = "min"; break;
2192 opname = "=="; break;
2194 opname = "!="; break;
2196 opname = "<="; break;
2198 opname = ">="; break;
2200 opname = "<"; break;
2202 opname = ">"; break;
2204 opname = "<<"; break;
2206 opname = ">>"; break;
2207 case TRUNC_MOD_EXPR:
2208 case FLOOR_MOD_EXPR:
2209 opname = "%"; break;
2210 case TRUNC_DIV_EXPR:
2211 case FLOOR_DIV_EXPR:
2212 opname = "/"; break;
2214 opname = "&"; break;
2216 opname = "|"; break;
2217 case TRUTH_ANDIF_EXPR:
2218 opname = "&&"; break;
2219 case TRUTH_ORIF_EXPR:
2220 opname = "||"; break;
2222 opname = "^"; break;
2225 opname = "rotate"; break;
2227 opname = "unknown"; break;
2229 error ("invalid operands to binary %s", opname);
2232 /* Subroutine of build_binary_op, used for comparison operations.
2233 See if the operands have both been converted from subword integer types
2234 and, if so, perhaps change them both back to their original type.
2235 This function is also responsible for converting the two operands
2236 to the proper common type for comparison.
2238 The arguments of this function are all pointers to local variables
2239 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2240 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2242 If this function returns nonzero, it means that the comparison has
2243 a constant value. What this function returns is an expression for
2247 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2248 tree *op0_ptr, *op1_ptr;
2250 enum tree_code *rescode_ptr;
2253 tree op0 = *op0_ptr;
2254 tree op1 = *op1_ptr;
2255 int unsignedp0, unsignedp1;
2257 tree primop0, primop1;
2258 enum tree_code code = *rescode_ptr;
2260 /* Throw away any conversions to wider types
2261 already present in the operands. */
2263 primop0 = get_narrower (op0, &unsignedp0);
2264 primop1 = get_narrower (op1, &unsignedp1);
2266 /* Handle the case that OP0 does not *contain* a conversion
2267 but it *requires* conversion to FINAL_TYPE. */
2269 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2270 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2271 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2272 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2274 /* If one of the operands must be floated, we cannot optimize. */
2275 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2276 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2278 /* If first arg is constant, swap the args (changing operation
2279 so value is preserved), for canonicalization. Don't do this if
2280 the second arg is 0. */
2282 if (TREE_CONSTANT (primop0)
2283 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2286 int temi = unsignedp0;
2294 unsignedp0 = unsignedp1;
2317 *rescode_ptr = code;
2320 /* If comparing an integer against a constant more bits wide,
2321 maybe we can deduce a value of 1 or 0 independent of the data.
2322 Or else truncate the constant now
2323 rather than extend the variable at run time.
2325 This is only interesting if the constant is the wider arg.
2326 Also, it is not safe if the constant is unsigned and the
2327 variable arg is signed, since in this case the variable
2328 would be sign-extended and then regarded as unsigned.
2329 Our technique fails in this case because the lowest/highest
2330 possible unsigned results don't follow naturally from the
2331 lowest/highest possible values of the variable operand.
2332 For just EQ_EXPR and NE_EXPR there is another technique that
2333 could be used: see if the constant can be faithfully represented
2334 in the other operand's type, by truncating it and reextending it
2335 and see if that preserves the constant's value. */
2337 if (!real1 && !real2
2338 && TREE_CODE (primop1) == INTEGER_CST
2339 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2341 int min_gt, max_gt, min_lt, max_lt;
2342 tree maxval, minval;
2343 /* 1 if comparison is nominally unsigned. */
2344 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2347 type = c_common_signed_or_unsigned_type (unsignedp0,
2348 TREE_TYPE (primop0));
2350 /* If TYPE is an enumeration, then we need to get its min/max
2351 values from it's underlying integral type, not the enumerated
2353 if (TREE_CODE (type) == ENUMERAL_TYPE)
2354 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2356 maxval = TYPE_MAX_VALUE (type);
2357 minval = TYPE_MIN_VALUE (type);
2359 if (unsignedp && !unsignedp0)
2360 *restype_ptr = c_common_signed_type (*restype_ptr);
2362 if (TREE_TYPE (primop1) != *restype_ptr)
2363 primop1 = convert (*restype_ptr, primop1);
2364 if (type != *restype_ptr)
2366 minval = convert (*restype_ptr, minval);
2367 maxval = convert (*restype_ptr, maxval);
2370 if (unsignedp && unsignedp0)
2372 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2373 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2374 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2375 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2379 min_gt = INT_CST_LT (primop1, minval);
2380 max_gt = INT_CST_LT (primop1, maxval);
2381 min_lt = INT_CST_LT (minval, primop1);
2382 max_lt = INT_CST_LT (maxval, primop1);
2386 /* This used to be a switch, but Genix compiler can't handle that. */
2387 if (code == NE_EXPR)
2389 if (max_lt || min_gt)
2390 val = boolean_true_node;
2392 else if (code == EQ_EXPR)
2394 if (max_lt || min_gt)
2395 val = boolean_false_node;
2397 else if (code == LT_EXPR)
2400 val = boolean_true_node;
2402 val = boolean_false_node;
2404 else if (code == GT_EXPR)
2407 val = boolean_true_node;
2409 val = boolean_false_node;
2411 else if (code == LE_EXPR)
2414 val = boolean_true_node;
2416 val = boolean_false_node;
2418 else if (code == GE_EXPR)
2421 val = boolean_true_node;
2423 val = boolean_false_node;
2426 /* If primop0 was sign-extended and unsigned comparison specd,
2427 we did a signed comparison above using the signed type bounds.
2428 But the comparison we output must be unsigned.
2430 Also, for inequalities, VAL is no good; but if the signed
2431 comparison had *any* fixed result, it follows that the
2432 unsigned comparison just tests the sign in reverse
2433 (positive values are LE, negative ones GE).
2434 So we can generate an unsigned comparison
2435 against an extreme value of the signed type. */
2437 if (unsignedp && !unsignedp0)
2444 primop1 = TYPE_MIN_VALUE (type);
2450 primop1 = TYPE_MAX_VALUE (type);
2457 type = c_common_unsigned_type (type);
2460 if (TREE_CODE (primop0) != INTEGER_CST)
2462 if (val == boolean_false_node)
2463 warning ("comparison is always false due to limited range of data type");
2464 if (val == boolean_true_node)
2465 warning ("comparison is always true due to limited range of data type");
2470 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2471 if (TREE_SIDE_EFFECTS (primop0))
2472 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2476 /* Value is not predetermined, but do the comparison
2477 in the type of the operand that is not constant.
2478 TYPE is already properly set. */
2480 else if (real1 && real2
2481 && (TYPE_PRECISION (TREE_TYPE (primop0))
2482 == TYPE_PRECISION (TREE_TYPE (primop1))))
2483 type = TREE_TYPE (primop0);
2485 /* If args' natural types are both narrower than nominal type
2486 and both extend in the same manner, compare them
2487 in the type of the wider arg.
2488 Otherwise must actually extend both to the nominal
2489 common type lest different ways of extending
2491 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2493 else if (unsignedp0 == unsignedp1 && real1 == real2
2494 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2495 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2497 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2498 type = c_common_signed_or_unsigned_type (unsignedp0
2499 || TREE_UNSIGNED (*restype_ptr),
2501 /* Make sure shorter operand is extended the right way
2502 to match the longer operand. */
2504 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2505 TREE_TYPE (primop0)),
2508 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2509 TREE_TYPE (primop1)),
2514 /* Here we must do the comparison on the nominal type
2515 using the args exactly as we received them. */
2516 type = *restype_ptr;
2520 if (!real1 && !real2 && integer_zerop (primop1)
2521 && TREE_UNSIGNED (*restype_ptr))
2527 /* All unsigned values are >= 0, so we warn if extra warnings
2528 are requested. However, if OP0 is a constant that is
2529 >= 0, the signedness of the comparison isn't an issue,
2530 so suppress the warning. */
2531 if (extra_warnings && !in_system_header
2532 && ! (TREE_CODE (primop0) == INTEGER_CST
2533 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2535 warning ("comparison of unsigned expression >= 0 is always true");
2536 value = boolean_true_node;
2540 if (extra_warnings && !in_system_header
2541 && ! (TREE_CODE (primop0) == INTEGER_CST
2542 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2544 warning ("comparison of unsigned expression < 0 is always false");
2545 value = boolean_false_node;
2554 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2555 if (TREE_SIDE_EFFECTS (primop0))
2556 return build (COMPOUND_EXPR, TREE_TYPE (value),
2563 *op0_ptr = convert (type, primop0);
2564 *op1_ptr = convert (type, primop1);
2566 *restype_ptr = boolean_type_node;
2571 /* Return a tree for the sum or difference (RESULTCODE says which)
2572 of pointer PTROP and integer INTOP. */
2575 pointer_int_sum (resultcode, ptrop, intop)
2576 enum tree_code resultcode;
2584 /* The result is a pointer of the same type that is being added. */
2586 tree result_type = TREE_TYPE (ptrop);
2588 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2590 if (pedantic || warn_pointer_arith)
2591 pedwarn ("pointer of type `void *' used in arithmetic");
2592 size_exp = integer_one_node;
2594 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2596 if (pedantic || warn_pointer_arith)
2597 pedwarn ("pointer to a function used in arithmetic");
2598 size_exp = integer_one_node;
2600 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2602 if (pedantic || warn_pointer_arith)
2603 pedwarn ("pointer to member function used in arithmetic");
2604 size_exp = integer_one_node;
2606 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2608 if (pedantic || warn_pointer_arith)
2609 pedwarn ("pointer to a member used in arithmetic");
2610 size_exp = integer_one_node;
2613 size_exp = size_in_bytes (TREE_TYPE (result_type));
2615 /* If what we are about to multiply by the size of the elements
2616 contains a constant term, apply distributive law
2617 and multiply that constant term separately.
2618 This helps produce common subexpressions. */
2620 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2621 && ! TREE_CONSTANT (intop)
2622 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2623 && TREE_CONSTANT (size_exp)
2624 /* If the constant comes from pointer subtraction,
2625 skip this optimization--it would cause an error. */
2626 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2627 /* If the constant is unsigned, and smaller than the pointer size,
2628 then we must skip this optimization. This is because it could cause
2629 an overflow error if the constant is negative but INTOP is not. */
2630 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2631 || (TYPE_PRECISION (TREE_TYPE (intop))
2632 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2634 enum tree_code subcode = resultcode;
2635 tree int_type = TREE_TYPE (intop);
2636 if (TREE_CODE (intop) == MINUS_EXPR)
2637 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2638 /* Convert both subexpression types to the type of intop,
2639 because weird cases involving pointer arithmetic
2640 can result in a sum or difference with different type args. */
2641 ptrop = build_binary_op (subcode, ptrop,
2642 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2643 intop = convert (int_type, TREE_OPERAND (intop, 0));
2646 /* Convert the integer argument to a type the same size as sizetype
2647 so the multiply won't overflow spuriously. */
2649 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2650 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2651 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2652 TREE_UNSIGNED (sizetype)), intop);
2654 /* Replace the integer argument with a suitable product by the object size.
2655 Do this multiplication as signed, then convert to the appropriate
2656 pointer type (actually unsigned integral). */
2658 intop = convert (result_type,
2659 build_binary_op (MULT_EXPR, intop,
2660 convert (TREE_TYPE (intop), size_exp), 1));
2662 /* Create the sum or difference. */
2664 result = build (resultcode, result_type, ptrop, intop);
2666 folded = fold (result);
2667 if (folded == result)
2668 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2672 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2673 or validate its data type for an `if' or `while' statement or ?..: exp.
2675 This preparation consists of taking the ordinary
2676 representation of an expression expr and producing a valid tree
2677 boolean expression describing whether expr is nonzero. We could
2678 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2679 but we optimize comparisons, &&, ||, and !.
2681 The resulting type should always be `boolean_type_node'. */
2684 c_common_truthvalue_conversion (expr)
2687 if (TREE_CODE (expr) == ERROR_MARK)
2690 #if 0 /* This appears to be wrong for C++. */
2691 /* These really should return error_mark_node after 2.4 is stable.
2692 But not all callers handle ERROR_MARK properly. */
2693 switch (TREE_CODE (TREE_TYPE (expr)))
2696 error ("struct type value used where scalar is required");
2697 return boolean_false_node;
2700 error ("union type value used where scalar is required");
2701 return boolean_false_node;
2704 error ("array type value used where scalar is required");
2705 return boolean_false_node;
2712 switch (TREE_CODE (expr))
2715 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2716 case TRUTH_ANDIF_EXPR:
2717 case TRUTH_ORIF_EXPR:
2718 case TRUTH_AND_EXPR:
2720 case TRUTH_XOR_EXPR:
2721 case TRUTH_NOT_EXPR:
2722 TREE_TYPE (expr) = boolean_type_node;
2729 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2732 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2735 /* If we are taking the address of an external decl, it might be zero
2736 if it is weak, so we cannot optimize. */
2737 if (DECL_P (TREE_OPERAND (expr, 0))
2738 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2741 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2742 return build (COMPOUND_EXPR, boolean_type_node,
2743 TREE_OPERAND (expr, 0), boolean_true_node);
2745 return boolean_true_node;
2748 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2749 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2750 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2751 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2758 /* These don't change whether an object is non-zero or zero. */
2759 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2763 /* These don't change whether an object is zero or non-zero, but
2764 we can't ignore them if their second arg has side-effects. */
2765 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2766 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2767 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2769 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2772 /* Distribute the conversion into the arms of a COND_EXPR. */
2773 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2774 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2775 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2778 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2779 since that affects how `default_conversion' will behave. */
2780 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2781 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2783 /* fall through... */
2785 /* If this is widening the argument, we can ignore it. */
2786 if (TYPE_PRECISION (TREE_TYPE (expr))
2787 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2788 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2792 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2793 aren't guaranteed to the be same for modes that can represent
2794 infinity, since if x and y are both +infinity, or both
2795 -infinity, then x - y is not a number.
2797 Note that this transformation is safe when x or y is NaN.
2798 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2800 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2802 /* fall through... */
2804 /* This and MINUS_EXPR can be changed into a comparison of the
2806 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2807 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2808 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2809 TREE_OPERAND (expr, 1), 1);
2810 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2811 fold (build1 (NOP_EXPR,
2812 TREE_TYPE (TREE_OPERAND (expr, 0)),
2813 TREE_OPERAND (expr, 1))), 1);
2816 if (integer_onep (TREE_OPERAND (expr, 1))
2817 && TREE_TYPE (expr) != boolean_type_node)
2818 /* Using convert here would cause infinite recursion. */
2819 return build1 (NOP_EXPR, boolean_type_node, expr);
2823 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2824 warning ("suggest parentheses around assignment used as truth value");
2831 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2833 tree t = save_expr (expr);
2834 return (build_binary_op
2835 ((TREE_SIDE_EFFECTS (expr)
2836 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2837 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2838 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2842 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2845 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2846 int, enum built_in_class, int, int,
2849 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2850 down to the element type of an array. */
2853 c_build_qualified_type (type, type_quals)
2857 /* A restrict-qualified pointer type must be a pointer to object or
2858 incomplete type. Note that the use of POINTER_TYPE_P also allows
2859 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2860 the C++ front-end also use POINTER_TYPE for pointer-to-member
2861 values, so even though it should be illegal to use `restrict'
2862 with such an entity we don't flag that here. Thus, special case
2863 code for that case is required in the C++ front-end. */
2864 if ((type_quals & TYPE_QUAL_RESTRICT)
2865 && (!POINTER_TYPE_P (type)
2866 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2868 error ("invalid use of `restrict'");
2869 type_quals &= ~TYPE_QUAL_RESTRICT;
2872 if (TREE_CODE (type) == ARRAY_TYPE)
2873 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2875 TYPE_DOMAIN (type));
2876 return build_qualified_type (type, type_quals);
2879 /* Apply the TYPE_QUALS to the new DECL. */
2882 c_apply_type_quals_to_decl (type_quals, decl)
2886 if ((type_quals & TYPE_QUAL_CONST)
2887 || (TREE_TYPE (decl)
2888 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2889 TREE_READONLY (decl) = 1;
2890 if (type_quals & TYPE_QUAL_VOLATILE)
2892 TREE_SIDE_EFFECTS (decl) = 1;
2893 TREE_THIS_VOLATILE (decl) = 1;
2895 if (type_quals & TYPE_QUAL_RESTRICT)
2897 if (!TREE_TYPE (decl)
2898 || !POINTER_TYPE_P (TREE_TYPE (decl))
2899 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2900 error ("invalid use of `restrict'");
2901 else if (flag_strict_aliasing)
2902 /* Indicate we need to make a unique alias set for this pointer.
2903 We can't do it here because it might be pointing to an
2905 DECL_POINTER_ALIAS_SET (decl) = -2;
2909 /* Return the typed-based alias set for T, which may be an expression
2910 or a type. Return -1 if we don't do anything special. */
2913 c_common_get_alias_set (t)
2918 /* Permit type-punning when accessing a union, provided the access
2919 is directly through the union. For example, this code does not
2920 permit taking the address of a union member and then storing
2921 through it. Even the type-punning allowed here is a GCC
2922 extension, albeit a common and useful one; the C standard says
2923 that such accesses have implementation-defined behavior. */
2925 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2926 u = TREE_OPERAND (u, 0))
2927 if (TREE_CODE (u) == COMPONENT_REF
2928 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2931 /* That's all the expressions we handle specially. */
2935 /* The C standard guarantess that any object may be accessed via an
2936 lvalue that has character type. */
2937 if (t == char_type_node
2938 || t == signed_char_type_node
2939 || t == unsigned_char_type_node)
2942 /* If it has the may_alias attribute, it can alias anything. */
2943 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2946 /* The C standard specifically allows aliasing between signed and
2947 unsigned variants of the same type. We treat the signed
2948 variant as canonical. */
2949 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2951 tree t1 = c_common_signed_type (t);
2953 /* t1 == t can happen for boolean nodes which are always unsigned. */
2955 return get_alias_set (t1);
2957 else if (POINTER_TYPE_P (t))
2961 /* Unfortunately, there is no canonical form of a pointer type.
2962 In particular, if we have `typedef int I', then `int *', and
2963 `I *' are different types. So, we have to pick a canonical
2964 representative. We do this below.
2966 Technically, this approach is actually more conservative that
2967 it needs to be. In particular, `const int *' and `int *'
2968 should be in different alias sets, according to the C and C++
2969 standard, since their types are not the same, and so,
2970 technically, an `int **' and `const int **' cannot point at
2973 But, the standard is wrong. In particular, this code is
2978 const int* const* cipp = &ipp;
2980 And, it doesn't make sense for that to be legal unless you
2981 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2982 the pointed-to types. This issue has been reported to the
2984 t1 = build_type_no_quals (t);
2986 return get_alias_set (t1);
2992 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2993 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2994 flag controls whether we should diagnose possibly ill-formed
2995 constructs or not. */
2997 c_sizeof_or_alignof_type (type, op, complain)
3002 const char *op_name;
3004 enum tree_code type_code = TREE_CODE (type);
3006 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
3007 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
3009 if (type_code == FUNCTION_TYPE)
3011 if (op == SIZEOF_EXPR)
3013 if (complain && (pedantic || warn_pointer_arith))
3014 pedwarn ("invalid application of `sizeof' to a function type");
3015 value = size_one_node;
3018 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3020 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3022 if (type_code == VOID_TYPE
3023 && complain && (pedantic || warn_pointer_arith))
3024 pedwarn ("invalid application of `%s' to a void type", op_name);
3025 value = size_one_node;
3027 else if (!COMPLETE_TYPE_P (type))
3030 error ("invalid application of `%s' to an incomplete type", op_name);
3031 value = size_zero_node;
3035 if (op == SIZEOF_EXPR)
3036 /* Convert in case a char is more than one unit. */
3037 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3038 size_int (TYPE_PRECISION (char_type_node)
3041 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
3044 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3045 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3046 never happen. However, this node should really have type
3047 `size_t', which is just a typedef for an ordinary integer type. */
3048 value = fold (build1 (NOP_EXPR, c_size_type_node, value));
3049 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
3054 /* Implement the __alignof keyword: Return the minimum required
3055 alignment of EXPR, measured in bytes. For VAR_DECL's and
3056 FIELD_DECL's return DECL_ALIGN (which can be set from an
3057 "aligned" __attribute__ specification). */
3060 c_alignof_expr (expr)
3065 if (TREE_CODE (expr) == VAR_DECL)
3066 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
3068 else if (TREE_CODE (expr) == COMPONENT_REF
3069 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3071 error ("`__alignof' applied to a bit-field");
3074 else if (TREE_CODE (expr) == COMPONENT_REF
3075 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3076 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
3078 else if (TREE_CODE (expr) == INDIRECT_REF)
3080 tree t = TREE_OPERAND (expr, 0);
3082 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3084 while (TREE_CODE (t) == NOP_EXPR
3085 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3089 t = TREE_OPERAND (t, 0);
3090 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3091 if (thisalign > bestalign)
3092 best = t, bestalign = thisalign;
3094 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3097 return c_alignof (TREE_TYPE (expr));
3099 return fold (build1 (NOP_EXPR, c_size_type_node, t));
3102 /* Handle C and C++ default attributes. */
3104 enum built_in_attribute
3106 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3107 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3108 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3109 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3110 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3111 #include "builtin-attrs.def"
3112 #undef DEF_ATTR_NULL_TREE
3114 #undef DEF_ATTR_IDENT
3115 #undef DEF_ATTR_TREE_LIST
3120 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3122 static bool c_attrs_initialized = false;
3124 static void c_init_attributes PARAMS ((void));
3126 /* Build tree nodes and builtin functions common to both C and C++ language
3130 c_common_nodes_and_builtins ()
3134 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3135 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3136 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3137 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3138 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3139 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3140 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3141 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3142 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3143 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3144 #include "builtin-types.def"
3145 #undef DEF_PRIMITIVE_TYPE
3146 #undef DEF_FUNCTION_TYPE_0
3147 #undef DEF_FUNCTION_TYPE_1
3148 #undef DEF_FUNCTION_TYPE_2
3149 #undef DEF_FUNCTION_TYPE_3
3150 #undef DEF_FUNCTION_TYPE_4
3151 #undef DEF_FUNCTION_TYPE_VAR_0
3152 #undef DEF_FUNCTION_TYPE_VAR_1
3153 #undef DEF_FUNCTION_TYPE_VAR_2
3154 #undef DEF_POINTER_TYPE
3158 typedef enum builtin_type builtin_type;
3160 tree builtin_types[(int) BT_LAST];
3161 int wchar_type_size;
3162 tree array_domain_type;
3163 tree va_list_ref_type_node;
3164 tree va_list_arg_type_node;
3166 /* Define `int' and `char' first so that dbx will output them first. */
3167 record_builtin_type (RID_INT, NULL, integer_type_node);
3168 record_builtin_type (RID_CHAR, "char", char_type_node);
3170 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3171 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3172 but not C. Are the conditionals here needed? */
3173 if (c_language == clk_cplusplus)
3174 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3175 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3176 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3177 record_builtin_type (RID_MAX, "long unsigned int",
3178 long_unsigned_type_node);
3179 if (c_language == clk_cplusplus)
3180 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3181 record_builtin_type (RID_MAX, "long long int",
3182 long_long_integer_type_node);
3183 record_builtin_type (RID_MAX, "long long unsigned int",
3184 long_long_unsigned_type_node);
3185 if (c_language == clk_cplusplus)
3186 record_builtin_type (RID_MAX, "long long unsigned",
3187 long_long_unsigned_type_node);
3188 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3189 record_builtin_type (RID_MAX, "short unsigned int",
3190 short_unsigned_type_node);
3191 if (c_language == clk_cplusplus)
3192 record_builtin_type (RID_MAX, "unsigned short",
3193 short_unsigned_type_node);
3195 /* Define both `signed char' and `unsigned char'. */
3196 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3197 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3199 /* These are types that c_common_type_for_size and
3200 c_common_type_for_mode use. */
3201 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3203 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3205 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3207 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3209 #if HOST_BITS_PER_WIDE_INT >= 64
3210 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3211 get_identifier ("__int128_t"),
3214 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3215 unsigned_intQI_type_node));
3216 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3217 unsigned_intHI_type_node));
3218 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3219 unsigned_intSI_type_node));
3220 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3221 unsigned_intDI_type_node));
3222 #if HOST_BITS_PER_WIDE_INT >= 64
3223 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3224 get_identifier ("__uint128_t"),
3225 unsigned_intTI_type_node));
3228 /* Create the widest literal types. */
3229 widest_integer_literal_type_node
3230 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3231 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3232 widest_integer_literal_type_node));
3234 widest_unsigned_literal_type_node
3235 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3236 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3237 widest_unsigned_literal_type_node));
3239 /* `unsigned long' is the standard type for sizeof.
3240 Note that stddef.h uses `unsigned long',
3241 and this must agree, even if long and int are the same size. */
3243 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3244 signed_size_type_node = c_common_signed_type (c_size_type_node);
3245 set_sizetype (c_size_type_node);
3247 build_common_tree_nodes_2 (flag_short_double);
3249 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3250 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3251 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3253 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3254 get_identifier ("complex int"),
3255 complex_integer_type_node));
3256 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3257 get_identifier ("complex float"),
3258 complex_float_type_node));
3259 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3260 get_identifier ("complex double"),
3261 complex_double_type_node));
3262 (*lang_hooks.decls.pushdecl)
3263 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3264 complex_long_double_type_node));
3266 /* Types which are common to the fortran compiler and libf2c. When
3267 changing these, you also need to be concerned with f/com.h. */
3269 if (TYPE_PRECISION (float_type_node)
3270 == TYPE_PRECISION (long_integer_type_node))
3272 g77_integer_type_node = long_integer_type_node;
3273 g77_uinteger_type_node = long_unsigned_type_node;
3275 else if (TYPE_PRECISION (float_type_node)
3276 == TYPE_PRECISION (integer_type_node))
3278 g77_integer_type_node = integer_type_node;
3279 g77_uinteger_type_node = unsigned_type_node;
3282 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3284 if (g77_integer_type_node != NULL_TREE)
3286 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3287 get_identifier ("__g77_integer"),
3288 g77_integer_type_node));
3289 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3290 get_identifier ("__g77_uinteger"),
3291 g77_uinteger_type_node));
3294 if (TYPE_PRECISION (float_type_node) * 2
3295 == TYPE_PRECISION (long_integer_type_node))
3297 g77_longint_type_node = long_integer_type_node;
3298 g77_ulongint_type_node = long_unsigned_type_node;
3300 else if (TYPE_PRECISION (float_type_node) * 2
3301 == TYPE_PRECISION (long_long_integer_type_node))
3303 g77_longint_type_node = long_long_integer_type_node;
3304 g77_ulongint_type_node = long_long_unsigned_type_node;
3307 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3309 if (g77_longint_type_node != NULL_TREE)
3311 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3312 get_identifier ("__g77_longint"),
3313 g77_longint_type_node));
3314 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3315 get_identifier ("__g77_ulongint"),
3316 g77_ulongint_type_node));
3319 record_builtin_type (RID_VOID, NULL, void_type_node);
3321 void_zero_node = build_int_2 (0, 0);
3322 TREE_TYPE (void_zero_node) = void_type_node;
3324 void_list_node = build_void_list_node ();
3326 /* Make a type to be the domain of a few array types
3327 whose domains don't really matter.
3328 200 is small enough that it always fits in size_t
3329 and large enough that it can hold most function names for the
3330 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3331 array_domain_type = build_index_type (size_int (200));
3333 /* Make a type for arrays of characters.
3334 With luck nothing will ever really depend on the length of this
3336 char_array_type_node
3337 = build_array_type (char_type_node, array_domain_type);
3339 /* Likewise for arrays of ints. */
3341 = build_array_type (integer_type_node, array_domain_type);
3343 string_type_node = build_pointer_type (char_type_node);
3344 const_string_type_node
3345 = build_pointer_type (build_qualified_type
3346 (char_type_node, TYPE_QUAL_CONST));
3348 (*targetm.init_builtins) ();
3350 /* This is special for C++ so functions can be overloaded. */
3351 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3352 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3353 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3354 if (c_language == clk_cplusplus)
3356 if (TREE_UNSIGNED (wchar_type_node))
3357 wchar_type_node = make_unsigned_type (wchar_type_size);
3359 wchar_type_node = make_signed_type (wchar_type_size);
3360 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3364 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3365 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3368 /* This is for wide string constants. */
3369 wchar_array_type_node
3370 = build_array_type (wchar_type_node, array_domain_type);
3373 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3376 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3378 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3380 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3382 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3383 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3385 (*lang_hooks.decls.pushdecl)
3386 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3387 va_list_type_node));
3389 (*lang_hooks.decls.pushdecl)
3390 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3391 ptrdiff_type_node));
3393 (*lang_hooks.decls.pushdecl)
3394 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3397 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3399 va_list_arg_type_node = va_list_ref_type_node =
3400 build_pointer_type (TREE_TYPE (va_list_type_node));
3404 va_list_arg_type_node = va_list_type_node;
3405 va_list_ref_type_node = build_reference_type (va_list_type_node);
3408 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3409 builtin_types[(int) ENUM] = VALUE;
3410 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3411 builtin_types[(int) ENUM] \
3412 = build_function_type (builtin_types[(int) RETURN], \
3414 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3415 builtin_types[(int) ENUM] \
3416 = build_function_type (builtin_types[(int) RETURN], \
3417 tree_cons (NULL_TREE, \
3418 builtin_types[(int) ARG1], \
3420 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3421 builtin_types[(int) ENUM] \
3422 = build_function_type \
3423 (builtin_types[(int) RETURN], \
3424 tree_cons (NULL_TREE, \
3425 builtin_types[(int) ARG1], \
3426 tree_cons (NULL_TREE, \
3427 builtin_types[(int) ARG2], \
3429 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3430 builtin_types[(int) ENUM] \
3431 = build_function_type \
3432 (builtin_types[(int) RETURN], \
3433 tree_cons (NULL_TREE, \
3434 builtin_types[(int) ARG1], \
3435 tree_cons (NULL_TREE, \
3436 builtin_types[(int) ARG2], \
3437 tree_cons (NULL_TREE, \
3438 builtin_types[(int) ARG3], \
3440 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3441 builtin_types[(int) ENUM] \
3442 = build_function_type \
3443 (builtin_types[(int) RETURN], \
3444 tree_cons (NULL_TREE, \
3445 builtin_types[(int) ARG1], \
3446 tree_cons (NULL_TREE, \
3447 builtin_types[(int) ARG2], \
3450 builtin_types[(int) ARG3], \
3451 tree_cons (NULL_TREE, \
3452 builtin_types[(int) ARG4], \
3453 void_list_node)))));
3454 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3455 builtin_types[(int) ENUM] \
3456 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3457 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3458 builtin_types[(int) ENUM] \
3459 = build_function_type (builtin_types[(int) RETURN], \
3460 tree_cons (NULL_TREE, \
3461 builtin_types[(int) ARG1], \
3464 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3465 builtin_types[(int) ENUM] \
3466 = build_function_type \
3467 (builtin_types[(int) RETURN], \
3468 tree_cons (NULL_TREE, \
3469 builtin_types[(int) ARG1], \
3470 tree_cons (NULL_TREE, \
3471 builtin_types[(int) ARG2], \
3473 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3474 builtin_types[(int) ENUM] \
3475 = build_pointer_type (builtin_types[(int) TYPE]);
3476 #include "builtin-types.def"
3477 #undef DEF_PRIMITIVE_TYPE
3478 #undef DEF_FUNCTION_TYPE_1
3479 #undef DEF_FUNCTION_TYPE_2
3480 #undef DEF_FUNCTION_TYPE_3
3481 #undef DEF_FUNCTION_TYPE_4
3482 #undef DEF_FUNCTION_TYPE_VAR_0
3483 #undef DEF_FUNCTION_TYPE_VAR_1
3484 #undef DEF_POINTER_TYPE
3486 if (!c_attrs_initialized)
3487 c_init_attributes ();
3489 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3490 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS) \
3495 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3499 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3502 ? (NAME + strlen ("__builtin_")) \
3504 built_in_attributes[(int) ATTRS]); \
3506 decl = builtin_function_2 (NAME, \
3507 NAME + strlen ("__builtin_"), \
3508 builtin_types[TYPE], \
3509 builtin_types[LIBTYPE], \
3514 built_in_attributes[(int) ATTRS]); \
3516 built_in_decls[(int) ENUM] = decl; \
3518 #include "builtins.def"
3521 main_identifier_node = get_identifier ("main");
3525 build_va_arg (expr, type)
3528 return build1 (VA_ARG_EXPR, type, expr);
3532 /* Linked list of disabled built-in functions. */
3534 typedef struct disabled_builtin
3537 struct disabled_builtin *next;
3539 static disabled_builtin *disabled_builtins = NULL;
3541 static bool builtin_function_disabled_p PARAMS ((const char *));
3543 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3544 begins with "__builtin_", give an error. */
3547 disable_builtin_function (name)
3550 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3551 error ("cannot disable built-in function `%s'", name);
3554 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3556 new->next = disabled_builtins;
3557 disabled_builtins = new;
3562 /* Return true if the built-in function NAME has been disabled, false
3566 builtin_function_disabled_p (name)
3569 disabled_builtin *p;
3570 for (p = disabled_builtins; p != NULL; p = p->next)
3572 if (strcmp (name, p->name) == 0)
3579 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3580 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3581 of these may be NULL (though both being NULL is useless).
3582 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3583 TYPE is the type of the function with the ordinary name. These
3584 may differ if the ordinary name is declared with a looser type to avoid
3585 conflicts with headers. FUNCTION_CODE and CLASS are as for
3586 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3587 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3588 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3589 ATTRS is the tree list representing the builtin's function attributes.
3590 Returns the declaration of BUILTIN_NAME, if any, otherwise
3591 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3592 or if NONANSI_P and flag_no_nonansi_builtin. */
3595 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3596 class, library_name_p, nonansi_p, attrs)
3597 const char *builtin_name;
3602 enum built_in_class class;
3607 tree bdecl = NULL_TREE;
3608 tree decl = NULL_TREE;
3609 if (builtin_name != 0)
3611 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3612 class, library_name_p ? name : NULL,
3615 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3616 && !(nonansi_p && flag_no_nonansi_builtin))
3618 decl = builtin_function (name, type, function_code, class, NULL,
3621 DECL_BUILT_IN_NONANSI (decl) = 1;
3623 return (bdecl != 0 ? bdecl : decl);
3626 /* Nonzero if the type T promotes to int. This is (nearly) the
3627 integral promotions defined in ISO C99 6.3.1.1/2. */
3630 c_promoting_integer_type_p (t)
3633 switch (TREE_CODE (t))
3636 return (TYPE_MAIN_VARIANT (t) == char_type_node
3637 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3638 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3639 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3640 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3641 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3644 /* ??? Technically all enumerations not larger than an int
3645 promote to an int. But this is used along code paths
3646 that only want to notice a size change. */
3647 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3657 /* Return 1 if PARMS specifies a fixed number of parameters
3658 and none of their types is affected by default promotions. */
3661 self_promoting_args_p (parms)
3665 for (t = parms; t; t = TREE_CHAIN (t))
3667 tree type = TREE_VALUE (t);
3669 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3675 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3678 if (c_promoting_integer_type_p (type))
3684 /* Recursively examines the array elements of TYPE, until a non-array
3685 element type is found. */
3688 strip_array_types (type)
3691 while (TREE_CODE (type) == ARRAY_TYPE)
3692 type = TREE_TYPE (type);
3697 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3700 /* Expand a call to an unordered comparison function such as
3701 __builtin_isgreater(). FUNCTION is the function's declaration and
3702 PARAMS a list of the values passed. For __builtin_isunordered(),
3703 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3704 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3705 that give the opposite of the desired result. UNORDERED_CODE is
3706 used for modes that can hold NaNs and ORDERED_CODE is used for the
3710 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3711 tree function, params;
3712 enum tree_code unordered_code, ordered_code;
3714 tree arg0, arg1, type;
3715 enum tree_code code0, code1;
3717 /* Check that we have exactly two arguments. */
3718 if (params == 0 || TREE_CHAIN (params) == 0)
3720 error ("too few arguments to function `%s'",
3721 IDENTIFIER_POINTER (DECL_NAME (function)));
3722 return error_mark_node;
3724 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3726 error ("too many arguments to function `%s'",
3727 IDENTIFIER_POINTER (DECL_NAME (function)));
3728 return error_mark_node;
3731 arg0 = TREE_VALUE (params);
3732 arg1 = TREE_VALUE (TREE_CHAIN (params));
3734 code0 = TREE_CODE (TREE_TYPE (arg0));
3735 code1 = TREE_CODE (TREE_TYPE (arg1));
3737 /* Make sure that the arguments have a common type of REAL. */
3739 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3740 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3741 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3743 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3745 error ("non-floating-point argument to function `%s'",
3746 IDENTIFIER_POINTER (DECL_NAME (function)));
3747 return error_mark_node;
3750 if (unordered_code == UNORDERED_EXPR)
3752 if (MODE_HAS_NANS (TYPE_MODE (type)))
3753 return build_binary_op (unordered_code,
3754 convert (type, arg0),
3755 convert (type, arg1),
3758 return integer_zero_node;
3761 return build_unary_op (TRUTH_NOT_EXPR,
3762 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3765 convert (type, arg0),
3766 convert (type, arg1),
3772 /* Recognize certain built-in functions so we can make tree-codes
3773 other than CALL_EXPR. We do this when it enables fold-const.c
3774 to do something useful. */
3775 /* ??? By rights this should go in builtins.c, but only C and C++
3776 implement build_{binary,unary}_op. Not exactly sure what bits
3777 of functionality are actually needed from those functions, or
3778 where the similar functionality exists in the other front ends. */
3781 expand_tree_builtin (function, params, coerced_params)
3782 tree function, params, coerced_params;
3784 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3787 switch (DECL_FUNCTION_CODE (function))
3791 case BUILT_IN_LLABS:
3792 case BUILT_IN_IMAXABS:
3794 case BUILT_IN_FABSL:
3795 case BUILT_IN_FABSF:
3796 if (coerced_params == 0)
3797 return integer_zero_node;
3798 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3801 case BUILT_IN_CONJF:
3802 case BUILT_IN_CONJL:
3803 if (coerced_params == 0)
3804 return integer_zero_node;
3805 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3807 case BUILT_IN_CREAL:
3808 case BUILT_IN_CREALF:
3809 case BUILT_IN_CREALL:
3810 if (coerced_params == 0)
3811 return integer_zero_node;
3812 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3814 case BUILT_IN_CIMAG:
3815 case BUILT_IN_CIMAGF:
3816 case BUILT_IN_CIMAGL:
3817 if (coerced_params == 0)
3818 return integer_zero_node;
3819 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3821 case BUILT_IN_ISGREATER:
3822 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3824 case BUILT_IN_ISGREATEREQUAL:
3825 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3827 case BUILT_IN_ISLESS:
3828 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3830 case BUILT_IN_ISLESSEQUAL:
3831 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3833 case BUILT_IN_ISLESSGREATER:
3834 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3836 case BUILT_IN_ISUNORDERED:
3837 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3846 /* Returns non-zero if CODE is the code for a statement. */
3849 statement_code_p (code)
3850 enum tree_code code;
3875 if (lang_statement_code_p)
3876 return (*lang_statement_code_p) (code);
3881 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3882 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3883 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3884 value, the traversal is aborted, and the value returned by FUNC is
3885 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3886 the node being visited are not walked.
3888 We don't need a without_duplicates variant of this one because the
3889 statement tree is a tree, not a graph. */
3892 walk_stmt_tree (tp, func, data)
3897 enum tree_code code;
3902 #define WALK_SUBTREE(NODE) \
3905 result = walk_stmt_tree (&(NODE), func, data); \
3911 /* Skip empty subtrees. */
3915 /* Skip subtrees below non-statement nodes. */
3916 if (!statement_code_p (TREE_CODE (*tp)))
3919 /* Call the function. */
3921 result = (*func) (tp, &walk_subtrees, data);
3923 /* If we found something, return it. */
3927 /* FUNC may have modified the tree, recheck that we're looking at a
3929 code = TREE_CODE (*tp);
3930 if (!statement_code_p (code))
3933 /* Visit the subtrees unless FUNC decided that there was nothing
3934 interesting below this point in the tree. */
3937 /* Walk over all the sub-trees of this operand. Statement nodes
3938 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3939 len = TREE_CODE_LENGTH (code);
3941 /* Go through the subtrees. We need to do this in forward order so
3942 that the scope of a FOR_EXPR is handled properly. */
3943 for (i = 0; i < len; ++i)
3944 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3947 /* Finally visit the chain. This can be tail-recursion optimized if
3948 we write it this way. */
3949 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3954 /* Used to compare case labels. K1 and K2 are actually tree nodes
3955 representing case labels, or NULL_TREE for a `default' label.
3956 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3957 K2, and 0 if K1 and K2 are equal. */
3960 case_compare (k1, k2)
3964 /* Consider a NULL key (such as arises with a `default' label) to be
3965 smaller than anything else. */
3971 return tree_int_cst_compare ((tree) k1, (tree) k2);
3974 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3975 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3976 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3977 case label was declared using the usual C/C++ syntax, rather than
3978 the GNU case range extension. CASES is a tree containing all the
3979 case ranges processed so far; COND is the condition for the
3980 switch-statement itself. Returns the CASE_LABEL created, or
3981 ERROR_MARK_NODE if no CASE_LABEL is created. */
3984 c_add_case_label (cases, cond, low_value, high_value)
3993 splay_tree_node node;
3995 /* Create the LABEL_DECL itself. */
3996 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3997 DECL_CONTEXT (label) = current_function_decl;
3999 /* If there was an error processing the switch condition, bail now
4000 before we get more confused. */
4001 if (!cond || cond == error_mark_node)
4003 /* Add a label anyhow so that the back-end doesn't think that
4004 the beginning of the switch is unreachable. */
4006 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4007 return error_mark_node;
4010 if ((low_value && TREE_TYPE (low_value)
4011 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4012 || (high_value && TREE_TYPE (high_value)
4013 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4014 error ("pointers are not permitted as case values");
4016 /* Case ranges are a GNU extension. */
4017 if (high_value && pedantic)
4019 if (c_language == clk_cplusplus)
4020 pedwarn ("ISO C++ forbids range expressions in switch statements");
4022 pedwarn ("ISO C forbids range expressions in switch statements");
4025 type = TREE_TYPE (cond);
4028 low_value = check_case_value (low_value);
4029 low_value = convert_and_check (type, low_value);
4033 high_value = check_case_value (high_value);
4034 high_value = convert_and_check (type, high_value);
4037 /* If an error has occurred, bail out now. */
4038 if (low_value == error_mark_node || high_value == error_mark_node)
4041 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4042 return error_mark_node;
4045 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4046 really a case range, even though it was written that way. Remove
4047 the HIGH_VALUE to simplify later processing. */
4048 if (tree_int_cst_equal (low_value, high_value))
4049 high_value = NULL_TREE;
4050 if (low_value && high_value
4051 && !tree_int_cst_lt (low_value, high_value))
4052 warning ("empty range specified");
4054 /* Look up the LOW_VALUE in the table of case labels we already
4056 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4057 /* If there was not an exact match, check for overlapping ranges.
4058 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4059 that's a `default' label and the only overlap is an exact match. */
4060 if (!node && (low_value || high_value))
4062 splay_tree_node low_bound;
4063 splay_tree_node high_bound;
4065 /* Even though there wasn't an exact match, there might be an
4066 overlap between this case range and another case range.
4067 Since we've (inductively) not allowed any overlapping case
4068 ranges, we simply need to find the greatest low case label
4069 that is smaller that LOW_VALUE, and the smallest low case
4070 label that is greater than LOW_VALUE. If there is an overlap
4071 it will occur in one of these two ranges. */
4072 low_bound = splay_tree_predecessor (cases,
4073 (splay_tree_key) low_value);
4074 high_bound = splay_tree_successor (cases,
4075 (splay_tree_key) low_value);
4077 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4078 the LOW_VALUE, so there is no need to check unless the
4079 LOW_BOUND is in fact itself a case range. */
4081 && CASE_HIGH ((tree) low_bound->value)
4082 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4085 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4086 range is bigger than the low end of the current range, so we
4087 are only interested if the current range is a real range, and
4088 not an ordinary case label. */
4091 && (tree_int_cst_compare ((tree) high_bound->key,
4096 /* If there was an overlap, issue an error. */
4099 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
4103 error ("duplicate (or overlapping) case value");
4104 error_with_decl (duplicate,
4105 "this is the first entry overlapping that value");
4109 error ("duplicate case value") ;
4110 error_with_decl (duplicate, "previously used here");
4114 error ("multiple default labels in one switch");
4115 error_with_decl (duplicate, "this is the first default label");
4118 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4121 /* Add a CASE_LABEL to the statement-tree. */
4122 case_label = add_stmt (build_case_label (low_value, high_value, label));
4123 /* Register this case label in the splay tree. */
4124 splay_tree_insert (cases,
4125 (splay_tree_key) low_value,
4126 (splay_tree_value) case_label);
4131 /* Finish an expression taking the address of LABEL. Returns an
4132 expression for the address. */
4135 finish_label_address_expr (label)
4142 if (c_language == clk_cplusplus)
4143 pedwarn ("ISO C++ forbids taking the address of a label");
4145 pedwarn ("ISO C forbids taking the address of a label");
4148 label = lookup_label (label);
4149 if (label == NULL_TREE)
4150 result = null_pointer_node;
4153 TREE_USED (label) = 1;
4154 result = build1 (ADDR_EXPR, ptr_type_node, label);
4155 TREE_CONSTANT (result) = 1;
4156 /* The current function in not necessarily uninlinable.
4157 Computed gotos are incompatible with inlining, but the value
4158 here could be used only in a diagnostic, for example. */
4164 /* Hook used by expand_expr to expand language-specific tree codes. */
4167 c_expand_expr (exp, target, tmode, modifier)
4170 enum machine_mode tmode;
4171 int modifier; /* Actually enum_modifier. */
4173 switch (TREE_CODE (exp))
4179 bool preserve_result = false;
4181 /* Since expand_expr_stmt calls free_temp_slots after every
4182 expression statement, we must call push_temp_slots here.
4183 Otherwise, any temporaries in use now would be considered
4184 out-of-scope after the first EXPR_STMT from within the
4187 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4189 /* If we want the result of this expression, find the last
4190 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4191 if (target != const0_rtx
4192 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4193 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4195 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4196 tree last = TREE_CHAIN (expr);
4198 while (TREE_CHAIN (last))
4201 last = TREE_CHAIN (last);
4204 if (TREE_CODE (last) == SCOPE_STMT
4205 && TREE_CODE (expr) == EXPR_STMT)
4207 TREE_ADDRESSABLE (expr) = 1;
4208 preserve_result = true;
4212 expand_stmt (STMT_EXPR_STMT (exp));
4213 expand_end_stmt_expr (rtl_expr);
4215 result = expand_expr (rtl_expr, target, tmode, modifier);
4216 if (preserve_result && GET_CODE (result) == MEM)
4218 if (GET_MODE (result) != BLKmode)
4219 result = copy_to_reg (result);
4221 preserve_temp_slots (result);
4224 /* If the statment-expression does not have a scope, then the
4225 new temporaries we created within it must live beyond the
4226 statement-expression. */
4227 if (STMT_EXPR_NO_SCOPE (exp))
4228 preserve_temp_slots (NULL_RTX);
4237 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
4238 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4240 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4241 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4242 == BUILT_IN_FRONTEND))
4243 return c_expand_builtin (exp, target, tmode, modifier);
4249 case COMPOUND_LITERAL_EXPR:
4251 /* Initialize the anonymous variable declared in the compound
4252 literal, then return the variable. */
4253 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4254 emit_local_var (decl);
4255 return expand_expr (decl, target, tmode, modifier);
4266 /* Hook used by safe_from_p to handle language-specific tree codes. */
4269 c_safe_from_p (target, exp)
4273 /* We can see statements here when processing the body of a
4274 statement-expression. For a declaration statement declaring a
4275 variable, look at the variable's initializer. */
4276 if (TREE_CODE (exp) == DECL_STMT)
4278 tree decl = DECL_STMT_DECL (exp);
4280 if (TREE_CODE (decl) == VAR_DECL
4281 && DECL_INITIAL (decl)
4282 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4286 /* For any statement, we must follow the statement-chain. */
4287 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
4288 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4290 /* Assume everything else is safe. */
4294 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4297 c_common_unsafe_for_reeval (exp)
4300 /* Statement expressions may not be reevaluated, likewise compound
4302 if (TREE_CODE (exp) == STMT_EXPR
4303 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4306 /* Walk all other expressions. */
4310 /* Hook used by staticp to handle language-specific tree codes. */
4316 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4317 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4322 #define CALLED_AS_BUILT_IN(NODE) \
4323 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4326 c_expand_builtin (exp, target, tmode, modifier)
4329 enum machine_mode tmode;
4330 enum expand_modifier modifier;
4332 tree type = TREE_TYPE (exp);
4333 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4334 tree arglist = TREE_OPERAND (exp, 1);
4335 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4336 enum tree_code code = TREE_CODE (exp);
4337 const int ignore = (target == const0_rtx
4338 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4339 || code == CONVERT_EXPR || code == REFERENCE_EXPR
4340 || code == COND_EXPR)
4341 && TREE_CODE (type) == VOID_TYPE));
4343 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4344 return expand_call (exp, target, ignore);
4348 case BUILT_IN_PRINTF:
4349 target = c_expand_builtin_printf (arglist, target, tmode,
4350 modifier, ignore, /*unlocked=*/ 0);
4355 case BUILT_IN_PRINTF_UNLOCKED:
4356 target = c_expand_builtin_printf (arglist, target, tmode,
4357 modifier, ignore, /*unlocked=*/ 1);
4362 case BUILT_IN_FPRINTF:
4363 target = c_expand_builtin_fprintf (arglist, target, tmode,
4364 modifier, ignore, /*unlocked=*/ 0);
4369 case BUILT_IN_FPRINTF_UNLOCKED:
4370 target = c_expand_builtin_fprintf (arglist, target, tmode,
4371 modifier, ignore, /*unlocked=*/ 1);
4376 default: /* just do library call, if unknown builtin */
4377 error ("built-in function `%s' not currently supported",
4378 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4381 /* The switch statement above can drop through to cause the function
4382 to be called normally. */
4383 return expand_call (exp, target, ignore);
4386 /* Check an arglist to *printf for problems. The arglist should start
4387 at the format specifier, with the remaining arguments immediately
4390 is_valid_printf_arglist (arglist)
4393 /* Save this value so we can restore it later. */
4394 const int SAVE_pedantic = pedantic;
4395 int diagnostic_occurred = 0;
4398 /* Set this to a known value so the user setting won't affect code
4401 /* Check to make sure there are no format specifier errors. */
4402 attrs = tree_cons (get_identifier ("format"),
4403 tree_cons (NULL_TREE,
4404 get_identifier ("printf"),
4405 tree_cons (NULL_TREE,
4407 tree_cons (NULL_TREE,
4411 check_function_format (&diagnostic_occurred, attrs, arglist);
4413 /* Restore the value of `pedantic'. */
4414 pedantic = SAVE_pedantic;
4416 /* If calling `check_function_format_ptr' produces a warning, we
4417 return false, otherwise we return true. */
4418 return ! diagnostic_occurred;
4421 /* If the arguments passed to printf are suitable for optimizations,
4422 we attempt to transform the call. */
4424 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
4427 enum machine_mode tmode;
4428 enum expand_modifier modifier;
4432 tree fn_putchar = unlocked ?
4433 built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
4434 tree fn_puts = unlocked ?
4435 built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
4436 tree fn, format_arg, stripped_string;
4438 /* If the return value is used, or the replacement _DECL isn't
4439 initialized, don't do the transformation. */
4440 if (!ignore || !fn_putchar || !fn_puts)
4443 /* Verify the required arguments in the original call. */
4445 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4448 /* Check the specifier vs. the parameters. */
4449 if (!is_valid_printf_arglist (arglist))
4452 format_arg = TREE_VALUE (arglist);
4453 stripped_string = format_arg;
4454 STRIP_NOPS (stripped_string);
4455 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4456 stripped_string = TREE_OPERAND (stripped_string, 0);
4458 /* If the format specifier isn't a STRING_CST, punt. */
4459 if (TREE_CODE (stripped_string) != STRING_CST)
4462 /* OK! We can attempt optimization. */
4464 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4465 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4467 arglist = TREE_CHAIN (arglist);
4470 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4471 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4473 arglist = TREE_CHAIN (arglist);
4478 /* We can't handle anything else with % args or %% ... yet. */
4479 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4482 /* If the resulting constant string has a length of 1, call
4483 putchar. Note, TREE_STRING_LENGTH includes the terminating
4484 NULL in its count. */
4485 if (TREE_STRING_LENGTH (stripped_string) == 2)
4487 /* Given printf("c"), (where c is any one character,)
4488 convert "c"[0] to an int and pass that to the replacement
4490 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4491 arglist = build_tree_list (NULL_TREE, arglist);
4495 /* If the resulting constant was "string\n", call
4496 __builtin_puts("string"). Ensure "string" has at least one
4497 character besides the trailing \n. Note, TREE_STRING_LENGTH
4498 includes the terminating NULL in its count. */
4499 else if (TREE_STRING_LENGTH (stripped_string) > 2
4500 && TREE_STRING_POINTER (stripped_string)
4501 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4503 /* Create a NULL-terminated string that's one char shorter
4504 than the original, stripping off the trailing '\n'. */
4505 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4506 char *newstr = (char *) alloca (newlen);
4507 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4508 newstr[newlen - 1] = 0;
4510 arglist = fix_string_type (build_string (newlen, newstr));
4511 arglist = build_tree_list (NULL_TREE, arglist);
4515 /* We'd like to arrange to call fputs(string) here, but we
4516 need stdout and don't have a way to get it ... yet. */
4520 return expand_expr (build_function_call (fn, arglist),
4521 (ignore ? const0_rtx : target),
4525 /* If the arguments passed to fprintf are suitable for optimizations,
4526 we attempt to transform the call. */
4528 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4531 enum machine_mode tmode;
4532 enum expand_modifier modifier;
4536 tree fn_fputc = unlocked ?
4537 built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
4538 tree fn_fputs = unlocked ?
4539 built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
4540 tree fn, format_arg, stripped_string;
4542 /* If the return value is used, or the replacement _DECL isn't
4543 initialized, don't do the transformation. */
4544 if (!ignore || !fn_fputc || !fn_fputs)
4547 /* Verify the required arguments in the original call. */
4549 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4550 || (TREE_CHAIN (arglist) == 0)
4551 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4555 /* Check the specifier vs. the parameters. */
4556 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4559 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4560 stripped_string = format_arg;
4561 STRIP_NOPS (stripped_string);
4562 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4563 stripped_string = TREE_OPERAND (stripped_string, 0);
4565 /* If the format specifier isn't a STRING_CST, punt. */
4566 if (TREE_CODE (stripped_string) != STRING_CST)
4569 /* OK! We can attempt optimization. */
4571 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4572 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4574 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4575 arglist = tree_cons (NULL_TREE,
4576 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4580 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4581 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4583 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4584 arglist = tree_cons (NULL_TREE,
4585 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4591 /* We can't handle anything else with % args or %% ... yet. */
4592 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4595 /* When "string" doesn't contain %, replace all cases of
4596 fprintf(stream,string) with fputs(string,stream). The fputs
4597 builtin will take take of special cases like length==1. */
4598 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4599 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4603 return expand_expr (build_function_call (fn, arglist),
4604 (ignore ? const0_rtx : target),
4609 /* Given a boolean expression ARG, return a tree representing an increment
4610 or decrement (as indicated by CODE) of ARG. The front end must check for
4611 invalid cases (e.g., decrement in C++). */
4613 boolean_increment (code, arg)
4614 enum tree_code code;
4618 tree true_res = (c_language == clk_cplusplus
4620 : c_bool_true_node);
4621 arg = stabilize_reference (arg);
4624 case PREINCREMENT_EXPR:
4625 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4627 case POSTINCREMENT_EXPR:
4628 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4629 arg = save_expr (arg);
4630 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4631 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4633 case PREDECREMENT_EXPR:
4634 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4636 case POSTDECREMENT_EXPR:
4637 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4638 arg = save_expr (arg);
4639 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4640 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4645 TREE_SIDE_EFFECTS (val) = 1;
4649 /* Common initialization before parsing options. */
4651 c_common_init_options (lang)
4652 enum c_language_kind lang;
4655 parse_in = cpp_create_reader (lang == clk_c || lang == clk_objective_c
4656 ? CLK_GNUC89 : CLK_GNUCXX);
4657 if (lang == clk_objective_c)
4658 cpp_get_options (parse_in)->objc = 1;
4660 flag_const_strings = (lang == clk_cplusplus);
4661 warn_pointer_arith = (lang == clk_cplusplus);
4663 warn_sign_compare = -1;
4665 /* Mark as "unspecified" (see c_common_post_options). */
4666 flag_bounds_check = -1;
4669 /* Post-switch processing. */
4671 c_common_post_options ()
4673 cpp_post_options (parse_in);
4675 flag_inline_trees = 1;
4677 /* Use tree inlining if possible. Function instrumentation is only
4678 done in the RTL level, so we disable tree inlining. */
4679 if (! flag_instrument_function_entry_exit)
4681 if (!flag_no_inline)
4683 if (flag_inline_functions)
4685 flag_inline_trees = 2;
4686 flag_inline_functions = 0;
4690 /* If still "unspecified", make it match -fbounded-pointers. */
4691 if (flag_bounds_check == -1)
4692 flag_bounds_check = flag_bounded_pointers;
4694 /* Special format checking options don't work without -Wformat; warn if
4696 if (warn_format_y2k && !warn_format)
4697 warning ("-Wformat-y2k ignored without -Wformat");
4698 if (warn_format_extra_args && !warn_format)
4699 warning ("-Wformat-extra-args ignored without -Wformat");
4700 if (warn_format_zero_length && !warn_format)
4701 warning ("-Wformat-zero-length ignored without -Wformat");
4702 if (warn_format_nonliteral && !warn_format)
4703 warning ("-Wformat-nonliteral ignored without -Wformat");
4704 if (warn_format_security && !warn_format)
4705 warning ("-Wformat-security ignored without -Wformat");
4706 if (warn_missing_format_attribute && !warn_format)
4707 warning ("-Wmissing-format-attribute ignored without -Wformat");
4709 /* If an error has occurred in cpplib, note it so we fail
4711 errorcount += cpp_errors (parse_in);
4713 return flag_preprocess_only;
4716 /* Hook that registers front end and target-specific built-ins. */
4718 cb_register_builtins (pfile)
4721 /* -undef turns off target-specific built-ins. */
4725 if (c_language == clk_cplusplus)
4727 if (SUPPORTS_ONE_ONLY)
4728 cpp_define (pfile, "__GXX_WEAK__=1");
4730 cpp_define (pfile, "__GXX_WEAK__=0");
4731 if (flag_exceptions)
4732 cpp_define (pfile, "__EXCEPTIONS");
4733 if (warn_deprecated)
4734 cpp_define (pfile, "__DEPRECATED");
4737 /* represents the C++ ABI version, always defined so it can be used while
4738 preprocessing C and assembler. */
4739 cpp_define (pfile, "__GXX_ABI_VERSION=102");
4741 /* libgcc needs to know this. */
4742 if (USING_SJLJ_EXCEPTIONS)
4743 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
4745 /* stddef.h needs to know these. */
4746 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4747 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4748 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4749 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4751 /* limits.h needs to know these. */
4752 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
4753 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
4754 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
4755 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
4756 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
4760 sprintf (buf, "%d", (int) TYPE_PRECISION (signed_char_type_node));
4761 builtin_define_with_value ("__CHAR_BIT__", buf, 0);
4764 /* For use in assembly language. */
4765 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
4766 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
4769 builtin_define_with_value ("__VERSION__", version_string, 1);
4771 /* Other target-independent built-ins determined by command-line
4774 cpp_define (pfile, "__OPTIMIZE_SIZE__");
4776 cpp_define (pfile, "__OPTIMIZE__");
4779 cpp_define (pfile, "__STDC_HOSTED__=1");
4781 cpp_define (pfile, "__STDC_HOSTED__=0");
4783 if (fast_math_flags_set_p ())
4784 cpp_define (pfile, "__FAST_MATH__");
4786 cpp_define (pfile, "__NO_INLINE__");
4787 if (flag_signaling_nans)
4788 cpp_define (pfile, "__SUPPORT_SNAN__");
4789 if (flag_finite_math_only)
4790 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
4792 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
4795 cpp_define (pfile, "__STRICT_ANSI__");
4797 if (!flag_signed_char)
4798 cpp_define (pfile, "__CHAR_UNSIGNED__");
4800 /* A straightforward target hook doesn't work, because of problems
4801 linking that hook's body when part of non-C front ends. */
4802 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
4803 # define builtin_define(TXT) cpp_define (pfile, TXT)
4804 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
4805 TARGET_CPU_CPP_BUILTINS ();
4806 TARGET_OS_CPP_BUILTINS ();
4809 /* Pass an object-like macro. If it doesn't lie in the user's
4810 namespace, defines it unconditionally. Otherwise define a version
4811 with two leading underscores, and another version with two leading
4812 and trailing underscores, and define the original only if an ISO
4813 standard was not nominated.
4815 e.g. passing "unix" defines "__unix", "__unix__" and possibly
4816 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
4819 builtin_define_std (macro)
4822 size_t len = strlen (macro);
4823 char *buff = alloca (len + 5);
4827 /* prepend __ (or maybe just _) if in user's namespace. */
4828 memcpy (p, macro, len + 1);
4829 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
4836 cpp_define (parse_in, p);
4838 /* If it was in user's namespace... */
4841 /* Define the macro with leading and following __. */
4847 cpp_define (parse_in, p);
4849 /* Finally, define the original macro if permitted. */
4851 cpp_define (parse_in, macro);
4855 /* Pass an object-like macro and a value to define it to. The third
4856 parameter says whether or not to turn the value into a string
4859 builtin_define_with_value (macro, expansion, is_str)
4861 const char *expansion;
4865 size_t mlen = strlen (macro);
4866 size_t elen = strlen (expansion);
4867 size_t extra = 2; /* space for an = and a NUL */
4870 extra += 2; /* space for two quote marks */
4872 buf = alloca (mlen + elen + extra);
4874 sprintf (buf, "%s=\"%s\"", macro, expansion);
4876 sprintf (buf, "%s=%s", macro, expansion);
4878 cpp_define (parse_in, buf);
4881 /* Define MAX for TYPE based on the precision of the type, which is assumed
4882 to be signed. IS_LONG is 1 for type "long" and 2 for "long long". */
4885 builtin_define_type_max (macro, type, is_long)
4892 size_t mlen, vlen, extra;
4894 /* Pre-rendering the values mean we don't have to futz with printing a
4895 multi-word decimal value. There are also a very limited number of
4896 precisions that we support, so it's really a waste of time. */
4897 switch (TYPE_PRECISION (type))
4906 value = "2147483647";
4909 value = "9223372036854775807";
4912 value = "170141183460469231731687303715884105727";
4918 mlen = strlen (macro);
4919 vlen = strlen (value);
4920 extra = 2 + is_long;
4921 buf = alloca (mlen + vlen + extra);
4923 sprintf (buf, "%s=%s%s", macro, value,
4924 (is_long == 1 ? "L" : is_long == 2 ? "LL" : ""));
4926 cpp_define (parse_in, buf);
4929 /* Front end initialization common to C, ObjC and C++. */
4931 c_common_init (filename)
4932 const char *filename;
4934 cpp_options *options = cpp_get_options (parse_in);
4936 /* Set up preprocessor arithmetic. Must be done after call to
4937 c_common_nodes_and_builtins for wchar_type_node to be good. */
4938 options->precision = TYPE_PRECISION (intmax_type_node);
4939 options->char_precision = TYPE_PRECISION (char_type_node);
4940 options->int_precision = TYPE_PRECISION (integer_type_node);
4941 options->wchar_precision = TYPE_PRECISION (wchar_type_node);
4942 options->unsigned_wchar = TREE_UNSIGNED (wchar_type_node);
4943 options->unsigned_char = !flag_signed_char;
4944 options->warn_multichar = warn_multichar;
4945 options->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
4947 /* We want -Wno-long-long to override -pedantic -std=non-c99
4948 and/or -Wtraditional, whatever the ordering. */
4949 options->warn_long_long
4950 = warn_long_long && ((!flag_isoc99 && pedantic) || warn_traditional);
4952 /* Register preprocessor built-ins before calls to
4954 cpp_get_callbacks (parse_in)->register_builtins = cb_register_builtins;
4956 /* NULL is passed up to toplev.c and we exit quickly. */
4957 if (flag_preprocess_only)
4959 cpp_preprocess_file (parse_in);
4963 /* Do this before initializing pragmas, as then cpplib's hash table
4965 filename = init_c_lex (filename);
4969 if (!c_attrs_initialized)
4970 c_init_attributes ();
4975 /* Common finish hook for the C, ObjC and C++ front ends. */
4979 cpp_finish (parse_in);
4981 /* For performance, avoid tearing down cpplib's internal structures.
4982 Call cpp_errors () instead of cpp_destroy (). */
4983 errorcount += cpp_errors (parse_in);
4987 c_init_attributes ()
4989 /* Fill in the built_in_attributes array. */
4990 #define DEF_ATTR_NULL_TREE(ENUM) \
4991 built_in_attributes[(int) ENUM] = NULL_TREE;
4992 #define DEF_ATTR_INT(ENUM, VALUE) \
4993 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4994 #define DEF_ATTR_IDENT(ENUM, STRING) \
4995 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4996 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4997 built_in_attributes[(int) ENUM] \
4998 = tree_cons (built_in_attributes[(int) PURPOSE], \
4999 built_in_attributes[(int) VALUE], \
5000 built_in_attributes[(int) CHAIN]);
5001 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
5002 #include "builtin-attrs.def"
5003 #undef DEF_ATTR_NULL_TREE
5005 #undef DEF_ATTR_IDENT
5006 #undef DEF_ATTR_TREE_LIST
5008 c_attrs_initialized = true;
5011 /* Depending on the name of DECL, apply default attributes to it. */
5014 c_common_insert_default_attributes (decl)
5017 tree name = DECL_NAME (decl);
5019 if (!c_attrs_initialized)
5020 c_init_attributes ();
5022 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
5023 #define DEF_ATTR_INT(ENUM, VALUE)
5024 #define DEF_ATTR_IDENT(ENUM, STRING)
5025 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
5026 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
5027 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
5028 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
5029 ATTR_FLAG_BUILT_IN);
5030 #include "builtin-attrs.def"
5031 #undef DEF_ATTR_NULL_TREE
5033 #undef DEF_ATTR_IDENT
5034 #undef DEF_ATTR_TREE_LIST
5038 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
5039 additionally give the location of the previous declaration DECL. */
5041 shadow_warning (msgid, name, decl)
5045 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
5046 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
5047 DECL_SOURCE_LINE (decl),
5048 "shadowed declaration is here");
5051 /* Attribute handlers common to C front ends. */
5053 /* Handle a "packed" attribute; arguments as in
5054 struct attribute_spec.handler. */
5057 handle_packed_attribute (node, name, args, flags, no_add_attrs)
5060 tree args ATTRIBUTE_UNUSED;
5067 if (TREE_CODE (*node) == TYPE_DECL)
5068 type = &TREE_TYPE (*node);
5075 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5076 *type = build_type_copy (*type);
5077 TYPE_PACKED (*type) = 1;
5079 else if (TREE_CODE (*node) == FIELD_DECL)
5080 DECL_PACKED (*node) = 1;
5081 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5082 used for DECL_REGISTER. It wouldn't mean anything anyway. */
5085 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5086 *no_add_attrs = true;
5092 /* Handle a "nocommon" attribute; arguments as in
5093 struct attribute_spec.handler. */
5096 handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
5099 tree args ATTRIBUTE_UNUSED;
5100 int flags ATTRIBUTE_UNUSED;
5103 if (TREE_CODE (*node) == VAR_DECL)
5104 DECL_COMMON (*node) = 0;
5107 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5108 *no_add_attrs = true;
5114 /* Handle a "common" attribute; arguments as in
5115 struct attribute_spec.handler. */
5118 handle_common_attribute (node, name, args, flags, no_add_attrs)
5121 tree args ATTRIBUTE_UNUSED;
5122 int flags ATTRIBUTE_UNUSED;
5125 if (TREE_CODE (*node) == VAR_DECL)
5126 DECL_COMMON (*node) = 1;
5129 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5130 *no_add_attrs = true;
5136 /* Handle a "noreturn" attribute; arguments as in
5137 struct attribute_spec.handler. */
5140 handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
5143 tree args ATTRIBUTE_UNUSED;
5144 int flags ATTRIBUTE_UNUSED;
5147 tree type = TREE_TYPE (*node);
5149 /* See FIXME comment in c_common_attribute_table. */
5150 if (TREE_CODE (*node) == FUNCTION_DECL)
5151 TREE_THIS_VOLATILE (*node) = 1;
5152 else if (TREE_CODE (type) == POINTER_TYPE
5153 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5155 = build_pointer_type
5156 (build_type_variant (TREE_TYPE (type),
5157 TREE_READONLY (TREE_TYPE (type)), 1));
5160 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5161 *no_add_attrs = true;
5167 /* Handle a "noinline" attribute; arguments as in
5168 struct attribute_spec.handler. */
5171 handle_noinline_attribute (node, name, args, flags, no_add_attrs)
5174 tree args ATTRIBUTE_UNUSED;
5175 int flags ATTRIBUTE_UNUSED;
5178 if (TREE_CODE (*node) == FUNCTION_DECL)
5179 DECL_UNINLINABLE (*node) = 1;
5182 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5183 *no_add_attrs = true;
5189 /* Handle a "always_inline" attribute; arguments as in
5190 struct attribute_spec.handler. */
5193 handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
5196 tree args ATTRIBUTE_UNUSED;
5197 int flags ATTRIBUTE_UNUSED;
5200 if (TREE_CODE (*node) == FUNCTION_DECL)
5202 /* Do nothing else, just set the attribute. We'll get at
5203 it later with lookup_attribute. */
5207 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5208 *no_add_attrs = true;
5214 /* Handle a "used" attribute; arguments as in
5215 struct attribute_spec.handler. */
5218 handle_used_attribute (node, name, args, flags, no_add_attrs)
5221 tree args ATTRIBUTE_UNUSED;
5222 int flags ATTRIBUTE_UNUSED;
5225 if (TREE_CODE (*node) == FUNCTION_DECL)
5226 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node))
5227 = TREE_USED (*node) = 1;
5230 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5231 *no_add_attrs = true;
5237 /* Handle a "unused" attribute; arguments as in
5238 struct attribute_spec.handler. */
5241 handle_unused_attribute (node, name, args, flags, no_add_attrs)
5244 tree args ATTRIBUTE_UNUSED;
5252 if (TREE_CODE (decl) == PARM_DECL
5253 || TREE_CODE (decl) == VAR_DECL
5254 || TREE_CODE (decl) == FUNCTION_DECL
5255 || TREE_CODE (decl) == LABEL_DECL
5256 || TREE_CODE (decl) == TYPE_DECL)
5257 TREE_USED (decl) = 1;
5260 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5261 *no_add_attrs = true;
5266 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5267 *node = build_type_copy (*node);
5268 TREE_USED (*node) = 1;
5274 /* Handle a "const" attribute; arguments as in
5275 struct attribute_spec.handler. */
5278 handle_const_attribute (node, name, args, flags, no_add_attrs)
5281 tree args ATTRIBUTE_UNUSED;
5282 int flags ATTRIBUTE_UNUSED;
5285 tree type = TREE_TYPE (*node);
5287 /* See FIXME comment on noreturn in c_common_attribute_table. */
5288 if (TREE_CODE (*node) == FUNCTION_DECL)
5289 TREE_READONLY (*node) = 1;
5290 else if (TREE_CODE (type) == POINTER_TYPE
5291 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5293 = build_pointer_type
5294 (build_type_variant (TREE_TYPE (type), 1,
5295 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5298 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5299 *no_add_attrs = true;
5305 /* Handle a "transparent_union" attribute; arguments as in
5306 struct attribute_spec.handler. */
5309 handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
5312 tree args ATTRIBUTE_UNUSED;
5316 tree decl = NULL_TREE;
5323 type = &TREE_TYPE (decl);
5324 is_type = TREE_CODE (*node) == TYPE_DECL;
5326 else if (TYPE_P (*node))
5327 type = node, is_type = 1;
5330 && TREE_CODE (*type) == UNION_TYPE
5332 || (TYPE_FIELDS (*type) != 0
5333 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
5335 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5336 *type = build_type_copy (*type);
5337 TYPE_TRANSPARENT_UNION (*type) = 1;
5339 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
5340 && TREE_CODE (*type) == UNION_TYPE
5341 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
5342 DECL_TRANSPARENT_UNION (decl) = 1;
5345 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5346 *no_add_attrs = true;
5352 /* Handle a "constructor" attribute; arguments as in
5353 struct attribute_spec.handler. */
5356 handle_constructor_attribute (node, name, args, flags, no_add_attrs)
5359 tree args ATTRIBUTE_UNUSED;
5360 int flags ATTRIBUTE_UNUSED;
5364 tree type = TREE_TYPE (decl);
5366 if (TREE_CODE (decl) == FUNCTION_DECL
5367 && TREE_CODE (type) == FUNCTION_TYPE
5368 && decl_function_context (decl) == 0)
5370 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5371 TREE_USED (decl) = 1;
5375 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5376 *no_add_attrs = true;
5382 /* Handle a "destructor" attribute; arguments as in
5383 struct attribute_spec.handler. */
5386 handle_destructor_attribute (node, name, args, flags, no_add_attrs)
5389 tree args ATTRIBUTE_UNUSED;
5390 int flags ATTRIBUTE_UNUSED;
5394 tree type = TREE_TYPE (decl);
5396 if (TREE_CODE (decl) == FUNCTION_DECL
5397 && TREE_CODE (type) == FUNCTION_TYPE
5398 && decl_function_context (decl) == 0)
5400 DECL_STATIC_DESTRUCTOR (decl) = 1;
5401 TREE_USED (decl) = 1;
5405 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5406 *no_add_attrs = true;
5412 /* Handle a "mode" attribute; arguments as in
5413 struct attribute_spec.handler. */
5416 handle_mode_attribute (node, name, args, flags, no_add_attrs)
5420 int flags ATTRIBUTE_UNUSED;
5425 *no_add_attrs = true;
5427 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5428 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5432 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5433 int len = strlen (p);
5434 enum machine_mode mode = VOIDmode;
5437 if (len > 4 && p[0] == '_' && p[1] == '_'
5438 && p[len - 1] == '_' && p[len - 2] == '_')
5440 char *newp = (char *) alloca (len - 1);
5442 strcpy (newp, &p[2]);
5443 newp[len - 4] = '\0';
5447 /* Change this type to have a type with the specified mode.
5448 First check for the special modes. */
5449 if (! strcmp (p, "byte"))
5451 else if (!strcmp (p, "word"))
5453 else if (! strcmp (p, "pointer"))
5456 for (j = 0; j < NUM_MACHINE_MODES; j++)
5457 if (!strcmp (p, GET_MODE_NAME (j)))
5458 mode = (enum machine_mode) j;
5460 if (mode == VOIDmode)
5461 error ("unknown machine mode `%s'", p);
5462 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
5463 (mode, TREE_UNSIGNED (type))))
5464 error ("no data type for mode `%s'", p);
5467 /* If this is a vector, make sure we either have hardware
5468 support, or we can emulate it. */
5469 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5470 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5471 && !vector_mode_valid_p (mode))
5473 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5478 /* No need to layout the type here. The caller should do this. */
5485 /* Handle a "section" attribute; arguments as in
5486 struct attribute_spec.handler. */
5489 handle_section_attribute (node, name, args, flags, no_add_attrs)
5491 tree name ATTRIBUTE_UNUSED;
5493 int flags ATTRIBUTE_UNUSED;
5498 if (targetm.have_named_sections)
5500 if ((TREE_CODE (decl) == FUNCTION_DECL
5501 || TREE_CODE (decl) == VAR_DECL)
5502 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5504 if (TREE_CODE (decl) == VAR_DECL
5505 && current_function_decl != NULL_TREE
5506 && ! TREE_STATIC (decl))
5508 error_with_decl (decl,
5509 "section attribute cannot be specified for local variables");
5510 *no_add_attrs = true;
5513 /* The decl may have already been given a section attribute
5514 from a previous declaration. Ensure they match. */
5515 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5516 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5517 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5519 error_with_decl (*node,
5520 "section of `%s' conflicts with previous declaration");
5521 *no_add_attrs = true;
5524 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5528 error_with_decl (*node,
5529 "section attribute not allowed for `%s'");
5530 *no_add_attrs = true;
5535 error_with_decl (*node,
5536 "section attributes are not supported for this target");
5537 *no_add_attrs = true;
5543 /* Handle a "aligned" attribute; arguments as in
5544 struct attribute_spec.handler. */
5547 handle_aligned_attribute (node, name, args, flags, no_add_attrs)
5549 tree name ATTRIBUTE_UNUSED;
5554 tree decl = NULL_TREE;
5557 tree align_expr = (args ? TREE_VALUE (args)
5558 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5564 type = &TREE_TYPE (decl);
5565 is_type = TREE_CODE (*node) == TYPE_DECL;
5567 else if (TYPE_P (*node))
5568 type = node, is_type = 1;
5570 /* Strip any NOPs of any kind. */
5571 while (TREE_CODE (align_expr) == NOP_EXPR
5572 || TREE_CODE (align_expr) == CONVERT_EXPR
5573 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
5574 align_expr = TREE_OPERAND (align_expr, 0);
5576 if (TREE_CODE (align_expr) != INTEGER_CST)
5578 error ("requested alignment is not a constant");
5579 *no_add_attrs = true;
5581 else if ((i = tree_log2 (align_expr)) == -1)
5583 error ("requested alignment is not a power of 2");
5584 *no_add_attrs = true;
5586 else if (i > HOST_BITS_PER_INT - 2)
5588 error ("requested alignment is too large");
5589 *no_add_attrs = true;
5593 /* If we have a TYPE_DECL, then copy the type, so that we
5594 don't accidentally modify a builtin type. See pushdecl. */
5595 if (decl && TREE_TYPE (decl) != error_mark_node
5596 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5598 tree tt = TREE_TYPE (decl);
5599 *type = build_type_copy (*type);
5600 DECL_ORIGINAL_TYPE (decl) = tt;
5601 TYPE_NAME (*type) = decl;
5602 TREE_USED (*type) = TREE_USED (decl);
5603 TREE_TYPE (decl) = *type;
5605 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5606 *type = build_type_copy (*type);
5608 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5609 TYPE_USER_ALIGN (*type) = 1;
5611 else if (TREE_CODE (decl) != VAR_DECL
5612 && TREE_CODE (decl) != FIELD_DECL)
5614 error_with_decl (decl,
5615 "alignment may not be specified for `%s'");
5616 *no_add_attrs = true;
5620 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5621 DECL_USER_ALIGN (decl) = 1;
5627 /* Handle a "weak" attribute; arguments as in
5628 struct attribute_spec.handler. */
5631 handle_weak_attribute (node, name, args, flags, no_add_attrs)
5633 tree name ATTRIBUTE_UNUSED;
5634 tree args ATTRIBUTE_UNUSED;
5635 int flags ATTRIBUTE_UNUSED;
5636 bool *no_add_attrs ATTRIBUTE_UNUSED;
5638 declare_weak (*node);
5643 /* Handle an "alias" attribute; arguments as in
5644 struct attribute_spec.handler. */
5647 handle_alias_attribute (node, name, args, flags, no_add_attrs)
5651 int flags ATTRIBUTE_UNUSED;
5656 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5657 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
5659 error_with_decl (decl,
5660 "`%s' defined both normally and as an alias");
5661 *no_add_attrs = true;
5663 else if (decl_function_context (decl) == 0)
5667 id = TREE_VALUE (args);
5668 if (TREE_CODE (id) != STRING_CST)
5670 error ("alias arg not a string");
5671 *no_add_attrs = true;
5674 id = get_identifier (TREE_STRING_POINTER (id));
5675 /* This counts as a use of the object pointed to. */
5678 if (TREE_CODE (decl) == FUNCTION_DECL)
5679 DECL_INITIAL (decl) = error_mark_node;
5681 DECL_EXTERNAL (decl) = 0;
5685 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5686 *no_add_attrs = true;
5692 /* Handle an "visibility" attribute; arguments as in
5693 struct attribute_spec.handler. */
5696 handle_visibility_attribute (node, name, args, flags, no_add_attrs)
5700 int flags ATTRIBUTE_UNUSED;
5705 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
5707 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5708 *no_add_attrs = true;
5714 id = TREE_VALUE (args);
5715 if (TREE_CODE (id) != STRING_CST)
5717 error ("visibility arg not a string");
5718 *no_add_attrs = true;
5721 if (strcmp (TREE_STRING_POINTER (id), "hidden")
5722 && strcmp (TREE_STRING_POINTER (id), "protected")
5723 && strcmp (TREE_STRING_POINTER (id), "internal"))
5725 error ("visibility arg must be one of \"hidden\", \"protected\" or \"internal\"");
5726 *no_add_attrs = true;
5734 /* Handle a "no_instrument_function" attribute; arguments as in
5735 struct attribute_spec.handler. */
5738 handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
5741 tree args ATTRIBUTE_UNUSED;
5742 int flags ATTRIBUTE_UNUSED;
5747 if (TREE_CODE (decl) != FUNCTION_DECL)
5749 error_with_decl (decl,
5750 "`%s' attribute applies only to functions",
5751 IDENTIFIER_POINTER (name));
5752 *no_add_attrs = true;
5754 else if (DECL_INITIAL (decl))
5756 error_with_decl (decl,
5757 "can't set `%s' attribute after definition",
5758 IDENTIFIER_POINTER (name));
5759 *no_add_attrs = true;
5762 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5767 /* Handle a "malloc" attribute; arguments as in
5768 struct attribute_spec.handler. */
5771 handle_malloc_attribute (node, name, args, flags, no_add_attrs)
5774 tree args ATTRIBUTE_UNUSED;
5775 int flags ATTRIBUTE_UNUSED;
5778 if (TREE_CODE (*node) == FUNCTION_DECL)
5779 DECL_IS_MALLOC (*node) = 1;
5780 /* ??? TODO: Support types. */
5783 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5784 *no_add_attrs = true;
5790 /* Handle a "no_limit_stack" attribute; arguments as in
5791 struct attribute_spec.handler. */
5794 handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
5797 tree args ATTRIBUTE_UNUSED;
5798 int flags ATTRIBUTE_UNUSED;
5803 if (TREE_CODE (decl) != FUNCTION_DECL)
5805 error_with_decl (decl,
5806 "`%s' attribute applies only to functions",
5807 IDENTIFIER_POINTER (name));
5808 *no_add_attrs = true;
5810 else if (DECL_INITIAL (decl))
5812 error_with_decl (decl,
5813 "can't set `%s' attribute after definition",
5814 IDENTIFIER_POINTER (name));
5815 *no_add_attrs = true;
5818 DECL_NO_LIMIT_STACK (decl) = 1;
5823 /* Handle a "pure" attribute; arguments as in
5824 struct attribute_spec.handler. */
5827 handle_pure_attribute (node, name, args, flags, no_add_attrs)
5830 tree args ATTRIBUTE_UNUSED;
5831 int flags ATTRIBUTE_UNUSED;
5834 if (TREE_CODE (*node) == FUNCTION_DECL)
5835 DECL_IS_PURE (*node) = 1;
5836 /* ??? TODO: Support types. */
5839 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5840 *no_add_attrs = true;
5846 /* Handle a "deprecated" attribute; arguments as in
5847 struct attribute_spec.handler. */
5850 handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
5853 tree args ATTRIBUTE_UNUSED;
5857 tree type = NULL_TREE;
5859 const char *what = NULL;
5864 type = TREE_TYPE (decl);
5866 if (TREE_CODE (decl) == TYPE_DECL
5867 || TREE_CODE (decl) == PARM_DECL
5868 || TREE_CODE (decl) == VAR_DECL
5869 || TREE_CODE (decl) == FUNCTION_DECL
5870 || TREE_CODE (decl) == FIELD_DECL)
5871 TREE_DEPRECATED (decl) = 1;
5875 else if (TYPE_P (*node))
5877 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5878 *node = build_type_copy (*node);
5879 TREE_DEPRECATED (*node) = 1;
5887 *no_add_attrs = true;
5888 if (type && TYPE_NAME (type))
5890 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5891 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5892 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5893 && DECL_NAME (TYPE_NAME (type)))
5894 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5897 warning ("`%s' attribute ignored for `%s'",
5898 IDENTIFIER_POINTER (name), what);
5900 warning ("`%s' attribute ignored",
5901 IDENTIFIER_POINTER (name));
5907 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5908 to prevent us from duplicating type nodes unnecessarily.
5909 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5910 since we want to distinguish types that are essentially identical (except
5911 for their debug representation), we use a local list here. */
5912 static tree vector_type_node_list = 0;
5914 /* Handle a "vector_size" attribute; arguments as in
5915 struct attribute_spec.handler. */
5918 handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
5922 int flags ATTRIBUTE_UNUSED;
5925 unsigned HOST_WIDE_INT vecsize, nunits;
5926 enum machine_mode mode, orig_mode, new_mode;
5927 tree type = *node, new_type = NULL_TREE;
5928 tree type_list_node;
5930 *no_add_attrs = true;
5932 if (! host_integerp (TREE_VALUE (args), 1))
5934 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5938 /* Get the vector size (in bytes). */
5939 vecsize = tree_low_cst (TREE_VALUE (args), 1);
5941 /* We need to provide for vector pointers, vector arrays, and
5942 functions returning vectors. For example:
5944 __attribute__((vector_size(16))) short *foo;
5946 In this case, the mode is SI, but the type being modified is
5947 HI, so we need to look further. */
5949 while (POINTER_TYPE_P (type)
5950 || TREE_CODE (type) == FUNCTION_TYPE
5951 || TREE_CODE (type) == ARRAY_TYPE)
5952 type = TREE_TYPE (type);
5954 /* Get the mode of the type being modified. */
5955 orig_mode = TYPE_MODE (type);
5957 if (TREE_CODE (type) == RECORD_TYPE
5958 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5959 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5960 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5962 error ("invalid vector type for attribute `%s'",
5963 IDENTIFIER_POINTER (name));
5967 /* Calculate how many units fit in the vector. */
5968 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5970 /* Find a suitably sized vector. */
5971 new_mode = VOIDmode;
5972 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5974 : MODE_VECTOR_FLOAT);
5976 mode = GET_MODE_WIDER_MODE (mode))
5977 if (vecsize == GET_MODE_SIZE (mode)
5978 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
5984 if (new_mode == VOIDmode)
5986 error ("no vector mode with the size and type specified could be found");
5990 for (type_list_node = vector_type_node_list; type_list_node;
5991 type_list_node = TREE_CHAIN (type_list_node))
5993 tree other_type = TREE_VALUE (type_list_node);
5994 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
5995 tree fields = TYPE_FIELDS (record);
5996 tree field_type = TREE_TYPE (fields);
5997 tree array_type = TREE_TYPE (field_type);
5998 if (TREE_CODE (fields) != FIELD_DECL
5999 || TREE_CODE (field_type) != ARRAY_TYPE)
6002 if (TYPE_MODE (other_type) == mode && type == array_type)
6004 new_type = other_type;
6009 if (new_type == NULL_TREE)
6011 tree index, array, rt, list_node;
6013 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
6014 TREE_UNSIGNED (type));
6018 error ("no vector mode with the size and type specified could be found");
6022 new_type = build_type_copy (new_type);
6024 /* If this is a vector, make sure we either have hardware
6025 support, or we can emulate it. */
6026 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
6027 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
6028 && !vector_mode_valid_p (mode))
6030 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
6034 /* Set the debug information here, because this is the only
6035 place where we know the underlying type for a vector made
6036 with vector_size. For debugging purposes we pretend a vector
6037 is an array within a structure. */
6038 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
6039 array = build_array_type (type, build_index_type (index));
6040 rt = make_node (RECORD_TYPE);
6042 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
6043 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
6045 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
6047 list_node = build_tree_list (NULL, new_type);
6048 TREE_CHAIN (list_node) = vector_type_node_list;
6049 vector_type_node_list = list_node;
6052 /* Build back pointers if needed. */
6053 *node = vector_size_helper (*node, new_type);
6058 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
6061 If we requested a pointer to a vector, build up the pointers that
6062 we stripped off while looking for the inner type. Similarly for
6063 return values from functions.
6065 The argument "type" is the top of the chain, and "bottom" is the
6066 new type which we will point to. */
6069 vector_size_helper (type, bottom)
6074 if (POINTER_TYPE_P (type))
6076 inner = vector_size_helper (TREE_TYPE (type), bottom);
6077 outer = build_pointer_type (inner);
6079 else if (TREE_CODE (type) == ARRAY_TYPE)
6081 inner = vector_size_helper (TREE_TYPE (type), bottom);
6082 outer = build_array_type (inner, TYPE_VALUES (type));
6084 else if (TREE_CODE (type) == FUNCTION_TYPE)
6086 inner = vector_size_helper (TREE_TYPE (type), bottom);
6087 outer = build_function_type (inner, TYPE_VALUES (type));
6092 TREE_READONLY (outer) = TREE_READONLY (type);
6093 TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
6098 /* Handle the "nonnull" attribute. */
6100 handle_nonnull_attribute (node, name, args, flags, no_add_attrs)
6102 tree name ATTRIBUTE_UNUSED;
6104 int flags ATTRIBUTE_UNUSED;
6108 unsigned HOST_WIDE_INT attr_arg_num;
6110 /* If no arguments are specified, all pointer arguments should be
6111 non-null. Veryify a full prototype is given so that the arguments
6112 will have the correct types when we actually check them later. */
6115 if (! TYPE_ARG_TYPES (type))
6117 error ("nonnull attribute without arguments on a non-prototype");
6118 *no_add_attrs = true;
6123 /* Argument list specified. Verify that each argument number references
6124 a pointer argument. */
6125 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6128 unsigned HOST_WIDE_INT arg_num, ck_num;
6130 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6132 error ("nonnull argument has invalid operand number (arg %lu)",
6133 (unsigned long) attr_arg_num);
6134 *no_add_attrs = true;
6138 argument = TYPE_ARG_TYPES (type);
6141 for (ck_num = 1; ; ck_num++)
6143 if (! argument || ck_num == arg_num)
6145 argument = TREE_CHAIN (argument);
6149 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6151 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
6152 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6153 *no_add_attrs = true;
6157 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6159 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
6160 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6161 *no_add_attrs = true;
6170 /* Check the argument list of a function call for null in argument slots
6171 that are marked as requiring a non-null pointer argument. */
6174 check_function_nonnull (attrs, params)
6178 tree a, args, param;
6181 for (a = attrs; a; a = TREE_CHAIN (a))
6183 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6185 args = TREE_VALUE (a);
6187 /* Walk the argument list. If we encounter an argument number we
6188 should check for non-null, do it. If the attribute has no args,
6189 then every pointer argument is checked (in which case the check
6190 for pointer type is done in check_nonnull_arg). */
6191 for (param = params, param_num = 1; ;
6192 param_num++, param = TREE_CHAIN (param))
6196 if (! args || nonnull_check_p (args, param_num))
6197 check_function_arguments_recurse (check_nonnull_arg, NULL,
6205 /* Helper for check_function_nonnull; given a list of operands which
6206 must be non-null in ARGS, determine if operand PARAM_NUM should be
6210 nonnull_check_p (args, param_num)
6212 unsigned HOST_WIDE_INT param_num;
6214 unsigned HOST_WIDE_INT arg_num;
6216 for (; args; args = TREE_CHAIN (args))
6218 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6221 if (arg_num == param_num)
6227 /* Check that the function argument PARAM (which is operand number
6228 PARAM_NUM) is non-null. This is called by check_function_nonnull
6229 via check_function_arguments_recurse. */
6232 check_nonnull_arg (ctx, param, param_num)
6233 void *ctx ATTRIBUTE_UNUSED;
6235 unsigned HOST_WIDE_INT param_num;
6237 /* Just skip checking the argument if it's not a pointer. This can
6238 happen if the "nonnull" attribute was given without an operand
6239 list (which means to check every pointer argument). */
6241 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6244 if (integer_zerop (param))
6245 warning ("null argument where non-null required (arg %lu)",
6246 (unsigned long) param_num);
6249 /* Helper for nonnull attribute handling; fetch the operand number
6250 from the attribute argument list. */
6253 get_nonnull_operand (arg_num_expr, valp)
6255 unsigned HOST_WIDE_INT *valp;
6257 /* Strip any conversions from the arg number and verify they
6259 while (TREE_CODE (arg_num_expr) == NOP_EXPR
6260 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
6261 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
6262 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
6264 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6265 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6268 *valp = TREE_INT_CST_LOW (arg_num_expr);
6272 /* Handle a "nothrow" attribute; arguments as in
6273 struct attribute_spec.handler. */
6276 handle_nothrow_attribute (node, name, args, flags, no_add_attrs)
6279 tree args ATTRIBUTE_UNUSED;
6280 int flags ATTRIBUTE_UNUSED;
6283 if (TREE_CODE (*node) == FUNCTION_DECL)
6284 TREE_NOTHROW (*node) = 1;
6285 /* ??? TODO: Support types. */
6288 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6289 *no_add_attrs = true;
6295 /* Check for valid arguments being passed to a function. */
6297 check_function_arguments (attrs, params)
6301 /* Check for null being passed in a pointer argument that must be
6302 non-null. We also need to do this if format checking is enabled. */
6305 check_function_nonnull (attrs, params);
6307 /* Check for errors in format strings. */
6310 check_function_format (NULL, attrs, params);
6313 /* Generic argument checking recursion routine. PARAM is the argument to
6314 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6315 once the argument is resolved. CTX is context for the callback. */
6317 check_function_arguments_recurse (callback, ctx, param, param_num)
6318 void (*callback) PARAMS ((void *, tree, unsigned HOST_WIDE_INT));
6321 unsigned HOST_WIDE_INT param_num;
6323 if (TREE_CODE (param) == NOP_EXPR)
6325 /* Strip coercion. */
6326 check_function_arguments_recurse (callback, ctx,
6327 TREE_OPERAND (param, 0), param_num);
6331 if (TREE_CODE (param) == CALL_EXPR)
6333 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
6335 bool found_format_arg = false;
6337 /* See if this is a call to a known internationalization function
6338 that modifies a format arg. Such a function may have multiple
6339 format_arg attributes (for example, ngettext). */
6341 for (attrs = TYPE_ATTRIBUTES (type);
6343 attrs = TREE_CHAIN (attrs))
6344 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6347 tree format_num_expr;
6351 /* Extract the argument number, which was previously checked
6353 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6354 while (TREE_CODE (format_num_expr) == NOP_EXPR
6355 || TREE_CODE (format_num_expr) == CONVERT_EXPR
6356 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
6357 format_num_expr = TREE_OPERAND (format_num_expr, 0);
6359 if (TREE_CODE (format_num_expr) != INTEGER_CST
6360 || TREE_INT_CST_HIGH (format_num_expr) != 0)
6363 format_num = TREE_INT_CST_LOW (format_num_expr);
6365 for (inner_args = TREE_OPERAND (param, 1), i = 1;
6367 inner_args = TREE_CHAIN (inner_args), i++)
6368 if (i == format_num)
6370 check_function_arguments_recurse (callback, ctx,
6371 TREE_VALUE (inner_args),
6373 found_format_arg = true;
6378 /* If we found a format_arg attribute and did a recursive check,
6379 we are done with checking this argument. Otherwise, we continue
6380 and this will be considered a non-literal. */
6381 if (found_format_arg)
6385 if (TREE_CODE (param) == COND_EXPR)
6387 /* Check both halves of the conditional expression. */
6388 check_function_arguments_recurse (callback, ctx,
6389 TREE_OPERAND (param, 1), param_num);
6390 check_function_arguments_recurse (callback, ctx,
6391 TREE_OPERAND (param, 2), param_num);
6395 (*callback) (ctx, param, param_num);
6398 #include "gt-c-common.h"