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. Performs the check on the whole selector
442 table at the end of compilation. */
446 /* Warn if a @selector() is found, and no method with that selector
447 has been previously declared. The check is done on each
448 @selector() as soon as it is found - so it warns about forward
451 int warn_undeclared_selector;
453 /* Warn if methods required by a protocol are not implemented in the
454 class adopting it. When turned off, methods inherited to that
455 class are also considered implemented. */
457 int warn_protocol = 1;
460 /* C++ language option variables. */
463 /* Nonzero means don't recognize any extension keywords. */
465 int flag_no_gnu_keywords;
467 /* Nonzero means do emit exported implementations of functions even if
468 they can be inlined. */
470 int flag_implement_inlines = 1;
472 /* Nonzero means do emit exported implementations of templates, instead of
473 multiple static copies in each file that needs a definition. */
475 int flag_external_templates;
477 /* Nonzero means that the decision to emit or not emit the implementation of a
478 template depends on where the template is instantiated, rather than where
481 int flag_alt_external_templates;
483 /* Nonzero means that implicit instantiations will be emitted if needed. */
485 int flag_implicit_templates = 1;
487 /* Nonzero means that implicit instantiations of inline templates will be
488 emitted if needed, even if instantiations of non-inline templates
491 int flag_implicit_inline_templates = 1;
493 /* Nonzero means generate separate instantiation control files and
494 juggle them at link time. */
496 int flag_use_repository;
498 /* Nonzero if we want to issue diagnostics that the standard says are not
501 int flag_optional_diags = 1;
503 /* Nonzero means we should attempt to elide constructors when possible. */
505 int flag_elide_constructors = 1;
507 /* Nonzero means that member functions defined in class scope are
508 inline by default. */
510 int flag_default_inline = 1;
512 /* Controls whether compiler generates 'type descriptor' that give
513 run-time type information. */
517 /* Nonzero if we want to conserve space in the .o files. We do this
518 by putting uninitialized data and runtime initialized data into
519 .common instead of .data at the expense of not flagging multiple
522 int flag_conserve_space;
524 /* Nonzero if we want to obey access control semantics. */
526 int flag_access_control = 1;
528 /* Nonzero if we want to check the return value of new and avoid calling
529 constructors if it is a null pointer. */
533 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
534 initialization variables.
535 0: Old rules, set by -fno-for-scope.
536 2: New ISO rules, set by -ffor-scope.
537 1: Try to implement new ISO rules, but with backup compatibility
538 (and warnings). This is the default, for now. */
540 int flag_new_for_scope = 1;
542 /* Nonzero if we want to emit defined symbols with common-like linkage as
543 weak symbols where possible, in order to conform to C++ semantics.
544 Otherwise, emit them as local symbols. */
548 /* Nonzero to use __cxa_atexit, rather than atexit, to register
549 destructors for local statics and global objects. */
551 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
553 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
557 /* Nonzero means make the default pedwarns warnings instead of errors.
558 The value of this flag is ignored if -pedantic is specified. */
562 /* Nonzero means to implement standard semantics for exception
563 specifications, calling unexpected if an exception is thrown that
564 doesn't match the specification. Zero means to treat them as
565 assertions and optimize accordingly, but not check them. */
567 int flag_enforce_eh_specs = 1;
569 /* Nonzero means warn about things that will change when compiling
570 with an ABI-compliant compiler. */
574 /* Nonzero means warn about implicit declarations. */
576 int warn_implicit = 1;
578 /* Nonzero means warn when all ctors or dtors are private, and the class
581 int warn_ctor_dtor_privacy = 1;
583 /* Non-zero means warn in function declared in derived class has the
584 same name as a virtual in the base class, but fails to match the
585 type signature of any virtual function in the base class. */
587 int warn_overloaded_virtual;
589 /* Non-zero means warn when declaring a class that has a non virtual
590 destructor, when it really ought to have a virtual one. */
594 /* Non-zero means warn when the compiler will reorder code. */
598 /* Non-zero means warn when synthesis behavior differs from Cfront's. */
602 /* Non-zero means warn when we convert a pointer to member function
603 into a pointer to (void or function). */
605 int warn_pmf2ptr = 1;
607 /* Nonzero means warn about violation of some Effective C++ style rules. */
611 /* Nonzero means warn where overload resolution chooses a promotion from
612 unsigned to signed over a conversion to an unsigned of the same size. */
616 /* Nonzero means warn when an old-style cast is used. */
618 int warn_old_style_cast;
620 /* Nonzero means warn when non-templatized friend functions are
621 declared within a template */
623 int warn_nontemplate_friend = 1;
625 /* Nonzero means complain about deprecated features. */
627 int warn_deprecated = 1;
629 /* Maximum template instantiation depth. This limit is rather
630 arbitrary, but it exists to limit the time it takes to notice
631 infinite template instantiations. */
633 int max_tinst_depth = 500;
637 /* The elements of `ridpointers' are identifier nodes for the reserved
638 type names and storage classes. It is indexed by a RID_... value. */
641 tree (*make_fname_decl) PARAMS ((tree, int));
643 /* If non-NULL, the address of a language-specific function that
644 returns 1 for language-specific statement codes. */
645 int (*lang_statement_code_p) PARAMS ((enum tree_code));
647 /* If non-NULL, the address of a language-specific function that takes
648 any action required right before expand_function_end is called. */
649 void (*lang_expand_function_end) PARAMS ((void));
651 /* Nonzero means the expression being parsed will never be evaluated.
652 This is a count, since unevaluated expressions can nest. */
655 /* Information about how a function name is generated. */
658 tree *const decl; /* pointer to the VAR_DECL. */
659 const unsigned rid; /* RID number for the identifier. */
660 const int pretty; /* How pretty is it? */
663 /* The three ways of getting then name of the current function. */
665 const struct fname_var_t fname_vars[] =
667 /* C99 compliant __func__, must be first. */
668 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
669 /* GCC __FUNCTION__ compliant. */
670 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
671 /* GCC __PRETTY_FUNCTION__ compliant. */
672 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
676 static int constant_fits_type_p PARAMS ((tree, tree));
678 /* Keep a stack of if statements. We record the number of compound
679 statements seen up to the if keyword, as well as the line number
680 and file of the if. If a potentially ambiguous else is seen, that
681 fact is recorded; the warning is issued when we can be sure that
682 the enclosing if statement does not have an else branch. */
692 static if_elt *if_stack;
694 /* Amount of space in the if statement stack. */
695 static int if_stack_space = 0;
698 static int if_stack_pointer = 0;
700 static tree handle_packed_attribute PARAMS ((tree *, tree, tree, int,
702 static tree handle_nocommon_attribute PARAMS ((tree *, tree, tree, int,
704 static tree handle_common_attribute PARAMS ((tree *, tree, tree, int,
706 static tree handle_noreturn_attribute PARAMS ((tree *, tree, tree, int,
708 static tree handle_noinline_attribute PARAMS ((tree *, tree, tree, int,
710 static tree handle_always_inline_attribute PARAMS ((tree *, tree, tree, int,
712 static tree handle_used_attribute PARAMS ((tree *, tree, tree, int,
714 static tree handle_unused_attribute PARAMS ((tree *, tree, tree, int,
716 static tree handle_const_attribute PARAMS ((tree *, tree, tree, int,
718 static tree handle_transparent_union_attribute PARAMS ((tree *, tree, tree,
720 static tree handle_constructor_attribute PARAMS ((tree *, tree, tree, int,
722 static tree handle_destructor_attribute PARAMS ((tree *, tree, tree, int,
724 static tree handle_mode_attribute PARAMS ((tree *, tree, tree, int,
726 static tree handle_section_attribute PARAMS ((tree *, tree, tree, int,
728 static tree handle_aligned_attribute PARAMS ((tree *, tree, tree, int,
730 static tree handle_weak_attribute PARAMS ((tree *, tree, tree, int,
732 static tree handle_alias_attribute PARAMS ((tree *, tree, tree, int,
734 static tree handle_visibility_attribute PARAMS ((tree *, tree, tree, int,
736 static tree handle_no_instrument_function_attribute PARAMS ((tree *, tree,
739 static tree handle_malloc_attribute PARAMS ((tree *, tree, tree, int,
741 static tree handle_no_limit_stack_attribute PARAMS ((tree *, tree, tree, int,
743 static tree handle_pure_attribute PARAMS ((tree *, tree, tree, int,
745 static tree handle_deprecated_attribute PARAMS ((tree *, tree, tree, int,
747 static tree handle_vector_size_attribute PARAMS ((tree *, tree, tree, int,
749 static tree handle_nonnull_attribute PARAMS ((tree *, tree, tree, int,
751 static tree handle_nothrow_attribute PARAMS ((tree *, tree, tree, int,
753 static tree vector_size_helper PARAMS ((tree, tree));
755 static void check_function_nonnull PARAMS ((tree, tree));
756 static void check_nonnull_arg PARAMS ((void *, tree,
757 unsigned HOST_WIDE_INT));
758 static bool nonnull_check_p PARAMS ((tree, unsigned HOST_WIDE_INT));
759 static bool get_nonnull_operand PARAMS ((tree,
760 unsigned HOST_WIDE_INT *));
761 void builtin_define_std PARAMS ((const char *));
762 static void builtin_define_with_value PARAMS ((const char *, const char *,
764 static void builtin_define_type_max PARAMS ((const char *, tree, int));
765 static void cpp_define_data_format PARAMS ((cpp_reader *));
766 static void builtin_define_type_precision PARAMS ((const char *, tree));
768 /* Table of machine-independent attributes common to all C-like languages. */
769 const struct attribute_spec c_common_attribute_table[] =
771 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
772 { "packed", 0, 0, false, false, false,
773 handle_packed_attribute },
774 { "nocommon", 0, 0, true, false, false,
775 handle_nocommon_attribute },
776 { "common", 0, 0, true, false, false,
777 handle_common_attribute },
778 /* FIXME: logically, noreturn attributes should be listed as
779 "false, true, true" and apply to function types. But implementing this
780 would require all the places in the compiler that use TREE_THIS_VOLATILE
781 on a decl to identify non-returning functions to be located and fixed
782 to check the function type instead. */
783 { "noreturn", 0, 0, true, false, false,
784 handle_noreturn_attribute },
785 { "volatile", 0, 0, true, false, false,
786 handle_noreturn_attribute },
787 { "noinline", 0, 0, true, false, false,
788 handle_noinline_attribute },
789 { "always_inline", 0, 0, true, false, false,
790 handle_always_inline_attribute },
791 { "used", 0, 0, true, false, false,
792 handle_used_attribute },
793 { "unused", 0, 0, false, false, false,
794 handle_unused_attribute },
795 /* The same comments as for noreturn attributes apply to const ones. */
796 { "const", 0, 0, true, false, false,
797 handle_const_attribute },
798 { "transparent_union", 0, 0, false, false, false,
799 handle_transparent_union_attribute },
800 { "constructor", 0, 0, true, false, false,
801 handle_constructor_attribute },
802 { "destructor", 0, 0, true, false, false,
803 handle_destructor_attribute },
804 { "mode", 1, 1, false, true, false,
805 handle_mode_attribute },
806 { "section", 1, 1, true, false, false,
807 handle_section_attribute },
808 { "aligned", 0, 1, false, false, false,
809 handle_aligned_attribute },
810 { "weak", 0, 0, true, false, false,
811 handle_weak_attribute },
812 { "alias", 1, 1, true, false, false,
813 handle_alias_attribute },
814 { "no_instrument_function", 0, 0, true, false, false,
815 handle_no_instrument_function_attribute },
816 { "malloc", 0, 0, true, false, false,
817 handle_malloc_attribute },
818 { "no_stack_limit", 0, 0, true, false, false,
819 handle_no_limit_stack_attribute },
820 { "pure", 0, 0, true, false, false,
821 handle_pure_attribute },
822 { "deprecated", 0, 0, false, false, false,
823 handle_deprecated_attribute },
824 { "vector_size", 1, 1, false, true, false,
825 handle_vector_size_attribute },
826 { "visibility", 1, 1, true, false, false,
827 handle_visibility_attribute },
828 { "nonnull", 0, -1, false, true, true,
829 handle_nonnull_attribute },
830 { "nothrow", 0, 0, true, false, false,
831 handle_nothrow_attribute },
832 { "may_alias", 0, 0, false, true, false, NULL },
833 { NULL, 0, 0, false, false, false, NULL }
836 /* Give the specifications for the format attributes, used by C and all
839 const struct attribute_spec c_common_format_attribute_table[] =
841 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
842 { "format", 3, 3, false, true, true,
843 handle_format_attribute },
844 { "format_arg", 1, 1, false, true, true,
845 handle_format_arg_attribute },
846 { NULL, 0, 0, false, false, false, NULL }
849 /* Record the start of an if-then, and record the start of it
850 for ambiguous else detection.
852 COND is the condition for the if-then statement.
854 IF_STMT is the statement node that has already been created for
855 this if-then statement. It is created before parsing the
856 condition to keep line number information accurate. */
859 c_expand_start_cond (cond, compstmt_count, if_stmt)
864 /* Make sure there is enough space on the stack. */
865 if (if_stack_space == 0)
868 if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
870 else if (if_stack_space == if_stack_pointer)
872 if_stack_space += 10;
873 if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
876 IF_COND (if_stmt) = cond;
879 /* Record this if statement. */
880 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
881 if_stack[if_stack_pointer].file = input_filename;
882 if_stack[if_stack_pointer].line = lineno;
883 if_stack[if_stack_pointer].needs_warning = 0;
884 if_stack[if_stack_pointer].if_stmt = if_stmt;
888 /* Called after the then-clause for an if-statement is processed. */
893 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
894 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
897 /* Record the end of an if-then. Optionally warn if a nested
898 if statement had an ambiguous else clause. */
904 if (if_stack[if_stack_pointer].needs_warning)
905 warning_with_file_and_line (if_stack[if_stack_pointer].file,
906 if_stack[if_stack_pointer].line,
907 "suggest explicit braces to avoid ambiguous `else'");
908 last_expr_type = NULL_TREE;
911 /* Called between the then-clause and the else-clause
912 of an if-then-else. */
915 c_expand_start_else ()
917 /* An ambiguous else warning must be generated for the enclosing if
918 statement, unless we see an else branch for that one, too. */
920 && if_stack_pointer > 1
921 && (if_stack[if_stack_pointer - 1].compstmt_count
922 == if_stack[if_stack_pointer - 2].compstmt_count))
923 if_stack[if_stack_pointer - 2].needs_warning = 1;
925 /* Even if a nested if statement had an else branch, it can't be
926 ambiguous if this one also has an else. So don't warn in that
927 case. Also don't warn for any if statements nested in this else. */
928 if_stack[if_stack_pointer - 1].needs_warning = 0;
929 if_stack[if_stack_pointer - 1].compstmt_count--;
932 /* Called after the else-clause for an if-statement is processed. */
937 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
938 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
941 /* Begin an if-statement. Returns a newly created IF_STMT if
944 Unlike the C++ front-end, we do not call add_stmt here; it is
945 probably safe to do so, but I am not very familiar with this
946 code so I am being extra careful not to change its behavior
947 beyond what is strictly necessary for correctness. */
953 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
957 /* Begin a while statement. Returns a newly created WHILE_STMT if
960 Unlike the C++ front-end, we do not call add_stmt here; it is
961 probably safe to do so, but I am not very familiar with this
962 code so I am being extra careful not to change its behavior
963 beyond what is strictly necessary for correctness. */
966 c_begin_while_stmt ()
969 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
974 c_finish_while_stmt_cond (cond, while_stmt)
978 WHILE_COND (while_stmt) = cond;
981 /* Push current bindings for the function name VAR_DECLS. */
987 tree saved = NULL_TREE;
989 for (ix = 0; fname_vars[ix].decl; ix++)
991 tree decl = *fname_vars[ix].decl;
995 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
996 *fname_vars[ix].decl = NULL_TREE;
999 if (saved || saved_function_name_decls)
1000 /* Normally they'll have been NULL, so only push if we've got a
1001 stack, or they are non-NULL. */
1002 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1003 saved_function_name_decls);
1006 /* Finish up the current bindings, adding them into the
1007 current function's statement tree. This is done by wrapping the
1008 function's body in a COMPOUND_STMT containing these decls too. This
1009 must be done _before_ finish_stmt_tree is called. If there is no
1010 current function, we must be at file scope and no statements are
1011 involved. Pop the previous bindings. */
1014 finish_fname_decls ()
1017 tree body = NULL_TREE;
1018 tree stack = saved_function_name_decls;
1020 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1021 body = chainon (TREE_VALUE (stack), body);
1025 /* They were called into existence, so add to statement tree. */
1026 body = chainon (body,
1027 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
1028 body = build_stmt (COMPOUND_STMT, body);
1030 COMPOUND_STMT_NO_SCOPE (body) = 1;
1031 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
1034 for (ix = 0; fname_vars[ix].decl; ix++)
1035 *fname_vars[ix].decl = NULL_TREE;
1039 /* We had saved values, restore them. */
1042 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1044 tree decl = TREE_PURPOSE (saved);
1045 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1047 *fname_vars[ix].decl = decl;
1049 stack = TREE_CHAIN (stack);
1051 saved_function_name_decls = stack;
1054 /* Return the text name of the current function, suitable prettified
1058 fname_as_string (pretty_p)
1061 const char *name = NULL;
1064 name = (current_function_decl
1065 ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
1067 else if (current_function_decl && DECL_NAME (current_function_decl))
1068 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
1074 /* Return the text name of the current function, formatted as
1075 required by the supplied RID value. */
1083 for (ix = 0; fname_vars[ix].decl; ix++)
1084 if (fname_vars[ix].rid == rid)
1086 return fname_as_string (fname_vars[ix].pretty);
1089 /* Return the VAR_DECL for a const char array naming the current
1090 function. If the VAR_DECL has not yet been created, create it
1091 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1092 ID is its name (unfortunately C and C++ hold the RID values of
1093 keywords in different places, so we can't derive RID from ID in
1094 this language independent code. */
1097 fname_decl (rid, id)
1102 tree decl = NULL_TREE;
1104 for (ix = 0; fname_vars[ix].decl; ix++)
1105 if (fname_vars[ix].rid == rid)
1108 decl = *fname_vars[ix].decl;
1111 tree saved_last_tree = last_tree;
1112 /* If a tree is built here, it would normally have the lineno of
1113 the current statement. Later this tree will be moved to the
1114 beginning of the function and this line number will be wrong.
1115 To avoid this problem set the lineno to 0 here; that prevents
1116 it from appearing in the RTL. */
1117 int saved_lineno = lineno;
1120 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1121 if (last_tree != saved_last_tree)
1123 /* We created some statement tree for the decl. This belongs
1124 at the start of the function, so remove it now and reinsert
1125 it after the function is complete. */
1126 tree stmts = TREE_CHAIN (saved_last_tree);
1128 TREE_CHAIN (saved_last_tree) = NULL_TREE;
1129 last_tree = saved_last_tree;
1130 saved_function_name_decls = tree_cons (decl, stmts,
1131 saved_function_name_decls);
1133 *fname_vars[ix].decl = decl;
1134 lineno = saved_lineno;
1136 if (!ix && !current_function_decl)
1137 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
1142 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1145 fix_string_type (value)
1148 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1149 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1150 const int nchars_max = flag_isoc99 ? 4095 : 509;
1151 int length = TREE_STRING_LENGTH (value);
1154 /* Compute the number of elements, for the array type. */
1155 nchars = wide_flag ? length / wchar_bytes : length;
1157 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
1158 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1159 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1161 /* Create the array type for the string constant.
1162 -Wwrite-strings says make the string constant an array of const char
1163 so that copying it to a non-const pointer will get a warning.
1164 For C++, this is the standard behavior. */
1165 if (flag_const_strings && ! flag_writable_strings)
1168 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1171 = build_array_type (elements,
1172 build_index_type (build_int_2 (nchars - 1, 0)));
1176 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1177 build_index_type (build_int_2 (nchars - 1, 0)));
1179 TREE_CONSTANT (value) = 1;
1180 TREE_READONLY (value) = ! flag_writable_strings;
1181 TREE_STATIC (value) = 1;
1185 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1189 combine_strings (strings)
1190 varray_type strings;
1192 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1193 const int nstrings = VARRAY_ACTIVE_SIZE (strings);
1196 int wide_length = 0;
1201 /* Don't include the \0 at the end of each substring. Count wide
1202 strings and ordinary strings separately. */
1203 for (i = 0; i < nstrings; ++i)
1205 t = VARRAY_TREE (strings, i);
1207 if (TREE_TYPE (t) == wchar_array_type_node)
1209 wide_length += TREE_STRING_LENGTH (t) - wchar_bytes;
1214 length += (TREE_STRING_LENGTH (t) - 1);
1215 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
1216 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1220 /* If anything is wide, the non-wides will be converted,
1221 which makes them take more space. */
1223 length = length * wchar_bytes + wide_length;
1225 p = xmalloc (length);
1227 /* Copy the individual strings into the new combined string.
1228 If the combined string is wide, convert the chars to ints
1229 for any individual strings that are not wide. */
1232 for (i = 0; i < nstrings; ++i)
1236 t = VARRAY_TREE (strings, i);
1237 this_wide = TREE_TYPE (t) == wchar_array_type_node;
1238 len = TREE_STRING_LENGTH (t) - (this_wide ? wchar_bytes : 1);
1239 if (this_wide == wide_flag)
1241 memcpy (q, TREE_STRING_POINTER (t), len);
1246 const int nzeros = (TYPE_PRECISION (wchar_type_node)
1247 / BITS_PER_UNIT) - 1;
1250 if (BYTES_BIG_ENDIAN)
1252 for (k = 0; k < len; k++)
1254 for (j = 0; j < nzeros; j++)
1256 *q++ = TREE_STRING_POINTER (t)[k];
1261 for (k = 0; k < len; k++)
1263 *q++ = TREE_STRING_POINTER (t)[k];
1264 for (j = 0; j < nzeros; j++)
1271 /* Nul terminate the string. */
1274 for (i = 0; i < wchar_bytes; i++)
1280 value = build_string (length, p);
1284 TREE_TYPE (value) = wchar_array_type_node;
1286 TREE_TYPE (value) = char_array_type_node;
1291 static int is_valid_printf_arglist PARAMS ((tree));
1292 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1293 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1294 enum expand_modifier, int, int));
1295 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
1296 enum expand_modifier, int, int));
1298 /* Print a warning if a constant expression had overflow in folding.
1299 Invoke this function on every expression that the language
1300 requires to be a constant expression.
1301 Note the ANSI C standard says it is erroneous for a
1302 constant expression to overflow. */
1305 constant_expression_warning (value)
1308 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1309 || TREE_CODE (value) == VECTOR_CST
1310 || TREE_CODE (value) == COMPLEX_CST)
1311 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1312 pedwarn ("overflow in constant expression");
1315 /* Print a warning if an expression had overflow in folding.
1316 Invoke this function on every expression that
1317 (1) appears in the source code, and
1318 (2) might be a constant expression that overflowed, and
1319 (3) is not already checked by convert_and_check;
1320 however, do not invoke this function on operands of explicit casts. */
1323 overflow_warning (value)
1326 if ((TREE_CODE (value) == INTEGER_CST
1327 || (TREE_CODE (value) == COMPLEX_CST
1328 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1329 && TREE_OVERFLOW (value))
1331 TREE_OVERFLOW (value) = 0;
1332 if (skip_evaluation == 0)
1333 warning ("integer overflow in expression");
1335 else if ((TREE_CODE (value) == REAL_CST
1336 || (TREE_CODE (value) == COMPLEX_CST
1337 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1338 && TREE_OVERFLOW (value))
1340 TREE_OVERFLOW (value) = 0;
1341 if (skip_evaluation == 0)
1342 warning ("floating point overflow in expression");
1344 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1346 TREE_OVERFLOW (value) = 0;
1347 if (skip_evaluation == 0)
1348 warning ("vector overflow in expression");
1352 /* Print a warning if a large constant is truncated to unsigned,
1353 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1354 Invoke this function on every expression that might be implicitly
1355 converted to an unsigned type. */
1358 unsigned_conversion_warning (result, operand)
1359 tree result, operand;
1361 tree type = TREE_TYPE (result);
1363 if (TREE_CODE (operand) == INTEGER_CST
1364 && TREE_CODE (type) == INTEGER_TYPE
1365 && TREE_UNSIGNED (type)
1366 && skip_evaluation == 0
1367 && !int_fits_type_p (operand, type))
1369 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1370 /* This detects cases like converting -129 or 256 to unsigned char. */
1371 warning ("large integer implicitly truncated to unsigned type");
1372 else if (warn_conversion)
1373 warning ("negative integer implicitly converted to unsigned type");
1377 /* Nonzero if constant C has a value that is permissible
1378 for type TYPE (an INTEGER_TYPE). */
1381 constant_fits_type_p (c, type)
1384 if (TREE_CODE (c) == INTEGER_CST)
1385 return int_fits_type_p (c, type);
1387 c = convert (type, c);
1388 return !TREE_OVERFLOW (c);
1391 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1392 Invoke this function on every expression that is converted implicitly,
1393 i.e. because of language rules and not because of an explicit cast. */
1396 convert_and_check (type, expr)
1399 tree t = convert (type, expr);
1400 if (TREE_CODE (t) == INTEGER_CST)
1402 if (TREE_OVERFLOW (t))
1404 TREE_OVERFLOW (t) = 0;
1406 /* Do not diagnose overflow in a constant expression merely
1407 because a conversion overflowed. */
1408 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1410 /* No warning for converting 0x80000000 to int. */
1411 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1412 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1413 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1414 /* If EXPR fits in the unsigned version of TYPE,
1415 don't warn unless pedantic. */
1417 || TREE_UNSIGNED (type)
1418 || ! constant_fits_type_p (expr,
1419 c_common_unsigned_type (type)))
1420 && skip_evaluation == 0)
1421 warning ("overflow in implicit constant conversion");
1424 unsigned_conversion_warning (t, expr);
1429 /* A node in a list that describes references to variables (EXPR), which are
1430 either read accesses if WRITER is zero, or write accesses, in which case
1431 WRITER is the parent of EXPR. */
1438 /* Used to implement a cache the results of a call to verify_tree. We only
1439 use this for SAVE_EXPRs. */
1442 struct tlist_cache *next;
1443 struct tlist *cache_before_sp;
1444 struct tlist *cache_after_sp;
1448 /* Obstack to use when allocating tlist structures, and corresponding
1450 static struct obstack tlist_obstack;
1451 static char *tlist_firstobj = 0;
1453 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1455 static struct tlist *warned_ids;
1456 /* SAVE_EXPRs need special treatment. We process them only once and then
1457 cache the results. */
1458 static struct tlist_cache *save_expr_cache;
1460 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1461 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1462 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1463 static int warning_candidate_p PARAMS ((tree));
1464 static void warn_for_collisions PARAMS ((struct tlist *));
1465 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1466 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1467 static void verify_sequence_points PARAMS ((tree));
1469 /* Create a new struct tlist and fill in its fields. */
1470 static struct tlist *
1471 new_tlist (next, t, writer)
1477 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1484 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1485 is nonnull, we ignore any node we find which has a writer equal to it. */
1488 add_tlist (to, add, exclude_writer, copy)
1491 tree exclude_writer;
1496 struct tlist *next = add->next;
1499 if (! exclude_writer || add->writer != exclude_writer)
1500 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1505 /* Merge the nodes of ADD into TO. This merging process is done so that for
1506 each variable that already exists in TO, no new node is added; however if
1507 there is a write access recorded in ADD, and an occurrence on TO is only
1508 a read access, then the occurrence in TO will be modified to record the
1512 merge_tlist (to, add, copy)
1517 struct tlist **end = to;
1520 end = &(*end)->next;
1526 struct tlist *next = add->next;
1528 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1529 if (tmp2->expr == add->expr)
1533 tmp2->writer = add->writer;
1537 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1538 end = &(*end)->next;
1545 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1546 references in list LIST conflict with it, excluding reads if ONLY writers
1550 warn_for_collisions_1 (written, writer, list, only_writes)
1551 tree written, writer;
1557 /* Avoid duplicate warnings. */
1558 for (tmp = warned_ids; tmp; tmp = tmp->next)
1559 if (tmp->expr == written)
1564 if (list->expr == written
1565 && list->writer != writer
1566 && (! only_writes || list->writer))
1568 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1569 warning ("operation on `%s' may be undefined",
1570 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1576 /* Given a list LIST of references to variables, find whether any of these
1577 can cause conflicts due to missing sequence points. */
1580 warn_for_collisions (list)
1585 for (tmp = list; tmp; tmp = tmp->next)
1588 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1592 /* Return nonzero if X is a tree that can be verified by the sequence point
1595 warning_candidate_p (x)
1598 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1601 /* Walk the tree X, and record accesses to variables. If X is written by the
1602 parent tree, WRITER is the parent.
1603 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1604 expression or its only operand forces a sequence point, then everything up
1605 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1607 Once we return, we will have emitted warnings if any subexpression before
1608 such a sequence point could be undefined. On a higher level, however, the
1609 sequence point may not be relevant, and we'll merge the two lists.
1611 Example: (b++, a) + b;
1612 The call that processes the COMPOUND_EXPR will store the increment of B
1613 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1614 processes the PLUS_EXPR will need to merge the two lists so that
1615 eventually, all accesses end up on the same list (and we'll warn about the
1616 unordered subexpressions b++ and b.
1618 A note on merging. If we modify the former example so that our expression
1621 care must be taken not simply to add all three expressions into the final
1622 PNO_SP list. The function merge_tlist takes care of that by merging the
1623 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1624 way, so that no more than one access to B is recorded. */
1627 verify_tree (x, pbefore_sp, pno_sp, writer)
1629 struct tlist **pbefore_sp, **pno_sp;
1632 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1633 enum tree_code code;
1636 /* X may be NULL if it is the operand of an empty statement expression
1642 code = TREE_CODE (x);
1643 class = TREE_CODE_CLASS (code);
1645 if (warning_candidate_p (x))
1647 *pno_sp = new_tlist (*pno_sp, x, writer);
1657 case TRUTH_ANDIF_EXPR:
1658 case TRUTH_ORIF_EXPR:
1659 tmp_before = tmp_nosp = tmp_list3 = 0;
1660 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1661 warn_for_collisions (tmp_nosp);
1662 merge_tlist (pbefore_sp, tmp_before, 0);
1663 merge_tlist (pbefore_sp, tmp_nosp, 0);
1664 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1665 merge_tlist (pbefore_sp, tmp_list3, 0);
1669 tmp_before = tmp_list2 = 0;
1670 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1671 warn_for_collisions (tmp_list2);
1672 merge_tlist (pbefore_sp, tmp_before, 0);
1673 merge_tlist (pbefore_sp, tmp_list2, 1);
1675 tmp_list3 = tmp_nosp = 0;
1676 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1677 warn_for_collisions (tmp_nosp);
1678 merge_tlist (pbefore_sp, tmp_list3, 0);
1680 tmp_list3 = tmp_list2 = 0;
1681 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1682 warn_for_collisions (tmp_list2);
1683 merge_tlist (pbefore_sp, tmp_list3, 0);
1684 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1685 two first, to avoid warning for (a ? b++ : b++). */
1686 merge_tlist (&tmp_nosp, tmp_list2, 0);
1687 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1690 case PREDECREMENT_EXPR:
1691 case PREINCREMENT_EXPR:
1692 case POSTDECREMENT_EXPR:
1693 case POSTINCREMENT_EXPR:
1694 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1698 tmp_before = tmp_nosp = tmp_list3 = 0;
1699 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1700 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1701 /* Expressions inside the LHS are not ordered wrt. the sequence points
1702 in the RHS. Example:
1704 Despite the fact that the modification of "a" is in the before_sp
1705 list (tmp_before), it conflicts with the use of "a" in the LHS.
1706 We can handle this by adding the contents of tmp_list3
1707 to those of tmp_before, and redoing the collision warnings for that
1709 add_tlist (&tmp_before, tmp_list3, x, 1);
1710 warn_for_collisions (tmp_before);
1711 /* Exclude the LHS itself here; we first have to merge it into the
1712 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1713 didn't exclude the LHS, we'd get it twice, once as a read and once
1715 add_tlist (pno_sp, tmp_list3, x, 0);
1716 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1718 merge_tlist (pbefore_sp, tmp_before, 0);
1719 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1720 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1721 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1725 /* We need to warn about conflicts among arguments and conflicts between
1726 args and the function address. Side effects of the function address,
1727 however, are not ordered by the sequence point of the call. */
1728 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1729 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1730 if (TREE_OPERAND (x, 1))
1731 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1732 merge_tlist (&tmp_list3, tmp_list2, 0);
1733 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1734 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1735 warn_for_collisions (tmp_before);
1736 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1740 /* Scan all the list, e.g. indices of multi dimensional array. */
1743 tmp_before = tmp_nosp = 0;
1744 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1745 merge_tlist (&tmp_nosp, tmp_before, 0);
1746 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1753 struct tlist_cache *t;
1754 for (t = save_expr_cache; t; t = t->next)
1760 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1762 t->next = save_expr_cache;
1764 save_expr_cache = t;
1766 tmp_before = tmp_nosp = 0;
1767 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1768 warn_for_collisions (tmp_nosp);
1773 struct tlist *t = tmp_nosp;
1775 merge_tlist (&tmp_list3, t, 0);
1777 t->cache_before_sp = tmp_before;
1778 t->cache_after_sp = tmp_list3;
1780 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1781 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1790 if (first_rtl_op (code) == 0)
1792 x = TREE_OPERAND (x, 0);
1808 int max = first_rtl_op (TREE_CODE (x));
1809 for (lp = 0; lp < max; lp++)
1811 tmp_before = tmp_nosp = 0;
1812 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1813 merge_tlist (&tmp_nosp, tmp_before, 0);
1814 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1821 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1825 verify_sequence_points (expr)
1828 struct tlist *before_sp = 0, *after_sp = 0;
1831 save_expr_cache = 0;
1832 if (tlist_firstobj == 0)
1834 gcc_obstack_init (&tlist_obstack);
1835 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1838 verify_tree (expr, &before_sp, &after_sp, 0);
1839 warn_for_collisions (after_sp);
1840 obstack_free (&tlist_obstack, tlist_firstobj);
1844 c_expand_expr_stmt (expr)
1847 /* Do default conversion if safe and possibly important,
1848 in case within ({...}). */
1849 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1850 && (flag_isoc99 || lvalue_p (expr)))
1851 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1852 expr = default_conversion (expr);
1854 if (warn_sequence_point)
1855 verify_sequence_points (expr);
1857 if (TREE_TYPE (expr) != error_mark_node
1858 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1859 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1860 error ("expression statement has incomplete type");
1862 last_expr_type = TREE_TYPE (expr);
1863 return add_stmt (build_stmt (EXPR_STMT, expr));
1866 /* Validate the expression after `case' and apply default promotions. */
1869 check_case_value (value)
1872 if (value == NULL_TREE)
1875 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1876 STRIP_TYPE_NOPS (value);
1877 /* In C++, the following is allowed:
1880 switch (...) { case i: ... }
1882 So, we try to reduce the VALUE to a constant that way. */
1883 if (c_language == clk_cplusplus)
1885 value = decl_constant_value (value);
1886 STRIP_TYPE_NOPS (value);
1887 value = fold (value);
1890 if (TREE_CODE (value) != INTEGER_CST
1891 && value != error_mark_node)
1893 error ("case label does not reduce to an integer constant");
1894 value = error_mark_node;
1897 /* Promote char or short to int. */
1898 value = default_conversion (value);
1900 constant_expression_warning (value);
1905 /* Return an integer type with BITS bits of precision,
1906 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1909 c_common_type_for_size (bits, unsignedp)
1913 if (bits == TYPE_PRECISION (integer_type_node))
1914 return unsignedp ? unsigned_type_node : integer_type_node;
1916 if (bits == TYPE_PRECISION (signed_char_type_node))
1917 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1919 if (bits == TYPE_PRECISION (short_integer_type_node))
1920 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1922 if (bits == TYPE_PRECISION (long_integer_type_node))
1923 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1925 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1926 return (unsignedp ? long_long_unsigned_type_node
1927 : long_long_integer_type_node);
1929 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1930 return (unsignedp ? widest_unsigned_literal_type_node
1931 : widest_integer_literal_type_node);
1933 if (bits <= TYPE_PRECISION (intQI_type_node))
1934 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1936 if (bits <= TYPE_PRECISION (intHI_type_node))
1937 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1939 if (bits <= TYPE_PRECISION (intSI_type_node))
1940 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1942 if (bits <= TYPE_PRECISION (intDI_type_node))
1943 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1948 /* Return a data type that has machine mode MODE.
1949 If the mode is an integer,
1950 then UNSIGNEDP selects between signed and unsigned types. */
1953 c_common_type_for_mode (mode, unsignedp)
1954 enum machine_mode mode;
1957 if (mode == TYPE_MODE (integer_type_node))
1958 return unsignedp ? unsigned_type_node : integer_type_node;
1960 if (mode == TYPE_MODE (signed_char_type_node))
1961 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1963 if (mode == TYPE_MODE (short_integer_type_node))
1964 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1966 if (mode == TYPE_MODE (long_integer_type_node))
1967 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1969 if (mode == TYPE_MODE (long_long_integer_type_node))
1970 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1972 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1973 return unsignedp ? widest_unsigned_literal_type_node
1974 : widest_integer_literal_type_node;
1977 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1980 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1983 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1986 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1988 #if HOST_BITS_PER_WIDE_INT >= 64
1989 if (mode == TYPE_MODE (intTI_type_node))
1990 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1993 if (mode == TYPE_MODE (float_type_node))
1994 return float_type_node;
1996 if (mode == TYPE_MODE (double_type_node))
1997 return double_type_node;
1999 if (mode == TYPE_MODE (long_double_type_node))
2000 return long_double_type_node;
2002 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2003 return build_pointer_type (char_type_node);
2005 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2006 return build_pointer_type (integer_type_node);
2011 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
2013 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
2015 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
2017 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
2019 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
2021 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
2023 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
2025 return V16SF_type_node;
2027 return V4SF_type_node;
2029 return V2SF_type_node;
2031 return V2DF_type_node;
2039 /* Return an unsigned type the same as TYPE in other respects. */
2041 c_common_unsigned_type (type)
2044 tree type1 = TYPE_MAIN_VARIANT (type);
2045 if (type1 == signed_char_type_node || type1 == char_type_node)
2046 return unsigned_char_type_node;
2047 if (type1 == integer_type_node)
2048 return unsigned_type_node;
2049 if (type1 == short_integer_type_node)
2050 return short_unsigned_type_node;
2051 if (type1 == long_integer_type_node)
2052 return long_unsigned_type_node;
2053 if (type1 == long_long_integer_type_node)
2054 return long_long_unsigned_type_node;
2055 if (type1 == widest_integer_literal_type_node)
2056 return widest_unsigned_literal_type_node;
2057 #if HOST_BITS_PER_WIDE_INT >= 64
2058 if (type1 == intTI_type_node)
2059 return unsigned_intTI_type_node;
2061 if (type1 == intDI_type_node)
2062 return unsigned_intDI_type_node;
2063 if (type1 == intSI_type_node)
2064 return unsigned_intSI_type_node;
2065 if (type1 == intHI_type_node)
2066 return unsigned_intHI_type_node;
2067 if (type1 == intQI_type_node)
2068 return unsigned_intQI_type_node;
2070 return c_common_signed_or_unsigned_type (1, type);
2073 /* Return a signed type the same as TYPE in other respects. */
2076 c_common_signed_type (type)
2079 tree type1 = TYPE_MAIN_VARIANT (type);
2080 if (type1 == unsigned_char_type_node || type1 == char_type_node)
2081 return signed_char_type_node;
2082 if (type1 == unsigned_type_node)
2083 return integer_type_node;
2084 if (type1 == short_unsigned_type_node)
2085 return short_integer_type_node;
2086 if (type1 == long_unsigned_type_node)
2087 return long_integer_type_node;
2088 if (type1 == long_long_unsigned_type_node)
2089 return long_long_integer_type_node;
2090 if (type1 == widest_unsigned_literal_type_node)
2091 return widest_integer_literal_type_node;
2092 #if HOST_BITS_PER_WIDE_INT >= 64
2093 if (type1 == unsigned_intTI_type_node)
2094 return intTI_type_node;
2096 if (type1 == unsigned_intDI_type_node)
2097 return intDI_type_node;
2098 if (type1 == unsigned_intSI_type_node)
2099 return intSI_type_node;
2100 if (type1 == unsigned_intHI_type_node)
2101 return intHI_type_node;
2102 if (type1 == unsigned_intQI_type_node)
2103 return intQI_type_node;
2105 return c_common_signed_or_unsigned_type (0, type);
2108 /* Return a type the same as TYPE except unsigned or
2109 signed according to UNSIGNEDP. */
2112 c_common_signed_or_unsigned_type (unsignedp, type)
2116 if (! INTEGRAL_TYPE_P (type)
2117 || TREE_UNSIGNED (type) == unsignedp)
2120 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2121 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2122 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2123 return unsignedp ? unsigned_type_node : integer_type_node;
2124 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2125 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2126 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2127 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2128 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2129 return (unsignedp ? long_long_unsigned_type_node
2130 : long_long_integer_type_node);
2131 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2132 return (unsignedp ? widest_unsigned_literal_type_node
2133 : widest_integer_literal_type_node);
2135 #if HOST_BITS_PER_WIDE_INT >= 64
2136 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
2137 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2139 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
2140 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2141 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
2142 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2143 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
2144 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2145 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
2146 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2151 /* Return the minimum number of bits needed to represent VALUE in a
2152 signed or unsigned type, UNSIGNEDP says which. */
2155 min_precision (value, unsignedp)
2161 /* If the value is negative, compute its negative minus 1. The latter
2162 adjustment is because the absolute value of the largest negative value
2163 is one larger than the largest positive value. This is equivalent to
2164 a bit-wise negation, so use that operation instead. */
2166 if (tree_int_cst_sgn (value) < 0)
2167 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2169 /* Return the number of bits needed, taking into account the fact
2170 that we need one more bit for a signed than unsigned type. */
2172 if (integer_zerop (value))
2175 log = tree_floor_log2 (value);
2177 return log + 1 + ! unsignedp;
2180 /* Print an error message for invalid operands to arith operation
2181 CODE. NOP_EXPR is used as a special case (see
2182 c_common_truthvalue_conversion). */
2185 binary_op_error (code)
2186 enum tree_code code;
2193 error ("invalid truth-value expression");
2197 opname = "+"; break;
2199 opname = "-"; break;
2201 opname = "*"; break;
2203 opname = "max"; break;
2205 opname = "min"; break;
2207 opname = "=="; break;
2209 opname = "!="; break;
2211 opname = "<="; break;
2213 opname = ">="; break;
2215 opname = "<"; break;
2217 opname = ">"; break;
2219 opname = "<<"; break;
2221 opname = ">>"; break;
2222 case TRUNC_MOD_EXPR:
2223 case FLOOR_MOD_EXPR:
2224 opname = "%"; break;
2225 case TRUNC_DIV_EXPR:
2226 case FLOOR_DIV_EXPR:
2227 opname = "/"; break;
2229 opname = "&"; break;
2231 opname = "|"; break;
2232 case TRUTH_ANDIF_EXPR:
2233 opname = "&&"; break;
2234 case TRUTH_ORIF_EXPR:
2235 opname = "||"; break;
2237 opname = "^"; break;
2240 opname = "rotate"; break;
2242 opname = "unknown"; break;
2244 error ("invalid operands to binary %s", opname);
2247 /* Subroutine of build_binary_op, used for comparison operations.
2248 See if the operands have both been converted from subword integer types
2249 and, if so, perhaps change them both back to their original type.
2250 This function is also responsible for converting the two operands
2251 to the proper common type for comparison.
2253 The arguments of this function are all pointers to local variables
2254 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2255 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2257 If this function returns nonzero, it means that the comparison has
2258 a constant value. What this function returns is an expression for
2262 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2263 tree *op0_ptr, *op1_ptr;
2265 enum tree_code *rescode_ptr;
2268 tree op0 = *op0_ptr;
2269 tree op1 = *op1_ptr;
2270 int unsignedp0, unsignedp1;
2272 tree primop0, primop1;
2273 enum tree_code code = *rescode_ptr;
2275 /* Throw away any conversions to wider types
2276 already present in the operands. */
2278 primop0 = get_narrower (op0, &unsignedp0);
2279 primop1 = get_narrower (op1, &unsignedp1);
2281 /* Handle the case that OP0 does not *contain* a conversion
2282 but it *requires* conversion to FINAL_TYPE. */
2284 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2285 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2286 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2287 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2289 /* If one of the operands must be floated, we cannot optimize. */
2290 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2291 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2293 /* If first arg is constant, swap the args (changing operation
2294 so value is preserved), for canonicalization. Don't do this if
2295 the second arg is 0. */
2297 if (TREE_CONSTANT (primop0)
2298 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2301 int temi = unsignedp0;
2309 unsignedp0 = unsignedp1;
2332 *rescode_ptr = code;
2335 /* If comparing an integer against a constant more bits wide,
2336 maybe we can deduce a value of 1 or 0 independent of the data.
2337 Or else truncate the constant now
2338 rather than extend the variable at run time.
2340 This is only interesting if the constant is the wider arg.
2341 Also, it is not safe if the constant is unsigned and the
2342 variable arg is signed, since in this case the variable
2343 would be sign-extended and then regarded as unsigned.
2344 Our technique fails in this case because the lowest/highest
2345 possible unsigned results don't follow naturally from the
2346 lowest/highest possible values of the variable operand.
2347 For just EQ_EXPR and NE_EXPR there is another technique that
2348 could be used: see if the constant can be faithfully represented
2349 in the other operand's type, by truncating it and reextending it
2350 and see if that preserves the constant's value. */
2352 if (!real1 && !real2
2353 && TREE_CODE (primop1) == INTEGER_CST
2354 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2356 int min_gt, max_gt, min_lt, max_lt;
2357 tree maxval, minval;
2358 /* 1 if comparison is nominally unsigned. */
2359 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2362 type = c_common_signed_or_unsigned_type (unsignedp0,
2363 TREE_TYPE (primop0));
2365 /* If TYPE is an enumeration, then we need to get its min/max
2366 values from it's underlying integral type, not the enumerated
2368 if (TREE_CODE (type) == ENUMERAL_TYPE)
2369 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2371 maxval = TYPE_MAX_VALUE (type);
2372 minval = TYPE_MIN_VALUE (type);
2374 if (unsignedp && !unsignedp0)
2375 *restype_ptr = c_common_signed_type (*restype_ptr);
2377 if (TREE_TYPE (primop1) != *restype_ptr)
2378 primop1 = convert (*restype_ptr, primop1);
2379 if (type != *restype_ptr)
2381 minval = convert (*restype_ptr, minval);
2382 maxval = convert (*restype_ptr, maxval);
2385 if (unsignedp && unsignedp0)
2387 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2388 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2389 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2390 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2394 min_gt = INT_CST_LT (primop1, minval);
2395 max_gt = INT_CST_LT (primop1, maxval);
2396 min_lt = INT_CST_LT (minval, primop1);
2397 max_lt = INT_CST_LT (maxval, primop1);
2401 /* This used to be a switch, but Genix compiler can't handle that. */
2402 if (code == NE_EXPR)
2404 if (max_lt || min_gt)
2405 val = boolean_true_node;
2407 else if (code == EQ_EXPR)
2409 if (max_lt || min_gt)
2410 val = boolean_false_node;
2412 else if (code == LT_EXPR)
2415 val = boolean_true_node;
2417 val = boolean_false_node;
2419 else if (code == GT_EXPR)
2422 val = boolean_true_node;
2424 val = boolean_false_node;
2426 else if (code == LE_EXPR)
2429 val = boolean_true_node;
2431 val = boolean_false_node;
2433 else if (code == GE_EXPR)
2436 val = boolean_true_node;
2438 val = boolean_false_node;
2441 /* If primop0 was sign-extended and unsigned comparison specd,
2442 we did a signed comparison above using the signed type bounds.
2443 But the comparison we output must be unsigned.
2445 Also, for inequalities, VAL is no good; but if the signed
2446 comparison had *any* fixed result, it follows that the
2447 unsigned comparison just tests the sign in reverse
2448 (positive values are LE, negative ones GE).
2449 So we can generate an unsigned comparison
2450 against an extreme value of the signed type. */
2452 if (unsignedp && !unsignedp0)
2459 primop1 = TYPE_MIN_VALUE (type);
2465 primop1 = TYPE_MAX_VALUE (type);
2472 type = c_common_unsigned_type (type);
2475 if (TREE_CODE (primop0) != INTEGER_CST)
2477 if (val == boolean_false_node)
2478 warning ("comparison is always false due to limited range of data type");
2479 if (val == boolean_true_node)
2480 warning ("comparison is always true due to limited range of data type");
2485 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2486 if (TREE_SIDE_EFFECTS (primop0))
2487 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2491 /* Value is not predetermined, but do the comparison
2492 in the type of the operand that is not constant.
2493 TYPE is already properly set. */
2495 else if (real1 && real2
2496 && (TYPE_PRECISION (TREE_TYPE (primop0))
2497 == TYPE_PRECISION (TREE_TYPE (primop1))))
2498 type = TREE_TYPE (primop0);
2500 /* If args' natural types are both narrower than nominal type
2501 and both extend in the same manner, compare them
2502 in the type of the wider arg.
2503 Otherwise must actually extend both to the nominal
2504 common type lest different ways of extending
2506 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2508 else if (unsignedp0 == unsignedp1 && real1 == real2
2509 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2510 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2512 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2513 type = c_common_signed_or_unsigned_type (unsignedp0
2514 || TREE_UNSIGNED (*restype_ptr),
2516 /* Make sure shorter operand is extended the right way
2517 to match the longer operand. */
2519 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2520 TREE_TYPE (primop0)),
2523 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2524 TREE_TYPE (primop1)),
2529 /* Here we must do the comparison on the nominal type
2530 using the args exactly as we received them. */
2531 type = *restype_ptr;
2535 if (!real1 && !real2 && integer_zerop (primop1)
2536 && TREE_UNSIGNED (*restype_ptr))
2542 /* All unsigned values are >= 0, so we warn if extra warnings
2543 are requested. However, if OP0 is a constant that is
2544 >= 0, the signedness of the comparison isn't an issue,
2545 so suppress the warning. */
2546 if (extra_warnings && !in_system_header
2547 && ! (TREE_CODE (primop0) == INTEGER_CST
2548 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2550 warning ("comparison of unsigned expression >= 0 is always true");
2551 value = boolean_true_node;
2555 if (extra_warnings && !in_system_header
2556 && ! (TREE_CODE (primop0) == INTEGER_CST
2557 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2559 warning ("comparison of unsigned expression < 0 is always false");
2560 value = boolean_false_node;
2569 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2570 if (TREE_SIDE_EFFECTS (primop0))
2571 return build (COMPOUND_EXPR, TREE_TYPE (value),
2578 *op0_ptr = convert (type, primop0);
2579 *op1_ptr = convert (type, primop1);
2581 *restype_ptr = boolean_type_node;
2586 /* Return a tree for the sum or difference (RESULTCODE says which)
2587 of pointer PTROP and integer INTOP. */
2590 pointer_int_sum (resultcode, ptrop, intop)
2591 enum tree_code resultcode;
2599 /* The result is a pointer of the same type that is being added. */
2601 tree result_type = TREE_TYPE (ptrop);
2603 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2605 if (pedantic || warn_pointer_arith)
2606 pedwarn ("pointer of type `void *' used in arithmetic");
2607 size_exp = integer_one_node;
2609 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2611 if (pedantic || warn_pointer_arith)
2612 pedwarn ("pointer to a function used in arithmetic");
2613 size_exp = integer_one_node;
2615 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2617 if (pedantic || warn_pointer_arith)
2618 pedwarn ("pointer to member function used in arithmetic");
2619 size_exp = integer_one_node;
2621 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2623 if (pedantic || warn_pointer_arith)
2624 pedwarn ("pointer to a member used in arithmetic");
2625 size_exp = integer_one_node;
2628 size_exp = size_in_bytes (TREE_TYPE (result_type));
2630 /* If what we are about to multiply by the size of the elements
2631 contains a constant term, apply distributive law
2632 and multiply that constant term separately.
2633 This helps produce common subexpressions. */
2635 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2636 && ! TREE_CONSTANT (intop)
2637 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2638 && TREE_CONSTANT (size_exp)
2639 /* If the constant comes from pointer subtraction,
2640 skip this optimization--it would cause an error. */
2641 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2642 /* If the constant is unsigned, and smaller than the pointer size,
2643 then we must skip this optimization. This is because it could cause
2644 an overflow error if the constant is negative but INTOP is not. */
2645 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2646 || (TYPE_PRECISION (TREE_TYPE (intop))
2647 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2649 enum tree_code subcode = resultcode;
2650 tree int_type = TREE_TYPE (intop);
2651 if (TREE_CODE (intop) == MINUS_EXPR)
2652 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2653 /* Convert both subexpression types to the type of intop,
2654 because weird cases involving pointer arithmetic
2655 can result in a sum or difference with different type args. */
2656 ptrop = build_binary_op (subcode, ptrop,
2657 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2658 intop = convert (int_type, TREE_OPERAND (intop, 0));
2661 /* Convert the integer argument to a type the same size as sizetype
2662 so the multiply won't overflow spuriously. */
2664 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2665 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2666 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2667 TREE_UNSIGNED (sizetype)), intop);
2669 /* Replace the integer argument with a suitable product by the object size.
2670 Do this multiplication as signed, then convert to the appropriate
2671 pointer type (actually unsigned integral). */
2673 intop = convert (result_type,
2674 build_binary_op (MULT_EXPR, intop,
2675 convert (TREE_TYPE (intop), size_exp), 1));
2677 /* Create the sum or difference. */
2679 result = build (resultcode, result_type, ptrop, intop);
2681 folded = fold (result);
2682 if (folded == result)
2683 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2687 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2688 or validate its data type for an `if' or `while' statement or ?..: exp.
2690 This preparation consists of taking the ordinary
2691 representation of an expression expr and producing a valid tree
2692 boolean expression describing whether expr is nonzero. We could
2693 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2694 but we optimize comparisons, &&, ||, and !.
2696 The resulting type should always be `boolean_type_node'. */
2699 c_common_truthvalue_conversion (expr)
2702 if (TREE_CODE (expr) == ERROR_MARK)
2705 #if 0 /* This appears to be wrong for C++. */
2706 /* These really should return error_mark_node after 2.4 is stable.
2707 But not all callers handle ERROR_MARK properly. */
2708 switch (TREE_CODE (TREE_TYPE (expr)))
2711 error ("struct type value used where scalar is required");
2712 return boolean_false_node;
2715 error ("union type value used where scalar is required");
2716 return boolean_false_node;
2719 error ("array type value used where scalar is required");
2720 return boolean_false_node;
2727 switch (TREE_CODE (expr))
2730 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2731 case TRUTH_ANDIF_EXPR:
2732 case TRUTH_ORIF_EXPR:
2733 case TRUTH_AND_EXPR:
2735 case TRUTH_XOR_EXPR:
2736 case TRUTH_NOT_EXPR:
2737 TREE_TYPE (expr) = boolean_type_node;
2744 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2747 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2750 /* If we are taking the address of an external decl, it might be zero
2751 if it is weak, so we cannot optimize. */
2752 if (DECL_P (TREE_OPERAND (expr, 0))
2753 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2756 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2757 return build (COMPOUND_EXPR, boolean_type_node,
2758 TREE_OPERAND (expr, 0), boolean_true_node);
2760 return boolean_true_node;
2763 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2764 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2765 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2766 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2773 /* These don't change whether an object is non-zero or zero. */
2774 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2778 /* These don't change whether an object is zero or non-zero, but
2779 we can't ignore them if their second arg has side-effects. */
2780 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2781 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2782 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2784 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2787 /* Distribute the conversion into the arms of a COND_EXPR. */
2788 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2789 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2790 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2793 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2794 since that affects how `default_conversion' will behave. */
2795 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2796 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2798 /* fall through... */
2800 /* If this is widening the argument, we can ignore it. */
2801 if (TYPE_PRECISION (TREE_TYPE (expr))
2802 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2803 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2807 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2808 aren't guaranteed to the be same for modes that can represent
2809 infinity, since if x and y are both +infinity, or both
2810 -infinity, then x - y is not a number.
2812 Note that this transformation is safe when x or y is NaN.
2813 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2815 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2817 /* fall through... */
2819 /* This and MINUS_EXPR can be changed into a comparison of the
2821 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2822 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2823 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2824 TREE_OPERAND (expr, 1), 1);
2825 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2826 fold (build1 (NOP_EXPR,
2827 TREE_TYPE (TREE_OPERAND (expr, 0)),
2828 TREE_OPERAND (expr, 1))), 1);
2831 if (integer_onep (TREE_OPERAND (expr, 1))
2832 && TREE_TYPE (expr) != boolean_type_node)
2833 /* Using convert here would cause infinite recursion. */
2834 return build1 (NOP_EXPR, boolean_type_node, expr);
2838 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2839 warning ("suggest parentheses around assignment used as truth value");
2846 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2848 tree t = save_expr (expr);
2849 return (build_binary_op
2850 ((TREE_SIDE_EFFECTS (expr)
2851 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2852 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2853 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2857 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2860 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2861 int, enum built_in_class, int, int,
2864 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2865 down to the element type of an array. */
2868 c_build_qualified_type (type, type_quals)
2872 /* A restrict-qualified pointer type must be a pointer to object or
2873 incomplete type. Note that the use of POINTER_TYPE_P also allows
2874 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2875 the C++ front-end also use POINTER_TYPE for pointer-to-member
2876 values, so even though it should be illegal to use `restrict'
2877 with such an entity we don't flag that here. Thus, special case
2878 code for that case is required in the C++ front-end. */
2879 if ((type_quals & TYPE_QUAL_RESTRICT)
2880 && (!POINTER_TYPE_P (type)
2881 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2883 error ("invalid use of `restrict'");
2884 type_quals &= ~TYPE_QUAL_RESTRICT;
2887 if (TREE_CODE (type) == ARRAY_TYPE)
2888 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2890 TYPE_DOMAIN (type));
2891 return build_qualified_type (type, type_quals);
2894 /* Apply the TYPE_QUALS to the new DECL. */
2897 c_apply_type_quals_to_decl (type_quals, decl)
2901 if ((type_quals & TYPE_QUAL_CONST)
2902 || (TREE_TYPE (decl)
2903 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2904 TREE_READONLY (decl) = 1;
2905 if (type_quals & TYPE_QUAL_VOLATILE)
2907 TREE_SIDE_EFFECTS (decl) = 1;
2908 TREE_THIS_VOLATILE (decl) = 1;
2910 if (type_quals & TYPE_QUAL_RESTRICT)
2912 if (!TREE_TYPE (decl)
2913 || !POINTER_TYPE_P (TREE_TYPE (decl))
2914 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2915 error ("invalid use of `restrict'");
2916 else if (flag_strict_aliasing)
2917 /* Indicate we need to make a unique alias set for this pointer.
2918 We can't do it here because it might be pointing to an
2920 DECL_POINTER_ALIAS_SET (decl) = -2;
2924 /* Return the typed-based alias set for T, which may be an expression
2925 or a type. Return -1 if we don't do anything special. */
2928 c_common_get_alias_set (t)
2933 /* Permit type-punning when accessing a union, provided the access
2934 is directly through the union. For example, this code does not
2935 permit taking the address of a union member and then storing
2936 through it. Even the type-punning allowed here is a GCC
2937 extension, albeit a common and useful one; the C standard says
2938 that such accesses have implementation-defined behavior. */
2940 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2941 u = TREE_OPERAND (u, 0))
2942 if (TREE_CODE (u) == COMPONENT_REF
2943 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2946 /* That's all the expressions we handle specially. */
2950 /* The C standard guarantess that any object may be accessed via an
2951 lvalue that has character type. */
2952 if (t == char_type_node
2953 || t == signed_char_type_node
2954 || t == unsigned_char_type_node)
2957 /* If it has the may_alias attribute, it can alias anything. */
2958 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2961 /* The C standard specifically allows aliasing between signed and
2962 unsigned variants of the same type. We treat the signed
2963 variant as canonical. */
2964 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2966 tree t1 = c_common_signed_type (t);
2968 /* t1 == t can happen for boolean nodes which are always unsigned. */
2970 return get_alias_set (t1);
2972 else if (POINTER_TYPE_P (t))
2976 /* Unfortunately, there is no canonical form of a pointer type.
2977 In particular, if we have `typedef int I', then `int *', and
2978 `I *' are different types. So, we have to pick a canonical
2979 representative. We do this below.
2981 Technically, this approach is actually more conservative that
2982 it needs to be. In particular, `const int *' and `int *'
2983 should be in different alias sets, according to the C and C++
2984 standard, since their types are not the same, and so,
2985 technically, an `int **' and `const int **' cannot point at
2988 But, the standard is wrong. In particular, this code is
2993 const int* const* cipp = &ipp;
2995 And, it doesn't make sense for that to be legal unless you
2996 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2997 the pointed-to types. This issue has been reported to the
2999 t1 = build_type_no_quals (t);
3001 return get_alias_set (t1);
3007 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3008 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3009 flag controls whether we should diagnose possibly ill-formed
3010 constructs or not. */
3012 c_sizeof_or_alignof_type (type, op, complain)
3017 const char *op_name;
3019 enum tree_code type_code = TREE_CODE (type);
3021 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
3022 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
3024 if (type_code == FUNCTION_TYPE)
3026 if (op == SIZEOF_EXPR)
3028 if (complain && (pedantic || warn_pointer_arith))
3029 pedwarn ("invalid application of `sizeof' to a function type");
3030 value = size_one_node;
3033 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3035 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3037 if (type_code == VOID_TYPE
3038 && complain && (pedantic || warn_pointer_arith))
3039 pedwarn ("invalid application of `%s' to a void type", op_name);
3040 value = size_one_node;
3042 else if (!COMPLETE_TYPE_P (type))
3045 error ("invalid application of `%s' to an incomplete type", op_name);
3046 value = size_zero_node;
3050 if (op == SIZEOF_EXPR)
3051 /* Convert in case a char is more than one unit. */
3052 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3053 size_int (TYPE_PRECISION (char_type_node)
3056 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
3059 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3060 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3061 never happen. However, this node should really have type
3062 `size_t', which is just a typedef for an ordinary integer type. */
3063 value = fold (build1 (NOP_EXPR, c_size_type_node, value));
3064 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
3069 /* Implement the __alignof keyword: Return the minimum required
3070 alignment of EXPR, measured in bytes. For VAR_DECL's and
3071 FIELD_DECL's return DECL_ALIGN (which can be set from an
3072 "aligned" __attribute__ specification). */
3075 c_alignof_expr (expr)
3080 if (TREE_CODE (expr) == VAR_DECL)
3081 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
3083 else if (TREE_CODE (expr) == COMPONENT_REF
3084 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3086 error ("`__alignof' applied to a bit-field");
3089 else if (TREE_CODE (expr) == COMPONENT_REF
3090 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3091 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
3093 else if (TREE_CODE (expr) == INDIRECT_REF)
3095 tree t = TREE_OPERAND (expr, 0);
3097 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3099 while (TREE_CODE (t) == NOP_EXPR
3100 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3104 t = TREE_OPERAND (t, 0);
3105 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3106 if (thisalign > bestalign)
3107 best = t, bestalign = thisalign;
3109 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3112 return c_alignof (TREE_TYPE (expr));
3114 return fold (build1 (NOP_EXPR, c_size_type_node, t));
3117 /* Handle C and C++ default attributes. */
3119 enum built_in_attribute
3121 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3122 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3123 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3124 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3125 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3126 #include "builtin-attrs.def"
3127 #undef DEF_ATTR_NULL_TREE
3129 #undef DEF_ATTR_IDENT
3130 #undef DEF_ATTR_TREE_LIST
3135 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3137 static bool c_attrs_initialized = false;
3139 static void c_init_attributes PARAMS ((void));
3141 /* Build tree nodes and builtin functions common to both C and C++ language
3145 c_common_nodes_and_builtins ()
3149 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3150 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3151 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3152 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3153 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3154 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3155 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3156 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3157 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3158 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3159 #include "builtin-types.def"
3160 #undef DEF_PRIMITIVE_TYPE
3161 #undef DEF_FUNCTION_TYPE_0
3162 #undef DEF_FUNCTION_TYPE_1
3163 #undef DEF_FUNCTION_TYPE_2
3164 #undef DEF_FUNCTION_TYPE_3
3165 #undef DEF_FUNCTION_TYPE_4
3166 #undef DEF_FUNCTION_TYPE_VAR_0
3167 #undef DEF_FUNCTION_TYPE_VAR_1
3168 #undef DEF_FUNCTION_TYPE_VAR_2
3169 #undef DEF_POINTER_TYPE
3173 typedef enum builtin_type builtin_type;
3175 tree builtin_types[(int) BT_LAST];
3176 int wchar_type_size;
3177 tree array_domain_type;
3178 tree va_list_ref_type_node;
3179 tree va_list_arg_type_node;
3181 /* Define `int' and `char' first so that dbx will output them first. */
3182 record_builtin_type (RID_INT, NULL, integer_type_node);
3183 record_builtin_type (RID_CHAR, "char", char_type_node);
3185 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3186 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3187 but not C. Are the conditionals here needed? */
3188 if (c_language == clk_cplusplus)
3189 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3190 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3191 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3192 record_builtin_type (RID_MAX, "long unsigned int",
3193 long_unsigned_type_node);
3194 if (c_language == clk_cplusplus)
3195 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3196 record_builtin_type (RID_MAX, "long long int",
3197 long_long_integer_type_node);
3198 record_builtin_type (RID_MAX, "long long unsigned int",
3199 long_long_unsigned_type_node);
3200 if (c_language == clk_cplusplus)
3201 record_builtin_type (RID_MAX, "long long unsigned",
3202 long_long_unsigned_type_node);
3203 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3204 record_builtin_type (RID_MAX, "short unsigned int",
3205 short_unsigned_type_node);
3206 if (c_language == clk_cplusplus)
3207 record_builtin_type (RID_MAX, "unsigned short",
3208 short_unsigned_type_node);
3210 /* Define both `signed char' and `unsigned char'. */
3211 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3212 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3214 /* These are types that c_common_type_for_size and
3215 c_common_type_for_mode use. */
3216 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3218 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3220 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3222 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3224 #if HOST_BITS_PER_WIDE_INT >= 64
3225 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3226 get_identifier ("__int128_t"),
3229 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3230 unsigned_intQI_type_node));
3231 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3232 unsigned_intHI_type_node));
3233 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3234 unsigned_intSI_type_node));
3235 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3236 unsigned_intDI_type_node));
3237 #if HOST_BITS_PER_WIDE_INT >= 64
3238 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3239 get_identifier ("__uint128_t"),
3240 unsigned_intTI_type_node));
3243 /* Create the widest literal types. */
3244 widest_integer_literal_type_node
3245 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3246 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3247 widest_integer_literal_type_node));
3249 widest_unsigned_literal_type_node
3250 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3251 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3252 widest_unsigned_literal_type_node));
3254 /* `unsigned long' is the standard type for sizeof.
3255 Note that stddef.h uses `unsigned long',
3256 and this must agree, even if long and int are the same size. */
3258 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3259 signed_size_type_node = c_common_signed_type (c_size_type_node);
3260 set_sizetype (c_size_type_node);
3262 build_common_tree_nodes_2 (flag_short_double);
3264 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3265 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3266 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3268 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3269 get_identifier ("complex int"),
3270 complex_integer_type_node));
3271 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3272 get_identifier ("complex float"),
3273 complex_float_type_node));
3274 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3275 get_identifier ("complex double"),
3276 complex_double_type_node));
3277 (*lang_hooks.decls.pushdecl)
3278 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3279 complex_long_double_type_node));
3281 /* Types which are common to the fortran compiler and libf2c. When
3282 changing these, you also need to be concerned with f/com.h. */
3284 if (TYPE_PRECISION (float_type_node)
3285 == TYPE_PRECISION (long_integer_type_node))
3287 g77_integer_type_node = long_integer_type_node;
3288 g77_uinteger_type_node = long_unsigned_type_node;
3290 else if (TYPE_PRECISION (float_type_node)
3291 == TYPE_PRECISION (integer_type_node))
3293 g77_integer_type_node = integer_type_node;
3294 g77_uinteger_type_node = unsigned_type_node;
3297 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3299 if (g77_integer_type_node != NULL_TREE)
3301 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3302 get_identifier ("__g77_integer"),
3303 g77_integer_type_node));
3304 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3305 get_identifier ("__g77_uinteger"),
3306 g77_uinteger_type_node));
3309 if (TYPE_PRECISION (float_type_node) * 2
3310 == TYPE_PRECISION (long_integer_type_node))
3312 g77_longint_type_node = long_integer_type_node;
3313 g77_ulongint_type_node = long_unsigned_type_node;
3315 else if (TYPE_PRECISION (float_type_node) * 2
3316 == TYPE_PRECISION (long_long_integer_type_node))
3318 g77_longint_type_node = long_long_integer_type_node;
3319 g77_ulongint_type_node = long_long_unsigned_type_node;
3322 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3324 if (g77_longint_type_node != NULL_TREE)
3326 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3327 get_identifier ("__g77_longint"),
3328 g77_longint_type_node));
3329 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3330 get_identifier ("__g77_ulongint"),
3331 g77_ulongint_type_node));
3334 record_builtin_type (RID_VOID, NULL, void_type_node);
3336 void_zero_node = build_int_2 (0, 0);
3337 TREE_TYPE (void_zero_node) = void_type_node;
3339 void_list_node = build_void_list_node ();
3341 /* Make a type to be the domain of a few array types
3342 whose domains don't really matter.
3343 200 is small enough that it always fits in size_t
3344 and large enough that it can hold most function names for the
3345 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3346 array_domain_type = build_index_type (size_int (200));
3348 /* Make a type for arrays of characters.
3349 With luck nothing will ever really depend on the length of this
3351 char_array_type_node
3352 = build_array_type (char_type_node, array_domain_type);
3354 /* Likewise for arrays of ints. */
3356 = build_array_type (integer_type_node, array_domain_type);
3358 string_type_node = build_pointer_type (char_type_node);
3359 const_string_type_node
3360 = build_pointer_type (build_qualified_type
3361 (char_type_node, TYPE_QUAL_CONST));
3363 (*targetm.init_builtins) ();
3365 /* This is special for C++ so functions can be overloaded. */
3366 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3367 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3368 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3369 if (c_language == clk_cplusplus)
3371 if (TREE_UNSIGNED (wchar_type_node))
3372 wchar_type_node = make_unsigned_type (wchar_type_size);
3374 wchar_type_node = make_signed_type (wchar_type_size);
3375 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3379 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3380 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3383 /* This is for wide string constants. */
3384 wchar_array_type_node
3385 = build_array_type (wchar_type_node, array_domain_type);
3388 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3391 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3393 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3395 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3397 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3398 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3400 (*lang_hooks.decls.pushdecl)
3401 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3402 va_list_type_node));
3404 (*lang_hooks.decls.pushdecl)
3405 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3406 ptrdiff_type_node));
3408 (*lang_hooks.decls.pushdecl)
3409 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3412 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3414 va_list_arg_type_node = va_list_ref_type_node =
3415 build_pointer_type (TREE_TYPE (va_list_type_node));
3419 va_list_arg_type_node = va_list_type_node;
3420 va_list_ref_type_node = build_reference_type (va_list_type_node);
3423 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3424 builtin_types[(int) ENUM] = VALUE;
3425 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3426 builtin_types[(int) ENUM] \
3427 = build_function_type (builtin_types[(int) RETURN], \
3429 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3430 builtin_types[(int) ENUM] \
3431 = build_function_type (builtin_types[(int) RETURN], \
3432 tree_cons (NULL_TREE, \
3433 builtin_types[(int) ARG1], \
3435 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3436 builtin_types[(int) ENUM] \
3437 = build_function_type \
3438 (builtin_types[(int) RETURN], \
3439 tree_cons (NULL_TREE, \
3440 builtin_types[(int) ARG1], \
3441 tree_cons (NULL_TREE, \
3442 builtin_types[(int) ARG2], \
3444 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3445 builtin_types[(int) ENUM] \
3446 = build_function_type \
3447 (builtin_types[(int) RETURN], \
3448 tree_cons (NULL_TREE, \
3449 builtin_types[(int) ARG1], \
3450 tree_cons (NULL_TREE, \
3451 builtin_types[(int) ARG2], \
3452 tree_cons (NULL_TREE, \
3453 builtin_types[(int) ARG3], \
3455 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3456 builtin_types[(int) ENUM] \
3457 = build_function_type \
3458 (builtin_types[(int) RETURN], \
3459 tree_cons (NULL_TREE, \
3460 builtin_types[(int) ARG1], \
3461 tree_cons (NULL_TREE, \
3462 builtin_types[(int) ARG2], \
3465 builtin_types[(int) ARG3], \
3466 tree_cons (NULL_TREE, \
3467 builtin_types[(int) ARG4], \
3468 void_list_node)))));
3469 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3470 builtin_types[(int) ENUM] \
3471 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3472 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3473 builtin_types[(int) ENUM] \
3474 = build_function_type (builtin_types[(int) RETURN], \
3475 tree_cons (NULL_TREE, \
3476 builtin_types[(int) ARG1], \
3479 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3480 builtin_types[(int) ENUM] \
3481 = build_function_type \
3482 (builtin_types[(int) RETURN], \
3483 tree_cons (NULL_TREE, \
3484 builtin_types[(int) ARG1], \
3485 tree_cons (NULL_TREE, \
3486 builtin_types[(int) ARG2], \
3488 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3489 builtin_types[(int) ENUM] \
3490 = build_pointer_type (builtin_types[(int) TYPE]);
3491 #include "builtin-types.def"
3492 #undef DEF_PRIMITIVE_TYPE
3493 #undef DEF_FUNCTION_TYPE_1
3494 #undef DEF_FUNCTION_TYPE_2
3495 #undef DEF_FUNCTION_TYPE_3
3496 #undef DEF_FUNCTION_TYPE_4
3497 #undef DEF_FUNCTION_TYPE_VAR_0
3498 #undef DEF_FUNCTION_TYPE_VAR_1
3499 #undef DEF_POINTER_TYPE
3501 if (!c_attrs_initialized)
3502 c_init_attributes ();
3504 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3505 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS) \
3510 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3514 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3517 ? (NAME + strlen ("__builtin_")) \
3519 built_in_attributes[(int) ATTRS]); \
3521 decl = builtin_function_2 (NAME, \
3522 NAME + strlen ("__builtin_"), \
3523 builtin_types[TYPE], \
3524 builtin_types[LIBTYPE], \
3529 built_in_attributes[(int) ATTRS]); \
3531 built_in_decls[(int) ENUM] = decl; \
3533 #include "builtins.def"
3536 main_identifier_node = get_identifier ("main");
3540 build_va_arg (expr, type)
3543 return build1 (VA_ARG_EXPR, type, expr);
3547 /* Linked list of disabled built-in functions. */
3549 typedef struct disabled_builtin
3552 struct disabled_builtin *next;
3554 static disabled_builtin *disabled_builtins = NULL;
3556 static bool builtin_function_disabled_p PARAMS ((const char *));
3558 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3559 begins with "__builtin_", give an error. */
3562 disable_builtin_function (name)
3565 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3566 error ("cannot disable built-in function `%s'", name);
3569 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3571 new->next = disabled_builtins;
3572 disabled_builtins = new;
3577 /* Return true if the built-in function NAME has been disabled, false
3581 builtin_function_disabled_p (name)
3584 disabled_builtin *p;
3585 for (p = disabled_builtins; p != NULL; p = p->next)
3587 if (strcmp (name, p->name) == 0)
3594 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3595 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3596 of these may be NULL (though both being NULL is useless).
3597 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3598 TYPE is the type of the function with the ordinary name. These
3599 may differ if the ordinary name is declared with a looser type to avoid
3600 conflicts with headers. FUNCTION_CODE and CLASS are as for
3601 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3602 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3603 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3604 ATTRS is the tree list representing the builtin's function attributes.
3605 Returns the declaration of BUILTIN_NAME, if any, otherwise
3606 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3607 or if NONANSI_P and flag_no_nonansi_builtin. */
3610 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3611 class, library_name_p, nonansi_p, attrs)
3612 const char *builtin_name;
3617 enum built_in_class class;
3622 tree bdecl = NULL_TREE;
3623 tree decl = NULL_TREE;
3624 if (builtin_name != 0)
3626 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3627 class, library_name_p ? name : NULL,
3630 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3631 && !(nonansi_p && flag_no_nonansi_builtin))
3633 decl = builtin_function (name, type, function_code, class, NULL,
3636 DECL_BUILT_IN_NONANSI (decl) = 1;
3638 return (bdecl != 0 ? bdecl : decl);
3641 /* Nonzero if the type T promotes to int. This is (nearly) the
3642 integral promotions defined in ISO C99 6.3.1.1/2. */
3645 c_promoting_integer_type_p (t)
3648 switch (TREE_CODE (t))
3651 return (TYPE_MAIN_VARIANT (t) == char_type_node
3652 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3653 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3654 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3655 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3656 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3659 /* ??? Technically all enumerations not larger than an int
3660 promote to an int. But this is used along code paths
3661 that only want to notice a size change. */
3662 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3672 /* Return 1 if PARMS specifies a fixed number of parameters
3673 and none of their types is affected by default promotions. */
3676 self_promoting_args_p (parms)
3680 for (t = parms; t; t = TREE_CHAIN (t))
3682 tree type = TREE_VALUE (t);
3684 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3690 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3693 if (c_promoting_integer_type_p (type))
3699 /* Recursively examines the array elements of TYPE, until a non-array
3700 element type is found. */
3703 strip_array_types (type)
3706 while (TREE_CODE (type) == ARRAY_TYPE)
3707 type = TREE_TYPE (type);
3712 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3715 /* Expand a call to an unordered comparison function such as
3716 __builtin_isgreater(). FUNCTION is the function's declaration and
3717 PARAMS a list of the values passed. For __builtin_isunordered(),
3718 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3719 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3720 that give the opposite of the desired result. UNORDERED_CODE is
3721 used for modes that can hold NaNs and ORDERED_CODE is used for the
3725 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3726 tree function, params;
3727 enum tree_code unordered_code, ordered_code;
3729 tree arg0, arg1, type;
3730 enum tree_code code0, code1;
3732 /* Check that we have exactly two arguments. */
3733 if (params == 0 || TREE_CHAIN (params) == 0)
3735 error ("too few arguments to function `%s'",
3736 IDENTIFIER_POINTER (DECL_NAME (function)));
3737 return error_mark_node;
3739 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3741 error ("too many arguments to function `%s'",
3742 IDENTIFIER_POINTER (DECL_NAME (function)));
3743 return error_mark_node;
3746 arg0 = TREE_VALUE (params);
3747 arg1 = TREE_VALUE (TREE_CHAIN (params));
3749 code0 = TREE_CODE (TREE_TYPE (arg0));
3750 code1 = TREE_CODE (TREE_TYPE (arg1));
3752 /* Make sure that the arguments have a common type of REAL. */
3754 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3755 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3756 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3758 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3760 error ("non-floating-point argument to function `%s'",
3761 IDENTIFIER_POINTER (DECL_NAME (function)));
3762 return error_mark_node;
3765 if (unordered_code == UNORDERED_EXPR)
3767 if (MODE_HAS_NANS (TYPE_MODE (type)))
3768 return build_binary_op (unordered_code,
3769 convert (type, arg0),
3770 convert (type, arg1),
3773 return integer_zero_node;
3776 return build_unary_op (TRUTH_NOT_EXPR,
3777 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3780 convert (type, arg0),
3781 convert (type, arg1),
3787 /* Recognize certain built-in functions so we can make tree-codes
3788 other than CALL_EXPR. We do this when it enables fold-const.c
3789 to do something useful. */
3790 /* ??? By rights this should go in builtins.c, but only C and C++
3791 implement build_{binary,unary}_op. Not exactly sure what bits
3792 of functionality are actually needed from those functions, or
3793 where the similar functionality exists in the other front ends. */
3796 expand_tree_builtin (function, params, coerced_params)
3797 tree function, params, coerced_params;
3799 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3802 switch (DECL_FUNCTION_CODE (function))
3806 case BUILT_IN_LLABS:
3807 case BUILT_IN_IMAXABS:
3809 case BUILT_IN_FABSL:
3810 case BUILT_IN_FABSF:
3811 if (coerced_params == 0)
3812 return integer_zero_node;
3813 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3816 case BUILT_IN_CONJF:
3817 case BUILT_IN_CONJL:
3818 if (coerced_params == 0)
3819 return integer_zero_node;
3820 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3822 case BUILT_IN_CREAL:
3823 case BUILT_IN_CREALF:
3824 case BUILT_IN_CREALL:
3825 if (coerced_params == 0)
3826 return integer_zero_node;
3827 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3829 case BUILT_IN_CIMAG:
3830 case BUILT_IN_CIMAGF:
3831 case BUILT_IN_CIMAGL:
3832 if (coerced_params == 0)
3833 return integer_zero_node;
3834 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3836 case BUILT_IN_ISGREATER:
3837 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3839 case BUILT_IN_ISGREATEREQUAL:
3840 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3842 case BUILT_IN_ISLESS:
3843 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3845 case BUILT_IN_ISLESSEQUAL:
3846 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3848 case BUILT_IN_ISLESSGREATER:
3849 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3851 case BUILT_IN_ISUNORDERED:
3852 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3861 /* Returns non-zero if CODE is the code for a statement. */
3864 statement_code_p (code)
3865 enum tree_code code;
3890 if (lang_statement_code_p)
3891 return (*lang_statement_code_p) (code);
3896 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3897 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3898 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3899 value, the traversal is aborted, and the value returned by FUNC is
3900 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3901 the node being visited are not walked.
3903 We don't need a without_duplicates variant of this one because the
3904 statement tree is a tree, not a graph. */
3907 walk_stmt_tree (tp, func, data)
3912 enum tree_code code;
3917 #define WALK_SUBTREE(NODE) \
3920 result = walk_stmt_tree (&(NODE), func, data); \
3926 /* Skip empty subtrees. */
3930 /* Skip subtrees below non-statement nodes. */
3931 if (!statement_code_p (TREE_CODE (*tp)))
3934 /* Call the function. */
3936 result = (*func) (tp, &walk_subtrees, data);
3938 /* If we found something, return it. */
3942 /* FUNC may have modified the tree, recheck that we're looking at a
3944 code = TREE_CODE (*tp);
3945 if (!statement_code_p (code))
3948 /* Visit the subtrees unless FUNC decided that there was nothing
3949 interesting below this point in the tree. */
3952 /* Walk over all the sub-trees of this operand. Statement nodes
3953 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3954 len = TREE_CODE_LENGTH (code);
3956 /* Go through the subtrees. We need to do this in forward order so
3957 that the scope of a FOR_EXPR is handled properly. */
3958 for (i = 0; i < len; ++i)
3959 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3962 /* Finally visit the chain. This can be tail-recursion optimized if
3963 we write it this way. */
3964 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3969 /* Used to compare case labels. K1 and K2 are actually tree nodes
3970 representing case labels, or NULL_TREE for a `default' label.
3971 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3972 K2, and 0 if K1 and K2 are equal. */
3975 case_compare (k1, k2)
3979 /* Consider a NULL key (such as arises with a `default' label) to be
3980 smaller than anything else. */
3986 return tree_int_cst_compare ((tree) k1, (tree) k2);
3989 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3990 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3991 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3992 case label was declared using the usual C/C++ syntax, rather than
3993 the GNU case range extension. CASES is a tree containing all the
3994 case ranges processed so far; COND is the condition for the
3995 switch-statement itself. Returns the CASE_LABEL created, or
3996 ERROR_MARK_NODE if no CASE_LABEL is created. */
3999 c_add_case_label (cases, cond, low_value, high_value)
4008 splay_tree_node node;
4010 /* Create the LABEL_DECL itself. */
4011 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
4012 DECL_CONTEXT (label) = current_function_decl;
4014 /* If there was an error processing the switch condition, bail now
4015 before we get more confused. */
4016 if (!cond || cond == error_mark_node)
4018 /* Add a label anyhow so that the back-end doesn't think that
4019 the beginning of the switch is unreachable. */
4021 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4022 return error_mark_node;
4025 if ((low_value && TREE_TYPE (low_value)
4026 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4027 || (high_value && TREE_TYPE (high_value)
4028 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4029 error ("pointers are not permitted as case values");
4031 /* Case ranges are a GNU extension. */
4032 if (high_value && pedantic)
4034 if (c_language == clk_cplusplus)
4035 pedwarn ("ISO C++ forbids range expressions in switch statements");
4037 pedwarn ("ISO C forbids range expressions in switch statements");
4040 type = TREE_TYPE (cond);
4043 low_value = check_case_value (low_value);
4044 low_value = convert_and_check (type, low_value);
4048 high_value = check_case_value (high_value);
4049 high_value = convert_and_check (type, high_value);
4052 /* If an error has occurred, bail out now. */
4053 if (low_value == error_mark_node || high_value == error_mark_node)
4056 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4057 return error_mark_node;
4060 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4061 really a case range, even though it was written that way. Remove
4062 the HIGH_VALUE to simplify later processing. */
4063 if (tree_int_cst_equal (low_value, high_value))
4064 high_value = NULL_TREE;
4065 if (low_value && high_value
4066 && !tree_int_cst_lt (low_value, high_value))
4067 warning ("empty range specified");
4069 /* Look up the LOW_VALUE in the table of case labels we already
4071 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4072 /* If there was not an exact match, check for overlapping ranges.
4073 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4074 that's a `default' label and the only overlap is an exact match. */
4075 if (!node && (low_value || high_value))
4077 splay_tree_node low_bound;
4078 splay_tree_node high_bound;
4080 /* Even though there wasn't an exact match, there might be an
4081 overlap between this case range and another case range.
4082 Since we've (inductively) not allowed any overlapping case
4083 ranges, we simply need to find the greatest low case label
4084 that is smaller that LOW_VALUE, and the smallest low case
4085 label that is greater than LOW_VALUE. If there is an overlap
4086 it will occur in one of these two ranges. */
4087 low_bound = splay_tree_predecessor (cases,
4088 (splay_tree_key) low_value);
4089 high_bound = splay_tree_successor (cases,
4090 (splay_tree_key) low_value);
4092 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4093 the LOW_VALUE, so there is no need to check unless the
4094 LOW_BOUND is in fact itself a case range. */
4096 && CASE_HIGH ((tree) low_bound->value)
4097 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4100 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4101 range is bigger than the low end of the current range, so we
4102 are only interested if the current range is a real range, and
4103 not an ordinary case label. */
4106 && (tree_int_cst_compare ((tree) high_bound->key,
4111 /* If there was an overlap, issue an error. */
4114 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
4118 error ("duplicate (or overlapping) case value");
4119 error_with_decl (duplicate,
4120 "this is the first entry overlapping that value");
4124 error ("duplicate case value") ;
4125 error_with_decl (duplicate, "previously used here");
4129 error ("multiple default labels in one switch");
4130 error_with_decl (duplicate, "this is the first default label");
4133 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4136 /* Add a CASE_LABEL to the statement-tree. */
4137 case_label = add_stmt (build_case_label (low_value, high_value, label));
4138 /* Register this case label in the splay tree. */
4139 splay_tree_insert (cases,
4140 (splay_tree_key) low_value,
4141 (splay_tree_value) case_label);
4146 /* Finish an expression taking the address of LABEL. Returns an
4147 expression for the address. */
4150 finish_label_address_expr (label)
4157 if (c_language == clk_cplusplus)
4158 pedwarn ("ISO C++ forbids taking the address of a label");
4160 pedwarn ("ISO C forbids taking the address of a label");
4163 label = lookup_label (label);
4164 if (label == NULL_TREE)
4165 result = null_pointer_node;
4168 TREE_USED (label) = 1;
4169 result = build1 (ADDR_EXPR, ptr_type_node, label);
4170 TREE_CONSTANT (result) = 1;
4171 /* The current function in not necessarily uninlinable.
4172 Computed gotos are incompatible with inlining, but the value
4173 here could be used only in a diagnostic, for example. */
4179 /* Hook used by expand_expr to expand language-specific tree codes. */
4182 c_expand_expr (exp, target, tmode, modifier)
4185 enum machine_mode tmode;
4186 int modifier; /* Actually enum_modifier. */
4188 switch (TREE_CODE (exp))
4194 bool preserve_result = false;
4195 bool return_target = false;
4197 /* Since expand_expr_stmt calls free_temp_slots after every
4198 expression statement, we must call push_temp_slots here.
4199 Otherwise, any temporaries in use now would be considered
4200 out-of-scope after the first EXPR_STMT from within the
4203 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4205 /* If we want the result of this expression, find the last
4206 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4207 if (target != const0_rtx
4208 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4209 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4211 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4212 tree last = TREE_CHAIN (expr);
4214 while (TREE_CHAIN (last))
4217 last = TREE_CHAIN (last);
4220 if (TREE_CODE (last) == SCOPE_STMT
4221 && TREE_CODE (expr) == EXPR_STMT)
4223 if (target && TREE_CODE (EXPR_STMT_EXPR (expr)) == VAR_DECL
4224 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr)) == target)
4225 /* If the last expression is a variable whose RTL is the
4226 same as our target, just return the target; if it
4227 isn't valid expanding the decl would produce different
4228 RTL, and store_expr would try to do a copy. */
4229 return_target = true;
4232 /* Otherwise, note that we want the value from the last
4234 TREE_ADDRESSABLE (expr) = 1;
4235 preserve_result = true;
4240 expand_stmt (STMT_EXPR_STMT (exp));
4241 expand_end_stmt_expr (rtl_expr);
4243 result = expand_expr (rtl_expr, target, tmode, modifier);
4246 else if (preserve_result && GET_CODE (result) == MEM)
4248 if (GET_MODE (result) != BLKmode)
4249 result = copy_to_reg (result);
4251 preserve_temp_slots (result);
4254 /* If the statment-expression does not have a scope, then the
4255 new temporaries we created within it must live beyond the
4256 statement-expression. */
4257 if (STMT_EXPR_NO_SCOPE (exp))
4258 preserve_temp_slots (NULL_RTX);
4267 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
4268 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4270 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4271 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4272 == BUILT_IN_FRONTEND))
4273 return c_expand_builtin (exp, target, tmode, modifier);
4279 case COMPOUND_LITERAL_EXPR:
4281 /* Initialize the anonymous variable declared in the compound
4282 literal, then return the variable. */
4283 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4284 emit_local_var (decl);
4285 return expand_expr (decl, target, tmode, modifier);
4296 /* Hook used by safe_from_p to handle language-specific tree codes. */
4299 c_safe_from_p (target, exp)
4303 /* We can see statements here when processing the body of a
4304 statement-expression. For a declaration statement declaring a
4305 variable, look at the variable's initializer. */
4306 if (TREE_CODE (exp) == DECL_STMT)
4308 tree decl = DECL_STMT_DECL (exp);
4310 if (TREE_CODE (decl) == VAR_DECL
4311 && DECL_INITIAL (decl)
4312 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4316 /* For any statement, we must follow the statement-chain. */
4317 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
4318 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4320 /* Assume everything else is safe. */
4324 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4327 c_common_unsafe_for_reeval (exp)
4330 /* Statement expressions may not be reevaluated, likewise compound
4332 if (TREE_CODE (exp) == STMT_EXPR
4333 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4336 /* Walk all other expressions. */
4340 /* Hook used by staticp to handle language-specific tree codes. */
4346 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4347 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4352 #define CALLED_AS_BUILT_IN(NODE) \
4353 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4356 c_expand_builtin (exp, target, tmode, modifier)
4359 enum machine_mode tmode;
4360 enum expand_modifier modifier;
4362 tree type = TREE_TYPE (exp);
4363 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4364 tree arglist = TREE_OPERAND (exp, 1);
4365 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4366 enum tree_code code = TREE_CODE (exp);
4367 const int ignore = (target == const0_rtx
4368 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4369 || code == CONVERT_EXPR || code == REFERENCE_EXPR
4370 || code == COND_EXPR)
4371 && TREE_CODE (type) == VOID_TYPE));
4373 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4374 return expand_call (exp, target, ignore);
4378 case BUILT_IN_PRINTF:
4379 target = c_expand_builtin_printf (arglist, target, tmode,
4380 modifier, ignore, /*unlocked=*/ 0);
4385 case BUILT_IN_PRINTF_UNLOCKED:
4386 target = c_expand_builtin_printf (arglist, target, tmode,
4387 modifier, ignore, /*unlocked=*/ 1);
4392 case BUILT_IN_FPRINTF:
4393 target = c_expand_builtin_fprintf (arglist, target, tmode,
4394 modifier, ignore, /*unlocked=*/ 0);
4399 case BUILT_IN_FPRINTF_UNLOCKED:
4400 target = c_expand_builtin_fprintf (arglist, target, tmode,
4401 modifier, ignore, /*unlocked=*/ 1);
4406 default: /* just do library call, if unknown builtin */
4407 error ("built-in function `%s' not currently supported",
4408 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4411 /* The switch statement above can drop through to cause the function
4412 to be called normally. */
4413 return expand_call (exp, target, ignore);
4416 /* Check an arglist to *printf for problems. The arglist should start
4417 at the format specifier, with the remaining arguments immediately
4420 is_valid_printf_arglist (arglist)
4423 /* Save this value so we can restore it later. */
4424 const int SAVE_pedantic = pedantic;
4425 int diagnostic_occurred = 0;
4428 /* Set this to a known value so the user setting won't affect code
4431 /* Check to make sure there are no format specifier errors. */
4432 attrs = tree_cons (get_identifier ("format"),
4433 tree_cons (NULL_TREE,
4434 get_identifier ("printf"),
4435 tree_cons (NULL_TREE,
4437 tree_cons (NULL_TREE,
4441 check_function_format (&diagnostic_occurred, attrs, arglist);
4443 /* Restore the value of `pedantic'. */
4444 pedantic = SAVE_pedantic;
4446 /* If calling `check_function_format_ptr' produces a warning, we
4447 return false, otherwise we return true. */
4448 return ! diagnostic_occurred;
4451 /* If the arguments passed to printf are suitable for optimizations,
4452 we attempt to transform the call. */
4454 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
4457 enum machine_mode tmode;
4458 enum expand_modifier modifier;
4462 tree fn_putchar = unlocked ?
4463 built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
4464 tree fn_puts = unlocked ?
4465 built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
4466 tree fn, format_arg, stripped_string;
4468 /* If the return value is used, or the replacement _DECL isn't
4469 initialized, don't do the transformation. */
4470 if (!ignore || !fn_putchar || !fn_puts)
4473 /* Verify the required arguments in the original call. */
4475 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4478 /* Check the specifier vs. the parameters. */
4479 if (!is_valid_printf_arglist (arglist))
4482 format_arg = TREE_VALUE (arglist);
4483 stripped_string = format_arg;
4484 STRIP_NOPS (stripped_string);
4485 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4486 stripped_string = TREE_OPERAND (stripped_string, 0);
4488 /* If the format specifier isn't a STRING_CST, punt. */
4489 if (TREE_CODE (stripped_string) != STRING_CST)
4492 /* OK! We can attempt optimization. */
4494 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4495 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4497 arglist = TREE_CHAIN (arglist);
4500 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4501 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4503 arglist = TREE_CHAIN (arglist);
4508 /* We can't handle anything else with % args or %% ... yet. */
4509 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4512 /* If the resulting constant string has a length of 1, call
4513 putchar. Note, TREE_STRING_LENGTH includes the terminating
4514 NULL in its count. */
4515 if (TREE_STRING_LENGTH (stripped_string) == 2)
4517 /* Given printf("c"), (where c is any one character,)
4518 convert "c"[0] to an int and pass that to the replacement
4520 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4521 arglist = build_tree_list (NULL_TREE, arglist);
4525 /* If the resulting constant was "string\n", call
4526 __builtin_puts("string"). Ensure "string" has at least one
4527 character besides the trailing \n. Note, TREE_STRING_LENGTH
4528 includes the terminating NULL in its count. */
4529 else if (TREE_STRING_LENGTH (stripped_string) > 2
4530 && TREE_STRING_POINTER (stripped_string)
4531 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4533 /* Create a NULL-terminated string that's one char shorter
4534 than the original, stripping off the trailing '\n'. */
4535 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4536 char *newstr = (char *) alloca (newlen);
4537 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4538 newstr[newlen - 1] = 0;
4540 arglist = fix_string_type (build_string (newlen, newstr));
4541 arglist = build_tree_list (NULL_TREE, arglist);
4545 /* We'd like to arrange to call fputs(string) here, but we
4546 need stdout and don't have a way to get it ... yet. */
4550 return expand_expr (build_function_call (fn, arglist),
4551 (ignore ? const0_rtx : target),
4555 /* If the arguments passed to fprintf are suitable for optimizations,
4556 we attempt to transform the call. */
4558 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4561 enum machine_mode tmode;
4562 enum expand_modifier modifier;
4566 tree fn_fputc = unlocked ?
4567 built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
4568 tree fn_fputs = unlocked ?
4569 built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
4570 tree fn, format_arg, stripped_string;
4572 /* If the return value is used, or the replacement _DECL isn't
4573 initialized, don't do the transformation. */
4574 if (!ignore || !fn_fputc || !fn_fputs)
4577 /* Verify the required arguments in the original call. */
4579 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4580 || (TREE_CHAIN (arglist) == 0)
4581 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4585 /* Check the specifier vs. the parameters. */
4586 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4589 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4590 stripped_string = format_arg;
4591 STRIP_NOPS (stripped_string);
4592 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4593 stripped_string = TREE_OPERAND (stripped_string, 0);
4595 /* If the format specifier isn't a STRING_CST, punt. */
4596 if (TREE_CODE (stripped_string) != STRING_CST)
4599 /* OK! We can attempt optimization. */
4601 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4602 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4604 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4605 arglist = tree_cons (NULL_TREE,
4606 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4610 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4611 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4613 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4614 arglist = tree_cons (NULL_TREE,
4615 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4621 /* We can't handle anything else with % args or %% ... yet. */
4622 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4625 /* When "string" doesn't contain %, replace all cases of
4626 fprintf(stream,string) with fputs(string,stream). The fputs
4627 builtin will take take of special cases like length==1. */
4628 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4629 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4633 return expand_expr (build_function_call (fn, arglist),
4634 (ignore ? const0_rtx : target),
4639 /* Given a boolean expression ARG, return a tree representing an increment
4640 or decrement (as indicated by CODE) of ARG. The front end must check for
4641 invalid cases (e.g., decrement in C++). */
4643 boolean_increment (code, arg)
4644 enum tree_code code;
4648 tree true_res = (c_language == clk_cplusplus
4650 : c_bool_true_node);
4651 arg = stabilize_reference (arg);
4654 case PREINCREMENT_EXPR:
4655 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4657 case POSTINCREMENT_EXPR:
4658 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4659 arg = save_expr (arg);
4660 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4661 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4663 case PREDECREMENT_EXPR:
4664 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4666 case POSTDECREMENT_EXPR:
4667 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4668 arg = save_expr (arg);
4669 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4670 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4675 TREE_SIDE_EFFECTS (val) = 1;
4679 /* Define macros necessary to describe fundamental data type formats. */
4681 cpp_define_data_format (pfile)
4685 /* Define endianness enumeration values. */
4686 cpp_define (pfile, "__GCC_LITTLE_ENDIAN__=0");
4687 cpp_define (pfile, "__GCC_BIG_ENDIAN__=1");
4689 /* Define supported floating-point format enumeration values. */
4690 cpp_define (pfile, "__UNKNOWN_FORMAT__=0");
4691 cpp_define (pfile, "__IEEE_FORMAT__=1");
4692 cpp_define (pfile, "__IBM_FORMAT__=2");
4693 cpp_define (pfile, "__C4X_FORMAT__=3");
4694 cpp_define (pfile, "__VAX_FORMAT__=4");
4696 /* Define target endianness:
4699 - word order in an integer that spans a multi-word
4700 - word order in a floating-poing that spans a multi-word */
4701 if (BITS_BIG_ENDIAN)
4702 cpp_define (pfile, "__TARGET_BITS_ORDER__=__GCC_BIG_ENDIAN__");
4704 cpp_define (pfile, "__TARGET_BITS_ORDER__=__GCC_BIG_ENDIAN__");
4705 if (BYTES_BIG_ENDIAN)
4706 cpp_define (pfile, "__TARGET_BYTES_ORDER__=__GCC_BIG_ENDIAN__");
4708 cpp_define (pfile, "__TARGET_BYTES_ORDER__=__GCC_LITTLE_ENDIAN__");
4709 /* Define words order in a multi-word integer. */
4710 if (WORDS_BIG_ENDIAN)
4711 cpp_define (pfile, "__TARGET_INT_WORDS_ORDER__=__GCC_BIG_ENDIAN__");
4713 cpp_define (pfile, "__TARGET_INT_WORDS_ORDER__=__GCC_LITTLE_ENDIAN__");
4714 /* Define words order in a multi-word floating point. */
4715 if (FLOAT_WORDS_BIG_ENDIAN)
4716 cpp_define (pfile, "__TARGET_FLOAT_WORDS_ORDER__=__GCC_BIG_ENDIAN__");
4718 cpp_define (pfile, "__TARGET_FLOAT_WORDS_ORDER__=__GCC_LITTLE_ENDIAN__");
4720 switch (TARGET_FLOAT_FORMAT)
4722 case UNKNOWN_FLOAT_FORMAT:
4723 format = "__UNKNOWN_FORMAT__";
4726 case IEEE_FLOAT_FORMAT:
4727 format = "__IEEE_FORMAT__";
4730 case VAX_FLOAT_FORMAT:
4731 format = "__VAX_FORMAT__";
4732 cpp_define (pfile, "__TARGET_USES_VAX_F_FLOAT__=1");
4733 #ifdef TARGET_G_FLOAT
4736 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=0");
4737 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=1");
4741 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=1");
4742 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=0");
4745 cpp_define (pfile, "__TARGET_USES_VAX_H_FLOAT__=1");
4748 case IBM_FLOAT_FORMAT:
4749 format = "__IBM_FORMAT__";
4752 case C4X_FLOAT_FORMAT:
4753 format = "__C4X_FORMAT__";
4759 if (TARGET_FLOAT_FORMAT != VAX_FLOAT_FORMAT)
4761 cpp_define (pfile, "__TARGET_USES_VAX_F_FLOAT__=0");
4762 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=0");
4763 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=0");
4764 cpp_define (pfile, "__TARGET_USES_VAX_H_FLOAT__=0");
4766 builtin_define_with_value ("__GCC_FLOAT_FORMAT__", format, 0);
4769 /* Define NAME with value TYPE precision. */
4771 builtin_define_type_precision (name, type)
4776 sprintf (buf, "%d", (int) TYPE_PRECISION (type));
4777 builtin_define_with_value (name, buf, 0);
4780 /* Hook that registers front end and target-specific built-ins. */
4782 cb_register_builtins (pfile)
4785 /* -undef turns off target-specific built-ins. */
4789 if (c_language == clk_cplusplus)
4791 if (SUPPORTS_ONE_ONLY)
4792 cpp_define (pfile, "__GXX_WEAK__=1");
4794 cpp_define (pfile, "__GXX_WEAK__=0");
4795 if (flag_exceptions)
4796 cpp_define (pfile, "__EXCEPTIONS");
4797 if (warn_deprecated)
4798 cpp_define (pfile, "__DEPRECATED");
4801 /* represents the C++ ABI version, always defined so it can be used while
4802 preprocessing C and assembler. */
4803 cpp_define (pfile, "__GXX_ABI_VERSION=102");
4805 /* libgcc needs to know this. */
4806 if (USING_SJLJ_EXCEPTIONS)
4807 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
4809 /* stddef.h needs to know these. */
4810 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4811 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4812 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4813 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4815 /* limits.h needs to know these. */
4816 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
4817 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
4818 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
4819 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
4820 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
4822 builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
4823 builtin_define_type_precision ("__WCHAR_BIT__", wchar_type_node);
4824 builtin_define_type_precision ("__SHRT_BIT__", short_integer_type_node);
4825 builtin_define_type_precision ("__INT_BIT__", integer_type_node);
4826 builtin_define_type_precision ("__LONG_BIT__", long_integer_type_node);
4827 builtin_define_type_precision ("__LONG_LONG_BIT__",
4828 long_long_integer_type_node);
4829 builtin_define_type_precision ("__FLOAT_BIT__", float_type_node);
4830 builtin_define_type_precision ("__DOUBLE_BIT__", double_type_node);
4831 builtin_define_type_precision ("__LONG_DOUBLE_BIT__", long_double_type_node);
4833 /* For use in assembly language. */
4834 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
4835 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
4838 builtin_define_with_value ("__VERSION__", version_string, 1);
4840 /* Other target-independent built-ins determined by command-line
4843 cpp_define (pfile, "__OPTIMIZE_SIZE__");
4845 cpp_define (pfile, "__OPTIMIZE__");
4848 cpp_define (pfile, "__STDC_HOSTED__=1");
4850 cpp_define (pfile, "__STDC_HOSTED__=0");
4852 if (fast_math_flags_set_p ())
4853 cpp_define (pfile, "__FAST_MATH__");
4855 cpp_define (pfile, "__NO_INLINE__");
4856 if (flag_signaling_nans)
4857 cpp_define (pfile, "__SUPPORT_SNAN__");
4858 if (flag_finite_math_only)
4859 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
4861 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
4864 cpp_define (pfile, "__STRICT_ANSI__");
4866 if (!flag_signed_char)
4867 cpp_define (pfile, "__CHAR_UNSIGNED__");
4869 if (c_language == clk_cplusplus && TREE_UNSIGNED (wchar_type_node))
4870 cpp_define (pfile, "__WCHAR_UNSIGNED__");
4872 cpp_define_data_format (pfile);
4874 /* Make the choice of ObjC runtime visible to source code. */
4875 if (flag_objc && flag_next_runtime)
4876 cpp_define (pfile, "__NEXT_RUNTIME__");
4878 /* A straightforward target hook doesn't work, because of problems
4879 linking that hook's body when part of non-C front ends. */
4880 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
4881 # define builtin_define(TXT) cpp_define (pfile, TXT)
4882 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
4883 TARGET_CPU_CPP_BUILTINS ();
4884 TARGET_OS_CPP_BUILTINS ();
4887 /* Pass an object-like macro. If it doesn't lie in the user's
4888 namespace, defines it unconditionally. Otherwise define a version
4889 with two leading underscores, and another version with two leading
4890 and trailing underscores, and define the original only if an ISO
4891 standard was not nominated.
4893 e.g. passing "unix" defines "__unix", "__unix__" and possibly
4894 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
4897 builtin_define_std (macro)
4900 size_t len = strlen (macro);
4901 char *buff = alloca (len + 5);
4905 /* prepend __ (or maybe just _) if in user's namespace. */
4906 memcpy (p, macro, len + 1);
4907 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
4914 cpp_define (parse_in, p);
4916 /* If it was in user's namespace... */
4919 /* Define the macro with leading and following __. */
4925 cpp_define (parse_in, p);
4927 /* Finally, define the original macro if permitted. */
4929 cpp_define (parse_in, macro);
4933 /* Pass an object-like macro and a value to define it to. The third
4934 parameter says whether or not to turn the value into a string
4937 builtin_define_with_value (macro, expansion, is_str)
4939 const char *expansion;
4943 size_t mlen = strlen (macro);
4944 size_t elen = strlen (expansion);
4945 size_t extra = 2; /* space for an = and a NUL */
4948 extra += 2; /* space for two quote marks */
4950 buf = alloca (mlen + elen + extra);
4952 sprintf (buf, "%s=\"%s\"", macro, expansion);
4954 sprintf (buf, "%s=%s", macro, expansion);
4956 cpp_define (parse_in, buf);
4959 /* Define MAX for TYPE based on the precision of the type, which is assumed
4960 to be signed. IS_LONG is 1 for type "long" and 2 for "long long". */
4963 builtin_define_type_max (macro, type, is_long)
4970 size_t mlen, vlen, extra;
4972 /* Pre-rendering the values mean we don't have to futz with printing a
4973 multi-word decimal value. There are also a very limited number of
4974 precisions that we support, so it's really a waste of time. */
4975 switch (TYPE_PRECISION (type))
4984 value = "2147483647";
4987 value = "9223372036854775807";
4990 value = "170141183460469231731687303715884105727";
4996 mlen = strlen (macro);
4997 vlen = strlen (value);
4998 extra = 2 + is_long;
4999 buf = alloca (mlen + vlen + extra);
5001 sprintf (buf, "%s=%s%s", macro, value,
5002 (is_long == 1 ? "L" : is_long == 2 ? "LL" : ""));
5004 cpp_define (parse_in, buf);
5008 c_init_attributes ()
5010 /* Fill in the built_in_attributes array. */
5011 #define DEF_ATTR_NULL_TREE(ENUM) \
5012 built_in_attributes[(int) ENUM] = NULL_TREE;
5013 #define DEF_ATTR_INT(ENUM, VALUE) \
5014 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
5015 #define DEF_ATTR_IDENT(ENUM, STRING) \
5016 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5017 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5018 built_in_attributes[(int) ENUM] \
5019 = tree_cons (built_in_attributes[(int) PURPOSE], \
5020 built_in_attributes[(int) VALUE], \
5021 built_in_attributes[(int) CHAIN]);
5022 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
5023 #include "builtin-attrs.def"
5024 #undef DEF_ATTR_NULL_TREE
5026 #undef DEF_ATTR_IDENT
5027 #undef DEF_ATTR_TREE_LIST
5029 c_attrs_initialized = true;
5032 /* Depending on the name of DECL, apply default attributes to it. */
5035 c_common_insert_default_attributes (decl)
5038 tree name = DECL_NAME (decl);
5040 if (!c_attrs_initialized)
5041 c_init_attributes ();
5043 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
5044 #define DEF_ATTR_INT(ENUM, VALUE)
5045 #define DEF_ATTR_IDENT(ENUM, STRING)
5046 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
5047 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
5048 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
5049 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
5050 ATTR_FLAG_BUILT_IN);
5051 #include "builtin-attrs.def"
5052 #undef DEF_ATTR_NULL_TREE
5054 #undef DEF_ATTR_IDENT
5055 #undef DEF_ATTR_TREE_LIST
5059 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
5060 additionally give the location of the previous declaration DECL. */
5062 shadow_warning (msgid, name, decl)
5066 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
5067 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
5068 DECL_SOURCE_LINE (decl),
5069 "shadowed declaration is here");
5072 /* Attribute handlers common to C front ends. */
5074 /* Handle a "packed" attribute; arguments as in
5075 struct attribute_spec.handler. */
5078 handle_packed_attribute (node, name, args, flags, no_add_attrs)
5081 tree args ATTRIBUTE_UNUSED;
5088 if (TREE_CODE (*node) == TYPE_DECL)
5089 type = &TREE_TYPE (*node);
5096 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5097 *type = build_type_copy (*type);
5098 TYPE_PACKED (*type) = 1;
5100 else if (TREE_CODE (*node) == FIELD_DECL)
5101 DECL_PACKED (*node) = 1;
5102 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5103 used for DECL_REGISTER. It wouldn't mean anything anyway. */
5106 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5107 *no_add_attrs = true;
5113 /* Handle a "nocommon" attribute; arguments as in
5114 struct attribute_spec.handler. */
5117 handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
5120 tree args ATTRIBUTE_UNUSED;
5121 int flags ATTRIBUTE_UNUSED;
5124 if (TREE_CODE (*node) == VAR_DECL)
5125 DECL_COMMON (*node) = 0;
5128 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5129 *no_add_attrs = true;
5135 /* Handle a "common" attribute; arguments as in
5136 struct attribute_spec.handler. */
5139 handle_common_attribute (node, name, args, flags, no_add_attrs)
5142 tree args ATTRIBUTE_UNUSED;
5143 int flags ATTRIBUTE_UNUSED;
5146 if (TREE_CODE (*node) == VAR_DECL)
5147 DECL_COMMON (*node) = 1;
5150 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5151 *no_add_attrs = true;
5157 /* Handle a "noreturn" attribute; arguments as in
5158 struct attribute_spec.handler. */
5161 handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
5164 tree args ATTRIBUTE_UNUSED;
5165 int flags ATTRIBUTE_UNUSED;
5168 tree type = TREE_TYPE (*node);
5170 /* See FIXME comment in c_common_attribute_table. */
5171 if (TREE_CODE (*node) == FUNCTION_DECL)
5172 TREE_THIS_VOLATILE (*node) = 1;
5173 else if (TREE_CODE (type) == POINTER_TYPE
5174 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5176 = build_pointer_type
5177 (build_type_variant (TREE_TYPE (type),
5178 TREE_READONLY (TREE_TYPE (type)), 1));
5181 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5182 *no_add_attrs = true;
5188 /* Handle a "noinline" attribute; arguments as in
5189 struct attribute_spec.handler. */
5192 handle_noinline_attribute (node, name, args, flags, no_add_attrs)
5195 tree args ATTRIBUTE_UNUSED;
5196 int flags ATTRIBUTE_UNUSED;
5199 if (TREE_CODE (*node) == FUNCTION_DECL)
5200 DECL_UNINLINABLE (*node) = 1;
5203 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5204 *no_add_attrs = true;
5210 /* Handle a "always_inline" attribute; arguments as in
5211 struct attribute_spec.handler. */
5214 handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
5217 tree args ATTRIBUTE_UNUSED;
5218 int flags ATTRIBUTE_UNUSED;
5221 if (TREE_CODE (*node) == FUNCTION_DECL)
5223 /* Do nothing else, just set the attribute. We'll get at
5224 it later with lookup_attribute. */
5228 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5229 *no_add_attrs = true;
5235 /* Handle a "used" attribute; arguments as in
5236 struct attribute_spec.handler. */
5239 handle_used_attribute (node, name, args, flags, no_add_attrs)
5242 tree args ATTRIBUTE_UNUSED;
5243 int flags ATTRIBUTE_UNUSED;
5246 if (TREE_CODE (*node) == FUNCTION_DECL)
5247 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node))
5248 = TREE_USED (*node) = 1;
5251 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5252 *no_add_attrs = true;
5258 /* Handle a "unused" attribute; arguments as in
5259 struct attribute_spec.handler. */
5262 handle_unused_attribute (node, name, args, flags, no_add_attrs)
5265 tree args ATTRIBUTE_UNUSED;
5273 if (TREE_CODE (decl) == PARM_DECL
5274 || TREE_CODE (decl) == VAR_DECL
5275 || TREE_CODE (decl) == FUNCTION_DECL
5276 || TREE_CODE (decl) == LABEL_DECL
5277 || TREE_CODE (decl) == TYPE_DECL)
5278 TREE_USED (decl) = 1;
5281 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5282 *no_add_attrs = true;
5287 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5288 *node = build_type_copy (*node);
5289 TREE_USED (*node) = 1;
5295 /* Handle a "const" attribute; arguments as in
5296 struct attribute_spec.handler. */
5299 handle_const_attribute (node, name, args, flags, no_add_attrs)
5302 tree args ATTRIBUTE_UNUSED;
5303 int flags ATTRIBUTE_UNUSED;
5306 tree type = TREE_TYPE (*node);
5308 /* See FIXME comment on noreturn in c_common_attribute_table. */
5309 if (TREE_CODE (*node) == FUNCTION_DECL)
5310 TREE_READONLY (*node) = 1;
5311 else if (TREE_CODE (type) == POINTER_TYPE
5312 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5314 = build_pointer_type
5315 (build_type_variant (TREE_TYPE (type), 1,
5316 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5319 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5320 *no_add_attrs = true;
5326 /* Handle a "transparent_union" attribute; arguments as in
5327 struct attribute_spec.handler. */
5330 handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
5333 tree args ATTRIBUTE_UNUSED;
5337 tree decl = NULL_TREE;
5344 type = &TREE_TYPE (decl);
5345 is_type = TREE_CODE (*node) == TYPE_DECL;
5347 else if (TYPE_P (*node))
5348 type = node, is_type = 1;
5351 && TREE_CODE (*type) == UNION_TYPE
5353 || (TYPE_FIELDS (*type) != 0
5354 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
5356 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5357 *type = build_type_copy (*type);
5358 TYPE_TRANSPARENT_UNION (*type) = 1;
5360 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
5361 && TREE_CODE (*type) == UNION_TYPE
5362 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
5363 DECL_TRANSPARENT_UNION (decl) = 1;
5366 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5367 *no_add_attrs = true;
5373 /* Handle a "constructor" attribute; arguments as in
5374 struct attribute_spec.handler. */
5377 handle_constructor_attribute (node, name, args, flags, no_add_attrs)
5380 tree args ATTRIBUTE_UNUSED;
5381 int flags ATTRIBUTE_UNUSED;
5385 tree type = TREE_TYPE (decl);
5387 if (TREE_CODE (decl) == FUNCTION_DECL
5388 && TREE_CODE (type) == FUNCTION_TYPE
5389 && decl_function_context (decl) == 0)
5391 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5392 TREE_USED (decl) = 1;
5396 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5397 *no_add_attrs = true;
5403 /* Handle a "destructor" attribute; arguments as in
5404 struct attribute_spec.handler. */
5407 handle_destructor_attribute (node, name, args, flags, no_add_attrs)
5410 tree args ATTRIBUTE_UNUSED;
5411 int flags ATTRIBUTE_UNUSED;
5415 tree type = TREE_TYPE (decl);
5417 if (TREE_CODE (decl) == FUNCTION_DECL
5418 && TREE_CODE (type) == FUNCTION_TYPE
5419 && decl_function_context (decl) == 0)
5421 DECL_STATIC_DESTRUCTOR (decl) = 1;
5422 TREE_USED (decl) = 1;
5426 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5427 *no_add_attrs = true;
5433 /* Handle a "mode" attribute; arguments as in
5434 struct attribute_spec.handler. */
5437 handle_mode_attribute (node, name, args, flags, no_add_attrs)
5441 int flags ATTRIBUTE_UNUSED;
5446 *no_add_attrs = true;
5448 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5449 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5453 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5454 int len = strlen (p);
5455 enum machine_mode mode = VOIDmode;
5458 if (len > 4 && p[0] == '_' && p[1] == '_'
5459 && p[len - 1] == '_' && p[len - 2] == '_')
5461 char *newp = (char *) alloca (len - 1);
5463 strcpy (newp, &p[2]);
5464 newp[len - 4] = '\0';
5468 /* Change this type to have a type with the specified mode.
5469 First check for the special modes. */
5470 if (! strcmp (p, "byte"))
5472 else if (!strcmp (p, "word"))
5474 else if (! strcmp (p, "pointer"))
5477 for (j = 0; j < NUM_MACHINE_MODES; j++)
5478 if (!strcmp (p, GET_MODE_NAME (j)))
5479 mode = (enum machine_mode) j;
5481 if (mode == VOIDmode)
5482 error ("unknown machine mode `%s'", p);
5483 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
5484 (mode, TREE_UNSIGNED (type))))
5485 error ("no data type for mode `%s'", p);
5488 /* If this is a vector, make sure we either have hardware
5489 support, or we can emulate it. */
5490 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5491 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5492 && !vector_mode_valid_p (mode))
5494 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5499 /* No need to layout the type here. The caller should do this. */
5506 /* Handle a "section" attribute; arguments as in
5507 struct attribute_spec.handler. */
5510 handle_section_attribute (node, name, args, flags, no_add_attrs)
5512 tree name ATTRIBUTE_UNUSED;
5514 int flags ATTRIBUTE_UNUSED;
5519 if (targetm.have_named_sections)
5521 if ((TREE_CODE (decl) == FUNCTION_DECL
5522 || TREE_CODE (decl) == VAR_DECL)
5523 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5525 if (TREE_CODE (decl) == VAR_DECL
5526 && current_function_decl != NULL_TREE
5527 && ! TREE_STATIC (decl))
5529 error_with_decl (decl,
5530 "section attribute cannot be specified for local variables");
5531 *no_add_attrs = true;
5534 /* The decl may have already been given a section attribute
5535 from a previous declaration. Ensure they match. */
5536 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5537 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5538 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5540 error_with_decl (*node,
5541 "section of `%s' conflicts with previous declaration");
5542 *no_add_attrs = true;
5545 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5549 error_with_decl (*node,
5550 "section attribute not allowed for `%s'");
5551 *no_add_attrs = true;
5556 error_with_decl (*node,
5557 "section attributes are not supported for this target");
5558 *no_add_attrs = true;
5564 /* Handle a "aligned" attribute; arguments as in
5565 struct attribute_spec.handler. */
5568 handle_aligned_attribute (node, name, args, flags, no_add_attrs)
5570 tree name ATTRIBUTE_UNUSED;
5575 tree decl = NULL_TREE;
5578 tree align_expr = (args ? TREE_VALUE (args)
5579 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5585 type = &TREE_TYPE (decl);
5586 is_type = TREE_CODE (*node) == TYPE_DECL;
5588 else if (TYPE_P (*node))
5589 type = node, is_type = 1;
5591 /* Strip any NOPs of any kind. */
5592 while (TREE_CODE (align_expr) == NOP_EXPR
5593 || TREE_CODE (align_expr) == CONVERT_EXPR
5594 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
5595 align_expr = TREE_OPERAND (align_expr, 0);
5597 if (TREE_CODE (align_expr) != INTEGER_CST)
5599 error ("requested alignment is not a constant");
5600 *no_add_attrs = true;
5602 else if ((i = tree_log2 (align_expr)) == -1)
5604 error ("requested alignment is not a power of 2");
5605 *no_add_attrs = true;
5607 else if (i > HOST_BITS_PER_INT - 2)
5609 error ("requested alignment is too large");
5610 *no_add_attrs = true;
5614 /* If we have a TYPE_DECL, then copy the type, so that we
5615 don't accidentally modify a builtin type. See pushdecl. */
5616 if (decl && TREE_TYPE (decl) != error_mark_node
5617 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5619 tree tt = TREE_TYPE (decl);
5620 *type = build_type_copy (*type);
5621 DECL_ORIGINAL_TYPE (decl) = tt;
5622 TYPE_NAME (*type) = decl;
5623 TREE_USED (*type) = TREE_USED (decl);
5624 TREE_TYPE (decl) = *type;
5626 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5627 *type = build_type_copy (*type);
5629 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5630 TYPE_USER_ALIGN (*type) = 1;
5632 else if (TREE_CODE (decl) != VAR_DECL
5633 && TREE_CODE (decl) != FIELD_DECL)
5635 error_with_decl (decl,
5636 "alignment may not be specified for `%s'");
5637 *no_add_attrs = true;
5641 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5642 DECL_USER_ALIGN (decl) = 1;
5648 /* Handle a "weak" attribute; arguments as in
5649 struct attribute_spec.handler. */
5652 handle_weak_attribute (node, name, args, flags, no_add_attrs)
5654 tree name ATTRIBUTE_UNUSED;
5655 tree args ATTRIBUTE_UNUSED;
5656 int flags ATTRIBUTE_UNUSED;
5657 bool *no_add_attrs ATTRIBUTE_UNUSED;
5659 declare_weak (*node);
5664 /* Handle an "alias" attribute; arguments as in
5665 struct attribute_spec.handler. */
5668 handle_alias_attribute (node, name, args, flags, no_add_attrs)
5672 int flags ATTRIBUTE_UNUSED;
5677 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5678 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
5680 error_with_decl (decl,
5681 "`%s' defined both normally and as an alias");
5682 *no_add_attrs = true;
5684 else if (decl_function_context (decl) == 0)
5688 id = TREE_VALUE (args);
5689 if (TREE_CODE (id) != STRING_CST)
5691 error ("alias arg not a string");
5692 *no_add_attrs = true;
5695 id = get_identifier (TREE_STRING_POINTER (id));
5696 /* This counts as a use of the object pointed to. */
5699 if (TREE_CODE (decl) == FUNCTION_DECL)
5700 DECL_INITIAL (decl) = error_mark_node;
5702 DECL_EXTERNAL (decl) = 0;
5706 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5707 *no_add_attrs = true;
5713 /* Handle an "visibility" attribute; arguments as in
5714 struct attribute_spec.handler. */
5717 handle_visibility_attribute (node, name, args, flags, no_add_attrs)
5721 int flags ATTRIBUTE_UNUSED;
5726 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
5728 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5729 *no_add_attrs = true;
5735 id = TREE_VALUE (args);
5736 if (TREE_CODE (id) != STRING_CST)
5738 error ("visibility arg not a string");
5739 *no_add_attrs = true;
5742 if (strcmp (TREE_STRING_POINTER (id), "hidden")
5743 && strcmp (TREE_STRING_POINTER (id), "protected")
5744 && strcmp (TREE_STRING_POINTER (id), "internal"))
5746 error ("visibility arg must be one of \"hidden\", \"protected\" or \"internal\"");
5747 *no_add_attrs = true;
5755 /* Handle a "no_instrument_function" attribute; arguments as in
5756 struct attribute_spec.handler. */
5759 handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
5762 tree args ATTRIBUTE_UNUSED;
5763 int flags ATTRIBUTE_UNUSED;
5768 if (TREE_CODE (decl) != FUNCTION_DECL)
5770 error_with_decl (decl,
5771 "`%s' attribute applies only to functions",
5772 IDENTIFIER_POINTER (name));
5773 *no_add_attrs = true;
5775 else if (DECL_INITIAL (decl))
5777 error_with_decl (decl,
5778 "can't set `%s' attribute after definition",
5779 IDENTIFIER_POINTER (name));
5780 *no_add_attrs = true;
5783 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5788 /* Handle a "malloc" attribute; arguments as in
5789 struct attribute_spec.handler. */
5792 handle_malloc_attribute (node, name, args, flags, no_add_attrs)
5795 tree args ATTRIBUTE_UNUSED;
5796 int flags ATTRIBUTE_UNUSED;
5799 if (TREE_CODE (*node) == FUNCTION_DECL)
5800 DECL_IS_MALLOC (*node) = 1;
5801 /* ??? TODO: Support types. */
5804 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5805 *no_add_attrs = true;
5811 /* Handle a "no_limit_stack" attribute; arguments as in
5812 struct attribute_spec.handler. */
5815 handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
5818 tree args ATTRIBUTE_UNUSED;
5819 int flags ATTRIBUTE_UNUSED;
5824 if (TREE_CODE (decl) != FUNCTION_DECL)
5826 error_with_decl (decl,
5827 "`%s' attribute applies only to functions",
5828 IDENTIFIER_POINTER (name));
5829 *no_add_attrs = true;
5831 else if (DECL_INITIAL (decl))
5833 error_with_decl (decl,
5834 "can't set `%s' attribute after definition",
5835 IDENTIFIER_POINTER (name));
5836 *no_add_attrs = true;
5839 DECL_NO_LIMIT_STACK (decl) = 1;
5844 /* Handle a "pure" attribute; arguments as in
5845 struct attribute_spec.handler. */
5848 handle_pure_attribute (node, name, args, flags, no_add_attrs)
5851 tree args ATTRIBUTE_UNUSED;
5852 int flags ATTRIBUTE_UNUSED;
5855 if (TREE_CODE (*node) == FUNCTION_DECL)
5856 DECL_IS_PURE (*node) = 1;
5857 /* ??? TODO: Support types. */
5860 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5861 *no_add_attrs = true;
5867 /* Handle a "deprecated" attribute; arguments as in
5868 struct attribute_spec.handler. */
5871 handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
5874 tree args ATTRIBUTE_UNUSED;
5878 tree type = NULL_TREE;
5880 const char *what = NULL;
5885 type = TREE_TYPE (decl);
5887 if (TREE_CODE (decl) == TYPE_DECL
5888 || TREE_CODE (decl) == PARM_DECL
5889 || TREE_CODE (decl) == VAR_DECL
5890 || TREE_CODE (decl) == FUNCTION_DECL
5891 || TREE_CODE (decl) == FIELD_DECL)
5892 TREE_DEPRECATED (decl) = 1;
5896 else if (TYPE_P (*node))
5898 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5899 *node = build_type_copy (*node);
5900 TREE_DEPRECATED (*node) = 1;
5908 *no_add_attrs = true;
5909 if (type && TYPE_NAME (type))
5911 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5912 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5913 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5914 && DECL_NAME (TYPE_NAME (type)))
5915 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5918 warning ("`%s' attribute ignored for `%s'",
5919 IDENTIFIER_POINTER (name), what);
5921 warning ("`%s' attribute ignored",
5922 IDENTIFIER_POINTER (name));
5928 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5929 to prevent us from duplicating type nodes unnecessarily.
5930 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5931 since we want to distinguish types that are essentially identical (except
5932 for their debug representation), we use a local list here. */
5933 static tree vector_type_node_list = 0;
5935 /* Handle a "vector_size" attribute; arguments as in
5936 struct attribute_spec.handler. */
5939 handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
5943 int flags ATTRIBUTE_UNUSED;
5946 unsigned HOST_WIDE_INT vecsize, nunits;
5947 enum machine_mode mode, orig_mode, new_mode;
5948 tree type = *node, new_type = NULL_TREE;
5949 tree type_list_node;
5951 *no_add_attrs = true;
5953 if (! host_integerp (TREE_VALUE (args), 1))
5955 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5959 /* Get the vector size (in bytes). */
5960 vecsize = tree_low_cst (TREE_VALUE (args), 1);
5962 /* We need to provide for vector pointers, vector arrays, and
5963 functions returning vectors. For example:
5965 __attribute__((vector_size(16))) short *foo;
5967 In this case, the mode is SI, but the type being modified is
5968 HI, so we need to look further. */
5970 while (POINTER_TYPE_P (type)
5971 || TREE_CODE (type) == FUNCTION_TYPE
5972 || TREE_CODE (type) == ARRAY_TYPE)
5973 type = TREE_TYPE (type);
5975 /* Get the mode of the type being modified. */
5976 orig_mode = TYPE_MODE (type);
5978 if (TREE_CODE (type) == RECORD_TYPE
5979 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5980 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5981 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5983 error ("invalid vector type for attribute `%s'",
5984 IDENTIFIER_POINTER (name));
5988 /* Calculate how many units fit in the vector. */
5989 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5991 /* Find a suitably sized vector. */
5992 new_mode = VOIDmode;
5993 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5995 : MODE_VECTOR_FLOAT);
5997 mode = GET_MODE_WIDER_MODE (mode))
5998 if (vecsize == GET_MODE_SIZE (mode)
5999 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
6005 if (new_mode == VOIDmode)
6007 error ("no vector mode with the size and type specified could be found");
6011 for (type_list_node = vector_type_node_list; type_list_node;
6012 type_list_node = TREE_CHAIN (type_list_node))
6014 tree other_type = TREE_VALUE (type_list_node);
6015 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
6016 tree fields = TYPE_FIELDS (record);
6017 tree field_type = TREE_TYPE (fields);
6018 tree array_type = TREE_TYPE (field_type);
6019 if (TREE_CODE (fields) != FIELD_DECL
6020 || TREE_CODE (field_type) != ARRAY_TYPE)
6023 if (TYPE_MODE (other_type) == mode && type == array_type)
6025 new_type = other_type;
6030 if (new_type == NULL_TREE)
6032 tree index, array, rt, list_node;
6034 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
6035 TREE_UNSIGNED (type));
6039 error ("no vector mode with the size and type specified could be found");
6043 new_type = build_type_copy (new_type);
6045 /* If this is a vector, make sure we either have hardware
6046 support, or we can emulate it. */
6047 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
6048 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
6049 && !vector_mode_valid_p (mode))
6051 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
6055 /* Set the debug information here, because this is the only
6056 place where we know the underlying type for a vector made
6057 with vector_size. For debugging purposes we pretend a vector
6058 is an array within a structure. */
6059 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
6060 array = build_array_type (type, build_index_type (index));
6061 rt = make_node (RECORD_TYPE);
6063 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
6064 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
6066 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
6068 list_node = build_tree_list (NULL, new_type);
6069 TREE_CHAIN (list_node) = vector_type_node_list;
6070 vector_type_node_list = list_node;
6073 /* Build back pointers if needed. */
6074 *node = vector_size_helper (*node, new_type);
6079 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
6082 If we requested a pointer to a vector, build up the pointers that
6083 we stripped off while looking for the inner type. Similarly for
6084 return values from functions.
6086 The argument "type" is the top of the chain, and "bottom" is the
6087 new type which we will point to. */
6090 vector_size_helper (type, bottom)
6095 if (POINTER_TYPE_P (type))
6097 inner = vector_size_helper (TREE_TYPE (type), bottom);
6098 outer = build_pointer_type (inner);
6100 else if (TREE_CODE (type) == ARRAY_TYPE)
6102 inner = vector_size_helper (TREE_TYPE (type), bottom);
6103 outer = build_array_type (inner, TYPE_VALUES (type));
6105 else if (TREE_CODE (type) == FUNCTION_TYPE)
6107 inner = vector_size_helper (TREE_TYPE (type), bottom);
6108 outer = build_function_type (inner, TYPE_VALUES (type));
6113 TREE_READONLY (outer) = TREE_READONLY (type);
6114 TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
6119 /* Handle the "nonnull" attribute. */
6121 handle_nonnull_attribute (node, name, args, flags, no_add_attrs)
6123 tree name ATTRIBUTE_UNUSED;
6125 int flags ATTRIBUTE_UNUSED;
6129 unsigned HOST_WIDE_INT attr_arg_num;
6131 /* If no arguments are specified, all pointer arguments should be
6132 non-null. Veryify a full prototype is given so that the arguments
6133 will have the correct types when we actually check them later. */
6136 if (! TYPE_ARG_TYPES (type))
6138 error ("nonnull attribute without arguments on a non-prototype");
6139 *no_add_attrs = true;
6144 /* Argument list specified. Verify that each argument number references
6145 a pointer argument. */
6146 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6149 unsigned HOST_WIDE_INT arg_num, ck_num;
6151 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6153 error ("nonnull argument has invalid operand number (arg %lu)",
6154 (unsigned long) attr_arg_num);
6155 *no_add_attrs = true;
6159 argument = TYPE_ARG_TYPES (type);
6162 for (ck_num = 1; ; ck_num++)
6164 if (! argument || ck_num == arg_num)
6166 argument = TREE_CHAIN (argument);
6170 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6172 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
6173 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6174 *no_add_attrs = true;
6178 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6180 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
6181 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6182 *no_add_attrs = true;
6191 /* Check the argument list of a function call for null in argument slots
6192 that are marked as requiring a non-null pointer argument. */
6195 check_function_nonnull (attrs, params)
6199 tree a, args, param;
6202 for (a = attrs; a; a = TREE_CHAIN (a))
6204 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6206 args = TREE_VALUE (a);
6208 /* Walk the argument list. If we encounter an argument number we
6209 should check for non-null, do it. If the attribute has no args,
6210 then every pointer argument is checked (in which case the check
6211 for pointer type is done in check_nonnull_arg). */
6212 for (param = params, param_num = 1; ;
6213 param_num++, param = TREE_CHAIN (param))
6217 if (! args || nonnull_check_p (args, param_num))
6218 check_function_arguments_recurse (check_nonnull_arg, NULL,
6226 /* Helper for check_function_nonnull; given a list of operands which
6227 must be non-null in ARGS, determine if operand PARAM_NUM should be
6231 nonnull_check_p (args, param_num)
6233 unsigned HOST_WIDE_INT param_num;
6235 unsigned HOST_WIDE_INT arg_num;
6237 for (; args; args = TREE_CHAIN (args))
6239 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6242 if (arg_num == param_num)
6248 /* Check that the function argument PARAM (which is operand number
6249 PARAM_NUM) is non-null. This is called by check_function_nonnull
6250 via check_function_arguments_recurse. */
6253 check_nonnull_arg (ctx, param, param_num)
6254 void *ctx ATTRIBUTE_UNUSED;
6256 unsigned HOST_WIDE_INT param_num;
6258 /* Just skip checking the argument if it's not a pointer. This can
6259 happen if the "nonnull" attribute was given without an operand
6260 list (which means to check every pointer argument). */
6262 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6265 if (integer_zerop (param))
6266 warning ("null argument where non-null required (arg %lu)",
6267 (unsigned long) param_num);
6270 /* Helper for nonnull attribute handling; fetch the operand number
6271 from the attribute argument list. */
6274 get_nonnull_operand (arg_num_expr, valp)
6276 unsigned HOST_WIDE_INT *valp;
6278 /* Strip any conversions from the arg number and verify they
6280 while (TREE_CODE (arg_num_expr) == NOP_EXPR
6281 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
6282 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
6283 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
6285 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6286 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6289 *valp = TREE_INT_CST_LOW (arg_num_expr);
6293 /* Handle a "nothrow" attribute; arguments as in
6294 struct attribute_spec.handler. */
6297 handle_nothrow_attribute (node, name, args, flags, no_add_attrs)
6300 tree args ATTRIBUTE_UNUSED;
6301 int flags ATTRIBUTE_UNUSED;
6304 if (TREE_CODE (*node) == FUNCTION_DECL)
6305 TREE_NOTHROW (*node) = 1;
6306 /* ??? TODO: Support types. */
6309 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6310 *no_add_attrs = true;
6316 /* Check for valid arguments being passed to a function. */
6318 check_function_arguments (attrs, params)
6322 /* Check for null being passed in a pointer argument that must be
6323 non-null. We also need to do this if format checking is enabled. */
6326 check_function_nonnull (attrs, params);
6328 /* Check for errors in format strings. */
6331 check_function_format (NULL, attrs, params);
6334 /* Generic argument checking recursion routine. PARAM is the argument to
6335 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6336 once the argument is resolved. CTX is context for the callback. */
6338 check_function_arguments_recurse (callback, ctx, param, param_num)
6339 void (*callback) PARAMS ((void *, tree, unsigned HOST_WIDE_INT));
6342 unsigned HOST_WIDE_INT param_num;
6344 if (TREE_CODE (param) == NOP_EXPR)
6346 /* Strip coercion. */
6347 check_function_arguments_recurse (callback, ctx,
6348 TREE_OPERAND (param, 0), param_num);
6352 if (TREE_CODE (param) == CALL_EXPR)
6354 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
6356 bool found_format_arg = false;
6358 /* See if this is a call to a known internationalization function
6359 that modifies a format arg. Such a function may have multiple
6360 format_arg attributes (for example, ngettext). */
6362 for (attrs = TYPE_ATTRIBUTES (type);
6364 attrs = TREE_CHAIN (attrs))
6365 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6368 tree format_num_expr;
6372 /* Extract the argument number, which was previously checked
6374 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6375 while (TREE_CODE (format_num_expr) == NOP_EXPR
6376 || TREE_CODE (format_num_expr) == CONVERT_EXPR
6377 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
6378 format_num_expr = TREE_OPERAND (format_num_expr, 0);
6380 if (TREE_CODE (format_num_expr) != INTEGER_CST
6381 || TREE_INT_CST_HIGH (format_num_expr) != 0)
6384 format_num = TREE_INT_CST_LOW (format_num_expr);
6386 for (inner_args = TREE_OPERAND (param, 1), i = 1;
6388 inner_args = TREE_CHAIN (inner_args), i++)
6389 if (i == format_num)
6391 check_function_arguments_recurse (callback, ctx,
6392 TREE_VALUE (inner_args),
6394 found_format_arg = true;
6399 /* If we found a format_arg attribute and did a recursive check,
6400 we are done with checking this argument. Otherwise, we continue
6401 and this will be considered a non-literal. */
6402 if (found_format_arg)
6406 if (TREE_CODE (param) == COND_EXPR)
6408 /* Check both halves of the conditional expression. */
6409 check_function_arguments_recurse (callback, ctx,
6410 TREE_OPERAND (param, 1), param_num);
6411 check_function_arguments_recurse (callback, ctx,
6412 TREE_OPERAND (param, 2), param_num);
6416 (*callback) (ctx, param, param_num);
6419 #include "gt-c-common.h"