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 "diagnostic.h"
39 #include "langhooks.h"
40 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
42 cpp_reader *parse_in; /* Declared in c-pragma.h. */
44 /* We let tm.h override the types used here, to handle trivial differences
45 such as the choice of unsigned int or long unsigned int for size_t.
46 When machines start needing nontrivial differences in the size type,
47 it would be best to do something here to figure out automatically
48 from other information what type to use. */
51 #define SIZE_TYPE "long unsigned int"
55 #define WCHAR_TYPE "int"
58 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
59 #define MODIFIED_WCHAR_TYPE \
60 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
63 #define PTRDIFF_TYPE "long int"
67 #define WINT_TYPE "unsigned int"
71 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
73 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
79 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
81 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
82 ? "long unsigned int" \
83 : "long long unsigned int"))
86 #ifndef REGISTER_PREFIX
87 #define REGISTER_PREFIX ""
90 /* The variant of the C language being processed. */
92 enum c_language_kind c_language;
94 /* The following symbols are subsumed in the c_global_trees array, and
95 listed here individually for documentation purposes.
97 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
99 tree short_integer_type_node;
100 tree long_integer_type_node;
101 tree long_long_integer_type_node;
103 tree short_unsigned_type_node;
104 tree long_unsigned_type_node;
105 tree long_long_unsigned_type_node;
107 tree boolean_type_node;
108 tree boolean_false_node;
109 tree boolean_true_node;
111 tree ptrdiff_type_node;
113 tree unsigned_char_type_node;
114 tree signed_char_type_node;
115 tree wchar_type_node;
116 tree signed_wchar_type_node;
117 tree unsigned_wchar_type_node;
119 tree float_type_node;
120 tree double_type_node;
121 tree long_double_type_node;
123 tree complex_integer_type_node;
124 tree complex_float_type_node;
125 tree complex_double_type_node;
126 tree complex_long_double_type_node;
128 tree intQI_type_node;
129 tree intHI_type_node;
130 tree intSI_type_node;
131 tree intDI_type_node;
132 tree intTI_type_node;
134 tree unsigned_intQI_type_node;
135 tree unsigned_intHI_type_node;
136 tree unsigned_intSI_type_node;
137 tree unsigned_intDI_type_node;
138 tree unsigned_intTI_type_node;
140 tree widest_integer_literal_type_node;
141 tree widest_unsigned_literal_type_node;
143 Nodes for types `void *' and `const void *'.
145 tree ptr_type_node, const_ptr_type_node;
147 Nodes for types `char *' and `const char *'.
149 tree string_type_node, const_string_type_node;
151 Type `char[SOMENUMBER]'.
152 Used when an array of char is needed and the size is irrelevant.
154 tree char_array_type_node;
156 Type `int[SOMENUMBER]' or something like it.
157 Used when an array of int needed and the size is irrelevant.
159 tree int_array_type_node;
161 Type `wchar_t[SOMENUMBER]' or something like it.
162 Used when a wide string literal is created.
164 tree wchar_array_type_node;
166 Type `int ()' -- used for implicit declaration of functions.
168 tree default_function_type;
170 A VOID_TYPE node, packaged in a TREE_LIST.
174 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
175 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
176 VAR_DECLS, but C++ does.)
178 tree function_name_decl_node;
179 tree pretty_function_name_decl_node;
180 tree c99_function_name_decl_node;
182 Stack of nested function name VAR_DECLs.
184 tree saved_function_name_decls;
188 tree c_global_trees[CTI_MAX];
190 /* Switches common to the C front ends. */
192 /* Nonzero if prepreprocessing only. */
193 int flag_preprocess_only;
195 /* Nonzero if an ISO standard was selected. It rejects macros in the
199 /* Nonzero whenever Objective-C functionality is being used. */
202 /* Nonzero if -undef was given. It suppresses target built-in macros
206 /* Nonzero means don't recognize the non-ANSI builtin functions. */
210 /* Nonzero means don't recognize the non-ANSI builtin functions.
213 int flag_no_nonansi_builtin;
215 /* Nonzero means give `double' the same size as `float'. */
217 int flag_short_double;
219 /* Nonzero means give `wchar_t' the same size as `short'. */
221 int flag_short_wchar;
223 /* Nonzero means allow Microsoft extensions without warnings or errors. */
224 int flag_ms_extensions;
226 /* Nonzero means don't recognize the keyword `asm'. */
230 /* Nonzero means give string constants the type `const char *', as mandated
233 int flag_const_strings;
235 /* Nonzero means `$' can be in an identifier. */
237 #ifndef DOLLARS_IN_IDENTIFIERS
238 #define DOLLARS_IN_IDENTIFIERS 1
240 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
242 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
244 int flag_signed_bitfields = 1;
245 int explicit_flag_signed_bitfields;
247 /* Nonzero means warn about pointer casts that can drop a type qualifier
248 from the pointer target type. */
252 /* Warn about functions which might be candidates for format attributes. */
254 int warn_missing_format_attribute;
256 /* Nonzero means warn about sizeof(function) or addition/subtraction
257 of function pointers. */
259 int warn_pointer_arith;
261 /* Nonzero means warn for any global function def
262 without separate previous prototype decl. */
264 int warn_missing_prototypes;
266 /* Warn if adding () is suggested. */
268 int warn_parentheses;
270 /* Warn if initializer is not completely bracketed. */
272 int warn_missing_braces;
274 /* Warn about comparison of signed and unsigned values.
275 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
277 int warn_sign_compare;
279 /* Nonzero means warn about usage of long long when `-pedantic'. */
281 int warn_long_long = 1;
283 /* Nonzero means warn about deprecated conversion from string constant to
286 int warn_write_strings;
288 /* Nonzero means warn about multiple (redundant) decls for the same single
289 variable or function. */
291 int warn_redundant_decls;
293 /* Warn about testing equality of floating point numbers. */
295 int warn_float_equal;
297 /* Warn about a subscript that has type char. */
299 int warn_char_subscripts;
301 /* Warn if a type conversion is done that might have confusing results. */
305 /* Warn about #pragma directives that are not recognised. */
307 int warn_unknown_pragmas; /* Tri state variable. */
309 /* Warn about format/argument anomalies in calls to formatted I/O functions
310 (*printf, *scanf, strftime, strfmon, etc.). */
314 /* Warn about Y2K problems with strftime formats. */
318 /* Warn about excess arguments to formats. */
320 int warn_format_extra_args;
322 /* Warn about zero-length formats. */
324 int warn_format_zero_length;
326 /* Warn about non-literal format arguments. */
328 int warn_format_nonliteral;
330 /* Warn about possible security problems with calls to format functions. */
332 int warn_format_security;
335 /* C/ObjC language option variables. */
338 /* Nonzero means message about use of implicit function declarations;
339 1 means warning; 2 means error. */
341 int mesg_implicit_function_declaration = -1;
343 /* Nonzero means allow type mismatches in conditional expressions;
344 just make their values `void'. */
346 int flag_cond_mismatch;
348 /* Nonzero means enable C89 Amendment 1 features. */
352 /* Nonzero means use the ISO C99 dialect of C. */
356 /* Nonzero means that we have builtin functions, and main is an int */
360 /* Nonzero means add default format_arg attributes for functions not
363 int flag_noniso_default_format_attributes = 1;
365 /* Nonzero means warn when casting a function call to a type that does
366 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
367 when there is no previous declaration of sqrt or malloc. */
369 int warn_bad_function_cast;
371 /* Warn about traditional constructs whose meanings changed in ANSI C. */
373 int warn_traditional;
375 /* Nonzero means warn for non-prototype function decls
376 or non-prototyped defs without previous prototype. */
378 int warn_strict_prototypes;
380 /* Nonzero means warn for any global function def
381 without separate previous decl. */
383 int warn_missing_declarations;
385 /* Nonzero means warn about declarations of objects not at
386 file-scope level and about *all* declarations of functions (whether
387 or static) not at file-scope level. Note that we exclude
388 implicit function declarations. To get warnings about those, use
391 int warn_nested_externs;
393 /* Warn if main is suspicious. */
397 /* Nonzero means warn about possible violations of sequence point rules. */
399 int warn_sequence_point;
401 /* Nonzero means to warn about compile-time division by zero. */
402 int warn_div_by_zero = 1;
404 /* Nonzero means warn about use of implicit int. */
406 int warn_implicit_int;
408 /* Warn about NULL being passed to argument slots marked as requiring
414 /* ObjC language option variables. */
417 /* Open and close the file for outputting class declarations, if
420 int flag_gen_declaration;
422 /* Generate code for GNU or NeXT runtime environment. */
424 #ifdef NEXT_OBJC_RUNTIME
425 int flag_next_runtime = 1;
427 int flag_next_runtime = 0;
430 /* Tells the compiler that this is a special run. Do not perform any
431 compiling, instead we are to test some platform dependent features
432 and output a C header file with appropriate definitions. */
434 int print_struct_values;
436 /* ???. Undocumented. */
438 const char *constant_string_class_name;
440 /* Warn if multiple methods are seen for the same selector, but with
441 different argument types. */
445 /* Warn if methods required by a protocol are not implemented in the
446 class adopting it. When turned off, methods inherited to that
447 class are also considered implemented. */
449 int warn_protocol = 1;
452 /* C++ language option variables. */
455 /* Nonzero means don't recognize any extension keywords. */
457 int flag_no_gnu_keywords;
459 /* Nonzero means do emit exported implementations of functions even if
460 they can be inlined. */
462 int flag_implement_inlines = 1;
464 /* Nonzero means do emit exported implementations of templates, instead of
465 multiple static copies in each file that needs a definition. */
467 int flag_external_templates;
469 /* Nonzero means that the decision to emit or not emit the implementation of a
470 template depends on where the template is instantiated, rather than where
473 int flag_alt_external_templates;
475 /* Nonzero means that implicit instantiations will be emitted if needed. */
477 int flag_implicit_templates = 1;
479 /* Nonzero means that implicit instantiations of inline templates will be
480 emitted if needed, even if instantiations of non-inline templates
483 int flag_implicit_inline_templates = 1;
485 /* Nonzero means generate separate instantiation control files and
486 juggle them at link time. */
488 int flag_use_repository;
490 /* Nonzero if we want to issue diagnostics that the standard says are not
493 int flag_optional_diags = 1;
495 /* Nonzero means we should attempt to elide constructors when possible. */
497 int flag_elide_constructors = 1;
499 /* Nonzero means that member functions defined in class scope are
500 inline by default. */
502 int flag_default_inline = 1;
504 /* Controls whether compiler generates 'type descriptor' that give
505 run-time type information. */
509 /* Nonzero if we want to conserve space in the .o files. We do this
510 by putting uninitialized data and runtime initialized data into
511 .common instead of .data at the expense of not flagging multiple
514 int flag_conserve_space;
516 /* Nonzero if we want to obey access control semantics. */
518 int flag_access_control = 1;
520 /* Nonzero if we want to check the return value of new and avoid calling
521 constructors if it is a null pointer. */
525 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
526 initialization variables.
527 0: Old rules, set by -fno-for-scope.
528 2: New ISO rules, set by -ffor-scope.
529 1: Try to implement new ISO rules, but with backup compatibility
530 (and warnings). This is the default, for now. */
532 int flag_new_for_scope = 1;
534 /* Nonzero if we want to emit defined symbols with common-like linkage as
535 weak symbols where possible, in order to conform to C++ semantics.
536 Otherwise, emit them as local symbols. */
540 /* Nonzero to use __cxa_atexit, rather than atexit, to register
541 destructors for local statics and global objects. */
543 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
545 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
549 /* Nonzero means make the default pedwarns warnings instead of errors.
550 The value of this flag is ignored if -pedantic is specified. */
554 /* Nonzero means to implement standard semantics for exception
555 specifications, calling unexpected if an exception is thrown that
556 doesn't match the specification. Zero means to treat them as
557 assertions and optimize accordingly, but not check them. */
559 int flag_enforce_eh_specs = 1;
561 /* Nonzero means warn about implicit declarations. */
563 int warn_implicit = 1;
565 /* Nonzero means warn when all ctors or dtors are private, and the class
568 int warn_ctor_dtor_privacy = 1;
570 /* Non-zero means warn in function declared in derived class has the
571 same name as a virtual in the base class, but fails to match the
572 type signature of any virtual function in the base class. */
574 int warn_overloaded_virtual;
576 /* Non-zero means warn when declaring a class that has a non virtual
577 destructor, when it really ought to have a virtual one. */
581 /* Non-zero means warn when the compiler will reorder code. */
585 /* Non-zero means warn when synthesis behavior differs from Cfront's. */
589 /* Non-zero means warn when we convert a pointer to member function
590 into a pointer to (void or function). */
592 int warn_pmf2ptr = 1;
594 /* Nonzero means warn about violation of some Effective C++ style rules. */
598 /* Nonzero means warn where overload resolution chooses a promotion from
599 unsigned to signed over a conversion to an unsigned of the same size. */
603 /* Nonzero means warn when an old-style cast is used. */
605 int warn_old_style_cast;
607 /* Nonzero means warn when non-templatized friend functions are
608 declared within a template */
610 int warn_nontemplate_friend = 1;
612 /* Nonzero means complain about deprecated features. */
614 int warn_deprecated = 1;
616 /* Maximum template instantiation depth. This limit is rather
617 arbitrary, but it exists to limit the time it takes to notice
618 infinite template instantiations. */
620 int max_tinst_depth = 500;
624 /* The elements of `ridpointers' are identifier nodes for the reserved
625 type names and storage classes. It is indexed by a RID_... value. */
628 tree (*make_fname_decl) PARAMS ((tree, int));
630 /* If non-NULL, the address of a language-specific function that
631 returns 1 for language-specific statement codes. */
632 int (*lang_statement_code_p) PARAMS ((enum tree_code));
634 /* If non-NULL, the address of a language-specific function that takes
635 any action required right before expand_function_end is called. */
636 void (*lang_expand_function_end) PARAMS ((void));
638 /* Nonzero means the expression being parsed will never be evaluated.
639 This is a count, since unevaluated expressions can nest. */
642 /* Information about how a function name is generated. */
645 tree *const decl; /* pointer to the VAR_DECL. */
646 const unsigned rid; /* RID number for the identifier. */
647 const int pretty; /* How pretty is it? */
650 /* The three ways of getting then name of the current function. */
652 const struct fname_var_t fname_vars[] =
654 /* C99 compliant __func__, must be first. */
655 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
656 /* GCC __FUNCTION__ compliant. */
657 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
658 /* GCC __PRETTY_FUNCTION__ compliant. */
659 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
663 static int constant_fits_type_p PARAMS ((tree, tree));
665 /* Keep a stack of if statements. We record the number of compound
666 statements seen up to the if keyword, as well as the line number
667 and file of the if. If a potentially ambiguous else is seen, that
668 fact is recorded; the warning is issued when we can be sure that
669 the enclosing if statement does not have an else branch. */
679 static if_elt *if_stack;
681 /* Amount of space in the if statement stack. */
682 static int if_stack_space = 0;
685 static int if_stack_pointer = 0;
687 static tree handle_packed_attribute PARAMS ((tree *, tree, tree, int,
689 static tree handle_nocommon_attribute PARAMS ((tree *, tree, tree, int,
691 static tree handle_common_attribute PARAMS ((tree *, tree, tree, int,
693 static tree handle_noreturn_attribute PARAMS ((tree *, tree, tree, int,
695 static tree handle_noinline_attribute PARAMS ((tree *, tree, tree, int,
697 static tree handle_always_inline_attribute PARAMS ((tree *, tree, tree, int,
699 static tree handle_used_attribute PARAMS ((tree *, tree, tree, int,
701 static tree handle_unused_attribute PARAMS ((tree *, tree, tree, int,
703 static tree handle_const_attribute PARAMS ((tree *, tree, tree, int,
705 static tree handle_transparent_union_attribute PARAMS ((tree *, tree, tree,
707 static tree handle_constructor_attribute PARAMS ((tree *, tree, tree, int,
709 static tree handle_destructor_attribute PARAMS ((tree *, tree, tree, int,
711 static tree handle_mode_attribute PARAMS ((tree *, tree, tree, int,
713 static tree handle_section_attribute PARAMS ((tree *, tree, tree, int,
715 static tree handle_aligned_attribute PARAMS ((tree *, tree, tree, int,
717 static tree handle_weak_attribute PARAMS ((tree *, tree, tree, int,
719 static tree handle_alias_attribute PARAMS ((tree *, tree, tree, int,
721 static tree handle_visibility_attribute PARAMS ((tree *, tree, tree, int,
723 static tree handle_no_instrument_function_attribute PARAMS ((tree *, tree,
726 static tree handle_malloc_attribute PARAMS ((tree *, tree, tree, int,
728 static tree handle_no_limit_stack_attribute PARAMS ((tree *, tree, tree, int,
730 static tree handle_pure_attribute PARAMS ((tree *, tree, tree, int,
732 static tree handle_deprecated_attribute PARAMS ((tree *, tree, tree, int,
734 static tree handle_vector_size_attribute PARAMS ((tree *, tree, tree, int,
736 static tree handle_nonnull_attribute PARAMS ((tree *, tree, tree, int,
738 static tree handle_nothrow_attribute PARAMS ((tree *, tree, tree, int,
740 static tree vector_size_helper PARAMS ((tree, tree));
742 static void check_function_nonnull PARAMS ((tree, tree));
743 static void check_nonnull_arg PARAMS ((void *, tree,
744 unsigned HOST_WIDE_INT));
745 static bool nonnull_check_p PARAMS ((tree, unsigned HOST_WIDE_INT));
746 static bool get_nonnull_operand PARAMS ((tree,
747 unsigned HOST_WIDE_INT *));
748 void builtin_define_std PARAMS ((const char *));
749 static void builtin_define_with_value PARAMS ((const char *, const char *,
751 static void builtin_define_type_max PARAMS ((const char *, tree, int));
752 static void cpp_define_data_format PARAMS ((cpp_reader *));
754 /* Table of machine-independent attributes common to all C-like languages. */
755 const struct attribute_spec c_common_attribute_table[] =
757 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
758 { "packed", 0, 0, false, false, false,
759 handle_packed_attribute },
760 { "nocommon", 0, 0, true, false, false,
761 handle_nocommon_attribute },
762 { "common", 0, 0, true, false, false,
763 handle_common_attribute },
764 /* FIXME: logically, noreturn attributes should be listed as
765 "false, true, true" and apply to function types. But implementing this
766 would require all the places in the compiler that use TREE_THIS_VOLATILE
767 on a decl to identify non-returning functions to be located and fixed
768 to check the function type instead. */
769 { "noreturn", 0, 0, true, false, false,
770 handle_noreturn_attribute },
771 { "volatile", 0, 0, true, false, false,
772 handle_noreturn_attribute },
773 { "noinline", 0, 0, true, false, false,
774 handle_noinline_attribute },
775 { "always_inline", 0, 0, true, false, false,
776 handle_always_inline_attribute },
777 { "used", 0, 0, true, false, false,
778 handle_used_attribute },
779 { "unused", 0, 0, false, false, false,
780 handle_unused_attribute },
781 /* The same comments as for noreturn attributes apply to const ones. */
782 { "const", 0, 0, true, false, false,
783 handle_const_attribute },
784 { "transparent_union", 0, 0, false, false, false,
785 handle_transparent_union_attribute },
786 { "constructor", 0, 0, true, false, false,
787 handle_constructor_attribute },
788 { "destructor", 0, 0, true, false, false,
789 handle_destructor_attribute },
790 { "mode", 1, 1, false, true, false,
791 handle_mode_attribute },
792 { "section", 1, 1, true, false, false,
793 handle_section_attribute },
794 { "aligned", 0, 1, false, false, false,
795 handle_aligned_attribute },
796 { "weak", 0, 0, true, false, false,
797 handle_weak_attribute },
798 { "alias", 1, 1, true, false, false,
799 handle_alias_attribute },
800 { "no_instrument_function", 0, 0, true, false, false,
801 handle_no_instrument_function_attribute },
802 { "malloc", 0, 0, true, false, false,
803 handle_malloc_attribute },
804 { "no_stack_limit", 0, 0, true, false, false,
805 handle_no_limit_stack_attribute },
806 { "pure", 0, 0, true, false, false,
807 handle_pure_attribute },
808 { "deprecated", 0, 0, false, false, false,
809 handle_deprecated_attribute },
810 { "vector_size", 1, 1, false, true, false,
811 handle_vector_size_attribute },
812 { "visibility", 1, 1, true, false, false,
813 handle_visibility_attribute },
814 { "nonnull", 0, -1, false, true, true,
815 handle_nonnull_attribute },
816 { "nothrow", 0, 0, true, false, false,
817 handle_nothrow_attribute },
818 { "may_alias", 0, 0, false, true, false, NULL },
819 { NULL, 0, 0, false, false, false, NULL }
822 /* Give the specifications for the format attributes, used by C and all
825 const struct attribute_spec c_common_format_attribute_table[] =
827 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
828 { "format", 3, 3, false, true, true,
829 handle_format_attribute },
830 { "format_arg", 1, 1, false, true, true,
831 handle_format_arg_attribute },
832 { NULL, 0, 0, false, false, false, NULL }
835 /* Record the start of an if-then, and record the start of it
836 for ambiguous else detection.
838 COND is the condition for the if-then statement.
840 IF_STMT is the statement node that has already been created for
841 this if-then statement. It is created before parsing the
842 condition to keep line number information accurate. */
845 c_expand_start_cond (cond, compstmt_count, if_stmt)
850 /* Make sure there is enough space on the stack. */
851 if (if_stack_space == 0)
854 if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
856 else if (if_stack_space == if_stack_pointer)
858 if_stack_space += 10;
859 if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
862 IF_COND (if_stmt) = cond;
865 /* Record this if statement. */
866 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
867 if_stack[if_stack_pointer].file = input_filename;
868 if_stack[if_stack_pointer].line = lineno;
869 if_stack[if_stack_pointer].needs_warning = 0;
870 if_stack[if_stack_pointer].if_stmt = if_stmt;
874 /* Called after the then-clause for an if-statement is processed. */
879 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
880 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
883 /* Record the end of an if-then. Optionally warn if a nested
884 if statement had an ambiguous else clause. */
890 if (if_stack[if_stack_pointer].needs_warning)
891 warning_with_file_and_line (if_stack[if_stack_pointer].file,
892 if_stack[if_stack_pointer].line,
893 "suggest explicit braces to avoid ambiguous `else'");
894 last_expr_type = NULL_TREE;
897 /* Called between the then-clause and the else-clause
898 of an if-then-else. */
901 c_expand_start_else ()
903 /* An ambiguous else warning must be generated for the enclosing if
904 statement, unless we see an else branch for that one, too. */
906 && if_stack_pointer > 1
907 && (if_stack[if_stack_pointer - 1].compstmt_count
908 == if_stack[if_stack_pointer - 2].compstmt_count))
909 if_stack[if_stack_pointer - 2].needs_warning = 1;
911 /* Even if a nested if statement had an else branch, it can't be
912 ambiguous if this one also has an else. So don't warn in that
913 case. Also don't warn for any if statements nested in this else. */
914 if_stack[if_stack_pointer - 1].needs_warning = 0;
915 if_stack[if_stack_pointer - 1].compstmt_count--;
918 /* Called after the else-clause for an if-statement is processed. */
923 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
924 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
927 /* Begin an if-statement. Returns a newly created IF_STMT if
930 Unlike the C++ front-end, we do not call add_stmt here; it is
931 probably safe to do so, but I am not very familiar with this
932 code so I am being extra careful not to change its behavior
933 beyond what is strictly necessary for correctness. */
939 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
943 /* Begin a while statement. Returns a newly created WHILE_STMT if
946 Unlike the C++ front-end, we do not call add_stmt here; it is
947 probably safe to do so, but I am not very familiar with this
948 code so I am being extra careful not to change its behavior
949 beyond what is strictly necessary for correctness. */
952 c_begin_while_stmt ()
955 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
960 c_finish_while_stmt_cond (cond, while_stmt)
964 WHILE_COND (while_stmt) = cond;
967 /* Push current bindings for the function name VAR_DECLS. */
973 tree saved = NULL_TREE;
975 for (ix = 0; fname_vars[ix].decl; ix++)
977 tree decl = *fname_vars[ix].decl;
981 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
982 *fname_vars[ix].decl = NULL_TREE;
985 if (saved || saved_function_name_decls)
986 /* Normally they'll have been NULL, so only push if we've got a
987 stack, or they are non-NULL. */
988 saved_function_name_decls = tree_cons (saved, NULL_TREE,
989 saved_function_name_decls);
992 /* Finish up the current bindings, adding them into the
993 current function's statement tree. This is done by wrapping the
994 function's body in a COMPOUND_STMT containing these decls too. This
995 must be done _before_ finish_stmt_tree is called. If there is no
996 current function, we must be at file scope and no statements are
997 involved. Pop the previous bindings. */
1000 finish_fname_decls ()
1003 tree body = NULL_TREE;
1004 tree stack = saved_function_name_decls;
1006 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1007 body = chainon (TREE_VALUE (stack), body);
1011 /* They were called into existence, so add to statement tree. */
1012 body = chainon (body,
1013 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
1014 body = build_stmt (COMPOUND_STMT, body);
1016 COMPOUND_STMT_NO_SCOPE (body) = 1;
1017 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
1020 for (ix = 0; fname_vars[ix].decl; ix++)
1021 *fname_vars[ix].decl = NULL_TREE;
1025 /* We had saved values, restore them. */
1028 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1030 tree decl = TREE_PURPOSE (saved);
1031 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1033 *fname_vars[ix].decl = decl;
1035 stack = TREE_CHAIN (stack);
1037 saved_function_name_decls = stack;
1040 /* Return the text name of the current function, suitable prettified
1044 fname_as_string (pretty_p)
1047 const char *name = NULL;
1050 name = (current_function_decl
1051 ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
1053 else if (current_function_decl && DECL_NAME (current_function_decl))
1054 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
1060 /* Return the text name of the current function, formatted as
1061 required by the supplied RID value. */
1069 for (ix = 0; fname_vars[ix].decl; ix++)
1070 if (fname_vars[ix].rid == rid)
1072 return fname_as_string (fname_vars[ix].pretty);
1075 /* Return the VAR_DECL for a const char array naming the current
1076 function. If the VAR_DECL has not yet been created, create it
1077 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1078 ID is its name (unfortunately C and C++ hold the RID values of
1079 keywords in different places, so we can't derive RID from ID in
1080 this language independent code. */
1083 fname_decl (rid, id)
1088 tree decl = NULL_TREE;
1090 for (ix = 0; fname_vars[ix].decl; ix++)
1091 if (fname_vars[ix].rid == rid)
1094 decl = *fname_vars[ix].decl;
1097 tree saved_last_tree = last_tree;
1098 /* If a tree is built here, it would normally have the lineno of
1099 the current statement. Later this tree will be moved to the
1100 beginning of the function and this line number will be wrong.
1101 To avoid this problem set the lineno to 0 here; that prevents
1102 it from appearing in the RTL. */
1103 int saved_lineno = lineno;
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;
1120 lineno = saved_lineno;
1122 if (!ix && !current_function_decl)
1123 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
1128 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1131 fix_string_type (value)
1134 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1135 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1136 const int nchars_max = flag_isoc99 ? 4095 : 509;
1137 int length = TREE_STRING_LENGTH (value);
1140 /* Compute the number of elements, for the array type. */
1141 nchars = wide_flag ? length / wchar_bytes : length;
1143 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
1144 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1145 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1147 /* Create the array type for the string constant.
1148 -Wwrite-strings says make the string constant an array of const char
1149 so that copying it to a non-const pointer will get a warning.
1150 For C++, this is the standard behavior. */
1151 if (flag_const_strings && ! flag_writable_strings)
1154 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1157 = build_array_type (elements,
1158 build_index_type (build_int_2 (nchars - 1, 0)));
1162 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1163 build_index_type (build_int_2 (nchars - 1, 0)));
1165 TREE_CONSTANT (value) = 1;
1166 TREE_READONLY (value) = ! flag_writable_strings;
1167 TREE_STATIC (value) = 1;
1171 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1175 combine_strings (strings)
1176 varray_type strings;
1178 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1179 const int nstrings = VARRAY_ACTIVE_SIZE (strings);
1182 int wide_length = 0;
1187 /* Don't include the \0 at the end of each substring. Count wide
1188 strings and ordinary strings separately. */
1189 for (i = 0; i < nstrings; ++i)
1191 t = VARRAY_TREE (strings, i);
1193 if (TREE_TYPE (t) == wchar_array_type_node)
1195 wide_length += TREE_STRING_LENGTH (t) - wchar_bytes;
1200 length += (TREE_STRING_LENGTH (t) - 1);
1201 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
1202 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1206 /* If anything is wide, the non-wides will be converted,
1207 which makes them take more space. */
1209 length = length * wchar_bytes + wide_length;
1211 p = xmalloc (length);
1213 /* Copy the individual strings into the new combined string.
1214 If the combined string is wide, convert the chars to ints
1215 for any individual strings that are not wide. */
1218 for (i = 0; i < nstrings; ++i)
1222 t = VARRAY_TREE (strings, i);
1223 this_wide = TREE_TYPE (t) == wchar_array_type_node;
1224 len = TREE_STRING_LENGTH (t) - (this_wide ? wchar_bytes : 1);
1225 if (this_wide == wide_flag)
1227 memcpy (q, TREE_STRING_POINTER (t), len);
1232 const int nzeros = (TYPE_PRECISION (wchar_type_node)
1233 / BITS_PER_UNIT) - 1;
1236 if (BYTES_BIG_ENDIAN)
1238 for (k = 0; k < len; k++)
1240 for (j = 0; j < nzeros; j++)
1242 *q++ = TREE_STRING_POINTER (t)[k];
1247 for (k = 0; k < len; k++)
1249 *q++ = TREE_STRING_POINTER (t)[k];
1250 for (j = 0; j < nzeros; j++)
1257 /* Nul terminate the string. */
1260 for (i = 0; i < wchar_bytes; i++)
1266 value = build_string (length, p);
1270 TREE_TYPE (value) = wchar_array_type_node;
1272 TREE_TYPE (value) = char_array_type_node;
1277 static int is_valid_printf_arglist PARAMS ((tree));
1278 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1279 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1280 enum expand_modifier, int, int));
1281 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
1282 enum expand_modifier, int, int));
1284 /* Print a warning if a constant expression had overflow in folding.
1285 Invoke this function on every expression that the language
1286 requires to be a constant expression.
1287 Note the ANSI C standard says it is erroneous for a
1288 constant expression to overflow. */
1291 constant_expression_warning (value)
1294 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1295 || TREE_CODE (value) == VECTOR_CST
1296 || TREE_CODE (value) == COMPLEX_CST)
1297 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1298 pedwarn ("overflow in constant expression");
1301 /* Print a warning if an expression had overflow in folding.
1302 Invoke this function on every expression that
1303 (1) appears in the source code, and
1304 (2) might be a constant expression that overflowed, and
1305 (3) is not already checked by convert_and_check;
1306 however, do not invoke this function on operands of explicit casts. */
1309 overflow_warning (value)
1312 if ((TREE_CODE (value) == INTEGER_CST
1313 || (TREE_CODE (value) == COMPLEX_CST
1314 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1315 && TREE_OVERFLOW (value))
1317 TREE_OVERFLOW (value) = 0;
1318 if (skip_evaluation == 0)
1319 warning ("integer overflow in expression");
1321 else if ((TREE_CODE (value) == REAL_CST
1322 || (TREE_CODE (value) == COMPLEX_CST
1323 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1324 && TREE_OVERFLOW (value))
1326 TREE_OVERFLOW (value) = 0;
1327 if (skip_evaluation == 0)
1328 warning ("floating point overflow in expression");
1330 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1332 TREE_OVERFLOW (value) = 0;
1333 if (skip_evaluation == 0)
1334 warning ("vector overflow in expression");
1338 /* Print a warning if a large constant is truncated to unsigned,
1339 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1340 Invoke this function on every expression that might be implicitly
1341 converted to an unsigned type. */
1344 unsigned_conversion_warning (result, operand)
1345 tree result, operand;
1347 tree type = TREE_TYPE (result);
1349 if (TREE_CODE (operand) == INTEGER_CST
1350 && TREE_CODE (type) == INTEGER_TYPE
1351 && TREE_UNSIGNED (type)
1352 && skip_evaluation == 0
1353 && !int_fits_type_p (operand, type))
1355 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1356 /* This detects cases like converting -129 or 256 to unsigned char. */
1357 warning ("large integer implicitly truncated to unsigned type");
1358 else if (warn_conversion)
1359 warning ("negative integer implicitly converted to unsigned type");
1363 /* Nonzero if constant C has a value that is permissible
1364 for type TYPE (an INTEGER_TYPE). */
1367 constant_fits_type_p (c, type)
1370 if (TREE_CODE (c) == INTEGER_CST)
1371 return int_fits_type_p (c, type);
1373 c = convert (type, c);
1374 return !TREE_OVERFLOW (c);
1377 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1378 Invoke this function on every expression that is converted implicitly,
1379 i.e. because of language rules and not because of an explicit cast. */
1382 convert_and_check (type, expr)
1385 tree t = convert (type, expr);
1386 if (TREE_CODE (t) == INTEGER_CST)
1388 if (TREE_OVERFLOW (t))
1390 TREE_OVERFLOW (t) = 0;
1392 /* Do not diagnose overflow in a constant expression merely
1393 because a conversion overflowed. */
1394 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1396 /* No warning for converting 0x80000000 to int. */
1397 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1398 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1399 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1400 /* If EXPR fits in the unsigned version of TYPE,
1401 don't warn unless pedantic. */
1403 || TREE_UNSIGNED (type)
1404 || ! constant_fits_type_p (expr,
1405 c_common_unsigned_type (type)))
1406 && skip_evaluation == 0)
1407 warning ("overflow in implicit constant conversion");
1410 unsigned_conversion_warning (t, expr);
1415 /* A node in a list that describes references to variables (EXPR), which are
1416 either read accesses if WRITER is zero, or write accesses, in which case
1417 WRITER is the parent of EXPR. */
1424 /* Used to implement a cache the results of a call to verify_tree. We only
1425 use this for SAVE_EXPRs. */
1428 struct tlist_cache *next;
1429 struct tlist *cache_before_sp;
1430 struct tlist *cache_after_sp;
1434 /* Obstack to use when allocating tlist structures, and corresponding
1436 static struct obstack tlist_obstack;
1437 static char *tlist_firstobj = 0;
1439 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1441 static struct tlist *warned_ids;
1442 /* SAVE_EXPRs need special treatment. We process them only once and then
1443 cache the results. */
1444 static struct tlist_cache *save_expr_cache;
1446 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1447 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1448 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1449 static int warning_candidate_p PARAMS ((tree));
1450 static void warn_for_collisions PARAMS ((struct tlist *));
1451 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1452 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1453 static void verify_sequence_points PARAMS ((tree));
1455 /* Create a new struct tlist and fill in its fields. */
1456 static struct tlist *
1457 new_tlist (next, t, writer)
1463 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1470 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1471 is nonnull, we ignore any node we find which has a writer equal to it. */
1474 add_tlist (to, add, exclude_writer, copy)
1477 tree exclude_writer;
1482 struct tlist *next = add->next;
1485 if (! exclude_writer || add->writer != exclude_writer)
1486 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1491 /* Merge the nodes of ADD into TO. This merging process is done so that for
1492 each variable that already exists in TO, no new node is added; however if
1493 there is a write access recorded in ADD, and an occurrence on TO is only
1494 a read access, then the occurrence in TO will be modified to record the
1498 merge_tlist (to, add, copy)
1503 struct tlist **end = to;
1506 end = &(*end)->next;
1512 struct tlist *next = add->next;
1514 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1515 if (tmp2->expr == add->expr)
1519 tmp2->writer = add->writer;
1523 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1524 end = &(*end)->next;
1531 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1532 references in list LIST conflict with it, excluding reads if ONLY writers
1536 warn_for_collisions_1 (written, writer, list, only_writes)
1537 tree written, writer;
1543 /* Avoid duplicate warnings. */
1544 for (tmp = warned_ids; tmp; tmp = tmp->next)
1545 if (tmp->expr == written)
1550 if (list->expr == written
1551 && list->writer != writer
1552 && (! only_writes || list->writer))
1554 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1555 warning ("operation on `%s' may be undefined",
1556 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1562 /* Given a list LIST of references to variables, find whether any of these
1563 can cause conflicts due to missing sequence points. */
1566 warn_for_collisions (list)
1571 for (tmp = list; tmp; tmp = tmp->next)
1574 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1578 /* Return nonzero if X is a tree that can be verified by the sequence point
1581 warning_candidate_p (x)
1584 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1587 /* Walk the tree X, and record accesses to variables. If X is written by the
1588 parent tree, WRITER is the parent.
1589 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1590 expression or its only operand forces a sequence point, then everything up
1591 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1593 Once we return, we will have emitted warnings if any subexpression before
1594 such a sequence point could be undefined. On a higher level, however, the
1595 sequence point may not be relevant, and we'll merge the two lists.
1597 Example: (b++, a) + b;
1598 The call that processes the COMPOUND_EXPR will store the increment of B
1599 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1600 processes the PLUS_EXPR will need to merge the two lists so that
1601 eventually, all accesses end up on the same list (and we'll warn about the
1602 unordered subexpressions b++ and b.
1604 A note on merging. If we modify the former example so that our expression
1607 care must be taken not simply to add all three expressions into the final
1608 PNO_SP list. The function merge_tlist takes care of that by merging the
1609 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1610 way, so that no more than one access to B is recorded. */
1613 verify_tree (x, pbefore_sp, pno_sp, writer)
1615 struct tlist **pbefore_sp, **pno_sp;
1618 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1619 enum tree_code code;
1622 /* X may be NULL if it is the operand of an empty statement expression
1628 code = TREE_CODE (x);
1629 class = TREE_CODE_CLASS (code);
1631 if (warning_candidate_p (x))
1633 *pno_sp = new_tlist (*pno_sp, x, writer);
1643 case TRUTH_ANDIF_EXPR:
1644 case TRUTH_ORIF_EXPR:
1645 tmp_before = tmp_nosp = tmp_list3 = 0;
1646 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1647 warn_for_collisions (tmp_nosp);
1648 merge_tlist (pbefore_sp, tmp_before, 0);
1649 merge_tlist (pbefore_sp, tmp_nosp, 0);
1650 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1651 merge_tlist (pbefore_sp, tmp_list3, 0);
1655 tmp_before = tmp_list2 = 0;
1656 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1657 warn_for_collisions (tmp_list2);
1658 merge_tlist (pbefore_sp, tmp_before, 0);
1659 merge_tlist (pbefore_sp, tmp_list2, 1);
1661 tmp_list3 = tmp_nosp = 0;
1662 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1663 warn_for_collisions (tmp_nosp);
1664 merge_tlist (pbefore_sp, tmp_list3, 0);
1666 tmp_list3 = tmp_list2 = 0;
1667 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1668 warn_for_collisions (tmp_list2);
1669 merge_tlist (pbefore_sp, tmp_list3, 0);
1670 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1671 two first, to avoid warning for (a ? b++ : b++). */
1672 merge_tlist (&tmp_nosp, tmp_list2, 0);
1673 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1676 case PREDECREMENT_EXPR:
1677 case PREINCREMENT_EXPR:
1678 case POSTDECREMENT_EXPR:
1679 case POSTINCREMENT_EXPR:
1680 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1684 tmp_before = tmp_nosp = tmp_list3 = 0;
1685 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1686 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1687 /* Expressions inside the LHS are not ordered wrt. the sequence points
1688 in the RHS. Example:
1690 Despite the fact that the modification of "a" is in the before_sp
1691 list (tmp_before), it conflicts with the use of "a" in the LHS.
1692 We can handle this by adding the contents of tmp_list3
1693 to those of tmp_before, and redoing the collision warnings for that
1695 add_tlist (&tmp_before, tmp_list3, x, 1);
1696 warn_for_collisions (tmp_before);
1697 /* Exclude the LHS itself here; we first have to merge it into the
1698 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1699 didn't exclude the LHS, we'd get it twice, once as a read and once
1701 add_tlist (pno_sp, tmp_list3, x, 0);
1702 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1704 merge_tlist (pbefore_sp, tmp_before, 0);
1705 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1706 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1707 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1711 /* We need to warn about conflicts among arguments and conflicts between
1712 args and the function address. Side effects of the function address,
1713 however, are not ordered by the sequence point of the call. */
1714 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1715 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1716 if (TREE_OPERAND (x, 1))
1717 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1718 merge_tlist (&tmp_list3, tmp_list2, 0);
1719 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1720 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1721 warn_for_collisions (tmp_before);
1722 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1726 /* Scan all the list, e.g. indices of multi dimensional array. */
1729 tmp_before = tmp_nosp = 0;
1730 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1731 merge_tlist (&tmp_nosp, tmp_before, 0);
1732 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1739 struct tlist_cache *t;
1740 for (t = save_expr_cache; t; t = t->next)
1746 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1748 t->next = save_expr_cache;
1750 save_expr_cache = t;
1752 tmp_before = tmp_nosp = 0;
1753 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1754 warn_for_collisions (tmp_nosp);
1759 struct tlist *t = tmp_nosp;
1761 merge_tlist (&tmp_list3, t, 0);
1763 t->cache_before_sp = tmp_before;
1764 t->cache_after_sp = tmp_list3;
1766 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1767 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1776 if (first_rtl_op (code) == 0)
1778 x = TREE_OPERAND (x, 0);
1794 int max = first_rtl_op (TREE_CODE (x));
1795 for (lp = 0; lp < max; lp++)
1797 tmp_before = tmp_nosp = 0;
1798 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1799 merge_tlist (&tmp_nosp, tmp_before, 0);
1800 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1807 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1811 verify_sequence_points (expr)
1814 struct tlist *before_sp = 0, *after_sp = 0;
1817 save_expr_cache = 0;
1818 if (tlist_firstobj == 0)
1820 gcc_obstack_init (&tlist_obstack);
1821 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1824 verify_tree (expr, &before_sp, &after_sp, 0);
1825 warn_for_collisions (after_sp);
1826 obstack_free (&tlist_obstack, tlist_firstobj);
1830 c_expand_expr_stmt (expr)
1833 /* Do default conversion if safe and possibly important,
1834 in case within ({...}). */
1835 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1836 && (flag_isoc99 || lvalue_p (expr)))
1837 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1838 expr = default_conversion (expr);
1840 if (warn_sequence_point)
1841 verify_sequence_points (expr);
1843 if (TREE_TYPE (expr) != error_mark_node
1844 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1845 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1846 error ("expression statement has incomplete type");
1848 last_expr_type = TREE_TYPE (expr);
1849 return add_stmt (build_stmt (EXPR_STMT, expr));
1852 /* Validate the expression after `case' and apply default promotions. */
1855 check_case_value (value)
1858 if (value == NULL_TREE)
1861 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1862 STRIP_TYPE_NOPS (value);
1863 /* In C++, the following is allowed:
1866 switch (...) { case i: ... }
1868 So, we try to reduce the VALUE to a constant that way. */
1869 if (c_language == clk_cplusplus)
1871 value = decl_constant_value (value);
1872 STRIP_TYPE_NOPS (value);
1873 value = fold (value);
1876 if (TREE_CODE (value) != INTEGER_CST
1877 && value != error_mark_node)
1879 error ("case label does not reduce to an integer constant");
1880 value = error_mark_node;
1883 /* Promote char or short to int. */
1884 value = default_conversion (value);
1886 constant_expression_warning (value);
1891 /* Return an integer type with BITS bits of precision,
1892 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1895 c_common_type_for_size (bits, unsignedp)
1899 if (bits == TYPE_PRECISION (integer_type_node))
1900 return unsignedp ? unsigned_type_node : integer_type_node;
1902 if (bits == TYPE_PRECISION (signed_char_type_node))
1903 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1905 if (bits == TYPE_PRECISION (short_integer_type_node))
1906 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1908 if (bits == TYPE_PRECISION (long_integer_type_node))
1909 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1911 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1912 return (unsignedp ? long_long_unsigned_type_node
1913 : long_long_integer_type_node);
1915 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1916 return (unsignedp ? widest_unsigned_literal_type_node
1917 : widest_integer_literal_type_node);
1919 if (bits <= TYPE_PRECISION (intQI_type_node))
1920 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1922 if (bits <= TYPE_PRECISION (intHI_type_node))
1923 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1925 if (bits <= TYPE_PRECISION (intSI_type_node))
1926 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1928 if (bits <= TYPE_PRECISION (intDI_type_node))
1929 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1934 /* Return a data type that has machine mode MODE.
1935 If the mode is an integer,
1936 then UNSIGNEDP selects between signed and unsigned types. */
1939 c_common_type_for_mode (mode, unsignedp)
1940 enum machine_mode mode;
1943 if (mode == TYPE_MODE (integer_type_node))
1944 return unsignedp ? unsigned_type_node : integer_type_node;
1946 if (mode == TYPE_MODE (signed_char_type_node))
1947 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1949 if (mode == TYPE_MODE (short_integer_type_node))
1950 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1952 if (mode == TYPE_MODE (long_integer_type_node))
1953 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1955 if (mode == TYPE_MODE (long_long_integer_type_node))
1956 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1958 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1959 return unsignedp ? widest_unsigned_literal_type_node
1960 : widest_integer_literal_type_node;
1963 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1966 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1969 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1972 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1974 #if HOST_BITS_PER_WIDE_INT >= 64
1975 if (mode == TYPE_MODE (intTI_type_node))
1976 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1979 if (mode == TYPE_MODE (float_type_node))
1980 return float_type_node;
1982 if (mode == TYPE_MODE (double_type_node))
1983 return double_type_node;
1985 if (mode == TYPE_MODE (long_double_type_node))
1986 return long_double_type_node;
1988 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1989 return build_pointer_type (char_type_node);
1991 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1992 return build_pointer_type (integer_type_node);
1997 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1999 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
2001 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
2003 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
2005 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
2007 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
2009 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
2011 return V16SF_type_node;
2013 return V4SF_type_node;
2015 return V2SF_type_node;
2017 return V2DF_type_node;
2025 /* Return an unsigned type the same as TYPE in other respects. */
2027 c_common_unsigned_type (type)
2030 tree type1 = TYPE_MAIN_VARIANT (type);
2031 if (type1 == signed_char_type_node || type1 == char_type_node)
2032 return unsigned_char_type_node;
2033 if (type1 == integer_type_node)
2034 return unsigned_type_node;
2035 if (type1 == short_integer_type_node)
2036 return short_unsigned_type_node;
2037 if (type1 == long_integer_type_node)
2038 return long_unsigned_type_node;
2039 if (type1 == long_long_integer_type_node)
2040 return long_long_unsigned_type_node;
2041 if (type1 == widest_integer_literal_type_node)
2042 return widest_unsigned_literal_type_node;
2043 #if HOST_BITS_PER_WIDE_INT >= 64
2044 if (type1 == intTI_type_node)
2045 return unsigned_intTI_type_node;
2047 if (type1 == intDI_type_node)
2048 return unsigned_intDI_type_node;
2049 if (type1 == intSI_type_node)
2050 return unsigned_intSI_type_node;
2051 if (type1 == intHI_type_node)
2052 return unsigned_intHI_type_node;
2053 if (type1 == intQI_type_node)
2054 return unsigned_intQI_type_node;
2056 return c_common_signed_or_unsigned_type (1, type);
2059 /* Return a signed type the same as TYPE in other respects. */
2062 c_common_signed_type (type)
2065 tree type1 = TYPE_MAIN_VARIANT (type);
2066 if (type1 == unsigned_char_type_node || type1 == char_type_node)
2067 return signed_char_type_node;
2068 if (type1 == unsigned_type_node)
2069 return integer_type_node;
2070 if (type1 == short_unsigned_type_node)
2071 return short_integer_type_node;
2072 if (type1 == long_unsigned_type_node)
2073 return long_integer_type_node;
2074 if (type1 == long_long_unsigned_type_node)
2075 return long_long_integer_type_node;
2076 if (type1 == widest_unsigned_literal_type_node)
2077 return widest_integer_literal_type_node;
2078 #if HOST_BITS_PER_WIDE_INT >= 64
2079 if (type1 == unsigned_intTI_type_node)
2080 return intTI_type_node;
2082 if (type1 == unsigned_intDI_type_node)
2083 return intDI_type_node;
2084 if (type1 == unsigned_intSI_type_node)
2085 return intSI_type_node;
2086 if (type1 == unsigned_intHI_type_node)
2087 return intHI_type_node;
2088 if (type1 == unsigned_intQI_type_node)
2089 return intQI_type_node;
2091 return c_common_signed_or_unsigned_type (0, type);
2094 /* Return a type the same as TYPE except unsigned or
2095 signed according to UNSIGNEDP. */
2098 c_common_signed_or_unsigned_type (unsignedp, type)
2102 if (! INTEGRAL_TYPE_P (type)
2103 || TREE_UNSIGNED (type) == unsignedp)
2106 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2107 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2108 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2109 return unsignedp ? unsigned_type_node : integer_type_node;
2110 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2111 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2112 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2113 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2114 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2115 return (unsignedp ? long_long_unsigned_type_node
2116 : long_long_integer_type_node);
2117 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2118 return (unsignedp ? widest_unsigned_literal_type_node
2119 : widest_integer_literal_type_node);
2121 #if HOST_BITS_PER_WIDE_INT >= 64
2122 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
2123 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2125 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
2126 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2127 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
2128 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2129 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
2130 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2131 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
2132 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2137 /* Return the minimum number of bits needed to represent VALUE in a
2138 signed or unsigned type, UNSIGNEDP says which. */
2141 min_precision (value, unsignedp)
2147 /* If the value is negative, compute its negative minus 1. The latter
2148 adjustment is because the absolute value of the largest negative value
2149 is one larger than the largest positive value. This is equivalent to
2150 a bit-wise negation, so use that operation instead. */
2152 if (tree_int_cst_sgn (value) < 0)
2153 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2155 /* Return the number of bits needed, taking into account the fact
2156 that we need one more bit for a signed than unsigned type. */
2158 if (integer_zerop (value))
2161 log = tree_floor_log2 (value);
2163 return log + 1 + ! unsignedp;
2166 /* Print an error message for invalid operands to arith operation
2167 CODE. NOP_EXPR is used as a special case (see
2168 c_common_truthvalue_conversion). */
2171 binary_op_error (code)
2172 enum tree_code code;
2179 error ("invalid truth-value expression");
2183 opname = "+"; break;
2185 opname = "-"; break;
2187 opname = "*"; break;
2189 opname = "max"; break;
2191 opname = "min"; break;
2193 opname = "=="; break;
2195 opname = "!="; break;
2197 opname = "<="; break;
2199 opname = ">="; break;
2201 opname = "<"; break;
2203 opname = ">"; break;
2205 opname = "<<"; break;
2207 opname = ">>"; break;
2208 case TRUNC_MOD_EXPR:
2209 case FLOOR_MOD_EXPR:
2210 opname = "%"; break;
2211 case TRUNC_DIV_EXPR:
2212 case FLOOR_DIV_EXPR:
2213 opname = "/"; break;
2215 opname = "&"; break;
2217 opname = "|"; break;
2218 case TRUTH_ANDIF_EXPR:
2219 opname = "&&"; break;
2220 case TRUTH_ORIF_EXPR:
2221 opname = "||"; break;
2223 opname = "^"; break;
2226 opname = "rotate"; break;
2228 opname = "unknown"; break;
2230 error ("invalid operands to binary %s", opname);
2233 /* Subroutine of build_binary_op, used for comparison operations.
2234 See if the operands have both been converted from subword integer types
2235 and, if so, perhaps change them both back to their original type.
2236 This function is also responsible for converting the two operands
2237 to the proper common type for comparison.
2239 The arguments of this function are all pointers to local variables
2240 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2241 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2243 If this function returns nonzero, it means that the comparison has
2244 a constant value. What this function returns is an expression for
2248 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2249 tree *op0_ptr, *op1_ptr;
2251 enum tree_code *rescode_ptr;
2254 tree op0 = *op0_ptr;
2255 tree op1 = *op1_ptr;
2256 int unsignedp0, unsignedp1;
2258 tree primop0, primop1;
2259 enum tree_code code = *rescode_ptr;
2261 /* Throw away any conversions to wider types
2262 already present in the operands. */
2264 primop0 = get_narrower (op0, &unsignedp0);
2265 primop1 = get_narrower (op1, &unsignedp1);
2267 /* Handle the case that OP0 does not *contain* a conversion
2268 but it *requires* conversion to FINAL_TYPE. */
2270 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2271 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2272 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2273 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2275 /* If one of the operands must be floated, we cannot optimize. */
2276 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2277 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2279 /* If first arg is constant, swap the args (changing operation
2280 so value is preserved), for canonicalization. Don't do this if
2281 the second arg is 0. */
2283 if (TREE_CONSTANT (primop0)
2284 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2287 int temi = unsignedp0;
2295 unsignedp0 = unsignedp1;
2318 *rescode_ptr = code;
2321 /* If comparing an integer against a constant more bits wide,
2322 maybe we can deduce a value of 1 or 0 independent of the data.
2323 Or else truncate the constant now
2324 rather than extend the variable at run time.
2326 This is only interesting if the constant is the wider arg.
2327 Also, it is not safe if the constant is unsigned and the
2328 variable arg is signed, since in this case the variable
2329 would be sign-extended and then regarded as unsigned.
2330 Our technique fails in this case because the lowest/highest
2331 possible unsigned results don't follow naturally from the
2332 lowest/highest possible values of the variable operand.
2333 For just EQ_EXPR and NE_EXPR there is another technique that
2334 could be used: see if the constant can be faithfully represented
2335 in the other operand's type, by truncating it and reextending it
2336 and see if that preserves the constant's value. */
2338 if (!real1 && !real2
2339 && TREE_CODE (primop1) == INTEGER_CST
2340 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2342 int min_gt, max_gt, min_lt, max_lt;
2343 tree maxval, minval;
2344 /* 1 if comparison is nominally unsigned. */
2345 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2348 type = c_common_signed_or_unsigned_type (unsignedp0,
2349 TREE_TYPE (primop0));
2351 /* If TYPE is an enumeration, then we need to get its min/max
2352 values from it's underlying integral type, not the enumerated
2354 if (TREE_CODE (type) == ENUMERAL_TYPE)
2355 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2357 maxval = TYPE_MAX_VALUE (type);
2358 minval = TYPE_MIN_VALUE (type);
2360 if (unsignedp && !unsignedp0)
2361 *restype_ptr = c_common_signed_type (*restype_ptr);
2363 if (TREE_TYPE (primop1) != *restype_ptr)
2364 primop1 = convert (*restype_ptr, primop1);
2365 if (type != *restype_ptr)
2367 minval = convert (*restype_ptr, minval);
2368 maxval = convert (*restype_ptr, maxval);
2371 if (unsignedp && unsignedp0)
2373 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2374 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2375 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2376 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2380 min_gt = INT_CST_LT (primop1, minval);
2381 max_gt = INT_CST_LT (primop1, maxval);
2382 min_lt = INT_CST_LT (minval, primop1);
2383 max_lt = INT_CST_LT (maxval, primop1);
2387 /* This used to be a switch, but Genix compiler can't handle that. */
2388 if (code == NE_EXPR)
2390 if (max_lt || min_gt)
2391 val = boolean_true_node;
2393 else if (code == EQ_EXPR)
2395 if (max_lt || min_gt)
2396 val = boolean_false_node;
2398 else if (code == LT_EXPR)
2401 val = boolean_true_node;
2403 val = boolean_false_node;
2405 else if (code == GT_EXPR)
2408 val = boolean_true_node;
2410 val = boolean_false_node;
2412 else if (code == LE_EXPR)
2415 val = boolean_true_node;
2417 val = boolean_false_node;
2419 else if (code == GE_EXPR)
2422 val = boolean_true_node;
2424 val = boolean_false_node;
2427 /* If primop0 was sign-extended and unsigned comparison specd,
2428 we did a signed comparison above using the signed type bounds.
2429 But the comparison we output must be unsigned.
2431 Also, for inequalities, VAL is no good; but if the signed
2432 comparison had *any* fixed result, it follows that the
2433 unsigned comparison just tests the sign in reverse
2434 (positive values are LE, negative ones GE).
2435 So we can generate an unsigned comparison
2436 against an extreme value of the signed type. */
2438 if (unsignedp && !unsignedp0)
2445 primop1 = TYPE_MIN_VALUE (type);
2451 primop1 = TYPE_MAX_VALUE (type);
2458 type = c_common_unsigned_type (type);
2461 if (TREE_CODE (primop0) != INTEGER_CST)
2463 if (val == boolean_false_node)
2464 warning ("comparison is always false due to limited range of data type");
2465 if (val == boolean_true_node)
2466 warning ("comparison is always true due to limited range of data type");
2471 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2472 if (TREE_SIDE_EFFECTS (primop0))
2473 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2477 /* Value is not predetermined, but do the comparison
2478 in the type of the operand that is not constant.
2479 TYPE is already properly set. */
2481 else if (real1 && real2
2482 && (TYPE_PRECISION (TREE_TYPE (primop0))
2483 == TYPE_PRECISION (TREE_TYPE (primop1))))
2484 type = TREE_TYPE (primop0);
2486 /* If args' natural types are both narrower than nominal type
2487 and both extend in the same manner, compare them
2488 in the type of the wider arg.
2489 Otherwise must actually extend both to the nominal
2490 common type lest different ways of extending
2492 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2494 else if (unsignedp0 == unsignedp1 && real1 == real2
2495 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2496 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2498 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2499 type = c_common_signed_or_unsigned_type (unsignedp0
2500 || TREE_UNSIGNED (*restype_ptr),
2502 /* Make sure shorter operand is extended the right way
2503 to match the longer operand. */
2505 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2506 TREE_TYPE (primop0)),
2509 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2510 TREE_TYPE (primop1)),
2515 /* Here we must do the comparison on the nominal type
2516 using the args exactly as we received them. */
2517 type = *restype_ptr;
2521 if (!real1 && !real2 && integer_zerop (primop1)
2522 && TREE_UNSIGNED (*restype_ptr))
2528 /* All unsigned values are >= 0, so we warn if extra warnings
2529 are requested. However, if OP0 is a constant that is
2530 >= 0, the signedness of the comparison isn't an issue,
2531 so suppress the warning. */
2532 if (extra_warnings && !in_system_header
2533 && ! (TREE_CODE (primop0) == INTEGER_CST
2534 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2536 warning ("comparison of unsigned expression >= 0 is always true");
2537 value = boolean_true_node;
2541 if (extra_warnings && !in_system_header
2542 && ! (TREE_CODE (primop0) == INTEGER_CST
2543 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2545 warning ("comparison of unsigned expression < 0 is always false");
2546 value = boolean_false_node;
2555 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2556 if (TREE_SIDE_EFFECTS (primop0))
2557 return build (COMPOUND_EXPR, TREE_TYPE (value),
2564 *op0_ptr = convert (type, primop0);
2565 *op1_ptr = convert (type, primop1);
2567 *restype_ptr = boolean_type_node;
2572 /* Return a tree for the sum or difference (RESULTCODE says which)
2573 of pointer PTROP and integer INTOP. */
2576 pointer_int_sum (resultcode, ptrop, intop)
2577 enum tree_code resultcode;
2585 /* The result is a pointer of the same type that is being added. */
2587 tree result_type = TREE_TYPE (ptrop);
2589 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2591 if (pedantic || warn_pointer_arith)
2592 pedwarn ("pointer of type `void *' used in arithmetic");
2593 size_exp = integer_one_node;
2595 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2597 if (pedantic || warn_pointer_arith)
2598 pedwarn ("pointer to a function used in arithmetic");
2599 size_exp = integer_one_node;
2601 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2603 if (pedantic || warn_pointer_arith)
2604 pedwarn ("pointer to member function used in arithmetic");
2605 size_exp = integer_one_node;
2607 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2609 if (pedantic || warn_pointer_arith)
2610 pedwarn ("pointer to a member used in arithmetic");
2611 size_exp = integer_one_node;
2614 size_exp = size_in_bytes (TREE_TYPE (result_type));
2616 /* If what we are about to multiply by the size of the elements
2617 contains a constant term, apply distributive law
2618 and multiply that constant term separately.
2619 This helps produce common subexpressions. */
2621 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2622 && ! TREE_CONSTANT (intop)
2623 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2624 && TREE_CONSTANT (size_exp)
2625 /* If the constant comes from pointer subtraction,
2626 skip this optimization--it would cause an error. */
2627 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2628 /* If the constant is unsigned, and smaller than the pointer size,
2629 then we must skip this optimization. This is because it could cause
2630 an overflow error if the constant is negative but INTOP is not. */
2631 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2632 || (TYPE_PRECISION (TREE_TYPE (intop))
2633 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2635 enum tree_code subcode = resultcode;
2636 tree int_type = TREE_TYPE (intop);
2637 if (TREE_CODE (intop) == MINUS_EXPR)
2638 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2639 /* Convert both subexpression types to the type of intop,
2640 because weird cases involving pointer arithmetic
2641 can result in a sum or difference with different type args. */
2642 ptrop = build_binary_op (subcode, ptrop,
2643 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2644 intop = convert (int_type, TREE_OPERAND (intop, 0));
2647 /* Convert the integer argument to a type the same size as sizetype
2648 so the multiply won't overflow spuriously. */
2650 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2651 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2652 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2653 TREE_UNSIGNED (sizetype)), intop);
2655 /* Replace the integer argument with a suitable product by the object size.
2656 Do this multiplication as signed, then convert to the appropriate
2657 pointer type (actually unsigned integral). */
2659 intop = convert (result_type,
2660 build_binary_op (MULT_EXPR, intop,
2661 convert (TREE_TYPE (intop), size_exp), 1));
2663 /* Create the sum or difference. */
2665 result = build (resultcode, result_type, ptrop, intop);
2667 folded = fold (result);
2668 if (folded == result)
2669 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2673 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2674 or validate its data type for an `if' or `while' statement or ?..: exp.
2676 This preparation consists of taking the ordinary
2677 representation of an expression expr and producing a valid tree
2678 boolean expression describing whether expr is nonzero. We could
2679 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2680 but we optimize comparisons, &&, ||, and !.
2682 The resulting type should always be `boolean_type_node'. */
2685 c_common_truthvalue_conversion (expr)
2688 if (TREE_CODE (expr) == ERROR_MARK)
2691 #if 0 /* This appears to be wrong for C++. */
2692 /* These really should return error_mark_node after 2.4 is stable.
2693 But not all callers handle ERROR_MARK properly. */
2694 switch (TREE_CODE (TREE_TYPE (expr)))
2697 error ("struct type value used where scalar is required");
2698 return boolean_false_node;
2701 error ("union type value used where scalar is required");
2702 return boolean_false_node;
2705 error ("array type value used where scalar is required");
2706 return boolean_false_node;
2713 switch (TREE_CODE (expr))
2716 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2717 case TRUTH_ANDIF_EXPR:
2718 case TRUTH_ORIF_EXPR:
2719 case TRUTH_AND_EXPR:
2721 case TRUTH_XOR_EXPR:
2722 case TRUTH_NOT_EXPR:
2723 TREE_TYPE (expr) = boolean_type_node;
2730 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2733 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2736 /* If we are taking the address of an external decl, it might be zero
2737 if it is weak, so we cannot optimize. */
2738 if (DECL_P (TREE_OPERAND (expr, 0))
2739 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2742 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2743 return build (COMPOUND_EXPR, boolean_type_node,
2744 TREE_OPERAND (expr, 0), boolean_true_node);
2746 return boolean_true_node;
2749 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2750 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2751 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2752 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2759 /* These don't change whether an object is non-zero or zero. */
2760 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2764 /* These don't change whether an object is zero or non-zero, but
2765 we can't ignore them if their second arg has side-effects. */
2766 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2767 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2768 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2770 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2773 /* Distribute the conversion into the arms of a COND_EXPR. */
2774 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2775 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2776 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2779 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2780 since that affects how `default_conversion' will behave. */
2781 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2782 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2784 /* fall through... */
2786 /* If this is widening the argument, we can ignore it. */
2787 if (TYPE_PRECISION (TREE_TYPE (expr))
2788 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2789 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2793 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2794 aren't guaranteed to the be same for modes that can represent
2795 infinity, since if x and y are both +infinity, or both
2796 -infinity, then x - y is not a number.
2798 Note that this transformation is safe when x or y is NaN.
2799 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2801 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2803 /* fall through... */
2805 /* This and MINUS_EXPR can be changed into a comparison of the
2807 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2808 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2809 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2810 TREE_OPERAND (expr, 1), 1);
2811 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2812 fold (build1 (NOP_EXPR,
2813 TREE_TYPE (TREE_OPERAND (expr, 0)),
2814 TREE_OPERAND (expr, 1))), 1);
2817 if (integer_onep (TREE_OPERAND (expr, 1))
2818 && TREE_TYPE (expr) != boolean_type_node)
2819 /* Using convert here would cause infinite recursion. */
2820 return build1 (NOP_EXPR, boolean_type_node, expr);
2824 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2825 warning ("suggest parentheses around assignment used as truth value");
2832 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2834 tree t = save_expr (expr);
2835 return (build_binary_op
2836 ((TREE_SIDE_EFFECTS (expr)
2837 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2838 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2839 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2843 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2846 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2847 int, enum built_in_class, int, int,
2850 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2851 down to the element type of an array. */
2854 c_build_qualified_type (type, type_quals)
2858 /* A restrict-qualified pointer type must be a pointer to object or
2859 incomplete type. Note that the use of POINTER_TYPE_P also allows
2860 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2861 the C++ front-end also use POINTER_TYPE for pointer-to-member
2862 values, so even though it should be illegal to use `restrict'
2863 with such an entity we don't flag that here. Thus, special case
2864 code for that case is required in the C++ front-end. */
2865 if ((type_quals & TYPE_QUAL_RESTRICT)
2866 && (!POINTER_TYPE_P (type)
2867 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2869 error ("invalid use of `restrict'");
2870 type_quals &= ~TYPE_QUAL_RESTRICT;
2873 if (TREE_CODE (type) == ARRAY_TYPE)
2874 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2876 TYPE_DOMAIN (type));
2877 return build_qualified_type (type, type_quals);
2880 /* Apply the TYPE_QUALS to the new DECL. */
2883 c_apply_type_quals_to_decl (type_quals, decl)
2887 if ((type_quals & TYPE_QUAL_CONST)
2888 || (TREE_TYPE (decl)
2889 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2890 TREE_READONLY (decl) = 1;
2891 if (type_quals & TYPE_QUAL_VOLATILE)
2893 TREE_SIDE_EFFECTS (decl) = 1;
2894 TREE_THIS_VOLATILE (decl) = 1;
2896 if (type_quals & TYPE_QUAL_RESTRICT)
2898 if (!TREE_TYPE (decl)
2899 || !POINTER_TYPE_P (TREE_TYPE (decl))
2900 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2901 error ("invalid use of `restrict'");
2902 else if (flag_strict_aliasing)
2903 /* Indicate we need to make a unique alias set for this pointer.
2904 We can't do it here because it might be pointing to an
2906 DECL_POINTER_ALIAS_SET (decl) = -2;
2910 /* Return the typed-based alias set for T, which may be an expression
2911 or a type. Return -1 if we don't do anything special. */
2914 c_common_get_alias_set (t)
2919 /* Permit type-punning when accessing a union, provided the access
2920 is directly through the union. For example, this code does not
2921 permit taking the address of a union member and then storing
2922 through it. Even the type-punning allowed here is a GCC
2923 extension, albeit a common and useful one; the C standard says
2924 that such accesses have implementation-defined behavior. */
2926 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2927 u = TREE_OPERAND (u, 0))
2928 if (TREE_CODE (u) == COMPONENT_REF
2929 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2932 /* That's all the expressions we handle specially. */
2936 /* The C standard guarantess that any object may be accessed via an
2937 lvalue that has character type. */
2938 if (t == char_type_node
2939 || t == signed_char_type_node
2940 || t == unsigned_char_type_node)
2943 /* If it has the may_alias attribute, it can alias anything. */
2944 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2947 /* The C standard specifically allows aliasing between signed and
2948 unsigned variants of the same type. We treat the signed
2949 variant as canonical. */
2950 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2952 tree t1 = c_common_signed_type (t);
2954 /* t1 == t can happen for boolean nodes which are always unsigned. */
2956 return get_alias_set (t1);
2958 else if (POINTER_TYPE_P (t))
2962 /* Unfortunately, there is no canonical form of a pointer type.
2963 In particular, if we have `typedef int I', then `int *', and
2964 `I *' are different types. So, we have to pick a canonical
2965 representative. We do this below.
2967 Technically, this approach is actually more conservative that
2968 it needs to be. In particular, `const int *' and `int *'
2969 should be in different alias sets, according to the C and C++
2970 standard, since their types are not the same, and so,
2971 technically, an `int **' and `const int **' cannot point at
2974 But, the standard is wrong. In particular, this code is
2979 const int* const* cipp = &ipp;
2981 And, it doesn't make sense for that to be legal unless you
2982 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2983 the pointed-to types. This issue has been reported to the
2985 t1 = build_type_no_quals (t);
2987 return get_alias_set (t1);
2993 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2994 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2995 flag controls whether we should diagnose possibly ill-formed
2996 constructs or not. */
2998 c_sizeof_or_alignof_type (type, op, complain)
3003 const char *op_name;
3005 enum tree_code type_code = TREE_CODE (type);
3007 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
3008 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
3010 if (type_code == FUNCTION_TYPE)
3012 if (op == SIZEOF_EXPR)
3014 if (complain && (pedantic || warn_pointer_arith))
3015 pedwarn ("invalid application of `sizeof' to a function type");
3016 value = size_one_node;
3019 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3021 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3023 if (type_code == VOID_TYPE
3024 && complain && (pedantic || warn_pointer_arith))
3025 pedwarn ("invalid application of `%s' to a void type", op_name);
3026 value = size_one_node;
3028 else if (!COMPLETE_TYPE_P (type))
3031 error ("invalid application of `%s' to an incomplete type", op_name);
3032 value = size_zero_node;
3036 if (op == SIZEOF_EXPR)
3037 /* Convert in case a char is more than one unit. */
3038 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3039 size_int (TYPE_PRECISION (char_type_node)
3042 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
3045 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3046 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3047 never happen. However, this node should really have type
3048 `size_t', which is just a typedef for an ordinary integer type. */
3049 value = fold (build1 (NOP_EXPR, c_size_type_node, value));
3050 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
3055 /* Implement the __alignof keyword: Return the minimum required
3056 alignment of EXPR, measured in bytes. For VAR_DECL's and
3057 FIELD_DECL's return DECL_ALIGN (which can be set from an
3058 "aligned" __attribute__ specification). */
3061 c_alignof_expr (expr)
3066 if (TREE_CODE (expr) == VAR_DECL)
3067 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
3069 else if (TREE_CODE (expr) == COMPONENT_REF
3070 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3072 error ("`__alignof' applied to a bit-field");
3075 else if (TREE_CODE (expr) == COMPONENT_REF
3076 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3077 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
3079 else if (TREE_CODE (expr) == INDIRECT_REF)
3081 tree t = TREE_OPERAND (expr, 0);
3083 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3085 while (TREE_CODE (t) == NOP_EXPR
3086 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3090 t = TREE_OPERAND (t, 0);
3091 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3092 if (thisalign > bestalign)
3093 best = t, bestalign = thisalign;
3095 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3098 return c_alignof (TREE_TYPE (expr));
3100 return fold (build1 (NOP_EXPR, c_size_type_node, t));
3103 /* Handle C and C++ default attributes. */
3105 enum built_in_attribute
3107 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3108 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3109 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3110 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3111 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3112 #include "builtin-attrs.def"
3113 #undef DEF_ATTR_NULL_TREE
3115 #undef DEF_ATTR_IDENT
3116 #undef DEF_ATTR_TREE_LIST
3121 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3123 static bool c_attrs_initialized = false;
3125 static void c_init_attributes PARAMS ((void));
3127 /* Build tree nodes and builtin functions common to both C and C++ language
3131 c_common_nodes_and_builtins ()
3135 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3136 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3137 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3138 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3139 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3140 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3141 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3142 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3143 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3144 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3145 #include "builtin-types.def"
3146 #undef DEF_PRIMITIVE_TYPE
3147 #undef DEF_FUNCTION_TYPE_0
3148 #undef DEF_FUNCTION_TYPE_1
3149 #undef DEF_FUNCTION_TYPE_2
3150 #undef DEF_FUNCTION_TYPE_3
3151 #undef DEF_FUNCTION_TYPE_4
3152 #undef DEF_FUNCTION_TYPE_VAR_0
3153 #undef DEF_FUNCTION_TYPE_VAR_1
3154 #undef DEF_FUNCTION_TYPE_VAR_2
3155 #undef DEF_POINTER_TYPE
3159 typedef enum builtin_type builtin_type;
3161 tree builtin_types[(int) BT_LAST];
3162 int wchar_type_size;
3163 tree array_domain_type;
3164 tree va_list_ref_type_node;
3165 tree va_list_arg_type_node;
3167 /* Define `int' and `char' first so that dbx will output them first. */
3168 record_builtin_type (RID_INT, NULL, integer_type_node);
3169 record_builtin_type (RID_CHAR, "char", char_type_node);
3171 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3172 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3173 but not C. Are the conditionals here needed? */
3174 if (c_language == clk_cplusplus)
3175 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3176 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3177 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3178 record_builtin_type (RID_MAX, "long unsigned int",
3179 long_unsigned_type_node);
3180 if (c_language == clk_cplusplus)
3181 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3182 record_builtin_type (RID_MAX, "long long int",
3183 long_long_integer_type_node);
3184 record_builtin_type (RID_MAX, "long long unsigned int",
3185 long_long_unsigned_type_node);
3186 if (c_language == clk_cplusplus)
3187 record_builtin_type (RID_MAX, "long long unsigned",
3188 long_long_unsigned_type_node);
3189 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3190 record_builtin_type (RID_MAX, "short unsigned int",
3191 short_unsigned_type_node);
3192 if (c_language == clk_cplusplus)
3193 record_builtin_type (RID_MAX, "unsigned short",
3194 short_unsigned_type_node);
3196 /* Define both `signed char' and `unsigned char'. */
3197 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3198 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3200 /* These are types that c_common_type_for_size and
3201 c_common_type_for_mode use. */
3202 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3204 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3206 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3208 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3210 #if HOST_BITS_PER_WIDE_INT >= 64
3211 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3212 get_identifier ("__int128_t"),
3215 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3216 unsigned_intQI_type_node));
3217 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3218 unsigned_intHI_type_node));
3219 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3220 unsigned_intSI_type_node));
3221 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3222 unsigned_intDI_type_node));
3223 #if HOST_BITS_PER_WIDE_INT >= 64
3224 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3225 get_identifier ("__uint128_t"),
3226 unsigned_intTI_type_node));
3229 /* Create the widest literal types. */
3230 widest_integer_literal_type_node
3231 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3232 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3233 widest_integer_literal_type_node));
3235 widest_unsigned_literal_type_node
3236 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3237 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3238 widest_unsigned_literal_type_node));
3240 /* `unsigned long' is the standard type for sizeof.
3241 Note that stddef.h uses `unsigned long',
3242 and this must agree, even if long and int are the same size. */
3244 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3245 signed_size_type_node = c_common_signed_type (c_size_type_node);
3246 set_sizetype (c_size_type_node);
3248 build_common_tree_nodes_2 (flag_short_double);
3250 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3251 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3252 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3254 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3255 get_identifier ("complex int"),
3256 complex_integer_type_node));
3257 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3258 get_identifier ("complex float"),
3259 complex_float_type_node));
3260 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3261 get_identifier ("complex double"),
3262 complex_double_type_node));
3263 (*lang_hooks.decls.pushdecl)
3264 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3265 complex_long_double_type_node));
3267 /* Types which are common to the fortran compiler and libf2c. When
3268 changing these, you also need to be concerned with f/com.h. */
3270 if (TYPE_PRECISION (float_type_node)
3271 == TYPE_PRECISION (long_integer_type_node))
3273 g77_integer_type_node = long_integer_type_node;
3274 g77_uinteger_type_node = long_unsigned_type_node;
3276 else if (TYPE_PRECISION (float_type_node)
3277 == TYPE_PRECISION (integer_type_node))
3279 g77_integer_type_node = integer_type_node;
3280 g77_uinteger_type_node = unsigned_type_node;
3283 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3285 if (g77_integer_type_node != NULL_TREE)
3287 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3288 get_identifier ("__g77_integer"),
3289 g77_integer_type_node));
3290 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3291 get_identifier ("__g77_uinteger"),
3292 g77_uinteger_type_node));
3295 if (TYPE_PRECISION (float_type_node) * 2
3296 == TYPE_PRECISION (long_integer_type_node))
3298 g77_longint_type_node = long_integer_type_node;
3299 g77_ulongint_type_node = long_unsigned_type_node;
3301 else if (TYPE_PRECISION (float_type_node) * 2
3302 == TYPE_PRECISION (long_long_integer_type_node))
3304 g77_longint_type_node = long_long_integer_type_node;
3305 g77_ulongint_type_node = long_long_unsigned_type_node;
3308 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3310 if (g77_longint_type_node != NULL_TREE)
3312 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3313 get_identifier ("__g77_longint"),
3314 g77_longint_type_node));
3315 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3316 get_identifier ("__g77_ulongint"),
3317 g77_ulongint_type_node));
3320 record_builtin_type (RID_VOID, NULL, void_type_node);
3322 void_zero_node = build_int_2 (0, 0);
3323 TREE_TYPE (void_zero_node) = void_type_node;
3325 void_list_node = build_void_list_node ();
3327 /* Make a type to be the domain of a few array types
3328 whose domains don't really matter.
3329 200 is small enough that it always fits in size_t
3330 and large enough that it can hold most function names for the
3331 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3332 array_domain_type = build_index_type (size_int (200));
3334 /* Make a type for arrays of characters.
3335 With luck nothing will ever really depend on the length of this
3337 char_array_type_node
3338 = build_array_type (char_type_node, array_domain_type);
3340 /* Likewise for arrays of ints. */
3342 = build_array_type (integer_type_node, array_domain_type);
3344 string_type_node = build_pointer_type (char_type_node);
3345 const_string_type_node
3346 = build_pointer_type (build_qualified_type
3347 (char_type_node, TYPE_QUAL_CONST));
3349 (*targetm.init_builtins) ();
3351 /* This is special for C++ so functions can be overloaded. */
3352 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3353 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3354 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3355 if (c_language == clk_cplusplus)
3357 if (TREE_UNSIGNED (wchar_type_node))
3358 wchar_type_node = make_unsigned_type (wchar_type_size);
3360 wchar_type_node = make_signed_type (wchar_type_size);
3361 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3365 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3366 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3369 /* This is for wide string constants. */
3370 wchar_array_type_node
3371 = build_array_type (wchar_type_node, array_domain_type);
3374 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3377 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3379 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3381 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3383 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3384 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3386 (*lang_hooks.decls.pushdecl)
3387 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3388 va_list_type_node));
3390 (*lang_hooks.decls.pushdecl)
3391 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3392 ptrdiff_type_node));
3394 (*lang_hooks.decls.pushdecl)
3395 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3398 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3400 va_list_arg_type_node = va_list_ref_type_node =
3401 build_pointer_type (TREE_TYPE (va_list_type_node));
3405 va_list_arg_type_node = va_list_type_node;
3406 va_list_ref_type_node = build_reference_type (va_list_type_node);
3409 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3410 builtin_types[(int) ENUM] = VALUE;
3411 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3412 builtin_types[(int) ENUM] \
3413 = build_function_type (builtin_types[(int) RETURN], \
3415 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3416 builtin_types[(int) ENUM] \
3417 = build_function_type (builtin_types[(int) RETURN], \
3418 tree_cons (NULL_TREE, \
3419 builtin_types[(int) ARG1], \
3421 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3422 builtin_types[(int) ENUM] \
3423 = build_function_type \
3424 (builtin_types[(int) RETURN], \
3425 tree_cons (NULL_TREE, \
3426 builtin_types[(int) ARG1], \
3427 tree_cons (NULL_TREE, \
3428 builtin_types[(int) ARG2], \
3430 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3431 builtin_types[(int) ENUM] \
3432 = build_function_type \
3433 (builtin_types[(int) RETURN], \
3434 tree_cons (NULL_TREE, \
3435 builtin_types[(int) ARG1], \
3436 tree_cons (NULL_TREE, \
3437 builtin_types[(int) ARG2], \
3438 tree_cons (NULL_TREE, \
3439 builtin_types[(int) ARG3], \
3441 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3442 builtin_types[(int) ENUM] \
3443 = build_function_type \
3444 (builtin_types[(int) RETURN], \
3445 tree_cons (NULL_TREE, \
3446 builtin_types[(int) ARG1], \
3447 tree_cons (NULL_TREE, \
3448 builtin_types[(int) ARG2], \
3451 builtin_types[(int) ARG3], \
3452 tree_cons (NULL_TREE, \
3453 builtin_types[(int) ARG4], \
3454 void_list_node)))));
3455 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3456 builtin_types[(int) ENUM] \
3457 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3458 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3459 builtin_types[(int) ENUM] \
3460 = build_function_type (builtin_types[(int) RETURN], \
3461 tree_cons (NULL_TREE, \
3462 builtin_types[(int) ARG1], \
3465 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3466 builtin_types[(int) ENUM] \
3467 = build_function_type \
3468 (builtin_types[(int) RETURN], \
3469 tree_cons (NULL_TREE, \
3470 builtin_types[(int) ARG1], \
3471 tree_cons (NULL_TREE, \
3472 builtin_types[(int) ARG2], \
3474 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3475 builtin_types[(int) ENUM] \
3476 = build_pointer_type (builtin_types[(int) TYPE]);
3477 #include "builtin-types.def"
3478 #undef DEF_PRIMITIVE_TYPE
3479 #undef DEF_FUNCTION_TYPE_1
3480 #undef DEF_FUNCTION_TYPE_2
3481 #undef DEF_FUNCTION_TYPE_3
3482 #undef DEF_FUNCTION_TYPE_4
3483 #undef DEF_FUNCTION_TYPE_VAR_0
3484 #undef DEF_FUNCTION_TYPE_VAR_1
3485 #undef DEF_POINTER_TYPE
3487 if (!c_attrs_initialized)
3488 c_init_attributes ();
3490 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3491 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS) \
3496 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3500 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3503 ? (NAME + strlen ("__builtin_")) \
3505 built_in_attributes[(int) ATTRS]); \
3507 decl = builtin_function_2 (NAME, \
3508 NAME + strlen ("__builtin_"), \
3509 builtin_types[TYPE], \
3510 builtin_types[LIBTYPE], \
3515 built_in_attributes[(int) ATTRS]); \
3517 built_in_decls[(int) ENUM] = decl; \
3519 #include "builtins.def"
3522 main_identifier_node = get_identifier ("main");
3526 build_va_arg (expr, type)
3529 return build1 (VA_ARG_EXPR, type, expr);
3533 /* Linked list of disabled built-in functions. */
3535 typedef struct disabled_builtin
3538 struct disabled_builtin *next;
3540 static disabled_builtin *disabled_builtins = NULL;
3542 static bool builtin_function_disabled_p PARAMS ((const char *));
3544 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3545 begins with "__builtin_", give an error. */
3548 disable_builtin_function (name)
3551 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3552 error ("cannot disable built-in function `%s'", name);
3555 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3557 new->next = disabled_builtins;
3558 disabled_builtins = new;
3563 /* Return true if the built-in function NAME has been disabled, false
3567 builtin_function_disabled_p (name)
3570 disabled_builtin *p;
3571 for (p = disabled_builtins; p != NULL; p = p->next)
3573 if (strcmp (name, p->name) == 0)
3580 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3581 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3582 of these may be NULL (though both being NULL is useless).
3583 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3584 TYPE is the type of the function with the ordinary name. These
3585 may differ if the ordinary name is declared with a looser type to avoid
3586 conflicts with headers. FUNCTION_CODE and CLASS are as for
3587 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3588 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3589 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3590 ATTRS is the tree list representing the builtin's function attributes.
3591 Returns the declaration of BUILTIN_NAME, if any, otherwise
3592 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3593 or if NONANSI_P and flag_no_nonansi_builtin. */
3596 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3597 class, library_name_p, nonansi_p, attrs)
3598 const char *builtin_name;
3603 enum built_in_class class;
3608 tree bdecl = NULL_TREE;
3609 tree decl = NULL_TREE;
3610 if (builtin_name != 0)
3612 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3613 class, library_name_p ? name : NULL,
3616 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3617 && !(nonansi_p && flag_no_nonansi_builtin))
3619 decl = builtin_function (name, type, function_code, class, NULL,
3622 DECL_BUILT_IN_NONANSI (decl) = 1;
3624 return (bdecl != 0 ? bdecl : decl);
3627 /* Nonzero if the type T promotes to int. This is (nearly) the
3628 integral promotions defined in ISO C99 6.3.1.1/2. */
3631 c_promoting_integer_type_p (t)
3634 switch (TREE_CODE (t))
3637 return (TYPE_MAIN_VARIANT (t) == char_type_node
3638 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3639 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3640 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3641 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3642 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3645 /* ??? Technically all enumerations not larger than an int
3646 promote to an int. But this is used along code paths
3647 that only want to notice a size change. */
3648 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3658 /* Return 1 if PARMS specifies a fixed number of parameters
3659 and none of their types is affected by default promotions. */
3662 self_promoting_args_p (parms)
3666 for (t = parms; t; t = TREE_CHAIN (t))
3668 tree type = TREE_VALUE (t);
3670 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3676 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3679 if (c_promoting_integer_type_p (type))
3685 /* Recursively examines the array elements of TYPE, until a non-array
3686 element type is found. */
3689 strip_array_types (type)
3692 while (TREE_CODE (type) == ARRAY_TYPE)
3693 type = TREE_TYPE (type);
3698 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3701 /* Expand a call to an unordered comparison function such as
3702 __builtin_isgreater(). FUNCTION is the function's declaration and
3703 PARAMS a list of the values passed. For __builtin_isunordered(),
3704 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3705 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3706 that give the opposite of the desired result. UNORDERED_CODE is
3707 used for modes that can hold NaNs and ORDERED_CODE is used for the
3711 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3712 tree function, params;
3713 enum tree_code unordered_code, ordered_code;
3715 tree arg0, arg1, type;
3716 enum tree_code code0, code1;
3718 /* Check that we have exactly two arguments. */
3719 if (params == 0 || TREE_CHAIN (params) == 0)
3721 error ("too few arguments to function `%s'",
3722 IDENTIFIER_POINTER (DECL_NAME (function)));
3723 return error_mark_node;
3725 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3727 error ("too many arguments to function `%s'",
3728 IDENTIFIER_POINTER (DECL_NAME (function)));
3729 return error_mark_node;
3732 arg0 = TREE_VALUE (params);
3733 arg1 = TREE_VALUE (TREE_CHAIN (params));
3735 code0 = TREE_CODE (TREE_TYPE (arg0));
3736 code1 = TREE_CODE (TREE_TYPE (arg1));
3738 /* Make sure that the arguments have a common type of REAL. */
3740 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3741 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3742 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3744 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3746 error ("non-floating-point argument to function `%s'",
3747 IDENTIFIER_POINTER (DECL_NAME (function)));
3748 return error_mark_node;
3751 if (unordered_code == UNORDERED_EXPR)
3753 if (MODE_HAS_NANS (TYPE_MODE (type)))
3754 return build_binary_op (unordered_code,
3755 convert (type, arg0),
3756 convert (type, arg1),
3759 return integer_zero_node;
3762 return build_unary_op (TRUTH_NOT_EXPR,
3763 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3766 convert (type, arg0),
3767 convert (type, arg1),
3773 /* Recognize certain built-in functions so we can make tree-codes
3774 other than CALL_EXPR. We do this when it enables fold-const.c
3775 to do something useful. */
3776 /* ??? By rights this should go in builtins.c, but only C and C++
3777 implement build_{binary,unary}_op. Not exactly sure what bits
3778 of functionality are actually needed from those functions, or
3779 where the similar functionality exists in the other front ends. */
3782 expand_tree_builtin (function, params, coerced_params)
3783 tree function, params, coerced_params;
3785 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3788 switch (DECL_FUNCTION_CODE (function))
3792 case BUILT_IN_LLABS:
3793 case BUILT_IN_IMAXABS:
3795 case BUILT_IN_FABSL:
3796 case BUILT_IN_FABSF:
3797 if (coerced_params == 0)
3798 return integer_zero_node;
3799 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3802 case BUILT_IN_CONJF:
3803 case BUILT_IN_CONJL:
3804 if (coerced_params == 0)
3805 return integer_zero_node;
3806 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3808 case BUILT_IN_CREAL:
3809 case BUILT_IN_CREALF:
3810 case BUILT_IN_CREALL:
3811 if (coerced_params == 0)
3812 return integer_zero_node;
3813 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3815 case BUILT_IN_CIMAG:
3816 case BUILT_IN_CIMAGF:
3817 case BUILT_IN_CIMAGL:
3818 if (coerced_params == 0)
3819 return integer_zero_node;
3820 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3822 case BUILT_IN_ISGREATER:
3823 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3825 case BUILT_IN_ISGREATEREQUAL:
3826 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3828 case BUILT_IN_ISLESS:
3829 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3831 case BUILT_IN_ISLESSEQUAL:
3832 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3834 case BUILT_IN_ISLESSGREATER:
3835 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3837 case BUILT_IN_ISUNORDERED:
3838 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3847 /* Returns non-zero if CODE is the code for a statement. */
3850 statement_code_p (code)
3851 enum tree_code code;
3876 if (lang_statement_code_p)
3877 return (*lang_statement_code_p) (code);
3882 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3883 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3884 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3885 value, the traversal is aborted, and the value returned by FUNC is
3886 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3887 the node being visited are not walked.
3889 We don't need a without_duplicates variant of this one because the
3890 statement tree is a tree, not a graph. */
3893 walk_stmt_tree (tp, func, data)
3898 enum tree_code code;
3903 #define WALK_SUBTREE(NODE) \
3906 result = walk_stmt_tree (&(NODE), func, data); \
3912 /* Skip empty subtrees. */
3916 /* Skip subtrees below non-statement nodes. */
3917 if (!statement_code_p (TREE_CODE (*tp)))
3920 /* Call the function. */
3922 result = (*func) (tp, &walk_subtrees, data);
3924 /* If we found something, return it. */
3928 /* FUNC may have modified the tree, recheck that we're looking at a
3930 code = TREE_CODE (*tp);
3931 if (!statement_code_p (code))
3934 /* Visit the subtrees unless FUNC decided that there was nothing
3935 interesting below this point in the tree. */
3938 /* Walk over all the sub-trees of this operand. Statement nodes
3939 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3940 len = TREE_CODE_LENGTH (code);
3942 /* Go through the subtrees. We need to do this in forward order so
3943 that the scope of a FOR_EXPR is handled properly. */
3944 for (i = 0; i < len; ++i)
3945 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3948 /* Finally visit the chain. This can be tail-recursion optimized if
3949 we write it this way. */
3950 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3955 /* Used to compare case labels. K1 and K2 are actually tree nodes
3956 representing case labels, or NULL_TREE for a `default' label.
3957 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3958 K2, and 0 if K1 and K2 are equal. */
3961 case_compare (k1, k2)
3965 /* Consider a NULL key (such as arises with a `default' label) to be
3966 smaller than anything else. */
3972 return tree_int_cst_compare ((tree) k1, (tree) k2);
3975 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3976 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3977 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3978 case label was declared using the usual C/C++ syntax, rather than
3979 the GNU case range extension. CASES is a tree containing all the
3980 case ranges processed so far; COND is the condition for the
3981 switch-statement itself. Returns the CASE_LABEL created, or
3982 ERROR_MARK_NODE if no CASE_LABEL is created. */
3985 c_add_case_label (cases, cond, low_value, high_value)
3994 splay_tree_node node;
3996 /* Create the LABEL_DECL itself. */
3997 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3998 DECL_CONTEXT (label) = current_function_decl;
4000 /* If there was an error processing the switch condition, bail now
4001 before we get more confused. */
4002 if (!cond || cond == error_mark_node)
4004 /* Add a label anyhow so that the back-end doesn't think that
4005 the beginning of the switch is unreachable. */
4007 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4008 return error_mark_node;
4011 if ((low_value && TREE_TYPE (low_value)
4012 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4013 || (high_value && TREE_TYPE (high_value)
4014 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4015 error ("pointers are not permitted as case values");
4017 /* Case ranges are a GNU extension. */
4018 if (high_value && pedantic)
4020 if (c_language == clk_cplusplus)
4021 pedwarn ("ISO C++ forbids range expressions in switch statements");
4023 pedwarn ("ISO C forbids range expressions in switch statements");
4026 type = TREE_TYPE (cond);
4029 low_value = check_case_value (low_value);
4030 low_value = convert_and_check (type, low_value);
4034 high_value = check_case_value (high_value);
4035 high_value = convert_and_check (type, high_value);
4038 /* If an error has occurred, bail out now. */
4039 if (low_value == error_mark_node || high_value == error_mark_node)
4042 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4043 return error_mark_node;
4046 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4047 really a case range, even though it was written that way. Remove
4048 the HIGH_VALUE to simplify later processing. */
4049 if (tree_int_cst_equal (low_value, high_value))
4050 high_value = NULL_TREE;
4051 if (low_value && high_value
4052 && !tree_int_cst_lt (low_value, high_value))
4053 warning ("empty range specified");
4055 /* Look up the LOW_VALUE in the table of case labels we already
4057 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4058 /* If there was not an exact match, check for overlapping ranges.
4059 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4060 that's a `default' label and the only overlap is an exact match. */
4061 if (!node && (low_value || high_value))
4063 splay_tree_node low_bound;
4064 splay_tree_node high_bound;
4066 /* Even though there wasn't an exact match, there might be an
4067 overlap between this case range and another case range.
4068 Since we've (inductively) not allowed any overlapping case
4069 ranges, we simply need to find the greatest low case label
4070 that is smaller that LOW_VALUE, and the smallest low case
4071 label that is greater than LOW_VALUE. If there is an overlap
4072 it will occur in one of these two ranges. */
4073 low_bound = splay_tree_predecessor (cases,
4074 (splay_tree_key) low_value);
4075 high_bound = splay_tree_successor (cases,
4076 (splay_tree_key) low_value);
4078 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4079 the LOW_VALUE, so there is no need to check unless the
4080 LOW_BOUND is in fact itself a case range. */
4082 && CASE_HIGH ((tree) low_bound->value)
4083 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4086 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4087 range is bigger than the low end of the current range, so we
4088 are only interested if the current range is a real range, and
4089 not an ordinary case label. */
4092 && (tree_int_cst_compare ((tree) high_bound->key,
4097 /* If there was an overlap, issue an error. */
4100 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
4104 error ("duplicate (or overlapping) case value");
4105 error_with_decl (duplicate,
4106 "this is the first entry overlapping that value");
4110 error ("duplicate case value") ;
4111 error_with_decl (duplicate, "previously used here");
4115 error ("multiple default labels in one switch");
4116 error_with_decl (duplicate, "this is the first default label");
4119 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4122 /* Add a CASE_LABEL to the statement-tree. */
4123 case_label = add_stmt (build_case_label (low_value, high_value, label));
4124 /* Register this case label in the splay tree. */
4125 splay_tree_insert (cases,
4126 (splay_tree_key) low_value,
4127 (splay_tree_value) case_label);
4132 /* Finish an expression taking the address of LABEL. Returns an
4133 expression for the address. */
4136 finish_label_address_expr (label)
4143 if (c_language == clk_cplusplus)
4144 pedwarn ("ISO C++ forbids taking the address of a label");
4146 pedwarn ("ISO C forbids taking the address of a label");
4149 label = lookup_label (label);
4150 if (label == NULL_TREE)
4151 result = null_pointer_node;
4154 TREE_USED (label) = 1;
4155 result = build1 (ADDR_EXPR, ptr_type_node, label);
4156 TREE_CONSTANT (result) = 1;
4157 /* The current function in not necessarily uninlinable.
4158 Computed gotos are incompatible with inlining, but the value
4159 here could be used only in a diagnostic, for example. */
4165 /* Hook used by expand_expr to expand language-specific tree codes. */
4168 c_expand_expr (exp, target, tmode, modifier)
4171 enum machine_mode tmode;
4172 int modifier; /* Actually enum_modifier. */
4174 switch (TREE_CODE (exp))
4180 bool preserve_result = false;
4181 bool return_target = false;
4183 /* Since expand_expr_stmt calls free_temp_slots after every
4184 expression statement, we must call push_temp_slots here.
4185 Otherwise, any temporaries in use now would be considered
4186 out-of-scope after the first EXPR_STMT from within the
4189 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4191 /* If we want the result of this expression, find the last
4192 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4193 if (target != const0_rtx
4194 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4195 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4197 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4198 tree last = TREE_CHAIN (expr);
4200 while (TREE_CHAIN (last))
4203 last = TREE_CHAIN (last);
4206 if (TREE_CODE (last) == SCOPE_STMT
4207 && TREE_CODE (expr) == EXPR_STMT)
4209 if (target && TREE_CODE (EXPR_STMT_EXPR (expr)) == VAR_DECL
4210 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr)) == target)
4211 /* If the last expression is a variable whose RTL is the
4212 same as our target, just return the target; if it
4213 isn't valid expanding the decl would produce different
4214 RTL, and store_expr would try to do a copy. */
4215 return_target = true;
4218 /* Otherwise, note that we want the value from the last
4220 TREE_ADDRESSABLE (expr) = 1;
4221 preserve_result = true;
4226 expand_stmt (STMT_EXPR_STMT (exp));
4227 expand_end_stmt_expr (rtl_expr);
4229 result = expand_expr (rtl_expr, target, tmode, modifier);
4232 else if (preserve_result && GET_CODE (result) == MEM)
4234 if (GET_MODE (result) != BLKmode)
4235 result = copy_to_reg (result);
4237 preserve_temp_slots (result);
4240 /* If the statment-expression does not have a scope, then the
4241 new temporaries we created within it must live beyond the
4242 statement-expression. */
4243 if (STMT_EXPR_NO_SCOPE (exp))
4244 preserve_temp_slots (NULL_RTX);
4253 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
4254 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4256 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4257 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4258 == BUILT_IN_FRONTEND))
4259 return c_expand_builtin (exp, target, tmode, modifier);
4265 case COMPOUND_LITERAL_EXPR:
4267 /* Initialize the anonymous variable declared in the compound
4268 literal, then return the variable. */
4269 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4270 emit_local_var (decl);
4271 return expand_expr (decl, target, tmode, modifier);
4282 /* Hook used by safe_from_p to handle language-specific tree codes. */
4285 c_safe_from_p (target, exp)
4289 /* We can see statements here when processing the body of a
4290 statement-expression. For a declaration statement declaring a
4291 variable, look at the variable's initializer. */
4292 if (TREE_CODE (exp) == DECL_STMT)
4294 tree decl = DECL_STMT_DECL (exp);
4296 if (TREE_CODE (decl) == VAR_DECL
4297 && DECL_INITIAL (decl)
4298 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4302 /* For any statement, we must follow the statement-chain. */
4303 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
4304 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4306 /* Assume everything else is safe. */
4310 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4313 c_common_unsafe_for_reeval (exp)
4316 /* Statement expressions may not be reevaluated, likewise compound
4318 if (TREE_CODE (exp) == STMT_EXPR
4319 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4322 /* Walk all other expressions. */
4326 /* Hook used by staticp to handle language-specific tree codes. */
4332 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4333 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4338 #define CALLED_AS_BUILT_IN(NODE) \
4339 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4342 c_expand_builtin (exp, target, tmode, modifier)
4345 enum machine_mode tmode;
4346 enum expand_modifier modifier;
4348 tree type = TREE_TYPE (exp);
4349 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4350 tree arglist = TREE_OPERAND (exp, 1);
4351 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4352 enum tree_code code = TREE_CODE (exp);
4353 const int ignore = (target == const0_rtx
4354 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4355 || code == CONVERT_EXPR || code == REFERENCE_EXPR
4356 || code == COND_EXPR)
4357 && TREE_CODE (type) == VOID_TYPE));
4359 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4360 return expand_call (exp, target, ignore);
4364 case BUILT_IN_PRINTF:
4365 target = c_expand_builtin_printf (arglist, target, tmode,
4366 modifier, ignore, /*unlocked=*/ 0);
4371 case BUILT_IN_PRINTF_UNLOCKED:
4372 target = c_expand_builtin_printf (arglist, target, tmode,
4373 modifier, ignore, /*unlocked=*/ 1);
4378 case BUILT_IN_FPRINTF:
4379 target = c_expand_builtin_fprintf (arglist, target, tmode,
4380 modifier, ignore, /*unlocked=*/ 0);
4385 case BUILT_IN_FPRINTF_UNLOCKED:
4386 target = c_expand_builtin_fprintf (arglist, target, tmode,
4387 modifier, ignore, /*unlocked=*/ 1);
4392 default: /* just do library call, if unknown builtin */
4393 error ("built-in function `%s' not currently supported",
4394 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4397 /* The switch statement above can drop through to cause the function
4398 to be called normally. */
4399 return expand_call (exp, target, ignore);
4402 /* Check an arglist to *printf for problems. The arglist should start
4403 at the format specifier, with the remaining arguments immediately
4406 is_valid_printf_arglist (arglist)
4409 /* Save this value so we can restore it later. */
4410 const int SAVE_pedantic = pedantic;
4411 int diagnostic_occurred = 0;
4414 /* Set this to a known value so the user setting won't affect code
4417 /* Check to make sure there are no format specifier errors. */
4418 attrs = tree_cons (get_identifier ("format"),
4419 tree_cons (NULL_TREE,
4420 get_identifier ("printf"),
4421 tree_cons (NULL_TREE,
4423 tree_cons (NULL_TREE,
4427 check_function_format (&diagnostic_occurred, attrs, arglist);
4429 /* Restore the value of `pedantic'. */
4430 pedantic = SAVE_pedantic;
4432 /* If calling `check_function_format_ptr' produces a warning, we
4433 return false, otherwise we return true. */
4434 return ! diagnostic_occurred;
4437 /* If the arguments passed to printf are suitable for optimizations,
4438 we attempt to transform the call. */
4440 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
4443 enum machine_mode tmode;
4444 enum expand_modifier modifier;
4448 tree fn_putchar = unlocked ?
4449 built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
4450 tree fn_puts = unlocked ?
4451 built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
4452 tree fn, format_arg, stripped_string;
4454 /* If the return value is used, or the replacement _DECL isn't
4455 initialized, don't do the transformation. */
4456 if (!ignore || !fn_putchar || !fn_puts)
4459 /* Verify the required arguments in the original call. */
4461 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4464 /* Check the specifier vs. the parameters. */
4465 if (!is_valid_printf_arglist (arglist))
4468 format_arg = TREE_VALUE (arglist);
4469 stripped_string = format_arg;
4470 STRIP_NOPS (stripped_string);
4471 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4472 stripped_string = TREE_OPERAND (stripped_string, 0);
4474 /* If the format specifier isn't a STRING_CST, punt. */
4475 if (TREE_CODE (stripped_string) != STRING_CST)
4478 /* OK! We can attempt optimization. */
4480 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4481 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4483 arglist = TREE_CHAIN (arglist);
4486 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4487 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4489 arglist = TREE_CHAIN (arglist);
4494 /* We can't handle anything else with % args or %% ... yet. */
4495 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4498 /* If the resulting constant string has a length of 1, call
4499 putchar. Note, TREE_STRING_LENGTH includes the terminating
4500 NULL in its count. */
4501 if (TREE_STRING_LENGTH (stripped_string) == 2)
4503 /* Given printf("c"), (where c is any one character,)
4504 convert "c"[0] to an int and pass that to the replacement
4506 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4507 arglist = build_tree_list (NULL_TREE, arglist);
4511 /* If the resulting constant was "string\n", call
4512 __builtin_puts("string"). Ensure "string" has at least one
4513 character besides the trailing \n. Note, TREE_STRING_LENGTH
4514 includes the terminating NULL in its count. */
4515 else if (TREE_STRING_LENGTH (stripped_string) > 2
4516 && TREE_STRING_POINTER (stripped_string)
4517 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4519 /* Create a NULL-terminated string that's one char shorter
4520 than the original, stripping off the trailing '\n'. */
4521 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4522 char *newstr = (char *) alloca (newlen);
4523 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4524 newstr[newlen - 1] = 0;
4526 arglist = fix_string_type (build_string (newlen, newstr));
4527 arglist = build_tree_list (NULL_TREE, arglist);
4531 /* We'd like to arrange to call fputs(string) here, but we
4532 need stdout and don't have a way to get it ... yet. */
4536 return expand_expr (build_function_call (fn, arglist),
4537 (ignore ? const0_rtx : target),
4541 /* If the arguments passed to fprintf are suitable for optimizations,
4542 we attempt to transform the call. */
4544 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4547 enum machine_mode tmode;
4548 enum expand_modifier modifier;
4552 tree fn_fputc = unlocked ?
4553 built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
4554 tree fn_fputs = unlocked ?
4555 built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
4556 tree fn, format_arg, stripped_string;
4558 /* If the return value is used, or the replacement _DECL isn't
4559 initialized, don't do the transformation. */
4560 if (!ignore || !fn_fputc || !fn_fputs)
4563 /* Verify the required arguments in the original call. */
4565 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4566 || (TREE_CHAIN (arglist) == 0)
4567 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4571 /* Check the specifier vs. the parameters. */
4572 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4575 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4576 stripped_string = format_arg;
4577 STRIP_NOPS (stripped_string);
4578 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4579 stripped_string = TREE_OPERAND (stripped_string, 0);
4581 /* If the format specifier isn't a STRING_CST, punt. */
4582 if (TREE_CODE (stripped_string) != STRING_CST)
4585 /* OK! We can attempt optimization. */
4587 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4588 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4590 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4591 arglist = tree_cons (NULL_TREE,
4592 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4596 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4597 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4599 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4600 arglist = tree_cons (NULL_TREE,
4601 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4607 /* We can't handle anything else with % args or %% ... yet. */
4608 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4611 /* When "string" doesn't contain %, replace all cases of
4612 fprintf(stream,string) with fputs(string,stream). The fputs
4613 builtin will take take of special cases like length==1. */
4614 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4615 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4619 return expand_expr (build_function_call (fn, arglist),
4620 (ignore ? const0_rtx : target),
4625 /* Given a boolean expression ARG, return a tree representing an increment
4626 or decrement (as indicated by CODE) of ARG. The front end must check for
4627 invalid cases (e.g., decrement in C++). */
4629 boolean_increment (code, arg)
4630 enum tree_code code;
4634 tree true_res = (c_language == clk_cplusplus
4636 : c_bool_true_node);
4637 arg = stabilize_reference (arg);
4640 case PREINCREMENT_EXPR:
4641 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4643 case POSTINCREMENT_EXPR:
4644 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4645 arg = save_expr (arg);
4646 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4647 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4649 case PREDECREMENT_EXPR:
4650 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4652 case POSTDECREMENT_EXPR:
4653 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4654 arg = save_expr (arg);
4655 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4656 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4661 TREE_SIDE_EFFECTS (val) = 1;
4665 /* Define macros necessary to describe fundamental data type formats. */
4667 cpp_define_data_format (pfile)
4671 /* Define endianness enumeration values. */
4672 cpp_define (pfile, "__GCC_LITTLE_ENDIAN__=0");
4673 cpp_define (pfile, "__GCC_BIG_ENDIAN__=1");
4675 /* Define supported floating-point format enumeration values. */
4676 cpp_define (pfile, "__UNKNOWN_FORMAT__=0");
4677 cpp_define (pfile, "__IEEE_FORMAT__=1");
4678 cpp_define (pfile, "__IBM_FORMAT__=2");
4679 cpp_define (pfile, "__C4X_FORMAT__=3");
4680 cpp_define (pfile, "__VAX_FORMAT__=4");
4682 /* Define target endianness:
4685 - word order in an integer that spans a multi-word
4686 - word order in a floating-poing that spans a multi-word */
4687 if (BITS_BIG_ENDIAN)
4688 cpp_define (pfile, "__TARGET_BITS_ORDER__=__GCC_BIG_ENDIAN__");
4690 cpp_define (pfile, "__TARGET_BITS_ORDER__=__GCC_BIG_ENDIAN__");
4691 if (BYTES_BIG_ENDIAN)
4692 cpp_define (pfile, "__TARGET_BYTES_ORDER__=__GCC_BIG_ENDIAN__");
4694 cpp_define (pfile, "__TARGET_BYTES_ORDER__=__GCC_LITTLE_ENDIAN__");
4695 /* Define words order in a multi-word integer. */
4696 if (WORDS_BIG_ENDIAN)
4697 cpp_define (pfile, "__TARGET_INT_WORDS_ORDER__=__GCC_BIG_ENDIAN__");
4699 cpp_define (pfile, "__TARGET_INT_WORDS_ORDER__=__GCC_LITTLE_ENDIAN__");
4700 /* Define words order in a multi-word floating point. */
4701 if (FLOAT_WORDS_BIG_ENDIAN)
4702 cpp_define (pfile, "__TARGET_FLOAT_WORDS_ORDER__=__GCC_BIG_ENDIAN__");
4704 cpp_define (pfile, "__TARGET_FLOAT_WORDS_ORDER__=__GCC_LITTLE_ENDIAN__");
4706 switch (TARGET_FLOAT_FORMAT)
4708 case UNKNOWN_FLOAT_FORMAT:
4709 format = "__UNKNOWN_FORMAT__";
4712 case IEEE_FLOAT_FORMAT:
4713 format = "__IEEE_FORMAT__";
4716 case VAX_FLOAT_FORMAT:
4717 format = "__VAX_FORMAT__";
4718 cpp_define (pfile, "__TARGET_USES_VAX_F_FLOAT__=1");
4719 #ifdef TARGET_G_FLOAT
4722 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=0");
4723 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=1");
4727 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=1");
4728 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=0");
4731 cpp_define (pfile, "__TARGET_USES_VAX_H_FLOAT__=1");
4734 case IBM_FLOAT_FORMAT:
4735 format = "__IBM_FORMAT__";
4738 case C4X_FLOAT_FORMAT:
4739 format = "__C4X_FORMAT__";
4745 if (TARGET_FLOAT_FORMAT != VAX_FLOAT_FORMAT)
4747 cpp_define (pfile, "__TARGET_USES_VAX_F_FLOAT__=0");
4748 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=0");
4749 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=0");
4750 cpp_define (pfile, "__TARGET_USES_VAX_H_FLOAT__=0");
4752 builtin_define_with_value ("__GCC_FLOAT_FORMAT__", format, 0);
4755 /* Hook that registers front end and target-specific built-ins. */
4757 cb_register_builtins (pfile)
4760 /* -undef turns off target-specific built-ins. */
4764 if (c_language == clk_cplusplus)
4766 if (SUPPORTS_ONE_ONLY)
4767 cpp_define (pfile, "__GXX_WEAK__=1");
4769 cpp_define (pfile, "__GXX_WEAK__=0");
4770 if (flag_exceptions)
4771 cpp_define (pfile, "__EXCEPTIONS");
4772 if (warn_deprecated)
4773 cpp_define (pfile, "__DEPRECATED");
4776 /* represents the C++ ABI version, always defined so it can be used while
4777 preprocessing C and assembler. */
4778 cpp_define (pfile, "__GXX_ABI_VERSION=102");
4780 /* libgcc needs to know this. */
4781 if (USING_SJLJ_EXCEPTIONS)
4782 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
4784 /* stddef.h needs to know these. */
4785 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4786 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4787 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4788 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4790 /* limits.h needs to know these. */
4791 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
4792 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
4793 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
4794 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
4795 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
4799 sprintf (buf, "%d", (int) TYPE_PRECISION (signed_char_type_node));
4800 builtin_define_with_value ("__CHAR_BIT__", buf, 0);
4803 /* For use in assembly language. */
4804 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
4805 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
4808 builtin_define_with_value ("__VERSION__", version_string, 1);
4810 /* Other target-independent built-ins determined by command-line
4813 cpp_define (pfile, "__OPTIMIZE_SIZE__");
4815 cpp_define (pfile, "__OPTIMIZE__");
4818 cpp_define (pfile, "__STDC_HOSTED__=1");
4820 cpp_define (pfile, "__STDC_HOSTED__=0");
4822 if (fast_math_flags_set_p ())
4823 cpp_define (pfile, "__FAST_MATH__");
4825 cpp_define (pfile, "__NO_INLINE__");
4826 if (flag_signaling_nans)
4827 cpp_define (pfile, "__SUPPORT_SNAN__");
4828 if (flag_finite_math_only)
4829 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
4831 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
4834 cpp_define (pfile, "__STRICT_ANSI__");
4836 if (!flag_signed_char)
4837 cpp_define (pfile, "__CHAR_UNSIGNED__");
4839 cpp_define_data_format (pfile);
4841 /* Make the choice of ObjC runtime visible to source code. */
4842 if (flag_objc && flag_next_runtime)
4843 cpp_define (pfile, "__NEXT_RUNTIME__");
4845 /* A straightforward target hook doesn't work, because of problems
4846 linking that hook's body when part of non-C front ends. */
4847 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
4848 # define builtin_define(TXT) cpp_define (pfile, TXT)
4849 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
4850 TARGET_CPU_CPP_BUILTINS ();
4851 TARGET_OS_CPP_BUILTINS ();
4854 /* Pass an object-like macro. If it doesn't lie in the user's
4855 namespace, defines it unconditionally. Otherwise define a version
4856 with two leading underscores, and another version with two leading
4857 and trailing underscores, and define the original only if an ISO
4858 standard was not nominated.
4860 e.g. passing "unix" defines "__unix", "__unix__" and possibly
4861 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
4864 builtin_define_std (macro)
4867 size_t len = strlen (macro);
4868 char *buff = alloca (len + 5);
4872 /* prepend __ (or maybe just _) if in user's namespace. */
4873 memcpy (p, macro, len + 1);
4874 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
4881 cpp_define (parse_in, p);
4883 /* If it was in user's namespace... */
4886 /* Define the macro with leading and following __. */
4892 cpp_define (parse_in, p);
4894 /* Finally, define the original macro if permitted. */
4896 cpp_define (parse_in, macro);
4900 /* Pass an object-like macro and a value to define it to. The third
4901 parameter says whether or not to turn the value into a string
4904 builtin_define_with_value (macro, expansion, is_str)
4906 const char *expansion;
4910 size_t mlen = strlen (macro);
4911 size_t elen = strlen (expansion);
4912 size_t extra = 2; /* space for an = and a NUL */
4915 extra += 2; /* space for two quote marks */
4917 buf = alloca (mlen + elen + extra);
4919 sprintf (buf, "%s=\"%s\"", macro, expansion);
4921 sprintf (buf, "%s=%s", macro, expansion);
4923 cpp_define (parse_in, buf);
4926 /* Define MAX for TYPE based on the precision of the type, which is assumed
4927 to be signed. IS_LONG is 1 for type "long" and 2 for "long long". */
4930 builtin_define_type_max (macro, type, is_long)
4937 size_t mlen, vlen, extra;
4939 /* Pre-rendering the values mean we don't have to futz with printing a
4940 multi-word decimal value. There are also a very limited number of
4941 precisions that we support, so it's really a waste of time. */
4942 switch (TYPE_PRECISION (type))
4951 value = "2147483647";
4954 value = "9223372036854775807";
4957 value = "170141183460469231731687303715884105727";
4963 mlen = strlen (macro);
4964 vlen = strlen (value);
4965 extra = 2 + is_long;
4966 buf = alloca (mlen + vlen + extra);
4968 sprintf (buf, "%s=%s%s", macro, value,
4969 (is_long == 1 ? "L" : is_long == 2 ? "LL" : ""));
4971 cpp_define (parse_in, buf);
4975 c_init_attributes ()
4977 /* Fill in the built_in_attributes array. */
4978 #define DEF_ATTR_NULL_TREE(ENUM) \
4979 built_in_attributes[(int) ENUM] = NULL_TREE;
4980 #define DEF_ATTR_INT(ENUM, VALUE) \
4981 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4982 #define DEF_ATTR_IDENT(ENUM, STRING) \
4983 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4984 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4985 built_in_attributes[(int) ENUM] \
4986 = tree_cons (built_in_attributes[(int) PURPOSE], \
4987 built_in_attributes[(int) VALUE], \
4988 built_in_attributes[(int) CHAIN]);
4989 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4990 #include "builtin-attrs.def"
4991 #undef DEF_ATTR_NULL_TREE
4993 #undef DEF_ATTR_IDENT
4994 #undef DEF_ATTR_TREE_LIST
4996 c_attrs_initialized = true;
4999 /* Depending on the name of DECL, apply default attributes to it. */
5002 c_common_insert_default_attributes (decl)
5005 tree name = DECL_NAME (decl);
5007 if (!c_attrs_initialized)
5008 c_init_attributes ();
5010 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
5011 #define DEF_ATTR_INT(ENUM, VALUE)
5012 #define DEF_ATTR_IDENT(ENUM, STRING)
5013 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
5014 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
5015 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
5016 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
5017 ATTR_FLAG_BUILT_IN);
5018 #include "builtin-attrs.def"
5019 #undef DEF_ATTR_NULL_TREE
5021 #undef DEF_ATTR_IDENT
5022 #undef DEF_ATTR_TREE_LIST
5026 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
5027 additionally give the location of the previous declaration DECL. */
5029 shadow_warning (msgid, name, decl)
5033 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
5034 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
5035 DECL_SOURCE_LINE (decl),
5036 "shadowed declaration is here");
5039 /* Attribute handlers common to C front ends. */
5041 /* Handle a "packed" attribute; arguments as in
5042 struct attribute_spec.handler. */
5045 handle_packed_attribute (node, name, args, flags, no_add_attrs)
5048 tree args ATTRIBUTE_UNUSED;
5055 if (TREE_CODE (*node) == TYPE_DECL)
5056 type = &TREE_TYPE (*node);
5063 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5064 *type = build_type_copy (*type);
5065 TYPE_PACKED (*type) = 1;
5067 else if (TREE_CODE (*node) == FIELD_DECL)
5068 DECL_PACKED (*node) = 1;
5069 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5070 used for DECL_REGISTER. It wouldn't mean anything anyway. */
5073 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5074 *no_add_attrs = true;
5080 /* Handle a "nocommon" attribute; arguments as in
5081 struct attribute_spec.handler. */
5084 handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
5087 tree args ATTRIBUTE_UNUSED;
5088 int flags ATTRIBUTE_UNUSED;
5091 if (TREE_CODE (*node) == VAR_DECL)
5092 DECL_COMMON (*node) = 0;
5095 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5096 *no_add_attrs = true;
5102 /* Handle a "common" attribute; arguments as in
5103 struct attribute_spec.handler. */
5106 handle_common_attribute (node, name, args, flags, no_add_attrs)
5109 tree args ATTRIBUTE_UNUSED;
5110 int flags ATTRIBUTE_UNUSED;
5113 if (TREE_CODE (*node) == VAR_DECL)
5114 DECL_COMMON (*node) = 1;
5117 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5118 *no_add_attrs = true;
5124 /* Handle a "noreturn" attribute; arguments as in
5125 struct attribute_spec.handler. */
5128 handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
5131 tree args ATTRIBUTE_UNUSED;
5132 int flags ATTRIBUTE_UNUSED;
5135 tree type = TREE_TYPE (*node);
5137 /* See FIXME comment in c_common_attribute_table. */
5138 if (TREE_CODE (*node) == FUNCTION_DECL)
5139 TREE_THIS_VOLATILE (*node) = 1;
5140 else if (TREE_CODE (type) == POINTER_TYPE
5141 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5143 = build_pointer_type
5144 (build_type_variant (TREE_TYPE (type),
5145 TREE_READONLY (TREE_TYPE (type)), 1));
5148 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5149 *no_add_attrs = true;
5155 /* Handle a "noinline" attribute; arguments as in
5156 struct attribute_spec.handler. */
5159 handle_noinline_attribute (node, name, args, flags, no_add_attrs)
5162 tree args ATTRIBUTE_UNUSED;
5163 int flags ATTRIBUTE_UNUSED;
5166 if (TREE_CODE (*node) == FUNCTION_DECL)
5167 DECL_UNINLINABLE (*node) = 1;
5170 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5171 *no_add_attrs = true;
5177 /* Handle a "always_inline" attribute; arguments as in
5178 struct attribute_spec.handler. */
5181 handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
5184 tree args ATTRIBUTE_UNUSED;
5185 int flags ATTRIBUTE_UNUSED;
5188 if (TREE_CODE (*node) == FUNCTION_DECL)
5190 /* Do nothing else, just set the attribute. We'll get at
5191 it later with lookup_attribute. */
5195 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5196 *no_add_attrs = true;
5202 /* Handle a "used" attribute; arguments as in
5203 struct attribute_spec.handler. */
5206 handle_used_attribute (node, name, args, flags, no_add_attrs)
5209 tree args ATTRIBUTE_UNUSED;
5210 int flags ATTRIBUTE_UNUSED;
5213 if (TREE_CODE (*node) == FUNCTION_DECL)
5214 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node))
5215 = TREE_USED (*node) = 1;
5218 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5219 *no_add_attrs = true;
5225 /* Handle a "unused" attribute; arguments as in
5226 struct attribute_spec.handler. */
5229 handle_unused_attribute (node, name, args, flags, no_add_attrs)
5232 tree args ATTRIBUTE_UNUSED;
5240 if (TREE_CODE (decl) == PARM_DECL
5241 || TREE_CODE (decl) == VAR_DECL
5242 || TREE_CODE (decl) == FUNCTION_DECL
5243 || TREE_CODE (decl) == LABEL_DECL
5244 || TREE_CODE (decl) == TYPE_DECL)
5245 TREE_USED (decl) = 1;
5248 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5249 *no_add_attrs = true;
5254 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5255 *node = build_type_copy (*node);
5256 TREE_USED (*node) = 1;
5262 /* Handle a "const" attribute; arguments as in
5263 struct attribute_spec.handler. */
5266 handle_const_attribute (node, name, args, flags, no_add_attrs)
5269 tree args ATTRIBUTE_UNUSED;
5270 int flags ATTRIBUTE_UNUSED;
5273 tree type = TREE_TYPE (*node);
5275 /* See FIXME comment on noreturn in c_common_attribute_table. */
5276 if (TREE_CODE (*node) == FUNCTION_DECL)
5277 TREE_READONLY (*node) = 1;
5278 else if (TREE_CODE (type) == POINTER_TYPE
5279 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5281 = build_pointer_type
5282 (build_type_variant (TREE_TYPE (type), 1,
5283 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5286 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5287 *no_add_attrs = true;
5293 /* Handle a "transparent_union" attribute; arguments as in
5294 struct attribute_spec.handler. */
5297 handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
5300 tree args ATTRIBUTE_UNUSED;
5304 tree decl = NULL_TREE;
5311 type = &TREE_TYPE (decl);
5312 is_type = TREE_CODE (*node) == TYPE_DECL;
5314 else if (TYPE_P (*node))
5315 type = node, is_type = 1;
5318 && TREE_CODE (*type) == UNION_TYPE
5320 || (TYPE_FIELDS (*type) != 0
5321 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
5323 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5324 *type = build_type_copy (*type);
5325 TYPE_TRANSPARENT_UNION (*type) = 1;
5327 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
5328 && TREE_CODE (*type) == UNION_TYPE
5329 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
5330 DECL_TRANSPARENT_UNION (decl) = 1;
5333 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5334 *no_add_attrs = true;
5340 /* Handle a "constructor" attribute; arguments as in
5341 struct attribute_spec.handler. */
5344 handle_constructor_attribute (node, name, args, flags, no_add_attrs)
5347 tree args ATTRIBUTE_UNUSED;
5348 int flags ATTRIBUTE_UNUSED;
5352 tree type = TREE_TYPE (decl);
5354 if (TREE_CODE (decl) == FUNCTION_DECL
5355 && TREE_CODE (type) == FUNCTION_TYPE
5356 && decl_function_context (decl) == 0)
5358 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5359 TREE_USED (decl) = 1;
5363 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5364 *no_add_attrs = true;
5370 /* Handle a "destructor" attribute; arguments as in
5371 struct attribute_spec.handler. */
5374 handle_destructor_attribute (node, name, args, flags, no_add_attrs)
5377 tree args ATTRIBUTE_UNUSED;
5378 int flags ATTRIBUTE_UNUSED;
5382 tree type = TREE_TYPE (decl);
5384 if (TREE_CODE (decl) == FUNCTION_DECL
5385 && TREE_CODE (type) == FUNCTION_TYPE
5386 && decl_function_context (decl) == 0)
5388 DECL_STATIC_DESTRUCTOR (decl) = 1;
5389 TREE_USED (decl) = 1;
5393 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5394 *no_add_attrs = true;
5400 /* Handle a "mode" attribute; arguments as in
5401 struct attribute_spec.handler. */
5404 handle_mode_attribute (node, name, args, flags, no_add_attrs)
5408 int flags ATTRIBUTE_UNUSED;
5413 *no_add_attrs = true;
5415 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5416 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5420 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5421 int len = strlen (p);
5422 enum machine_mode mode = VOIDmode;
5425 if (len > 4 && p[0] == '_' && p[1] == '_'
5426 && p[len - 1] == '_' && p[len - 2] == '_')
5428 char *newp = (char *) alloca (len - 1);
5430 strcpy (newp, &p[2]);
5431 newp[len - 4] = '\0';
5435 /* Change this type to have a type with the specified mode.
5436 First check for the special modes. */
5437 if (! strcmp (p, "byte"))
5439 else if (!strcmp (p, "word"))
5441 else if (! strcmp (p, "pointer"))
5444 for (j = 0; j < NUM_MACHINE_MODES; j++)
5445 if (!strcmp (p, GET_MODE_NAME (j)))
5446 mode = (enum machine_mode) j;
5448 if (mode == VOIDmode)
5449 error ("unknown machine mode `%s'", p);
5450 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
5451 (mode, TREE_UNSIGNED (type))))
5452 error ("no data type for mode `%s'", p);
5455 /* If this is a vector, make sure we either have hardware
5456 support, or we can emulate it. */
5457 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5458 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5459 && !vector_mode_valid_p (mode))
5461 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5466 /* No need to layout the type here. The caller should do this. */
5473 /* Handle a "section" attribute; arguments as in
5474 struct attribute_spec.handler. */
5477 handle_section_attribute (node, name, args, flags, no_add_attrs)
5479 tree name ATTRIBUTE_UNUSED;
5481 int flags ATTRIBUTE_UNUSED;
5486 if (targetm.have_named_sections)
5488 if ((TREE_CODE (decl) == FUNCTION_DECL
5489 || TREE_CODE (decl) == VAR_DECL)
5490 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5492 if (TREE_CODE (decl) == VAR_DECL
5493 && current_function_decl != NULL_TREE
5494 && ! TREE_STATIC (decl))
5496 error_with_decl (decl,
5497 "section attribute cannot be specified for local variables");
5498 *no_add_attrs = true;
5501 /* The decl may have already been given a section attribute
5502 from a previous declaration. Ensure they match. */
5503 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5504 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5505 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5507 error_with_decl (*node,
5508 "section of `%s' conflicts with previous declaration");
5509 *no_add_attrs = true;
5512 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5516 error_with_decl (*node,
5517 "section attribute not allowed for `%s'");
5518 *no_add_attrs = true;
5523 error_with_decl (*node,
5524 "section attributes are not supported for this target");
5525 *no_add_attrs = true;
5531 /* Handle a "aligned" attribute; arguments as in
5532 struct attribute_spec.handler. */
5535 handle_aligned_attribute (node, name, args, flags, no_add_attrs)
5537 tree name ATTRIBUTE_UNUSED;
5542 tree decl = NULL_TREE;
5545 tree align_expr = (args ? TREE_VALUE (args)
5546 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5552 type = &TREE_TYPE (decl);
5553 is_type = TREE_CODE (*node) == TYPE_DECL;
5555 else if (TYPE_P (*node))
5556 type = node, is_type = 1;
5558 /* Strip any NOPs of any kind. */
5559 while (TREE_CODE (align_expr) == NOP_EXPR
5560 || TREE_CODE (align_expr) == CONVERT_EXPR
5561 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
5562 align_expr = TREE_OPERAND (align_expr, 0);
5564 if (TREE_CODE (align_expr) != INTEGER_CST)
5566 error ("requested alignment is not a constant");
5567 *no_add_attrs = true;
5569 else if ((i = tree_log2 (align_expr)) == -1)
5571 error ("requested alignment is not a power of 2");
5572 *no_add_attrs = true;
5574 else if (i > HOST_BITS_PER_INT - 2)
5576 error ("requested alignment is too large");
5577 *no_add_attrs = true;
5581 /* If we have a TYPE_DECL, then copy the type, so that we
5582 don't accidentally modify a builtin type. See pushdecl. */
5583 if (decl && TREE_TYPE (decl) != error_mark_node
5584 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5586 tree tt = TREE_TYPE (decl);
5587 *type = build_type_copy (*type);
5588 DECL_ORIGINAL_TYPE (decl) = tt;
5589 TYPE_NAME (*type) = decl;
5590 TREE_USED (*type) = TREE_USED (decl);
5591 TREE_TYPE (decl) = *type;
5593 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5594 *type = build_type_copy (*type);
5596 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5597 TYPE_USER_ALIGN (*type) = 1;
5599 else if (TREE_CODE (decl) != VAR_DECL
5600 && TREE_CODE (decl) != FIELD_DECL)
5602 error_with_decl (decl,
5603 "alignment may not be specified for `%s'");
5604 *no_add_attrs = true;
5608 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5609 DECL_USER_ALIGN (decl) = 1;
5615 /* Handle a "weak" attribute; arguments as in
5616 struct attribute_spec.handler. */
5619 handle_weak_attribute (node, name, args, flags, no_add_attrs)
5621 tree name ATTRIBUTE_UNUSED;
5622 tree args ATTRIBUTE_UNUSED;
5623 int flags ATTRIBUTE_UNUSED;
5624 bool *no_add_attrs ATTRIBUTE_UNUSED;
5626 declare_weak (*node);
5631 /* Handle an "alias" attribute; arguments as in
5632 struct attribute_spec.handler. */
5635 handle_alias_attribute (node, name, args, flags, no_add_attrs)
5639 int flags ATTRIBUTE_UNUSED;
5644 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5645 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
5647 error_with_decl (decl,
5648 "`%s' defined both normally and as an alias");
5649 *no_add_attrs = true;
5651 else if (decl_function_context (decl) == 0)
5655 id = TREE_VALUE (args);
5656 if (TREE_CODE (id) != STRING_CST)
5658 error ("alias arg not a string");
5659 *no_add_attrs = true;
5662 id = get_identifier (TREE_STRING_POINTER (id));
5663 /* This counts as a use of the object pointed to. */
5666 if (TREE_CODE (decl) == FUNCTION_DECL)
5667 DECL_INITIAL (decl) = error_mark_node;
5669 DECL_EXTERNAL (decl) = 0;
5673 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5674 *no_add_attrs = true;
5680 /* Handle an "visibility" attribute; arguments as in
5681 struct attribute_spec.handler. */
5684 handle_visibility_attribute (node, name, args, flags, no_add_attrs)
5688 int flags ATTRIBUTE_UNUSED;
5693 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
5695 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5696 *no_add_attrs = true;
5702 id = TREE_VALUE (args);
5703 if (TREE_CODE (id) != STRING_CST)
5705 error ("visibility arg not a string");
5706 *no_add_attrs = true;
5709 if (strcmp (TREE_STRING_POINTER (id), "hidden")
5710 && strcmp (TREE_STRING_POINTER (id), "protected")
5711 && strcmp (TREE_STRING_POINTER (id), "internal"))
5713 error ("visibility arg must be one of \"hidden\", \"protected\" or \"internal\"");
5714 *no_add_attrs = true;
5722 /* Handle a "no_instrument_function" attribute; arguments as in
5723 struct attribute_spec.handler. */
5726 handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
5729 tree args ATTRIBUTE_UNUSED;
5730 int flags ATTRIBUTE_UNUSED;
5735 if (TREE_CODE (decl) != FUNCTION_DECL)
5737 error_with_decl (decl,
5738 "`%s' attribute applies only to functions",
5739 IDENTIFIER_POINTER (name));
5740 *no_add_attrs = true;
5742 else if (DECL_INITIAL (decl))
5744 error_with_decl (decl,
5745 "can't set `%s' attribute after definition",
5746 IDENTIFIER_POINTER (name));
5747 *no_add_attrs = true;
5750 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5755 /* Handle a "malloc" attribute; arguments as in
5756 struct attribute_spec.handler. */
5759 handle_malloc_attribute (node, name, args, flags, no_add_attrs)
5762 tree args ATTRIBUTE_UNUSED;
5763 int flags ATTRIBUTE_UNUSED;
5766 if (TREE_CODE (*node) == FUNCTION_DECL)
5767 DECL_IS_MALLOC (*node) = 1;
5768 /* ??? TODO: Support types. */
5771 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5772 *no_add_attrs = true;
5778 /* Handle a "no_limit_stack" attribute; arguments as in
5779 struct attribute_spec.handler. */
5782 handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
5785 tree args ATTRIBUTE_UNUSED;
5786 int flags ATTRIBUTE_UNUSED;
5791 if (TREE_CODE (decl) != FUNCTION_DECL)
5793 error_with_decl (decl,
5794 "`%s' attribute applies only to functions",
5795 IDENTIFIER_POINTER (name));
5796 *no_add_attrs = true;
5798 else if (DECL_INITIAL (decl))
5800 error_with_decl (decl,
5801 "can't set `%s' attribute after definition",
5802 IDENTIFIER_POINTER (name));
5803 *no_add_attrs = true;
5806 DECL_NO_LIMIT_STACK (decl) = 1;
5811 /* Handle a "pure" attribute; arguments as in
5812 struct attribute_spec.handler. */
5815 handle_pure_attribute (node, name, args, flags, no_add_attrs)
5818 tree args ATTRIBUTE_UNUSED;
5819 int flags ATTRIBUTE_UNUSED;
5822 if (TREE_CODE (*node) == FUNCTION_DECL)
5823 DECL_IS_PURE (*node) = 1;
5824 /* ??? TODO: Support types. */
5827 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5828 *no_add_attrs = true;
5834 /* Handle a "deprecated" attribute; arguments as in
5835 struct attribute_spec.handler. */
5838 handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
5841 tree args ATTRIBUTE_UNUSED;
5845 tree type = NULL_TREE;
5847 const char *what = NULL;
5852 type = TREE_TYPE (decl);
5854 if (TREE_CODE (decl) == TYPE_DECL
5855 || TREE_CODE (decl) == PARM_DECL
5856 || TREE_CODE (decl) == VAR_DECL
5857 || TREE_CODE (decl) == FUNCTION_DECL
5858 || TREE_CODE (decl) == FIELD_DECL)
5859 TREE_DEPRECATED (decl) = 1;
5863 else if (TYPE_P (*node))
5865 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5866 *node = build_type_copy (*node);
5867 TREE_DEPRECATED (*node) = 1;
5875 *no_add_attrs = true;
5876 if (type && TYPE_NAME (type))
5878 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5879 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5880 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5881 && DECL_NAME (TYPE_NAME (type)))
5882 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5885 warning ("`%s' attribute ignored for `%s'",
5886 IDENTIFIER_POINTER (name), what);
5888 warning ("`%s' attribute ignored",
5889 IDENTIFIER_POINTER (name));
5895 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5896 to prevent us from duplicating type nodes unnecessarily.
5897 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5898 since we want to distinguish types that are essentially identical (except
5899 for their debug representation), we use a local list here. */
5900 static tree vector_type_node_list = 0;
5902 /* Handle a "vector_size" attribute; arguments as in
5903 struct attribute_spec.handler. */
5906 handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
5910 int flags ATTRIBUTE_UNUSED;
5913 unsigned HOST_WIDE_INT vecsize, nunits;
5914 enum machine_mode mode, orig_mode, new_mode;
5915 tree type = *node, new_type = NULL_TREE;
5916 tree type_list_node;
5918 *no_add_attrs = true;
5920 if (! host_integerp (TREE_VALUE (args), 1))
5922 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5926 /* Get the vector size (in bytes). */
5927 vecsize = tree_low_cst (TREE_VALUE (args), 1);
5929 /* We need to provide for vector pointers, vector arrays, and
5930 functions returning vectors. For example:
5932 __attribute__((vector_size(16))) short *foo;
5934 In this case, the mode is SI, but the type being modified is
5935 HI, so we need to look further. */
5937 while (POINTER_TYPE_P (type)
5938 || TREE_CODE (type) == FUNCTION_TYPE
5939 || TREE_CODE (type) == ARRAY_TYPE)
5940 type = TREE_TYPE (type);
5942 /* Get the mode of the type being modified. */
5943 orig_mode = TYPE_MODE (type);
5945 if (TREE_CODE (type) == RECORD_TYPE
5946 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5947 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5948 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5950 error ("invalid vector type for attribute `%s'",
5951 IDENTIFIER_POINTER (name));
5955 /* Calculate how many units fit in the vector. */
5956 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5958 /* Find a suitably sized vector. */
5959 new_mode = VOIDmode;
5960 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5962 : MODE_VECTOR_FLOAT);
5964 mode = GET_MODE_WIDER_MODE (mode))
5965 if (vecsize == GET_MODE_SIZE (mode)
5966 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
5972 if (new_mode == VOIDmode)
5974 error ("no vector mode with the size and type specified could be found");
5978 for (type_list_node = vector_type_node_list; type_list_node;
5979 type_list_node = TREE_CHAIN (type_list_node))
5981 tree other_type = TREE_VALUE (type_list_node);
5982 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
5983 tree fields = TYPE_FIELDS (record);
5984 tree field_type = TREE_TYPE (fields);
5985 tree array_type = TREE_TYPE (field_type);
5986 if (TREE_CODE (fields) != FIELD_DECL
5987 || TREE_CODE (field_type) != ARRAY_TYPE)
5990 if (TYPE_MODE (other_type) == mode && type == array_type)
5992 new_type = other_type;
5997 if (new_type == NULL_TREE)
5999 tree index, array, rt, list_node;
6001 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
6002 TREE_UNSIGNED (type));
6006 error ("no vector mode with the size and type specified could be found");
6010 new_type = build_type_copy (new_type);
6012 /* If this is a vector, make sure we either have hardware
6013 support, or we can emulate it. */
6014 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
6015 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
6016 && !vector_mode_valid_p (mode))
6018 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
6022 /* Set the debug information here, because this is the only
6023 place where we know the underlying type for a vector made
6024 with vector_size. For debugging purposes we pretend a vector
6025 is an array within a structure. */
6026 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
6027 array = build_array_type (type, build_index_type (index));
6028 rt = make_node (RECORD_TYPE);
6030 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
6031 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
6033 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
6035 list_node = build_tree_list (NULL, new_type);
6036 TREE_CHAIN (list_node) = vector_type_node_list;
6037 vector_type_node_list = list_node;
6040 /* Build back pointers if needed. */
6041 *node = vector_size_helper (*node, new_type);
6046 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
6049 If we requested a pointer to a vector, build up the pointers that
6050 we stripped off while looking for the inner type. Similarly for
6051 return values from functions.
6053 The argument "type" is the top of the chain, and "bottom" is the
6054 new type which we will point to. */
6057 vector_size_helper (type, bottom)
6062 if (POINTER_TYPE_P (type))
6064 inner = vector_size_helper (TREE_TYPE (type), bottom);
6065 outer = build_pointer_type (inner);
6067 else if (TREE_CODE (type) == ARRAY_TYPE)
6069 inner = vector_size_helper (TREE_TYPE (type), bottom);
6070 outer = build_array_type (inner, TYPE_VALUES (type));
6072 else if (TREE_CODE (type) == FUNCTION_TYPE)
6074 inner = vector_size_helper (TREE_TYPE (type), bottom);
6075 outer = build_function_type (inner, TYPE_VALUES (type));
6080 TREE_READONLY (outer) = TREE_READONLY (type);
6081 TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
6086 /* Handle the "nonnull" attribute. */
6088 handle_nonnull_attribute (node, name, args, flags, no_add_attrs)
6090 tree name ATTRIBUTE_UNUSED;
6092 int flags ATTRIBUTE_UNUSED;
6096 unsigned HOST_WIDE_INT attr_arg_num;
6098 /* If no arguments are specified, all pointer arguments should be
6099 non-null. Veryify a full prototype is given so that the arguments
6100 will have the correct types when we actually check them later. */
6103 if (! TYPE_ARG_TYPES (type))
6105 error ("nonnull attribute without arguments on a non-prototype");
6106 *no_add_attrs = true;
6111 /* Argument list specified. Verify that each argument number references
6112 a pointer argument. */
6113 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6116 unsigned HOST_WIDE_INT arg_num, ck_num;
6118 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6120 error ("nonnull argument has invalid operand number (arg %lu)",
6121 (unsigned long) attr_arg_num);
6122 *no_add_attrs = true;
6126 argument = TYPE_ARG_TYPES (type);
6129 for (ck_num = 1; ; ck_num++)
6131 if (! argument || ck_num == arg_num)
6133 argument = TREE_CHAIN (argument);
6137 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6139 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
6140 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6141 *no_add_attrs = true;
6145 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6147 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
6148 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6149 *no_add_attrs = true;
6158 /* Check the argument list of a function call for null in argument slots
6159 that are marked as requiring a non-null pointer argument. */
6162 check_function_nonnull (attrs, params)
6166 tree a, args, param;
6169 for (a = attrs; a; a = TREE_CHAIN (a))
6171 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6173 args = TREE_VALUE (a);
6175 /* Walk the argument list. If we encounter an argument number we
6176 should check for non-null, do it. If the attribute has no args,
6177 then every pointer argument is checked (in which case the check
6178 for pointer type is done in check_nonnull_arg). */
6179 for (param = params, param_num = 1; ;
6180 param_num++, param = TREE_CHAIN (param))
6184 if (! args || nonnull_check_p (args, param_num))
6185 check_function_arguments_recurse (check_nonnull_arg, NULL,
6193 /* Helper for check_function_nonnull; given a list of operands which
6194 must be non-null in ARGS, determine if operand PARAM_NUM should be
6198 nonnull_check_p (args, param_num)
6200 unsigned HOST_WIDE_INT param_num;
6202 unsigned HOST_WIDE_INT arg_num;
6204 for (; args; args = TREE_CHAIN (args))
6206 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6209 if (arg_num == param_num)
6215 /* Check that the function argument PARAM (which is operand number
6216 PARAM_NUM) is non-null. This is called by check_function_nonnull
6217 via check_function_arguments_recurse. */
6220 check_nonnull_arg (ctx, param, param_num)
6221 void *ctx ATTRIBUTE_UNUSED;
6223 unsigned HOST_WIDE_INT param_num;
6225 /* Just skip checking the argument if it's not a pointer. This can
6226 happen if the "nonnull" attribute was given without an operand
6227 list (which means to check every pointer argument). */
6229 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6232 if (integer_zerop (param))
6233 warning ("null argument where non-null required (arg %lu)",
6234 (unsigned long) param_num);
6237 /* Helper for nonnull attribute handling; fetch the operand number
6238 from the attribute argument list. */
6241 get_nonnull_operand (arg_num_expr, valp)
6243 unsigned HOST_WIDE_INT *valp;
6245 /* Strip any conversions from the arg number and verify they
6247 while (TREE_CODE (arg_num_expr) == NOP_EXPR
6248 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
6249 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
6250 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
6252 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6253 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6256 *valp = TREE_INT_CST_LOW (arg_num_expr);
6260 /* Handle a "nothrow" attribute; arguments as in
6261 struct attribute_spec.handler. */
6264 handle_nothrow_attribute (node, name, args, flags, no_add_attrs)
6267 tree args ATTRIBUTE_UNUSED;
6268 int flags ATTRIBUTE_UNUSED;
6271 if (TREE_CODE (*node) == FUNCTION_DECL)
6272 TREE_NOTHROW (*node) = 1;
6273 /* ??? TODO: Support types. */
6276 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6277 *no_add_attrs = true;
6283 /* Check for valid arguments being passed to a function. */
6285 check_function_arguments (attrs, params)
6289 /* Check for null being passed in a pointer argument that must be
6290 non-null. We also need to do this if format checking is enabled. */
6293 check_function_nonnull (attrs, params);
6295 /* Check for errors in format strings. */
6298 check_function_format (NULL, attrs, params);
6301 /* Generic argument checking recursion routine. PARAM is the argument to
6302 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6303 once the argument is resolved. CTX is context for the callback. */
6305 check_function_arguments_recurse (callback, ctx, param, param_num)
6306 void (*callback) PARAMS ((void *, tree, unsigned HOST_WIDE_INT));
6309 unsigned HOST_WIDE_INT param_num;
6311 if (TREE_CODE (param) == NOP_EXPR)
6313 /* Strip coercion. */
6314 check_function_arguments_recurse (callback, ctx,
6315 TREE_OPERAND (param, 0), param_num);
6319 if (TREE_CODE (param) == CALL_EXPR)
6321 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
6323 bool found_format_arg = false;
6325 /* See if this is a call to a known internationalization function
6326 that modifies a format arg. Such a function may have multiple
6327 format_arg attributes (for example, ngettext). */
6329 for (attrs = TYPE_ATTRIBUTES (type);
6331 attrs = TREE_CHAIN (attrs))
6332 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6335 tree format_num_expr;
6339 /* Extract the argument number, which was previously checked
6341 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6342 while (TREE_CODE (format_num_expr) == NOP_EXPR
6343 || TREE_CODE (format_num_expr) == CONVERT_EXPR
6344 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
6345 format_num_expr = TREE_OPERAND (format_num_expr, 0);
6347 if (TREE_CODE (format_num_expr) != INTEGER_CST
6348 || TREE_INT_CST_HIGH (format_num_expr) != 0)
6351 format_num = TREE_INT_CST_LOW (format_num_expr);
6353 for (inner_args = TREE_OPERAND (param, 1), i = 1;
6355 inner_args = TREE_CHAIN (inner_args), i++)
6356 if (i == format_num)
6358 check_function_arguments_recurse (callback, ctx,
6359 TREE_VALUE (inner_args),
6361 found_format_arg = true;
6366 /* If we found a format_arg attribute and did a recursive check,
6367 we are done with checking this argument. Otherwise, we continue
6368 and this will be considered a non-literal. */
6369 if (found_format_arg)
6373 if (TREE_CODE (param) == COND_EXPR)
6375 /* Check both halves of the conditional expression. */
6376 check_function_arguments_recurse (callback, ctx,
6377 TREE_OPERAND (param, 1), param_num);
6378 check_function_arguments_recurse (callback, ctx,
6379 TREE_OPERAND (param, 2), param_num);
6383 (*callback) (ctx, param, param_num);
6386 #include "gt-c-common.h"