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
24 #include "coretypes.h"
37 #include "diagnostic.h"
42 #include "langhooks.h"
43 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
44 #include "tree-inline.h"
46 cpp_reader *parse_in; /* Declared in c-pragma.h. */
48 /* We let tm.h override the types used here, to handle trivial differences
49 such as the choice of unsigned int or long unsigned int for size_t.
50 When machines start needing nontrivial differences in the size type,
51 it would be best to do something here to figure out automatically
52 from other information what type to use. */
55 #define SIZE_TYPE "long unsigned int"
59 #define WCHAR_TYPE "int"
62 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
63 #define MODIFIED_WCHAR_TYPE \
64 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
67 #define PTRDIFF_TYPE "long int"
71 #define WINT_TYPE "unsigned int"
75 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
77 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
83 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
85 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
86 ? "long unsigned int" \
87 : "long long unsigned int"))
90 #ifndef REGISTER_PREFIX
91 #define REGISTER_PREFIX ""
94 /* The variant of the C language being processed. */
96 enum c_language_kind c_language;
98 /* The following symbols are subsumed in the c_global_trees array, and
99 listed here individually for documentation purposes.
101 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
103 tree short_integer_type_node;
104 tree long_integer_type_node;
105 tree long_long_integer_type_node;
107 tree short_unsigned_type_node;
108 tree long_unsigned_type_node;
109 tree long_long_unsigned_type_node;
111 tree boolean_type_node;
112 tree boolean_false_node;
113 tree boolean_true_node;
115 tree ptrdiff_type_node;
117 tree unsigned_char_type_node;
118 tree signed_char_type_node;
119 tree wchar_type_node;
120 tree signed_wchar_type_node;
121 tree unsigned_wchar_type_node;
123 tree float_type_node;
124 tree double_type_node;
125 tree long_double_type_node;
127 tree complex_integer_type_node;
128 tree complex_float_type_node;
129 tree complex_double_type_node;
130 tree complex_long_double_type_node;
132 tree intQI_type_node;
133 tree intHI_type_node;
134 tree intSI_type_node;
135 tree intDI_type_node;
136 tree intTI_type_node;
138 tree unsigned_intQI_type_node;
139 tree unsigned_intHI_type_node;
140 tree unsigned_intSI_type_node;
141 tree unsigned_intDI_type_node;
142 tree unsigned_intTI_type_node;
144 tree widest_integer_literal_type_node;
145 tree widest_unsigned_literal_type_node;
147 Nodes for types `void *' and `const void *'.
149 tree ptr_type_node, const_ptr_type_node;
151 Nodes for types `char *' and `const char *'.
153 tree string_type_node, const_string_type_node;
155 Type `char[SOMENUMBER]'.
156 Used when an array of char is needed and the size is irrelevant.
158 tree char_array_type_node;
160 Type `int[SOMENUMBER]' or something like it.
161 Used when an array of int needed and the size is irrelevant.
163 tree int_array_type_node;
165 Type `wchar_t[SOMENUMBER]' or something like it.
166 Used when a wide string literal is created.
168 tree wchar_array_type_node;
170 Type `int ()' -- used for implicit declaration of functions.
172 tree default_function_type;
174 A VOID_TYPE node, packaged in a TREE_LIST.
178 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
179 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
180 VAR_DECLS, but C++ does.)
182 tree function_name_decl_node;
183 tree pretty_function_name_decl_node;
184 tree c99_function_name_decl_node;
186 Stack of nested function name VAR_DECLs.
188 tree saved_function_name_decls;
192 tree c_global_trees[CTI_MAX];
194 /* Nonzero if we can read a PCH file now. */
198 /* Switches common to the C front ends. */
200 /* Nonzero if prepreprocessing only. */
202 int flag_preprocess_only;
204 /* Nonzero means don't output line number information. */
206 char flag_no_line_commands;
208 /* Nonzero causes -E output not to be done, but directives such as
209 #define that have side effects are still obeyed. */
213 /* Nonzero means dump macros in some fashion. */
215 char flag_dump_macros;
217 /* Nonzero means pass #include lines through to the output. */
219 char flag_dump_includes;
221 /* The file name to which we should write a precompiled header, or
222 NULL if no header will be written in this compile. */
224 const char *pch_file;
226 /* Nonzero if an ISO standard was selected. It rejects macros in the
230 /* Nonzero whenever Objective-C functionality is being used. */
233 /* Nonzero if -undef was given. It suppresses target built-in macros
237 /* Nonzero means don't recognize the non-ANSI builtin functions. */
241 /* Nonzero means don't recognize the non-ANSI builtin functions.
244 int flag_no_nonansi_builtin;
246 /* Nonzero means give `double' the same size as `float'. */
248 int flag_short_double;
250 /* Nonzero means give `wchar_t' the same size as `short'. */
252 int flag_short_wchar;
254 /* Nonzero means allow Microsoft extensions without warnings or errors. */
255 int flag_ms_extensions;
257 /* Nonzero means don't recognize the keyword `asm'. */
261 /* Nonzero means give string constants the type `const char *', as mandated
264 int flag_const_strings;
266 /* Nonzero means `$' can be in an identifier. */
268 #ifndef DOLLARS_IN_IDENTIFIERS
269 #define DOLLARS_IN_IDENTIFIERS 1
271 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
273 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
275 int flag_signed_bitfields = 1;
276 int explicit_flag_signed_bitfields;
278 /* Nonzero means warn about pointer casts that can drop a type qualifier
279 from the pointer target type. */
283 /* Warn about functions which might be candidates for format attributes. */
285 int warn_missing_format_attribute;
287 /* Nonzero means warn about sizeof(function) or addition/subtraction
288 of function pointers. */
290 int warn_pointer_arith;
292 /* Nonzero means warn for any global function def
293 without separate previous prototype decl. */
295 int warn_missing_prototypes;
297 /* Warn if adding () is suggested. */
299 int warn_parentheses;
301 /* Warn if initializer is not completely bracketed. */
303 int warn_missing_braces;
305 /* Warn about comparison of signed and unsigned values.
306 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
308 int warn_sign_compare;
310 /* Nonzero means warn about usage of long long when `-pedantic'. */
312 int warn_long_long = 1;
314 /* Nonzero means warn about deprecated conversion from string constant to
317 int warn_write_strings;
319 /* Nonzero means warn about multiple (redundant) decls for the same single
320 variable or function. */
322 int warn_redundant_decls;
324 /* Warn about testing equality of floating point numbers. */
326 int warn_float_equal;
328 /* Warn about a subscript that has type char. */
330 int warn_char_subscripts;
332 /* Warn if a type conversion is done that might have confusing results. */
336 /* Warn about #pragma directives that are not recognized. */
338 int warn_unknown_pragmas; /* Tri state variable. */
340 /* Warn about format/argument anomalies in calls to formatted I/O functions
341 (*printf, *scanf, strftime, strfmon, etc.). */
345 /* Warn about Y2K problems with strftime formats. */
349 /* Warn about excess arguments to formats. */
351 int warn_format_extra_args;
353 /* Warn about zero-length formats. */
355 int warn_format_zero_length;
357 /* Warn about non-literal format arguments. */
359 int warn_format_nonliteral;
361 /* Warn about possible security problems with calls to format functions. */
363 int warn_format_security;
366 /* C/ObjC language option variables. */
369 /* Nonzero means message about use of implicit function declarations;
370 1 means warning; 2 means error. */
372 int mesg_implicit_function_declaration = -1;
374 /* Nonzero means allow type mismatches in conditional expressions;
375 just make their values `void'. */
377 int flag_cond_mismatch;
379 /* Nonzero means enable C89 Amendment 1 features. */
383 /* Nonzero means use the ISO C99 dialect of C. */
387 /* Nonzero means that we have builtin functions, and main is an int */
391 /* Nonzero means add default format_arg attributes for functions not
394 int flag_noniso_default_format_attributes = 1;
396 /* Nonzero means warn when casting a function call to a type that does
397 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
398 when there is no previous declaration of sqrt or malloc. */
400 int warn_bad_function_cast;
402 /* Warn about traditional constructs whose meanings changed in ANSI C. */
404 int warn_traditional;
406 /* Nonzero means warn for non-prototype function decls
407 or non-prototyped defs without previous prototype. */
409 int warn_strict_prototypes;
411 /* Nonzero means warn for any global function def
412 without separate previous decl. */
414 int warn_missing_declarations;
416 /* Nonzero means warn about declarations of objects not at
417 file-scope level and about *all* declarations of functions (whether
418 or static) not at file-scope level. Note that we exclude
419 implicit function declarations. To get warnings about those, use
422 int warn_nested_externs;
424 /* Warn if main is suspicious. */
428 /* Nonzero means warn about possible violations of sequence point rules. */
430 int warn_sequence_point;
432 /* Nonzero means to warn about compile-time division by zero. */
433 int warn_div_by_zero = 1;
435 /* Nonzero means warn about use of implicit int. */
437 int warn_implicit_int;
439 /* Warn about NULL being passed to argument slots marked as requiring
445 /* ObjC language option variables. */
448 /* Open and close the file for outputting class declarations, if
451 int flag_gen_declaration;
453 /* Generate code for GNU or NeXT runtime environment. */
455 #ifdef NEXT_OBJC_RUNTIME
456 int flag_next_runtime = 1;
458 int flag_next_runtime = 0;
461 /* Tells the compiler that this is a special run. Do not perform any
462 compiling, instead we are to test some platform dependent features
463 and output a C header file with appropriate definitions. */
465 int print_struct_values;
467 /* ???. Undocumented. */
469 const char *constant_string_class_name;
471 /* Warn if multiple methods are seen for the same selector, but with
472 different argument types. Performs the check on the whole selector
473 table at the end of compilation. */
477 /* Warn if a @selector() is found, and no method with that selector
478 has been previously declared. The check is done on each
479 @selector() as soon as it is found - so it warns about forward
482 int warn_undeclared_selector;
484 /* Warn if methods required by a protocol are not implemented in the
485 class adopting it. When turned off, methods inherited to that
486 class are also considered implemented. */
488 int warn_protocol = 1;
491 /* C++ language option variables. */
494 /* Nonzero means don't recognize any extension keywords. */
496 int flag_no_gnu_keywords;
498 /* Nonzero means do emit exported implementations of functions even if
499 they can be inlined. */
501 int flag_implement_inlines = 1;
503 /* Nonzero means do emit exported implementations of templates, instead of
504 multiple static copies in each file that needs a definition. */
506 int flag_external_templates;
508 /* Nonzero means that the decision to emit or not emit the implementation of a
509 template depends on where the template is instantiated, rather than where
512 int flag_alt_external_templates;
514 /* Nonzero means that implicit instantiations will be emitted if needed. */
516 int flag_implicit_templates = 1;
518 /* Nonzero means that implicit instantiations of inline templates will be
519 emitted if needed, even if instantiations of non-inline templates
522 int flag_implicit_inline_templates = 1;
524 /* Nonzero means generate separate instantiation control files and
525 juggle them at link time. */
527 int flag_use_repository;
529 /* Nonzero if we want to issue diagnostics that the standard says are not
532 int flag_optional_diags = 1;
534 /* Nonzero means we should attempt to elide constructors when possible. */
536 int flag_elide_constructors = 1;
538 /* Nonzero means that member functions defined in class scope are
539 inline by default. */
541 int flag_default_inline = 1;
543 /* Controls whether compiler generates 'type descriptor' that give
544 run-time type information. */
548 /* Nonzero if we want to conserve space in the .o files. We do this
549 by putting uninitialized data and runtime initialized data into
550 .common instead of .data at the expense of not flagging multiple
553 int flag_conserve_space;
555 /* Nonzero if we want to obey access control semantics. */
557 int flag_access_control = 1;
559 /* Nonzero if we want to check the return value of new and avoid calling
560 constructors if it is a null pointer. */
564 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
565 initialization variables.
566 0: Old rules, set by -fno-for-scope.
567 2: New ISO rules, set by -ffor-scope.
568 1: Try to implement new ISO rules, but with backup compatibility
569 (and warnings). This is the default, for now. */
571 int flag_new_for_scope = 1;
573 /* Nonzero if we want to emit defined symbols with common-like linkage as
574 weak symbols where possible, in order to conform to C++ semantics.
575 Otherwise, emit them as local symbols. */
579 /* Nonzero to use __cxa_atexit, rather than atexit, to register
580 destructors for local statics and global objects. */
582 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
584 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
588 /* Nonzero means make the default pedwarns warnings instead of errors.
589 The value of this flag is ignored if -pedantic is specified. */
593 /* Nonzero means to implement standard semantics for exception
594 specifications, calling unexpected if an exception is thrown that
595 doesn't match the specification. Zero means to treat them as
596 assertions and optimize accordingly, but not check them. */
598 int flag_enforce_eh_specs = 1;
600 /* The version of the C++ ABI in use. The following values are
603 0: The version of the ABI believed most conformant with the
604 C++ ABI specification. This ABI may change as bugs are
605 discovered and fixed. Therefore, 0 will not necessarily
606 indicate the same ABI in different versions of G++.
608 1: The version of the ABI first used in G++ 3.2.
610 Additional positive integers will be assigned as new versions of
611 the ABI become the default version of the ABI. */
613 int flag_abi_version = 1;
615 /* Nonzero means warn about things that will change when compiling
616 with an ABI-compliant compiler. */
620 /* Nonzero means warn about implicit declarations. */
622 int warn_implicit = 1;
624 /* Nonzero means warn when all ctors or dtors are private, and the class
627 int warn_ctor_dtor_privacy = 1;
629 /* Nonzero means warn in function declared in derived class has the
630 same name as a virtual in the base class, but fails to match the
631 type signature of any virtual function in the base class. */
633 int warn_overloaded_virtual;
635 /* Nonzero means warn when declaring a class that has a non virtual
636 destructor, when it really ought to have a virtual one. */
640 /* Nonzero means warn when the compiler will reorder code. */
644 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
648 /* Nonzero means warn when we convert a pointer to member function
649 into a pointer to (void or function). */
651 int warn_pmf2ptr = 1;
653 /* Nonzero means warn about violation of some Effective C++ style rules. */
657 /* Nonzero means warn where overload resolution chooses a promotion from
658 unsigned to signed over a conversion to an unsigned of the same size. */
662 /* Nonzero means warn when an old-style cast is used. */
664 int warn_old_style_cast;
666 /* Nonzero means warn when non-templatized friend functions are
667 declared within a template */
669 int warn_nontemplate_friend = 1;
671 /* Nonzero means complain about deprecated features. */
673 int warn_deprecated = 1;
675 /* Maximum template instantiation depth. This limit is rather
676 arbitrary, but it exists to limit the time it takes to notice
677 infinite template instantiations. */
679 int max_tinst_depth = 500;
683 /* The elements of `ridpointers' are identifier nodes for the reserved
684 type names and storage classes. It is indexed by a RID_... value. */
687 tree (*make_fname_decl) PARAMS ((tree, int));
689 /* If non-NULL, the address of a language-specific function that
690 returns 1 for language-specific statement codes. */
691 int (*lang_statement_code_p) PARAMS ((enum tree_code));
693 /* If non-NULL, the address of a language-specific function that takes
694 any action required right before expand_function_end is called. */
695 void (*lang_expand_function_end) PARAMS ((void));
697 /* Nonzero means the expression being parsed will never be evaluated.
698 This is a count, since unevaluated expressions can nest. */
701 /* Information about how a function name is generated. */
704 tree *const decl; /* pointer to the VAR_DECL. */
705 const unsigned rid; /* RID number for the identifier. */
706 const int pretty; /* How pretty is it? */
709 /* The three ways of getting then name of the current function. */
711 const struct fname_var_t fname_vars[] =
713 /* C99 compliant __func__, must be first. */
714 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
715 /* GCC __FUNCTION__ compliant. */
716 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
717 /* GCC __PRETTY_FUNCTION__ compliant. */
718 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
722 static int constant_fits_type_p PARAMS ((tree, tree));
724 /* Keep a stack of if statements. We record the number of compound
725 statements seen up to the if keyword, as well as the line number
726 and file of the if. If a potentially ambiguous else is seen, that
727 fact is recorded; the warning is issued when we can be sure that
728 the enclosing if statement does not have an else branch. */
738 static if_elt *if_stack;
740 /* Amount of space in the if statement stack. */
741 static int if_stack_space = 0;
744 static int if_stack_pointer = 0;
746 static tree handle_packed_attribute PARAMS ((tree *, tree, tree, int,
748 static tree handle_nocommon_attribute PARAMS ((tree *, tree, tree, int,
750 static tree handle_common_attribute PARAMS ((tree *, tree, tree, int,
752 static tree handle_noreturn_attribute PARAMS ((tree *, tree, tree, int,
754 static tree handle_noinline_attribute PARAMS ((tree *, tree, tree, int,
756 static tree handle_always_inline_attribute PARAMS ((tree *, tree, tree, int,
758 static tree handle_used_attribute PARAMS ((tree *, tree, tree, int,
760 static tree handle_unused_attribute PARAMS ((tree *, tree, tree, int,
762 static tree handle_const_attribute PARAMS ((tree *, tree, tree, int,
764 static tree handle_transparent_union_attribute PARAMS ((tree *, tree, tree,
766 static tree handle_constructor_attribute PARAMS ((tree *, tree, tree, int,
768 static tree handle_destructor_attribute PARAMS ((tree *, tree, tree, int,
770 static tree handle_mode_attribute PARAMS ((tree *, tree, tree, int,
772 static tree handle_section_attribute PARAMS ((tree *, tree, tree, int,
774 static tree handle_aligned_attribute PARAMS ((tree *, tree, tree, int,
776 static tree handle_weak_attribute PARAMS ((tree *, tree, tree, int,
778 static tree handle_alias_attribute PARAMS ((tree *, tree, tree, int,
780 static tree handle_visibility_attribute PARAMS ((tree *, tree, tree, int,
782 static tree handle_tls_model_attribute PARAMS ((tree *, tree, tree, int,
784 static tree handle_no_instrument_function_attribute PARAMS ((tree *, tree,
787 static tree handle_malloc_attribute PARAMS ((tree *, tree, tree, int,
789 static tree handle_no_limit_stack_attribute PARAMS ((tree *, tree, tree, int,
791 static tree handle_pure_attribute PARAMS ((tree *, tree, tree, int,
793 static tree handle_deprecated_attribute PARAMS ((tree *, tree, tree, int,
795 static tree handle_vector_size_attribute PARAMS ((tree *, tree, tree, int,
797 static tree handle_nonnull_attribute PARAMS ((tree *, tree, tree, int,
799 static tree handle_nothrow_attribute PARAMS ((tree *, tree, tree, int,
801 static tree vector_size_helper PARAMS ((tree, tree));
803 static void check_function_nonnull PARAMS ((tree, tree));
804 static void check_nonnull_arg PARAMS ((void *, tree,
805 unsigned HOST_WIDE_INT));
806 static bool nonnull_check_p PARAMS ((tree, unsigned HOST_WIDE_INT));
807 static bool get_nonnull_operand PARAMS ((tree,
808 unsigned HOST_WIDE_INT *));
809 void builtin_define_std PARAMS ((const char *));
810 static void builtin_define_with_value PARAMS ((const char *, const char *,
812 static void builtin_define_with_int_value PARAMS ((const char *,
814 static void builtin_define_with_hex_fp_value PARAMS ((const char *, tree,
817 static void builtin_define_type_max PARAMS ((const char *, tree, int));
818 static void builtin_define_type_precision PARAMS ((const char *, tree));
819 static void builtin_define_float_constants PARAMS ((const char *,
820 const char *, tree));
822 /* Table of machine-independent attributes common to all C-like languages. */
823 const struct attribute_spec c_common_attribute_table[] =
825 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
826 { "packed", 0, 0, false, false, false,
827 handle_packed_attribute },
828 { "nocommon", 0, 0, true, false, false,
829 handle_nocommon_attribute },
830 { "common", 0, 0, true, false, false,
831 handle_common_attribute },
832 /* FIXME: logically, noreturn attributes should be listed as
833 "false, true, true" and apply to function types. But implementing this
834 would require all the places in the compiler that use TREE_THIS_VOLATILE
835 on a decl to identify non-returning functions to be located and fixed
836 to check the function type instead. */
837 { "noreturn", 0, 0, true, false, false,
838 handle_noreturn_attribute },
839 { "volatile", 0, 0, true, false, false,
840 handle_noreturn_attribute },
841 { "noinline", 0, 0, true, false, false,
842 handle_noinline_attribute },
843 { "always_inline", 0, 0, true, false, false,
844 handle_always_inline_attribute },
845 { "used", 0, 0, true, false, false,
846 handle_used_attribute },
847 { "unused", 0, 0, false, false, false,
848 handle_unused_attribute },
849 /* The same comments as for noreturn attributes apply to const ones. */
850 { "const", 0, 0, true, false, false,
851 handle_const_attribute },
852 { "transparent_union", 0, 0, false, false, false,
853 handle_transparent_union_attribute },
854 { "constructor", 0, 0, true, false, false,
855 handle_constructor_attribute },
856 { "destructor", 0, 0, true, false, false,
857 handle_destructor_attribute },
858 { "mode", 1, 1, false, true, false,
859 handle_mode_attribute },
860 { "section", 1, 1, true, false, false,
861 handle_section_attribute },
862 { "aligned", 0, 1, false, false, false,
863 handle_aligned_attribute },
864 { "weak", 0, 0, true, false, false,
865 handle_weak_attribute },
866 { "alias", 1, 1, true, false, false,
867 handle_alias_attribute },
868 { "no_instrument_function", 0, 0, true, false, false,
869 handle_no_instrument_function_attribute },
870 { "malloc", 0, 0, true, false, false,
871 handle_malloc_attribute },
872 { "no_stack_limit", 0, 0, true, false, false,
873 handle_no_limit_stack_attribute },
874 { "pure", 0, 0, true, false, false,
875 handle_pure_attribute },
876 { "deprecated", 0, 0, false, false, false,
877 handle_deprecated_attribute },
878 { "vector_size", 1, 1, false, true, false,
879 handle_vector_size_attribute },
880 { "visibility", 1, 1, true, false, false,
881 handle_visibility_attribute },
882 { "tls_model", 1, 1, true, false, false,
883 handle_tls_model_attribute },
884 { "nonnull", 0, -1, false, true, true,
885 handle_nonnull_attribute },
886 { "nothrow", 0, 0, true, false, false,
887 handle_nothrow_attribute },
888 { "may_alias", 0, 0, false, true, false, NULL },
889 { NULL, 0, 0, false, false, false, NULL }
892 /* Give the specifications for the format attributes, used by C and all
895 const struct attribute_spec c_common_format_attribute_table[] =
897 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
898 { "format", 3, 3, false, true, true,
899 handle_format_attribute },
900 { "format_arg", 1, 1, false, true, true,
901 handle_format_arg_attribute },
902 { NULL, 0, 0, false, false, false, NULL }
905 /* Record the start of an if-then, and record the start of it
906 for ambiguous else detection.
908 COND is the condition for the if-then statement.
910 IF_STMT is the statement node that has already been created for
911 this if-then statement. It is created before parsing the
912 condition to keep line number information accurate. */
915 c_expand_start_cond (cond, compstmt_count, if_stmt)
920 /* Make sure there is enough space on the stack. */
921 if (if_stack_space == 0)
924 if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
926 else if (if_stack_space == if_stack_pointer)
928 if_stack_space += 10;
929 if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
932 IF_COND (if_stmt) = cond;
935 /* Record this if statement. */
936 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
937 if_stack[if_stack_pointer].file = input_filename;
938 if_stack[if_stack_pointer].line = lineno;
939 if_stack[if_stack_pointer].needs_warning = 0;
940 if_stack[if_stack_pointer].if_stmt = if_stmt;
944 /* Called after the then-clause for an if-statement is processed. */
949 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
950 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
953 /* Record the end of an if-then. Optionally warn if a nested
954 if statement had an ambiguous else clause. */
960 if (if_stack[if_stack_pointer].needs_warning)
961 warning_with_file_and_line (if_stack[if_stack_pointer].file,
962 if_stack[if_stack_pointer].line,
963 "suggest explicit braces to avoid ambiguous `else'");
964 last_expr_type = NULL_TREE;
967 /* Called between the then-clause and the else-clause
968 of an if-then-else. */
971 c_expand_start_else ()
973 /* An ambiguous else warning must be generated for the enclosing if
974 statement, unless we see an else branch for that one, too. */
976 && if_stack_pointer > 1
977 && (if_stack[if_stack_pointer - 1].compstmt_count
978 == if_stack[if_stack_pointer - 2].compstmt_count))
979 if_stack[if_stack_pointer - 2].needs_warning = 1;
981 /* Even if a nested if statement had an else branch, it can't be
982 ambiguous if this one also has an else. So don't warn in that
983 case. Also don't warn for any if statements nested in this else. */
984 if_stack[if_stack_pointer - 1].needs_warning = 0;
985 if_stack[if_stack_pointer - 1].compstmt_count--;
988 /* Called after the else-clause for an if-statement is processed. */
993 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
994 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
997 /* Begin an if-statement. Returns a newly created IF_STMT if
1000 Unlike the C++ front-end, we do not call add_stmt here; it is
1001 probably safe to do so, but I am not very familiar with this
1002 code so I am being extra careful not to change its behavior
1003 beyond what is strictly necessary for correctness. */
1009 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
1013 /* Begin a while statement. Returns a newly created WHILE_STMT if
1016 Unlike the C++ front-end, we do not call add_stmt here; it is
1017 probably safe to do so, but I am not very familiar with this
1018 code so I am being extra careful not to change its behavior
1019 beyond what is strictly necessary for correctness. */
1022 c_begin_while_stmt ()
1025 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
1030 c_finish_while_stmt_cond (cond, while_stmt)
1034 WHILE_COND (while_stmt) = cond;
1037 /* Push current bindings for the function name VAR_DECLS. */
1040 start_fname_decls ()
1043 tree saved = NULL_TREE;
1045 for (ix = 0; fname_vars[ix].decl; ix++)
1047 tree decl = *fname_vars[ix].decl;
1051 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
1052 *fname_vars[ix].decl = NULL_TREE;
1055 if (saved || saved_function_name_decls)
1056 /* Normally they'll have been NULL, so only push if we've got a
1057 stack, or they are non-NULL. */
1058 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1059 saved_function_name_decls);
1062 /* Finish up the current bindings, adding them into the
1063 current function's statement tree. This is done by wrapping the
1064 function's body in a COMPOUND_STMT containing these decls too. This
1065 must be done _before_ finish_stmt_tree is called. If there is no
1066 current function, we must be at file scope and no statements are
1067 involved. Pop the previous bindings. */
1070 finish_fname_decls ()
1073 tree body = NULL_TREE;
1074 tree stack = saved_function_name_decls;
1076 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1077 body = chainon (TREE_VALUE (stack), body);
1081 /* They were called into existence, so add to statement tree. Add
1082 the DECL_STMTs inside the outermost scope. */
1083 tree *p = &DECL_SAVED_TREE (current_function_decl);
1084 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1085 while (TREE_CODE (*p) != COMPOUND_STMT)
1086 p = &TREE_CHAIN (*p);
1087 p = &COMPOUND_BODY (*p);
1088 if (TREE_CODE (*p) == SCOPE_STMT)
1089 p = &TREE_CHAIN (*p);
1091 body = chainon (body, *p);
1095 for (ix = 0; fname_vars[ix].decl; ix++)
1096 *fname_vars[ix].decl = NULL_TREE;
1100 /* We had saved values, restore them. */
1103 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1105 tree decl = TREE_PURPOSE (saved);
1106 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1108 *fname_vars[ix].decl = decl;
1110 stack = TREE_CHAIN (stack);
1112 saved_function_name_decls = stack;
1115 /* Return the text name of the current function, suitably prettified
1119 fname_as_string (pretty_p)
1122 const char *name = NULL;
1125 name = (current_function_decl
1126 ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
1128 else if (current_function_decl && DECL_NAME (current_function_decl))
1129 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
1135 /* Return the text name of the current function, formatted as
1136 required by the supplied RID value. */
1144 for (ix = 0; fname_vars[ix].decl; ix++)
1145 if (fname_vars[ix].rid == rid)
1147 return fname_as_string (fname_vars[ix].pretty);
1150 /* Return the VAR_DECL for a const char array naming the current
1151 function. If the VAR_DECL has not yet been created, create it
1152 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1153 ID is its name (unfortunately C and C++ hold the RID values of
1154 keywords in different places, so we can't derive RID from ID in
1155 this language independent code. */
1158 fname_decl (rid, id)
1163 tree decl = NULL_TREE;
1165 for (ix = 0; fname_vars[ix].decl; ix++)
1166 if (fname_vars[ix].rid == rid)
1169 decl = *fname_vars[ix].decl;
1172 tree saved_last_tree = last_tree;
1173 /* If a tree is built here, it would normally have the lineno of
1174 the current statement. Later this tree will be moved to the
1175 beginning of the function and this line number will be wrong.
1176 To avoid this problem set the lineno to 0 here; that prevents
1177 it from appearing in the RTL. */
1178 int saved_lineno = lineno;
1181 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1182 if (last_tree != saved_last_tree)
1184 /* We created some statement tree for the decl. This belongs
1185 at the start of the function, so remove it now and reinsert
1186 it after the function is complete. */
1187 tree stmts = TREE_CHAIN (saved_last_tree);
1189 TREE_CHAIN (saved_last_tree) = NULL_TREE;
1190 last_tree = saved_last_tree;
1191 saved_function_name_decls = tree_cons (decl, stmts,
1192 saved_function_name_decls);
1194 *fname_vars[ix].decl = decl;
1195 lineno = saved_lineno;
1197 if (!ix && !current_function_decl)
1198 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
1203 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1206 fix_string_type (value)
1209 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1210 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1211 const int nchars_max = flag_isoc99 ? 4095 : 509;
1212 int length = TREE_STRING_LENGTH (value);
1215 /* Compute the number of elements, for the array type. */
1216 nchars = wide_flag ? length / wchar_bytes : length;
1218 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
1219 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1220 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1222 /* Create the array type for the string constant.
1223 -Wwrite-strings says make the string constant an array of const char
1224 so that copying it to a non-const pointer will get a warning.
1225 For C++, this is the standard behavior. */
1226 if (flag_const_strings && ! flag_writable_strings)
1229 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1232 = build_array_type (elements,
1233 build_index_type (build_int_2 (nchars - 1, 0)));
1237 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1238 build_index_type (build_int_2 (nchars - 1, 0)));
1240 TREE_CONSTANT (value) = 1;
1241 TREE_READONLY (value) = ! flag_writable_strings;
1242 TREE_STATIC (value) = 1;
1246 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1250 combine_strings (strings)
1251 varray_type strings;
1253 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1254 const int nstrings = VARRAY_ACTIVE_SIZE (strings);
1257 int wide_length = 0;
1262 /* Don't include the \0 at the end of each substring. Count wide
1263 strings and ordinary strings separately. */
1264 for (i = 0; i < nstrings; ++i)
1266 t = VARRAY_TREE (strings, i);
1268 if (TREE_TYPE (t) == wchar_array_type_node)
1270 wide_length += TREE_STRING_LENGTH (t) - wchar_bytes;
1275 length += (TREE_STRING_LENGTH (t) - 1);
1276 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
1277 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1281 /* If anything is wide, the non-wides will be converted,
1282 which makes them take more space. */
1284 length = length * wchar_bytes + wide_length;
1286 p = xmalloc (length);
1288 /* Copy the individual strings into the new combined string.
1289 If the combined string is wide, convert the chars to ints
1290 for any individual strings that are not wide. */
1293 for (i = 0; i < nstrings; ++i)
1297 t = VARRAY_TREE (strings, i);
1298 this_wide = TREE_TYPE (t) == wchar_array_type_node;
1299 len = TREE_STRING_LENGTH (t) - (this_wide ? wchar_bytes : 1);
1300 if (this_wide == wide_flag)
1302 memcpy (q, TREE_STRING_POINTER (t), len);
1307 const int nzeros = (TYPE_PRECISION (wchar_type_node)
1308 / BITS_PER_UNIT) - 1;
1311 if (BYTES_BIG_ENDIAN)
1313 for (k = 0; k < len; k++)
1315 for (j = 0; j < nzeros; j++)
1317 *q++ = TREE_STRING_POINTER (t)[k];
1322 for (k = 0; k < len; k++)
1324 *q++ = TREE_STRING_POINTER (t)[k];
1325 for (j = 0; j < nzeros; j++)
1332 /* Nul terminate the string. */
1335 for (i = 0; i < wchar_bytes; i++)
1341 value = build_string (length, p);
1345 TREE_TYPE (value) = wchar_array_type_node;
1347 TREE_TYPE (value) = char_array_type_node;
1352 static int is_valid_printf_arglist PARAMS ((tree));
1353 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1354 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1355 enum expand_modifier, int, int));
1356 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
1357 enum expand_modifier, int, int));
1359 /* Print a warning if a constant expression had overflow in folding.
1360 Invoke this function on every expression that the language
1361 requires to be a constant expression.
1362 Note the ANSI C standard says it is erroneous for a
1363 constant expression to overflow. */
1366 constant_expression_warning (value)
1369 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1370 || TREE_CODE (value) == VECTOR_CST
1371 || TREE_CODE (value) == COMPLEX_CST)
1372 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1373 pedwarn ("overflow in constant expression");
1376 /* Print a warning if an expression had overflow in folding.
1377 Invoke this function on every expression that
1378 (1) appears in the source code, and
1379 (2) might be a constant expression that overflowed, and
1380 (3) is not already checked by convert_and_check;
1381 however, do not invoke this function on operands of explicit casts. */
1384 overflow_warning (value)
1387 if ((TREE_CODE (value) == INTEGER_CST
1388 || (TREE_CODE (value) == COMPLEX_CST
1389 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1390 && TREE_OVERFLOW (value))
1392 TREE_OVERFLOW (value) = 0;
1393 if (skip_evaluation == 0)
1394 warning ("integer overflow in expression");
1396 else if ((TREE_CODE (value) == REAL_CST
1397 || (TREE_CODE (value) == COMPLEX_CST
1398 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1399 && TREE_OVERFLOW (value))
1401 TREE_OVERFLOW (value) = 0;
1402 if (skip_evaluation == 0)
1403 warning ("floating point overflow in expression");
1405 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1407 TREE_OVERFLOW (value) = 0;
1408 if (skip_evaluation == 0)
1409 warning ("vector overflow in expression");
1413 /* Print a warning if a large constant is truncated to unsigned,
1414 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1415 Invoke this function on every expression that might be implicitly
1416 converted to an unsigned type. */
1419 unsigned_conversion_warning (result, operand)
1420 tree result, operand;
1422 tree type = TREE_TYPE (result);
1424 if (TREE_CODE (operand) == INTEGER_CST
1425 && TREE_CODE (type) == INTEGER_TYPE
1426 && TREE_UNSIGNED (type)
1427 && skip_evaluation == 0
1428 && !int_fits_type_p (operand, type))
1430 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1431 /* This detects cases like converting -129 or 256 to unsigned char. */
1432 warning ("large integer implicitly truncated to unsigned type");
1433 else if (warn_conversion)
1434 warning ("negative integer implicitly converted to unsigned type");
1438 /* Nonzero if constant C has a value that is permissible
1439 for type TYPE (an INTEGER_TYPE). */
1442 constant_fits_type_p (c, type)
1445 if (TREE_CODE (c) == INTEGER_CST)
1446 return int_fits_type_p (c, type);
1448 c = convert (type, c);
1449 return !TREE_OVERFLOW (c);
1452 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1453 Invoke this function on every expression that is converted implicitly,
1454 i.e. because of language rules and not because of an explicit cast. */
1457 convert_and_check (type, expr)
1460 tree t = convert (type, expr);
1461 if (TREE_CODE (t) == INTEGER_CST)
1463 if (TREE_OVERFLOW (t))
1465 TREE_OVERFLOW (t) = 0;
1467 /* Do not diagnose overflow in a constant expression merely
1468 because a conversion overflowed. */
1469 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1471 /* No warning for converting 0x80000000 to int. */
1472 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1473 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1474 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1475 /* If EXPR fits in the unsigned version of TYPE,
1476 don't warn unless pedantic. */
1478 || TREE_UNSIGNED (type)
1479 || ! constant_fits_type_p (expr,
1480 c_common_unsigned_type (type)))
1481 && skip_evaluation == 0)
1482 warning ("overflow in implicit constant conversion");
1485 unsigned_conversion_warning (t, expr);
1490 /* A node in a list that describes references to variables (EXPR), which are
1491 either read accesses if WRITER is zero, or write accesses, in which case
1492 WRITER is the parent of EXPR. */
1499 /* Used to implement a cache the results of a call to verify_tree. We only
1500 use this for SAVE_EXPRs. */
1503 struct tlist_cache *next;
1504 struct tlist *cache_before_sp;
1505 struct tlist *cache_after_sp;
1509 /* Obstack to use when allocating tlist structures, and corresponding
1511 static struct obstack tlist_obstack;
1512 static char *tlist_firstobj = 0;
1514 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1516 static struct tlist *warned_ids;
1517 /* SAVE_EXPRs need special treatment. We process them only once and then
1518 cache the results. */
1519 static struct tlist_cache *save_expr_cache;
1521 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1522 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1523 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1524 static int warning_candidate_p PARAMS ((tree));
1525 static void warn_for_collisions PARAMS ((struct tlist *));
1526 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1527 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1528 static void verify_sequence_points PARAMS ((tree));
1530 /* Create a new struct tlist and fill in its fields. */
1531 static struct tlist *
1532 new_tlist (next, t, writer)
1538 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1545 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1546 is nonnull, we ignore any node we find which has a writer equal to it. */
1549 add_tlist (to, add, exclude_writer, copy)
1552 tree exclude_writer;
1557 struct tlist *next = add->next;
1560 if (! exclude_writer || add->writer != exclude_writer)
1561 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1566 /* Merge the nodes of ADD into TO. This merging process is done so that for
1567 each variable that already exists in TO, no new node is added; however if
1568 there is a write access recorded in ADD, and an occurrence on TO is only
1569 a read access, then the occurrence in TO will be modified to record the
1573 merge_tlist (to, add, copy)
1578 struct tlist **end = to;
1581 end = &(*end)->next;
1587 struct tlist *next = add->next;
1589 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1590 if (tmp2->expr == add->expr)
1594 tmp2->writer = add->writer;
1598 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1599 end = &(*end)->next;
1606 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1607 references in list LIST conflict with it, excluding reads if ONLY writers
1611 warn_for_collisions_1 (written, writer, list, only_writes)
1612 tree written, writer;
1618 /* Avoid duplicate warnings. */
1619 for (tmp = warned_ids; tmp; tmp = tmp->next)
1620 if (tmp->expr == written)
1625 if (list->expr == written
1626 && list->writer != writer
1627 && (! only_writes || list->writer))
1629 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1630 warning ("operation on `%s' may be undefined",
1631 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1637 /* Given a list LIST of references to variables, find whether any of these
1638 can cause conflicts due to missing sequence points. */
1641 warn_for_collisions (list)
1646 for (tmp = list; tmp; tmp = tmp->next)
1649 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1653 /* Return nonzero if X is a tree that can be verified by the sequence point
1656 warning_candidate_p (x)
1659 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1662 /* Walk the tree X, and record accesses to variables. If X is written by the
1663 parent tree, WRITER is the parent.
1664 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1665 expression or its only operand forces a sequence point, then everything up
1666 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1668 Once we return, we will have emitted warnings if any subexpression before
1669 such a sequence point could be undefined. On a higher level, however, the
1670 sequence point may not be relevant, and we'll merge the two lists.
1672 Example: (b++, a) + b;
1673 The call that processes the COMPOUND_EXPR will store the increment of B
1674 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1675 processes the PLUS_EXPR will need to merge the two lists so that
1676 eventually, all accesses end up on the same list (and we'll warn about the
1677 unordered subexpressions b++ and b.
1679 A note on merging. If we modify the former example so that our expression
1682 care must be taken not simply to add all three expressions into the final
1683 PNO_SP list. The function merge_tlist takes care of that by merging the
1684 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1685 way, so that no more than one access to B is recorded. */
1688 verify_tree (x, pbefore_sp, pno_sp, writer)
1690 struct tlist **pbefore_sp, **pno_sp;
1693 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1694 enum tree_code code;
1697 /* X may be NULL if it is the operand of an empty statement expression
1703 code = TREE_CODE (x);
1704 class = TREE_CODE_CLASS (code);
1706 if (warning_candidate_p (x))
1708 *pno_sp = new_tlist (*pno_sp, x, writer);
1718 case TRUTH_ANDIF_EXPR:
1719 case TRUTH_ORIF_EXPR:
1720 tmp_before = tmp_nosp = tmp_list3 = 0;
1721 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1722 warn_for_collisions (tmp_nosp);
1723 merge_tlist (pbefore_sp, tmp_before, 0);
1724 merge_tlist (pbefore_sp, tmp_nosp, 0);
1725 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1726 merge_tlist (pbefore_sp, tmp_list3, 0);
1730 tmp_before = tmp_list2 = 0;
1731 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1732 warn_for_collisions (tmp_list2);
1733 merge_tlist (pbefore_sp, tmp_before, 0);
1734 merge_tlist (pbefore_sp, tmp_list2, 1);
1736 tmp_list3 = tmp_nosp = 0;
1737 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1738 warn_for_collisions (tmp_nosp);
1739 merge_tlist (pbefore_sp, tmp_list3, 0);
1741 tmp_list3 = tmp_list2 = 0;
1742 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1743 warn_for_collisions (tmp_list2);
1744 merge_tlist (pbefore_sp, tmp_list3, 0);
1745 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1746 two first, to avoid warning for (a ? b++ : b++). */
1747 merge_tlist (&tmp_nosp, tmp_list2, 0);
1748 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1751 case PREDECREMENT_EXPR:
1752 case PREINCREMENT_EXPR:
1753 case POSTDECREMENT_EXPR:
1754 case POSTINCREMENT_EXPR:
1755 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1759 tmp_before = tmp_nosp = tmp_list3 = 0;
1760 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1761 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1762 /* Expressions inside the LHS are not ordered wrt. the sequence points
1763 in the RHS. Example:
1765 Despite the fact that the modification of "a" is in the before_sp
1766 list (tmp_before), it conflicts with the use of "a" in the LHS.
1767 We can handle this by adding the contents of tmp_list3
1768 to those of tmp_before, and redoing the collision warnings for that
1770 add_tlist (&tmp_before, tmp_list3, x, 1);
1771 warn_for_collisions (tmp_before);
1772 /* Exclude the LHS itself here; we first have to merge it into the
1773 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1774 didn't exclude the LHS, we'd get it twice, once as a read and once
1776 add_tlist (pno_sp, tmp_list3, x, 0);
1777 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1779 merge_tlist (pbefore_sp, tmp_before, 0);
1780 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1781 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1782 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1786 /* We need to warn about conflicts among arguments and conflicts between
1787 args and the function address. Side effects of the function address,
1788 however, are not ordered by the sequence point of the call. */
1789 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1790 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1791 if (TREE_OPERAND (x, 1))
1792 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1793 merge_tlist (&tmp_list3, tmp_list2, 0);
1794 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1795 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1796 warn_for_collisions (tmp_before);
1797 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1801 /* Scan all the list, e.g. indices of multi dimensional array. */
1804 tmp_before = tmp_nosp = 0;
1805 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1806 merge_tlist (&tmp_nosp, tmp_before, 0);
1807 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1814 struct tlist_cache *t;
1815 for (t = save_expr_cache; t; t = t->next)
1821 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1823 t->next = save_expr_cache;
1825 save_expr_cache = t;
1827 tmp_before = tmp_nosp = 0;
1828 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1829 warn_for_collisions (tmp_nosp);
1834 struct tlist *t = tmp_nosp;
1836 merge_tlist (&tmp_list3, t, 0);
1838 t->cache_before_sp = tmp_before;
1839 t->cache_after_sp = tmp_list3;
1841 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1842 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1851 if (first_rtl_op (code) == 0)
1853 x = TREE_OPERAND (x, 0);
1869 int max = first_rtl_op (TREE_CODE (x));
1870 for (lp = 0; lp < max; lp++)
1872 tmp_before = tmp_nosp = 0;
1873 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1874 merge_tlist (&tmp_nosp, tmp_before, 0);
1875 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1882 /* Try to warn for undefined behavior in EXPR due to missing sequence
1886 verify_sequence_points (expr)
1889 struct tlist *before_sp = 0, *after_sp = 0;
1892 save_expr_cache = 0;
1893 if (tlist_firstobj == 0)
1895 gcc_obstack_init (&tlist_obstack);
1896 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1899 verify_tree (expr, &before_sp, &after_sp, 0);
1900 warn_for_collisions (after_sp);
1901 obstack_free (&tlist_obstack, tlist_firstobj);
1905 c_expand_expr_stmt (expr)
1908 /* Do default conversion if safe and possibly important,
1909 in case within ({...}). */
1910 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1911 && (flag_isoc99 || lvalue_p (expr)))
1912 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1913 expr = default_conversion (expr);
1915 if (warn_sequence_point)
1916 verify_sequence_points (expr);
1918 if (TREE_TYPE (expr) != error_mark_node
1919 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1920 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1921 error ("expression statement has incomplete type");
1923 last_expr_type = TREE_TYPE (expr);
1924 return add_stmt (build_stmt (EXPR_STMT, expr));
1927 /* Validate the expression after `case' and apply default promotions. */
1930 check_case_value (value)
1933 if (value == NULL_TREE)
1936 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1937 STRIP_TYPE_NOPS (value);
1938 /* In C++, the following is allowed:
1941 switch (...) { case i: ... }
1943 So, we try to reduce the VALUE to a constant that way. */
1944 if (c_language == clk_cplusplus)
1946 value = decl_constant_value (value);
1947 STRIP_TYPE_NOPS (value);
1948 value = fold (value);
1951 if (TREE_CODE (value) != INTEGER_CST
1952 && value != error_mark_node)
1954 error ("case label does not reduce to an integer constant");
1955 value = error_mark_node;
1958 /* Promote char or short to int. */
1959 value = default_conversion (value);
1961 constant_expression_warning (value);
1966 /* Return an integer type with BITS bits of precision,
1967 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1970 c_common_type_for_size (bits, unsignedp)
1974 if (bits == TYPE_PRECISION (integer_type_node))
1975 return unsignedp ? unsigned_type_node : integer_type_node;
1977 if (bits == TYPE_PRECISION (signed_char_type_node))
1978 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1980 if (bits == TYPE_PRECISION (short_integer_type_node))
1981 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1983 if (bits == TYPE_PRECISION (long_integer_type_node))
1984 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1986 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1987 return (unsignedp ? long_long_unsigned_type_node
1988 : long_long_integer_type_node);
1990 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1991 return (unsignedp ? widest_unsigned_literal_type_node
1992 : widest_integer_literal_type_node);
1994 if (bits <= TYPE_PRECISION (intQI_type_node))
1995 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1997 if (bits <= TYPE_PRECISION (intHI_type_node))
1998 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2000 if (bits <= TYPE_PRECISION (intSI_type_node))
2001 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2003 if (bits <= TYPE_PRECISION (intDI_type_node))
2004 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2009 /* Return a data type that has machine mode MODE.
2010 If the mode is an integer,
2011 then UNSIGNEDP selects between signed and unsigned types. */
2014 c_common_type_for_mode (mode, unsignedp)
2015 enum machine_mode mode;
2018 if (mode == TYPE_MODE (integer_type_node))
2019 return unsignedp ? unsigned_type_node : integer_type_node;
2021 if (mode == TYPE_MODE (signed_char_type_node))
2022 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2024 if (mode == TYPE_MODE (short_integer_type_node))
2025 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2027 if (mode == TYPE_MODE (long_integer_type_node))
2028 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2030 if (mode == TYPE_MODE (long_long_integer_type_node))
2031 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2033 if (mode == TYPE_MODE (widest_integer_literal_type_node))
2034 return unsignedp ? widest_unsigned_literal_type_node
2035 : widest_integer_literal_type_node;
2038 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2041 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2044 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2047 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2049 #if HOST_BITS_PER_WIDE_INT >= 64
2050 if (mode == TYPE_MODE (intTI_type_node))
2051 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2054 if (mode == TYPE_MODE (float_type_node))
2055 return float_type_node;
2057 if (mode == TYPE_MODE (double_type_node))
2058 return double_type_node;
2060 if (mode == TYPE_MODE (long_double_type_node))
2061 return long_double_type_node;
2063 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2064 return build_pointer_type (char_type_node);
2066 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2067 return build_pointer_type (integer_type_node);
2072 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
2074 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
2076 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
2078 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
2080 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
2082 return unsignedp ? unsigned_V2HI_type_node : V2HI_type_node;
2084 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
2086 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
2088 return unsignedp ? unsigned_V1DI_type_node : V1DI_type_node;
2090 return V16SF_type_node;
2092 return V4SF_type_node;
2094 return V2SF_type_node;
2096 return V2DF_type_node;
2104 /* Return an unsigned type the same as TYPE in other respects. */
2106 c_common_unsigned_type (type)
2109 tree type1 = TYPE_MAIN_VARIANT (type);
2110 if (type1 == signed_char_type_node || type1 == char_type_node)
2111 return unsigned_char_type_node;
2112 if (type1 == integer_type_node)
2113 return unsigned_type_node;
2114 if (type1 == short_integer_type_node)
2115 return short_unsigned_type_node;
2116 if (type1 == long_integer_type_node)
2117 return long_unsigned_type_node;
2118 if (type1 == long_long_integer_type_node)
2119 return long_long_unsigned_type_node;
2120 if (type1 == widest_integer_literal_type_node)
2121 return widest_unsigned_literal_type_node;
2122 #if HOST_BITS_PER_WIDE_INT >= 64
2123 if (type1 == intTI_type_node)
2124 return unsigned_intTI_type_node;
2126 if (type1 == intDI_type_node)
2127 return unsigned_intDI_type_node;
2128 if (type1 == intSI_type_node)
2129 return unsigned_intSI_type_node;
2130 if (type1 == intHI_type_node)
2131 return unsigned_intHI_type_node;
2132 if (type1 == intQI_type_node)
2133 return unsigned_intQI_type_node;
2135 return c_common_signed_or_unsigned_type (1, type);
2138 /* Return a signed type the same as TYPE in other respects. */
2141 c_common_signed_type (type)
2144 tree type1 = TYPE_MAIN_VARIANT (type);
2145 if (type1 == unsigned_char_type_node || type1 == char_type_node)
2146 return signed_char_type_node;
2147 if (type1 == unsigned_type_node)
2148 return integer_type_node;
2149 if (type1 == short_unsigned_type_node)
2150 return short_integer_type_node;
2151 if (type1 == long_unsigned_type_node)
2152 return long_integer_type_node;
2153 if (type1 == long_long_unsigned_type_node)
2154 return long_long_integer_type_node;
2155 if (type1 == widest_unsigned_literal_type_node)
2156 return widest_integer_literal_type_node;
2157 #if HOST_BITS_PER_WIDE_INT >= 64
2158 if (type1 == unsigned_intTI_type_node)
2159 return intTI_type_node;
2161 if (type1 == unsigned_intDI_type_node)
2162 return intDI_type_node;
2163 if (type1 == unsigned_intSI_type_node)
2164 return intSI_type_node;
2165 if (type1 == unsigned_intHI_type_node)
2166 return intHI_type_node;
2167 if (type1 == unsigned_intQI_type_node)
2168 return intQI_type_node;
2170 return c_common_signed_or_unsigned_type (0, type);
2173 /* Return a type the same as TYPE except unsigned or
2174 signed according to UNSIGNEDP. */
2177 c_common_signed_or_unsigned_type (unsignedp, type)
2181 if (! INTEGRAL_TYPE_P (type)
2182 || TREE_UNSIGNED (type) == unsignedp)
2185 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2186 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2187 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2188 return unsignedp ? unsigned_type_node : integer_type_node;
2189 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2190 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2191 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2192 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2193 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2194 return (unsignedp ? long_long_unsigned_type_node
2195 : long_long_integer_type_node);
2196 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2197 return (unsignedp ? widest_unsigned_literal_type_node
2198 : widest_integer_literal_type_node);
2200 #if HOST_BITS_PER_WIDE_INT >= 64
2201 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
2202 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2204 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
2205 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2206 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
2207 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2208 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
2209 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2210 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
2211 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2216 /* Return the minimum number of bits needed to represent VALUE in a
2217 signed or unsigned type, UNSIGNEDP says which. */
2220 min_precision (value, unsignedp)
2226 /* If the value is negative, compute its negative minus 1. The latter
2227 adjustment is because the absolute value of the largest negative value
2228 is one larger than the largest positive value. This is equivalent to
2229 a bit-wise negation, so use that operation instead. */
2231 if (tree_int_cst_sgn (value) < 0)
2232 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2234 /* Return the number of bits needed, taking into account the fact
2235 that we need one more bit for a signed than unsigned type. */
2237 if (integer_zerop (value))
2240 log = tree_floor_log2 (value);
2242 return log + 1 + ! unsignedp;
2245 /* Print an error message for invalid operands to arith operation
2246 CODE. NOP_EXPR is used as a special case (see
2247 c_common_truthvalue_conversion). */
2250 binary_op_error (code)
2251 enum tree_code code;
2258 error ("invalid truth-value expression");
2262 opname = "+"; break;
2264 opname = "-"; break;
2266 opname = "*"; break;
2268 opname = "max"; break;
2270 opname = "min"; break;
2272 opname = "=="; break;
2274 opname = "!="; break;
2276 opname = "<="; break;
2278 opname = ">="; break;
2280 opname = "<"; break;
2282 opname = ">"; break;
2284 opname = "<<"; break;
2286 opname = ">>"; break;
2287 case TRUNC_MOD_EXPR:
2288 case FLOOR_MOD_EXPR:
2289 opname = "%"; break;
2290 case TRUNC_DIV_EXPR:
2291 case FLOOR_DIV_EXPR:
2292 opname = "/"; break;
2294 opname = "&"; break;
2296 opname = "|"; break;
2297 case TRUTH_ANDIF_EXPR:
2298 opname = "&&"; break;
2299 case TRUTH_ORIF_EXPR:
2300 opname = "||"; break;
2302 opname = "^"; break;
2305 opname = "rotate"; break;
2307 opname = "unknown"; break;
2309 error ("invalid operands to binary %s", opname);
2312 /* Subroutine of build_binary_op, used for comparison operations.
2313 See if the operands have both been converted from subword integer types
2314 and, if so, perhaps change them both back to their original type.
2315 This function is also responsible for converting the two operands
2316 to the proper common type for comparison.
2318 The arguments of this function are all pointers to local variables
2319 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2320 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2322 If this function returns nonzero, it means that the comparison has
2323 a constant value. What this function returns is an expression for
2327 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2328 tree *op0_ptr, *op1_ptr;
2330 enum tree_code *rescode_ptr;
2333 tree op0 = *op0_ptr;
2334 tree op1 = *op1_ptr;
2335 int unsignedp0, unsignedp1;
2337 tree primop0, primop1;
2338 enum tree_code code = *rescode_ptr;
2340 /* Throw away any conversions to wider types
2341 already present in the operands. */
2343 primop0 = get_narrower (op0, &unsignedp0);
2344 primop1 = get_narrower (op1, &unsignedp1);
2346 /* Handle the case that OP0 does not *contain* a conversion
2347 but it *requires* conversion to FINAL_TYPE. */
2349 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2350 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2351 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2352 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2354 /* If one of the operands must be floated, we cannot optimize. */
2355 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2356 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2358 /* If first arg is constant, swap the args (changing operation
2359 so value is preserved), for canonicalization. Don't do this if
2360 the second arg is 0. */
2362 if (TREE_CONSTANT (primop0)
2363 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2366 int temi = unsignedp0;
2374 unsignedp0 = unsignedp1;
2397 *rescode_ptr = code;
2400 /* If comparing an integer against a constant more bits wide,
2401 maybe we can deduce a value of 1 or 0 independent of the data.
2402 Or else truncate the constant now
2403 rather than extend the variable at run time.
2405 This is only interesting if the constant is the wider arg.
2406 Also, it is not safe if the constant is unsigned and the
2407 variable arg is signed, since in this case the variable
2408 would be sign-extended and then regarded as unsigned.
2409 Our technique fails in this case because the lowest/highest
2410 possible unsigned results don't follow naturally from the
2411 lowest/highest possible values of the variable operand.
2412 For just EQ_EXPR and NE_EXPR there is another technique that
2413 could be used: see if the constant can be faithfully represented
2414 in the other operand's type, by truncating it and reextending it
2415 and see if that preserves the constant's value. */
2417 if (!real1 && !real2
2418 && TREE_CODE (primop1) == INTEGER_CST
2419 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2421 int min_gt, max_gt, min_lt, max_lt;
2422 tree maxval, minval;
2423 /* 1 if comparison is nominally unsigned. */
2424 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2427 type = c_common_signed_or_unsigned_type (unsignedp0,
2428 TREE_TYPE (primop0));
2430 /* If TYPE is an enumeration, then we need to get its min/max
2431 values from it's underlying integral type, not the enumerated
2433 if (TREE_CODE (type) == ENUMERAL_TYPE)
2434 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2436 maxval = TYPE_MAX_VALUE (type);
2437 minval = TYPE_MIN_VALUE (type);
2439 if (unsignedp && !unsignedp0)
2440 *restype_ptr = c_common_signed_type (*restype_ptr);
2442 if (TREE_TYPE (primop1) != *restype_ptr)
2443 primop1 = convert (*restype_ptr, primop1);
2444 if (type != *restype_ptr)
2446 minval = convert (*restype_ptr, minval);
2447 maxval = convert (*restype_ptr, maxval);
2450 if (unsignedp && unsignedp0)
2452 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2453 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2454 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2455 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2459 min_gt = INT_CST_LT (primop1, minval);
2460 max_gt = INT_CST_LT (primop1, maxval);
2461 min_lt = INT_CST_LT (minval, primop1);
2462 max_lt = INT_CST_LT (maxval, primop1);
2466 /* This used to be a switch, but Genix compiler can't handle that. */
2467 if (code == NE_EXPR)
2469 if (max_lt || min_gt)
2470 val = boolean_true_node;
2472 else if (code == EQ_EXPR)
2474 if (max_lt || min_gt)
2475 val = boolean_false_node;
2477 else if (code == LT_EXPR)
2480 val = boolean_true_node;
2482 val = boolean_false_node;
2484 else if (code == GT_EXPR)
2487 val = boolean_true_node;
2489 val = boolean_false_node;
2491 else if (code == LE_EXPR)
2494 val = boolean_true_node;
2496 val = boolean_false_node;
2498 else if (code == GE_EXPR)
2501 val = boolean_true_node;
2503 val = boolean_false_node;
2506 /* If primop0 was sign-extended and unsigned comparison specd,
2507 we did a signed comparison above using the signed type bounds.
2508 But the comparison we output must be unsigned.
2510 Also, for inequalities, VAL is no good; but if the signed
2511 comparison had *any* fixed result, it follows that the
2512 unsigned comparison just tests the sign in reverse
2513 (positive values are LE, negative ones GE).
2514 So we can generate an unsigned comparison
2515 against an extreme value of the signed type. */
2517 if (unsignedp && !unsignedp0)
2524 primop1 = TYPE_MIN_VALUE (type);
2530 primop1 = TYPE_MAX_VALUE (type);
2537 type = c_common_unsigned_type (type);
2540 if (TREE_CODE (primop0) != INTEGER_CST)
2542 if (val == boolean_false_node)
2543 warning ("comparison is always false due to limited range of data type");
2544 if (val == boolean_true_node)
2545 warning ("comparison is always true due to limited range of data type");
2550 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2551 if (TREE_SIDE_EFFECTS (primop0))
2552 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2556 /* Value is not predetermined, but do the comparison
2557 in the type of the operand that is not constant.
2558 TYPE is already properly set. */
2560 else if (real1 && real2
2561 && (TYPE_PRECISION (TREE_TYPE (primop0))
2562 == TYPE_PRECISION (TREE_TYPE (primop1))))
2563 type = TREE_TYPE (primop0);
2565 /* If args' natural types are both narrower than nominal type
2566 and both extend in the same manner, compare them
2567 in the type of the wider arg.
2568 Otherwise must actually extend both to the nominal
2569 common type lest different ways of extending
2571 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2573 else if (unsignedp0 == unsignedp1 && real1 == real2
2574 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2575 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2577 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2578 type = c_common_signed_or_unsigned_type (unsignedp0
2579 || TREE_UNSIGNED (*restype_ptr),
2581 /* Make sure shorter operand is extended the right way
2582 to match the longer operand. */
2584 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2585 TREE_TYPE (primop0)),
2588 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2589 TREE_TYPE (primop1)),
2594 /* Here we must do the comparison on the nominal type
2595 using the args exactly as we received them. */
2596 type = *restype_ptr;
2600 if (!real1 && !real2 && integer_zerop (primop1)
2601 && TREE_UNSIGNED (*restype_ptr))
2607 /* All unsigned values are >= 0, so we warn if extra warnings
2608 are requested. However, if OP0 is a constant that is
2609 >= 0, the signedness of the comparison isn't an issue,
2610 so suppress the warning. */
2611 if (extra_warnings && !in_system_header
2612 && ! (TREE_CODE (primop0) == INTEGER_CST
2613 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2615 warning ("comparison of unsigned expression >= 0 is always true");
2616 value = boolean_true_node;
2620 if (extra_warnings && !in_system_header
2621 && ! (TREE_CODE (primop0) == INTEGER_CST
2622 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2624 warning ("comparison of unsigned expression < 0 is always false");
2625 value = boolean_false_node;
2634 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2635 if (TREE_SIDE_EFFECTS (primop0))
2636 return build (COMPOUND_EXPR, TREE_TYPE (value),
2643 *op0_ptr = convert (type, primop0);
2644 *op1_ptr = convert (type, primop1);
2646 *restype_ptr = boolean_type_node;
2651 /* Return a tree for the sum or difference (RESULTCODE says which)
2652 of pointer PTROP and integer INTOP. */
2655 pointer_int_sum (resultcode, ptrop, intop)
2656 enum tree_code resultcode;
2664 /* The result is a pointer of the same type that is being added. */
2666 tree result_type = TREE_TYPE (ptrop);
2668 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2670 if (pedantic || warn_pointer_arith)
2671 pedwarn ("pointer of type `void *' used in arithmetic");
2672 size_exp = integer_one_node;
2674 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2676 if (pedantic || warn_pointer_arith)
2677 pedwarn ("pointer to a function used in arithmetic");
2678 size_exp = integer_one_node;
2680 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2682 if (pedantic || warn_pointer_arith)
2683 pedwarn ("pointer to member function used in arithmetic");
2684 size_exp = integer_one_node;
2686 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2688 if (pedantic || warn_pointer_arith)
2689 pedwarn ("pointer to a member used in arithmetic");
2690 size_exp = integer_one_node;
2693 size_exp = size_in_bytes (TREE_TYPE (result_type));
2695 /* If what we are about to multiply by the size of the elements
2696 contains a constant term, apply distributive law
2697 and multiply that constant term separately.
2698 This helps produce common subexpressions. */
2700 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2701 && ! TREE_CONSTANT (intop)
2702 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2703 && TREE_CONSTANT (size_exp)
2704 /* If the constant comes from pointer subtraction,
2705 skip this optimization--it would cause an error. */
2706 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2707 /* If the constant is unsigned, and smaller than the pointer size,
2708 then we must skip this optimization. This is because it could cause
2709 an overflow error if the constant is negative but INTOP is not. */
2710 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2711 || (TYPE_PRECISION (TREE_TYPE (intop))
2712 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2714 enum tree_code subcode = resultcode;
2715 tree int_type = TREE_TYPE (intop);
2716 if (TREE_CODE (intop) == MINUS_EXPR)
2717 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2718 /* Convert both subexpression types to the type of intop,
2719 because weird cases involving pointer arithmetic
2720 can result in a sum or difference with different type args. */
2721 ptrop = build_binary_op (subcode, ptrop,
2722 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2723 intop = convert (int_type, TREE_OPERAND (intop, 0));
2726 /* Convert the integer argument to a type the same size as sizetype
2727 so the multiply won't overflow spuriously. */
2729 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2730 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2731 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2732 TREE_UNSIGNED (sizetype)), intop);
2734 /* Replace the integer argument with a suitable product by the object size.
2735 Do this multiplication as signed, then convert to the appropriate
2736 pointer type (actually unsigned integral). */
2738 intop = convert (result_type,
2739 build_binary_op (MULT_EXPR, intop,
2740 convert (TREE_TYPE (intop), size_exp), 1));
2742 /* Create the sum or difference. */
2744 result = build (resultcode, result_type, ptrop, intop);
2746 folded = fold (result);
2747 if (folded == result)
2748 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2752 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2753 or validate its data type for an `if' or `while' statement or ?..: exp.
2755 This preparation consists of taking the ordinary
2756 representation of an expression expr and producing a valid tree
2757 boolean expression describing whether expr is nonzero. We could
2758 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2759 but we optimize comparisons, &&, ||, and !.
2761 The resulting type should always be `boolean_type_node'. */
2764 c_common_truthvalue_conversion (expr)
2767 if (TREE_CODE (expr) == ERROR_MARK)
2770 #if 0 /* This appears to be wrong for C++. */
2771 /* These really should return error_mark_node after 2.4 is stable.
2772 But not all callers handle ERROR_MARK properly. */
2773 switch (TREE_CODE (TREE_TYPE (expr)))
2776 error ("struct type value used where scalar is required");
2777 return boolean_false_node;
2780 error ("union type value used where scalar is required");
2781 return boolean_false_node;
2784 error ("array type value used where scalar is required");
2785 return boolean_false_node;
2792 switch (TREE_CODE (expr))
2795 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2796 case TRUTH_ANDIF_EXPR:
2797 case TRUTH_ORIF_EXPR:
2798 case TRUTH_AND_EXPR:
2800 case TRUTH_XOR_EXPR:
2801 case TRUTH_NOT_EXPR:
2802 TREE_TYPE (expr) = boolean_type_node;
2809 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2812 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2815 /* If we are taking the address of an external decl, it might be zero
2816 if it is weak, so we cannot optimize. */
2817 if (DECL_P (TREE_OPERAND (expr, 0))
2818 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2821 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2822 return build (COMPOUND_EXPR, boolean_type_node,
2823 TREE_OPERAND (expr, 0), boolean_true_node);
2825 return boolean_true_node;
2828 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2829 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2830 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2831 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2839 /* These don't change whether an object is nonzero or zero. */
2840 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2844 /* These don't change whether an object is zero or nonzero, but
2845 we can't ignore them if their second arg has side-effects. */
2846 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2847 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2848 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2850 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2853 /* Distribute the conversion into the arms of a COND_EXPR. */
2854 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2855 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2856 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2859 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2860 since that affects how `default_conversion' will behave. */
2861 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2862 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2864 /* fall through... */
2866 /* If this is widening the argument, we can ignore it. */
2867 if (TYPE_PRECISION (TREE_TYPE (expr))
2868 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2869 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2873 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2874 aren't guaranteed to the be same for modes that can represent
2875 infinity, since if x and y are both +infinity, or both
2876 -infinity, then x - y is not a number.
2878 Note that this transformation is safe when x or y is NaN.
2879 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2881 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2883 /* fall through... */
2885 /* This and MINUS_EXPR can be changed into a comparison of the
2887 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2888 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2889 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2890 TREE_OPERAND (expr, 1), 1);
2891 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2892 fold (build1 (NOP_EXPR,
2893 TREE_TYPE (TREE_OPERAND (expr, 0)),
2894 TREE_OPERAND (expr, 1))), 1);
2897 if (integer_onep (TREE_OPERAND (expr, 1))
2898 && TREE_TYPE (expr) != boolean_type_node)
2899 /* Using convert here would cause infinite recursion. */
2900 return build1 (NOP_EXPR, boolean_type_node, expr);
2904 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2905 warning ("suggest parentheses around assignment used as truth value");
2912 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2914 tree t = save_expr (expr);
2915 return (build_binary_op
2916 ((TREE_SIDE_EFFECTS (expr)
2917 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2918 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2919 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2923 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2926 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2927 int, enum built_in_class, int, int,
2930 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2931 down to the element type of an array. */
2934 c_build_qualified_type (type, type_quals)
2938 /* A restrict-qualified pointer type must be a pointer to object or
2939 incomplete type. Note that the use of POINTER_TYPE_P also allows
2940 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2941 the C++ front-end also use POINTER_TYPE for pointer-to-member
2942 values, so even though it should be illegal to use `restrict'
2943 with such an entity we don't flag that here. Thus, special case
2944 code for that case is required in the C++ front-end. */
2945 if ((type_quals & TYPE_QUAL_RESTRICT)
2946 && (!POINTER_TYPE_P (type)
2947 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2949 error ("invalid use of `restrict'");
2950 type_quals &= ~TYPE_QUAL_RESTRICT;
2953 if (TREE_CODE (type) == ARRAY_TYPE)
2954 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2956 TYPE_DOMAIN (type));
2957 return build_qualified_type (type, type_quals);
2960 /* Apply the TYPE_QUALS to the new DECL. */
2963 c_apply_type_quals_to_decl (type_quals, decl)
2967 if ((type_quals & TYPE_QUAL_CONST)
2968 || (TREE_TYPE (decl)
2969 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2970 TREE_READONLY (decl) = 1;
2971 if (type_quals & TYPE_QUAL_VOLATILE)
2973 TREE_SIDE_EFFECTS (decl) = 1;
2974 TREE_THIS_VOLATILE (decl) = 1;
2976 if (type_quals & TYPE_QUAL_RESTRICT)
2978 if (!TREE_TYPE (decl)
2979 || !POINTER_TYPE_P (TREE_TYPE (decl))
2980 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2981 error ("invalid use of `restrict'");
2982 else if (flag_strict_aliasing)
2983 /* Indicate we need to make a unique alias set for this pointer.
2984 We can't do it here because it might be pointing to an
2986 DECL_POINTER_ALIAS_SET (decl) = -2;
2990 /* Return the typed-based alias set for T, which may be an expression
2991 or a type. Return -1 if we don't do anything special. */
2994 c_common_get_alias_set (t)
2999 /* Permit type-punning when accessing a union, provided the access
3000 is directly through the union. For example, this code does not
3001 permit taking the address of a union member and then storing
3002 through it. Even the type-punning allowed here is a GCC
3003 extension, albeit a common and useful one; the C standard says
3004 that such accesses have implementation-defined behavior. */
3006 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3007 u = TREE_OPERAND (u, 0))
3008 if (TREE_CODE (u) == COMPONENT_REF
3009 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3012 /* That's all the expressions we handle specially. */
3016 /* The C standard guarantees that any object may be accessed via an
3017 lvalue that has character type. */
3018 if (t == char_type_node
3019 || t == signed_char_type_node
3020 || t == unsigned_char_type_node)
3023 /* If it has the may_alias attribute, it can alias anything. */
3024 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
3027 /* The C standard specifically allows aliasing between signed and
3028 unsigned variants of the same type. We treat the signed
3029 variant as canonical. */
3030 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
3032 tree t1 = c_common_signed_type (t);
3034 /* t1 == t can happen for boolean nodes which are always unsigned. */
3036 return get_alias_set (t1);
3038 else if (POINTER_TYPE_P (t))
3042 /* Unfortunately, there is no canonical form of a pointer type.
3043 In particular, if we have `typedef int I', then `int *', and
3044 `I *' are different types. So, we have to pick a canonical
3045 representative. We do this below.
3047 Technically, this approach is actually more conservative that
3048 it needs to be. In particular, `const int *' and `int *'
3049 should be in different alias sets, according to the C and C++
3050 standard, since their types are not the same, and so,
3051 technically, an `int **' and `const int **' cannot point at
3054 But, the standard is wrong. In particular, this code is
3059 const int* const* cipp = &ipp;
3061 And, it doesn't make sense for that to be legal unless you
3062 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3063 the pointed-to types. This issue has been reported to the
3065 t1 = build_type_no_quals (t);
3067 return get_alias_set (t1);
3073 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3074 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3075 flag controls whether we should diagnose possibly ill-formed
3076 constructs or not. */
3078 c_sizeof_or_alignof_type (type, op, complain)
3083 const char *op_name;
3085 enum tree_code type_code = TREE_CODE (type);
3087 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
3088 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
3090 if (type_code == FUNCTION_TYPE)
3092 if (op == SIZEOF_EXPR)
3094 if (complain && (pedantic || warn_pointer_arith))
3095 pedwarn ("invalid application of `sizeof' to a function type");
3096 value = size_one_node;
3099 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3101 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3103 if (type_code == VOID_TYPE
3104 && complain && (pedantic || warn_pointer_arith))
3105 pedwarn ("invalid application of `%s' to a void type", op_name);
3106 value = size_one_node;
3108 else if (!COMPLETE_TYPE_P (type))
3111 error ("invalid application of `%s' to an incomplete type", op_name);
3112 value = size_zero_node;
3116 if (op == SIZEOF_EXPR)
3117 /* Convert in case a char is more than one unit. */
3118 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3119 size_int (TYPE_PRECISION (char_type_node)
3122 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
3125 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3126 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3127 never happen. However, this node should really have type
3128 `size_t', which is just a typedef for an ordinary integer type. */
3129 value = fold (build1 (NOP_EXPR, size_type_node, value));
3130 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
3135 /* Implement the __alignof keyword: Return the minimum required
3136 alignment of EXPR, measured in bytes. For VAR_DECL's and
3137 FIELD_DECL's return DECL_ALIGN (which can be set from an
3138 "aligned" __attribute__ specification). */
3141 c_alignof_expr (expr)
3146 if (TREE_CODE (expr) == VAR_DECL)
3147 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
3149 else if (TREE_CODE (expr) == COMPONENT_REF
3150 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3152 error ("`__alignof' applied to a bit-field");
3155 else if (TREE_CODE (expr) == COMPONENT_REF
3156 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3157 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
3159 else if (TREE_CODE (expr) == INDIRECT_REF)
3161 tree t = TREE_OPERAND (expr, 0);
3163 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3165 while (TREE_CODE (t) == NOP_EXPR
3166 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3170 t = TREE_OPERAND (t, 0);
3171 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3172 if (thisalign > bestalign)
3173 best = t, bestalign = thisalign;
3175 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3178 return c_alignof (TREE_TYPE (expr));
3180 return fold (build1 (NOP_EXPR, size_type_node, t));
3183 /* Handle C and C++ default attributes. */
3185 enum built_in_attribute
3187 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3188 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3189 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3190 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3191 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3192 #include "builtin-attrs.def"
3193 #undef DEF_ATTR_NULL_TREE
3195 #undef DEF_ATTR_IDENT
3196 #undef DEF_ATTR_TREE_LIST
3201 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3203 static bool c_attrs_initialized = false;
3205 static void c_init_attributes PARAMS ((void));
3207 /* Build tree nodes and builtin functions common to both C and C++ language
3211 c_common_nodes_and_builtins ()
3215 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3216 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3217 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3218 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3219 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3220 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3221 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3222 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3223 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3224 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3225 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3226 #include "builtin-types.def"
3227 #undef DEF_PRIMITIVE_TYPE
3228 #undef DEF_FUNCTION_TYPE_0
3229 #undef DEF_FUNCTION_TYPE_1
3230 #undef DEF_FUNCTION_TYPE_2
3231 #undef DEF_FUNCTION_TYPE_3
3232 #undef DEF_FUNCTION_TYPE_4
3233 #undef DEF_FUNCTION_TYPE_VAR_0
3234 #undef DEF_FUNCTION_TYPE_VAR_1
3235 #undef DEF_FUNCTION_TYPE_VAR_2
3236 #undef DEF_FUNCTION_TYPE_VAR_3
3237 #undef DEF_POINTER_TYPE
3241 typedef enum builtin_type builtin_type;
3243 tree builtin_types[(int) BT_LAST];
3244 int wchar_type_size;
3245 tree array_domain_type;
3246 tree va_list_ref_type_node;
3247 tree va_list_arg_type_node;
3249 /* Define `int' and `char' first so that dbx will output them first. */
3250 record_builtin_type (RID_INT, NULL, integer_type_node);
3251 record_builtin_type (RID_CHAR, "char", char_type_node);
3253 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3254 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3255 but not C. Are the conditionals here needed? */
3256 if (c_language == clk_cplusplus)
3257 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3258 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3259 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3260 record_builtin_type (RID_MAX, "long unsigned int",
3261 long_unsigned_type_node);
3262 if (c_language == clk_cplusplus)
3263 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3264 record_builtin_type (RID_MAX, "long long int",
3265 long_long_integer_type_node);
3266 record_builtin_type (RID_MAX, "long long unsigned int",
3267 long_long_unsigned_type_node);
3268 if (c_language == clk_cplusplus)
3269 record_builtin_type (RID_MAX, "long long unsigned",
3270 long_long_unsigned_type_node);
3271 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3272 record_builtin_type (RID_MAX, "short unsigned int",
3273 short_unsigned_type_node);
3274 if (c_language == clk_cplusplus)
3275 record_builtin_type (RID_MAX, "unsigned short",
3276 short_unsigned_type_node);
3278 /* Define both `signed char' and `unsigned char'. */
3279 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3280 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3282 /* These are types that c_common_type_for_size and
3283 c_common_type_for_mode use. */
3284 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3286 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3288 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3290 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3292 #if HOST_BITS_PER_WIDE_INT >= 64
3293 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3294 get_identifier ("__int128_t"),
3297 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3298 unsigned_intQI_type_node));
3299 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3300 unsigned_intHI_type_node));
3301 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3302 unsigned_intSI_type_node));
3303 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3304 unsigned_intDI_type_node));
3305 #if HOST_BITS_PER_WIDE_INT >= 64
3306 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3307 get_identifier ("__uint128_t"),
3308 unsigned_intTI_type_node));
3311 /* Create the widest literal types. */
3312 widest_integer_literal_type_node
3313 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3314 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3315 widest_integer_literal_type_node));
3317 widest_unsigned_literal_type_node
3318 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3319 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3320 widest_unsigned_literal_type_node));
3322 /* `unsigned long' is the standard type for sizeof.
3323 Note that stddef.h uses `unsigned long',
3324 and this must agree, even if long and int are the same size. */
3326 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3327 signed_size_type_node = c_common_signed_type (size_type_node);
3328 set_sizetype (size_type_node);
3330 build_common_tree_nodes_2 (flag_short_double);
3332 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3333 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3334 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3336 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3337 get_identifier ("complex int"),
3338 complex_integer_type_node));
3339 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3340 get_identifier ("complex float"),
3341 complex_float_type_node));
3342 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3343 get_identifier ("complex double"),
3344 complex_double_type_node));
3345 (*lang_hooks.decls.pushdecl)
3346 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3347 complex_long_double_type_node));
3349 /* Types which are common to the fortran compiler and libf2c. When
3350 changing these, you also need to be concerned with f/com.h. */
3352 if (TYPE_PRECISION (float_type_node)
3353 == TYPE_PRECISION (long_integer_type_node))
3355 g77_integer_type_node = long_integer_type_node;
3356 g77_uinteger_type_node = long_unsigned_type_node;
3358 else if (TYPE_PRECISION (float_type_node)
3359 == TYPE_PRECISION (integer_type_node))
3361 g77_integer_type_node = integer_type_node;
3362 g77_uinteger_type_node = unsigned_type_node;
3365 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3367 if (g77_integer_type_node != NULL_TREE)
3369 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3370 get_identifier ("__g77_integer"),
3371 g77_integer_type_node));
3372 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3373 get_identifier ("__g77_uinteger"),
3374 g77_uinteger_type_node));
3377 if (TYPE_PRECISION (float_type_node) * 2
3378 == TYPE_PRECISION (long_integer_type_node))
3380 g77_longint_type_node = long_integer_type_node;
3381 g77_ulongint_type_node = long_unsigned_type_node;
3383 else if (TYPE_PRECISION (float_type_node) * 2
3384 == TYPE_PRECISION (long_long_integer_type_node))
3386 g77_longint_type_node = long_long_integer_type_node;
3387 g77_ulongint_type_node = long_long_unsigned_type_node;
3390 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3392 if (g77_longint_type_node != NULL_TREE)
3394 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3395 get_identifier ("__g77_longint"),
3396 g77_longint_type_node));
3397 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3398 get_identifier ("__g77_ulongint"),
3399 g77_ulongint_type_node));
3402 record_builtin_type (RID_VOID, NULL, void_type_node);
3404 void_zero_node = build_int_2 (0, 0);
3405 TREE_TYPE (void_zero_node) = void_type_node;
3407 void_list_node = build_void_list_node ();
3409 /* Make a type to be the domain of a few array types
3410 whose domains don't really matter.
3411 200 is small enough that it always fits in size_t
3412 and large enough that it can hold most function names for the
3413 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3414 array_domain_type = build_index_type (size_int (200));
3416 /* Make a type for arrays of characters.
3417 With luck nothing will ever really depend on the length of this
3419 char_array_type_node
3420 = build_array_type (char_type_node, array_domain_type);
3422 /* Likewise for arrays of ints. */
3424 = build_array_type (integer_type_node, array_domain_type);
3426 string_type_node = build_pointer_type (char_type_node);
3427 const_string_type_node
3428 = build_pointer_type (build_qualified_type
3429 (char_type_node, TYPE_QUAL_CONST));
3431 (*targetm.init_builtins) ();
3433 /* This is special for C++ so functions can be overloaded. */
3434 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3435 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3436 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3437 if (c_language == clk_cplusplus)
3439 if (TREE_UNSIGNED (wchar_type_node))
3440 wchar_type_node = make_unsigned_type (wchar_type_size);
3442 wchar_type_node = make_signed_type (wchar_type_size);
3443 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3447 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3448 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3451 /* This is for wide string constants. */
3452 wchar_array_type_node
3453 = build_array_type (wchar_type_node, array_domain_type);
3456 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3459 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3461 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3463 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3465 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3466 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3468 (*lang_hooks.decls.pushdecl)
3469 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3470 va_list_type_node));
3472 (*lang_hooks.decls.pushdecl)
3473 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3474 ptrdiff_type_node));
3476 (*lang_hooks.decls.pushdecl)
3477 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3480 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3482 va_list_arg_type_node = va_list_ref_type_node =
3483 build_pointer_type (TREE_TYPE (va_list_type_node));
3487 va_list_arg_type_node = va_list_type_node;
3488 va_list_ref_type_node = build_reference_type (va_list_type_node);
3491 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3492 builtin_types[(int) ENUM] = VALUE;
3493 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3494 builtin_types[(int) ENUM] \
3495 = build_function_type (builtin_types[(int) RETURN], \
3497 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3498 builtin_types[(int) ENUM] \
3499 = build_function_type (builtin_types[(int) RETURN], \
3500 tree_cons (NULL_TREE, \
3501 builtin_types[(int) ARG1], \
3503 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3504 builtin_types[(int) ENUM] \
3505 = build_function_type \
3506 (builtin_types[(int) RETURN], \
3507 tree_cons (NULL_TREE, \
3508 builtin_types[(int) ARG1], \
3509 tree_cons (NULL_TREE, \
3510 builtin_types[(int) ARG2], \
3512 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3513 builtin_types[(int) ENUM] \
3514 = build_function_type \
3515 (builtin_types[(int) RETURN], \
3516 tree_cons (NULL_TREE, \
3517 builtin_types[(int) ARG1], \
3518 tree_cons (NULL_TREE, \
3519 builtin_types[(int) ARG2], \
3520 tree_cons (NULL_TREE, \
3521 builtin_types[(int) ARG3], \
3523 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3524 builtin_types[(int) ENUM] \
3525 = build_function_type \
3526 (builtin_types[(int) RETURN], \
3527 tree_cons (NULL_TREE, \
3528 builtin_types[(int) ARG1], \
3529 tree_cons (NULL_TREE, \
3530 builtin_types[(int) ARG2], \
3533 builtin_types[(int) ARG3], \
3534 tree_cons (NULL_TREE, \
3535 builtin_types[(int) ARG4], \
3536 void_list_node)))));
3537 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3538 builtin_types[(int) ENUM] \
3539 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3540 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3541 builtin_types[(int) ENUM] \
3542 = build_function_type (builtin_types[(int) RETURN], \
3543 tree_cons (NULL_TREE, \
3544 builtin_types[(int) ARG1], \
3547 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3548 builtin_types[(int) ENUM] \
3549 = build_function_type \
3550 (builtin_types[(int) RETURN], \
3551 tree_cons (NULL_TREE, \
3552 builtin_types[(int) ARG1], \
3553 tree_cons (NULL_TREE, \
3554 builtin_types[(int) ARG2], \
3557 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3558 builtin_types[(int) ENUM] \
3559 = build_function_type \
3560 (builtin_types[(int) RETURN], \
3561 tree_cons (NULL_TREE, \
3562 builtin_types[(int) ARG1], \
3563 tree_cons (NULL_TREE, \
3564 builtin_types[(int) ARG2], \
3565 tree_cons (NULL_TREE, \
3566 builtin_types[(int) ARG3], \
3569 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3570 builtin_types[(int) ENUM] \
3571 = build_pointer_type (builtin_types[(int) TYPE]);
3572 #include "builtin-types.def"
3573 #undef DEF_PRIMITIVE_TYPE
3574 #undef DEF_FUNCTION_TYPE_1
3575 #undef DEF_FUNCTION_TYPE_2
3576 #undef DEF_FUNCTION_TYPE_3
3577 #undef DEF_FUNCTION_TYPE_4
3578 #undef DEF_FUNCTION_TYPE_VAR_0
3579 #undef DEF_FUNCTION_TYPE_VAR_1
3580 #undef DEF_FUNCTION_TYPE_VAR_2
3581 #undef DEF_FUNCTION_TYPE_VAR_3
3582 #undef DEF_POINTER_TYPE
3584 if (!c_attrs_initialized)
3585 c_init_attributes ();
3587 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3588 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3593 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3597 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3600 ? (NAME + strlen ("__builtin_")) \
3602 built_in_attributes[(int) ATTRS]); \
3604 decl = builtin_function_2 (NAME, \
3605 NAME + strlen ("__builtin_"), \
3606 builtin_types[TYPE], \
3607 builtin_types[LIBTYPE], \
3612 built_in_attributes[(int) ATTRS]); \
3614 built_in_decls[(int) ENUM] = decl; \
3616 implicit_built_in_decls[(int) ENUM] = decl; \
3618 #include "builtins.def"
3621 main_identifier_node = get_identifier ("main");
3625 build_va_arg (expr, type)
3628 return build1 (VA_ARG_EXPR, type, expr);
3632 /* Linked list of disabled built-in functions. */
3634 typedef struct disabled_builtin
3637 struct disabled_builtin *next;
3639 static disabled_builtin *disabled_builtins = NULL;
3641 static bool builtin_function_disabled_p PARAMS ((const char *));
3643 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3644 begins with "__builtin_", give an error. */
3647 disable_builtin_function (name)
3650 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3651 error ("cannot disable built-in function `%s'", name);
3654 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3656 new->next = disabled_builtins;
3657 disabled_builtins = new;
3662 /* Return true if the built-in function NAME has been disabled, false
3666 builtin_function_disabled_p (name)
3669 disabled_builtin *p;
3670 for (p = disabled_builtins; p != NULL; p = p->next)
3672 if (strcmp (name, p->name) == 0)
3679 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3680 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3681 of these may be NULL (though both being NULL is useless).
3682 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3683 TYPE is the type of the function with the ordinary name. These
3684 may differ if the ordinary name is declared with a looser type to avoid
3685 conflicts with headers. FUNCTION_CODE and CLASS are as for
3686 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3687 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3688 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3689 ATTRS is the tree list representing the builtin's function attributes.
3690 Returns the declaration of BUILTIN_NAME, if any, otherwise
3691 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3692 or if NONANSI_P and flag_no_nonansi_builtin. */
3695 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3696 class, library_name_p, nonansi_p, attrs)
3697 const char *builtin_name;
3702 enum built_in_class class;
3707 tree bdecl = NULL_TREE;
3708 tree decl = NULL_TREE;
3709 if (builtin_name != 0)
3711 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3712 class, library_name_p ? name : NULL,
3715 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3716 && !(nonansi_p && flag_no_nonansi_builtin))
3718 decl = builtin_function (name, type, function_code, class, NULL,
3721 DECL_BUILT_IN_NONANSI (decl) = 1;
3723 return (bdecl != 0 ? bdecl : decl);
3726 /* Nonzero if the type T promotes to int. This is (nearly) the
3727 integral promotions defined in ISO C99 6.3.1.1/2. */
3730 c_promoting_integer_type_p (t)
3733 switch (TREE_CODE (t))
3736 return (TYPE_MAIN_VARIANT (t) == char_type_node
3737 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3738 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3739 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3740 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3741 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3744 /* ??? Technically all enumerations not larger than an int
3745 promote to an int. But this is used along code paths
3746 that only want to notice a size change. */
3747 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3757 /* Return 1 if PARMS specifies a fixed number of parameters
3758 and none of their types is affected by default promotions. */
3761 self_promoting_args_p (parms)
3765 for (t = parms; t; t = TREE_CHAIN (t))
3767 tree type = TREE_VALUE (t);
3769 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3775 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3778 if (c_promoting_integer_type_p (type))
3784 /* Recursively examines the array elements of TYPE, until a non-array
3785 element type is found. */
3788 strip_array_types (type)
3791 while (TREE_CODE (type) == ARRAY_TYPE)
3792 type = TREE_TYPE (type);
3797 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3800 /* Expand a call to an unordered comparison function such as
3801 __builtin_isgreater(). FUNCTION is the function's declaration and
3802 PARAMS a list of the values passed. For __builtin_isunordered(),
3803 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3804 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3805 that give the opposite of the desired result. UNORDERED_CODE is
3806 used for modes that can hold NaNs and ORDERED_CODE is used for the
3810 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3811 tree function, params;
3812 enum tree_code unordered_code, ordered_code;
3814 tree arg0, arg1, type;
3815 enum tree_code code0, code1;
3817 /* Check that we have exactly two arguments. */
3818 if (params == 0 || TREE_CHAIN (params) == 0)
3820 error ("too few arguments to function `%s'",
3821 IDENTIFIER_POINTER (DECL_NAME (function)));
3822 return error_mark_node;
3824 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3826 error ("too many arguments to function `%s'",
3827 IDENTIFIER_POINTER (DECL_NAME (function)));
3828 return error_mark_node;
3831 arg0 = TREE_VALUE (params);
3832 arg1 = TREE_VALUE (TREE_CHAIN (params));
3834 code0 = TREE_CODE (TREE_TYPE (arg0));
3835 code1 = TREE_CODE (TREE_TYPE (arg1));
3837 /* Make sure that the arguments have a common type of REAL. */
3839 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3840 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3841 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3843 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3845 error ("non-floating-point argument to function `%s'",
3846 IDENTIFIER_POINTER (DECL_NAME (function)));
3847 return error_mark_node;
3850 if (unordered_code == UNORDERED_EXPR)
3852 if (MODE_HAS_NANS (TYPE_MODE (type)))
3853 return build_binary_op (unordered_code,
3854 convert (type, arg0),
3855 convert (type, arg1),
3858 return integer_zero_node;
3861 return build_unary_op (TRUTH_NOT_EXPR,
3862 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3865 convert (type, arg0),
3866 convert (type, arg1),
3872 /* Recognize certain built-in functions so we can make tree-codes
3873 other than CALL_EXPR. We do this when it enables fold-const.c
3874 to do something useful. */
3875 /* ??? By rights this should go in builtins.c, but only C and C++
3876 implement build_{binary,unary}_op. Not exactly sure what bits
3877 of functionality are actually needed from those functions, or
3878 where the similar functionality exists in the other front ends. */
3881 expand_tree_builtin (function, params, coerced_params)
3882 tree function, params, coerced_params;
3884 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3887 switch (DECL_FUNCTION_CODE (function))
3891 case BUILT_IN_LLABS:
3892 case BUILT_IN_IMAXABS:
3894 case BUILT_IN_FABSL:
3895 case BUILT_IN_FABSF:
3896 if (coerced_params == 0)
3897 return integer_zero_node;
3898 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3901 case BUILT_IN_CONJF:
3902 case BUILT_IN_CONJL:
3903 if (coerced_params == 0)
3904 return integer_zero_node;
3905 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3907 case BUILT_IN_CREAL:
3908 case BUILT_IN_CREALF:
3909 case BUILT_IN_CREALL:
3910 if (coerced_params == 0)
3911 return integer_zero_node;
3912 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3914 case BUILT_IN_CIMAG:
3915 case BUILT_IN_CIMAGF:
3916 case BUILT_IN_CIMAGL:
3917 if (coerced_params == 0)
3918 return integer_zero_node;
3919 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3921 case BUILT_IN_ISGREATER:
3922 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3924 case BUILT_IN_ISGREATEREQUAL:
3925 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3927 case BUILT_IN_ISLESS:
3928 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3930 case BUILT_IN_ISLESSEQUAL:
3931 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3933 case BUILT_IN_ISLESSGREATER:
3934 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3936 case BUILT_IN_ISUNORDERED:
3937 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3946 /* Returns nonzero if CODE is the code for a statement. */
3949 statement_code_p (code)
3950 enum tree_code code;
3975 if (lang_statement_code_p)
3976 return (*lang_statement_code_p) (code);
3981 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3982 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3983 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3984 value, the traversal is aborted, and the value returned by FUNC is
3985 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3986 the node being visited are not walked.
3988 We don't need a without_duplicates variant of this one because the
3989 statement tree is a tree, not a graph. */
3992 walk_stmt_tree (tp, func, data)
3997 enum tree_code code;
4002 #define WALK_SUBTREE(NODE) \
4005 result = walk_stmt_tree (&(NODE), func, data); \
4011 /* Skip empty subtrees. */
4015 /* Skip subtrees below non-statement nodes. */
4016 if (!statement_code_p (TREE_CODE (*tp)))
4019 /* Call the function. */
4021 result = (*func) (tp, &walk_subtrees, data);
4023 /* If we found something, return it. */
4027 /* FUNC may have modified the tree, recheck that we're looking at a
4029 code = TREE_CODE (*tp);
4030 if (!statement_code_p (code))
4033 /* Visit the subtrees unless FUNC decided that there was nothing
4034 interesting below this point in the tree. */
4037 /* Walk over all the sub-trees of this operand. Statement nodes
4038 never contain RTL, and we needn't worry about TARGET_EXPRs. */
4039 len = TREE_CODE_LENGTH (code);
4041 /* Go through the subtrees. We need to do this in forward order so
4042 that the scope of a FOR_EXPR is handled properly. */
4043 for (i = 0; i < len; ++i)
4044 WALK_SUBTREE (TREE_OPERAND (*tp, i));
4047 /* Finally visit the chain. This can be tail-recursion optimized if
4048 we write it this way. */
4049 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
4054 /* Used to compare case labels. K1 and K2 are actually tree nodes
4055 representing case labels, or NULL_TREE for a `default' label.
4056 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4057 K2, and 0 if K1 and K2 are equal. */
4060 case_compare (k1, k2)
4064 /* Consider a NULL key (such as arises with a `default' label) to be
4065 smaller than anything else. */
4071 return tree_int_cst_compare ((tree) k1, (tree) k2);
4074 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4075 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4076 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4077 case label was declared using the usual C/C++ syntax, rather than
4078 the GNU case range extension. CASES is a tree containing all the
4079 case ranges processed so far; COND is the condition for the
4080 switch-statement itself. Returns the CASE_LABEL created, or
4081 ERROR_MARK_NODE if no CASE_LABEL is created. */
4084 c_add_case_label (cases, cond, low_value, high_value)
4093 splay_tree_node node;
4095 /* Create the LABEL_DECL itself. */
4096 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
4097 DECL_CONTEXT (label) = current_function_decl;
4099 /* If there was an error processing the switch condition, bail now
4100 before we get more confused. */
4101 if (!cond || cond == error_mark_node)
4103 /* Add a label anyhow so that the back-end doesn't think that
4104 the beginning of the switch is unreachable. */
4106 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4107 return error_mark_node;
4110 if ((low_value && TREE_TYPE (low_value)
4111 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4112 || (high_value && TREE_TYPE (high_value)
4113 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4114 error ("pointers are not permitted as case values");
4116 /* Case ranges are a GNU extension. */
4117 if (high_value && pedantic)
4119 if (c_language == clk_cplusplus)
4120 pedwarn ("ISO C++ forbids range expressions in switch statements");
4122 pedwarn ("ISO C forbids range expressions in switch statements");
4125 type = TREE_TYPE (cond);
4128 low_value = check_case_value (low_value);
4129 low_value = convert_and_check (type, low_value);
4133 high_value = check_case_value (high_value);
4134 high_value = convert_and_check (type, high_value);
4137 /* If an error has occurred, bail out now. */
4138 if (low_value == error_mark_node || high_value == error_mark_node)
4141 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4142 return error_mark_node;
4145 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4146 really a case range, even though it was written that way. Remove
4147 the HIGH_VALUE to simplify later processing. */
4148 if (tree_int_cst_equal (low_value, high_value))
4149 high_value = NULL_TREE;
4150 if (low_value && high_value
4151 && !tree_int_cst_lt (low_value, high_value))
4152 warning ("empty range specified");
4154 /* Look up the LOW_VALUE in the table of case labels we already
4156 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4157 /* If there was not an exact match, check for overlapping ranges.
4158 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4159 that's a `default' label and the only overlap is an exact match. */
4160 if (!node && (low_value || high_value))
4162 splay_tree_node low_bound;
4163 splay_tree_node high_bound;
4165 /* Even though there wasn't an exact match, there might be an
4166 overlap between this case range and another case range.
4167 Since we've (inductively) not allowed any overlapping case
4168 ranges, we simply need to find the greatest low case label
4169 that is smaller that LOW_VALUE, and the smallest low case
4170 label that is greater than LOW_VALUE. If there is an overlap
4171 it will occur in one of these two ranges. */
4172 low_bound = splay_tree_predecessor (cases,
4173 (splay_tree_key) low_value);
4174 high_bound = splay_tree_successor (cases,
4175 (splay_tree_key) low_value);
4177 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4178 the LOW_VALUE, so there is no need to check unless the
4179 LOW_BOUND is in fact itself a case range. */
4181 && CASE_HIGH ((tree) low_bound->value)
4182 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4185 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4186 range is bigger than the low end of the current range, so we
4187 are only interested if the current range is a real range, and
4188 not an ordinary case label. */
4191 && (tree_int_cst_compare ((tree) high_bound->key,
4196 /* If there was an overlap, issue an error. */
4199 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
4203 error ("duplicate (or overlapping) case value");
4204 error_with_decl (duplicate,
4205 "this is the first entry overlapping that value");
4209 error ("duplicate case value") ;
4210 error_with_decl (duplicate, "previously used here");
4214 error ("multiple default labels in one switch");
4215 error_with_decl (duplicate, "this is the first default label");
4218 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4221 /* Add a CASE_LABEL to the statement-tree. */
4222 case_label = add_stmt (build_case_label (low_value, high_value, label));
4223 /* Register this case label in the splay tree. */
4224 splay_tree_insert (cases,
4225 (splay_tree_key) low_value,
4226 (splay_tree_value) case_label);
4231 /* Finish an expression taking the address of LABEL. Returns an
4232 expression for the address. */
4235 finish_label_address_expr (label)
4242 if (c_language == clk_cplusplus)
4243 pedwarn ("ISO C++ forbids taking the address of a label");
4245 pedwarn ("ISO C forbids taking the address of a label");
4248 label = lookup_label (label);
4249 if (label == NULL_TREE)
4250 result = null_pointer_node;
4253 TREE_USED (label) = 1;
4254 result = build1 (ADDR_EXPR, ptr_type_node, label);
4255 TREE_CONSTANT (result) = 1;
4256 /* The current function in not necessarily uninlinable.
4257 Computed gotos are incompatible with inlining, but the value
4258 here could be used only in a diagnostic, for example. */
4264 /* Hook used by expand_expr to expand language-specific tree codes. */
4267 c_expand_expr (exp, target, tmode, modifier)
4270 enum machine_mode tmode;
4271 int modifier; /* Actually enum_modifier. */
4273 switch (TREE_CODE (exp))
4279 bool preserve_result = false;
4280 bool return_target = false;
4282 /* Since expand_expr_stmt calls free_temp_slots after every
4283 expression statement, we must call push_temp_slots here.
4284 Otherwise, any temporaries in use now would be considered
4285 out-of-scope after the first EXPR_STMT from within the
4288 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4290 /* If we want the result of this expression, find the last
4291 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4292 if (target != const0_rtx
4293 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4294 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4296 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4297 tree last = TREE_CHAIN (expr);
4299 while (TREE_CHAIN (last))
4302 last = TREE_CHAIN (last);
4305 if (TREE_CODE (last) == SCOPE_STMT
4306 && TREE_CODE (expr) == EXPR_STMT)
4308 if (target && TREE_CODE (EXPR_STMT_EXPR (expr)) == VAR_DECL
4309 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr)) == target)
4310 /* If the last expression is a variable whose RTL is the
4311 same as our target, just return the target; if it
4312 isn't valid expanding the decl would produce different
4313 RTL, and store_expr would try to do a copy. */
4314 return_target = true;
4317 /* Otherwise, note that we want the value from the last
4319 TREE_ADDRESSABLE (expr) = 1;
4320 preserve_result = true;
4325 expand_stmt (STMT_EXPR_STMT (exp));
4326 expand_end_stmt_expr (rtl_expr);
4328 result = expand_expr (rtl_expr, target, tmode, modifier);
4331 else if (preserve_result && GET_CODE (result) == MEM)
4333 if (GET_MODE (result) != BLKmode)
4334 result = copy_to_reg (result);
4336 preserve_temp_slots (result);
4339 /* If the statment-expression does not have a scope, then the
4340 new temporaries we created within it must live beyond the
4341 statement-expression. */
4342 if (STMT_EXPR_NO_SCOPE (exp))
4343 preserve_temp_slots (NULL_RTX);
4352 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
4353 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4355 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4356 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4357 == BUILT_IN_FRONTEND))
4358 return c_expand_builtin (exp, target, tmode, modifier);
4364 case COMPOUND_LITERAL_EXPR:
4366 /* Initialize the anonymous variable declared in the compound
4367 literal, then return the variable. */
4368 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4369 emit_local_var (decl);
4370 return expand_expr (decl, target, tmode, modifier);
4381 /* Hook used by safe_from_p to handle language-specific tree codes. */
4384 c_safe_from_p (target, exp)
4388 /* We can see statements here when processing the body of a
4389 statement-expression. For a declaration statement declaring a
4390 variable, look at the variable's initializer. */
4391 if (TREE_CODE (exp) == DECL_STMT)
4393 tree decl = DECL_STMT_DECL (exp);
4395 if (TREE_CODE (decl) == VAR_DECL
4396 && DECL_INITIAL (decl)
4397 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4401 /* For any statement, we must follow the statement-chain. */
4402 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
4403 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4405 /* Assume everything else is safe. */
4409 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4412 c_common_unsafe_for_reeval (exp)
4415 /* Statement expressions may not be reevaluated, likewise compound
4417 if (TREE_CODE (exp) == STMT_EXPR
4418 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4421 /* Walk all other expressions. */
4425 /* Hook used by staticp to handle language-specific tree codes. */
4431 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4432 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4437 #define CALLED_AS_BUILT_IN(NODE) \
4438 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4441 c_expand_builtin (exp, target, tmode, modifier)
4444 enum machine_mode tmode;
4445 enum expand_modifier modifier;
4447 tree type = TREE_TYPE (exp);
4448 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4449 tree arglist = TREE_OPERAND (exp, 1);
4450 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4451 enum tree_code code = TREE_CODE (exp);
4452 const int ignore = (target == const0_rtx
4453 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4454 || code == CONVERT_EXPR || code == REFERENCE_EXPR
4455 || code == COND_EXPR)
4456 && TREE_CODE (type) == VOID_TYPE));
4458 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4459 return expand_call (exp, target, ignore);
4463 case BUILT_IN_PRINTF:
4464 target = c_expand_builtin_printf (arglist, target, tmode,
4465 modifier, ignore, /*unlocked=*/ 0);
4470 case BUILT_IN_PRINTF_UNLOCKED:
4471 target = c_expand_builtin_printf (arglist, target, tmode,
4472 modifier, ignore, /*unlocked=*/ 1);
4477 case BUILT_IN_FPRINTF:
4478 target = c_expand_builtin_fprintf (arglist, target, tmode,
4479 modifier, ignore, /*unlocked=*/ 0);
4484 case BUILT_IN_FPRINTF_UNLOCKED:
4485 target = c_expand_builtin_fprintf (arglist, target, tmode,
4486 modifier, ignore, /*unlocked=*/ 1);
4491 default: /* just do library call, if unknown builtin */
4492 error ("built-in function `%s' not currently supported",
4493 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4496 /* The switch statement above can drop through to cause the function
4497 to be called normally. */
4498 return expand_call (exp, target, ignore);
4501 /* Check an arglist to *printf for problems. The arglist should start
4502 at the format specifier, with the remaining arguments immediately
4505 is_valid_printf_arglist (arglist)
4508 /* Save this value so we can restore it later. */
4509 const int SAVE_pedantic = pedantic;
4510 int diagnostic_occurred = 0;
4513 /* Set this to a known value so the user setting won't affect code
4516 /* Check to make sure there are no format specifier errors. */
4517 attrs = tree_cons (get_identifier ("format"),
4518 tree_cons (NULL_TREE,
4519 get_identifier ("printf"),
4520 tree_cons (NULL_TREE,
4522 tree_cons (NULL_TREE,
4526 check_function_format (&diagnostic_occurred, attrs, arglist);
4528 /* Restore the value of `pedantic'. */
4529 pedantic = SAVE_pedantic;
4531 /* If calling `check_function_format_ptr' produces a warning, we
4532 return false, otherwise we return true. */
4533 return ! diagnostic_occurred;
4536 /* If the arguments passed to printf are suitable for optimizations,
4537 we attempt to transform the call. */
4539 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
4542 enum machine_mode tmode;
4543 enum expand_modifier modifier;
4547 tree fn_putchar = unlocked ?
4548 implicit_built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : implicit_built_in_decls[BUILT_IN_PUTCHAR];
4549 tree fn_puts = unlocked ?
4550 implicit_built_in_decls[BUILT_IN_PUTS_UNLOCKED] : implicit_built_in_decls[BUILT_IN_PUTS];
4551 tree fn, format_arg, stripped_string;
4553 /* If the return value is used, or the replacement _DECL isn't
4554 initialized, don't do the transformation. */
4555 if (!ignore || !fn_putchar || !fn_puts)
4558 /* Verify the required arguments in the original call. */
4560 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4563 /* Check the specifier vs. the parameters. */
4564 if (!is_valid_printf_arglist (arglist))
4567 format_arg = TREE_VALUE (arglist);
4568 stripped_string = format_arg;
4569 STRIP_NOPS (stripped_string);
4570 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4571 stripped_string = TREE_OPERAND (stripped_string, 0);
4573 /* If the format specifier isn't a STRING_CST, punt. */
4574 if (TREE_CODE (stripped_string) != STRING_CST)
4577 /* OK! We can attempt optimization. */
4579 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4580 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4582 arglist = TREE_CHAIN (arglist);
4585 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4586 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4588 arglist = TREE_CHAIN (arglist);
4593 /* We can't handle anything else with % args or %% ... yet. */
4594 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4597 /* If the resulting constant string has a length of 1, call
4598 putchar. Note, TREE_STRING_LENGTH includes the terminating
4599 NULL in its count. */
4600 if (TREE_STRING_LENGTH (stripped_string) == 2)
4602 /* Given printf("c"), (where c is any one character,)
4603 convert "c"[0] to an int and pass that to the replacement
4605 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4606 arglist = build_tree_list (NULL_TREE, arglist);
4610 /* If the resulting constant was "string\n", call
4611 __builtin_puts("string"). Ensure "string" has at least one
4612 character besides the trailing \n. Note, TREE_STRING_LENGTH
4613 includes the terminating NULL in its count. */
4614 else if (TREE_STRING_LENGTH (stripped_string) > 2
4615 && TREE_STRING_POINTER (stripped_string)
4616 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4618 /* Create a NULL-terminated string that's one char shorter
4619 than the original, stripping off the trailing '\n'. */
4620 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4621 char *newstr = (char *) alloca (newlen);
4622 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4623 newstr[newlen - 1] = 0;
4625 arglist = fix_string_type (build_string (newlen, newstr));
4626 arglist = build_tree_list (NULL_TREE, arglist);
4630 /* We'd like to arrange to call fputs(string) here, but we
4631 need stdout and don't have a way to get it ... yet. */
4635 return expand_expr (build_function_call (fn, arglist),
4636 (ignore ? const0_rtx : target),
4640 /* If the arguments passed to fprintf are suitable for optimizations,
4641 we attempt to transform the call. */
4643 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4646 enum machine_mode tmode;
4647 enum expand_modifier modifier;
4651 tree fn_fputc = unlocked ?
4652 implicit_built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : implicit_built_in_decls[BUILT_IN_FPUTC];
4653 tree fn_fputs = unlocked ?
4654 implicit_built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : implicit_built_in_decls[BUILT_IN_FPUTS];
4655 tree fn, format_arg, stripped_string;
4657 /* If the return value is used, or the replacement _DECL isn't
4658 initialized, don't do the transformation. */
4659 if (!ignore || !fn_fputc || !fn_fputs)
4662 /* Verify the required arguments in the original call. */
4664 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4665 || (TREE_CHAIN (arglist) == 0)
4666 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4670 /* Check the specifier vs. the parameters. */
4671 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4674 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4675 stripped_string = format_arg;
4676 STRIP_NOPS (stripped_string);
4677 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4678 stripped_string = TREE_OPERAND (stripped_string, 0);
4680 /* If the format specifier isn't a STRING_CST, punt. */
4681 if (TREE_CODE (stripped_string) != STRING_CST)
4684 /* OK! We can attempt optimization. */
4686 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4687 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4689 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4690 arglist = tree_cons (NULL_TREE,
4691 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4695 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4696 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4698 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4699 arglist = tree_cons (NULL_TREE,
4700 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4706 /* We can't handle anything else with % args or %% ... yet. */
4707 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4710 /* When "string" doesn't contain %, replace all cases of
4711 fprintf(stream,string) with fputs(string,stream). The fputs
4712 builtin will take take of special cases like length==1. */
4713 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4714 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4718 return expand_expr (build_function_call (fn, arglist),
4719 (ignore ? const0_rtx : target),
4724 /* Given a boolean expression ARG, return a tree representing an increment
4725 or decrement (as indicated by CODE) of ARG. The front end must check for
4726 invalid cases (e.g., decrement in C++). */
4728 boolean_increment (code, arg)
4729 enum tree_code code;
4733 tree true_res = (c_language == clk_cplusplus
4735 : c_bool_true_node);
4736 arg = stabilize_reference (arg);
4739 case PREINCREMENT_EXPR:
4740 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4742 case POSTINCREMENT_EXPR:
4743 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4744 arg = save_expr (arg);
4745 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4746 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4748 case PREDECREMENT_EXPR:
4749 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4751 case POSTDECREMENT_EXPR:
4752 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4753 arg = save_expr (arg);
4754 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4755 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4760 TREE_SIDE_EFFECTS (val) = 1;
4764 /* Define NAME with value TYPE precision. */
4766 builtin_define_type_precision (name, type)
4770 builtin_define_with_int_value (name, TYPE_PRECISION (type));
4773 /* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
4775 builtin_define_float_constants (name_prefix, fp_suffix, type)
4776 const char *name_prefix;
4777 const char *fp_suffix;
4780 /* Used to convert radix-based values to base 10 values in several cases.
4782 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
4783 least 6 significant digits for correct results. Using the fraction
4784 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
4785 intermediate; perhaps someone can find a better approximation, in the
4786 mean time, I suspect using doubles won't harm the bootstrap here. */
4788 const double log10_2 = .30102999566398119521;
4790 const struct real_format *fmt;
4792 char name[64], buf[128];
4793 int dig, min_10_exp, max_10_exp;
4796 fmt = real_format_for_mode[TYPE_MODE (type) - QFmode];
4798 /* The radix of the exponent representation. */
4799 if (type == float_type_node)
4800 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
4801 log10_b = log10_2 * fmt->log2_b;
4803 /* The number of radix digits, p, in the floating-point significand. */
4804 sprintf (name, "__%s_MANT_DIG__", name_prefix);
4805 builtin_define_with_int_value (name, fmt->p);
4807 /* The number of decimal digits, q, such that any floating-point number
4808 with q decimal digits can be rounded into a floating-point number with
4809 p radix b digits and back again without change to the q decimal digits,
4811 p log10 b if b is a power of 10
4812 floor((p - 1) log10 b) otherwise
4814 dig = (fmt->p - 1) * log10_b;
4815 sprintf (name, "__%s_DIG__", name_prefix);
4816 builtin_define_with_int_value (name, dig);
4818 /* The minimum negative int x such that b**(x-1) is a normalized float. */
4819 sprintf (name, "__%s_MIN_EXP__", name_prefix);
4820 sprintf (buf, "(%d)", fmt->emin);
4821 builtin_define_with_value (name, buf, 0);
4823 /* The minimum negative int x such that 10**x is a normalized float,
4825 ceil (log10 (b ** (emin - 1)))
4826 = ceil (log10 (b) * (emin - 1))
4828 Recall that emin is negative, so the integer truncation calculates
4829 the ceiling, not the floor, in this case. */
4830 min_10_exp = (fmt->emin - 1) * log10_b;
4831 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
4832 sprintf (buf, "(%d)", min_10_exp);
4833 builtin_define_with_value (name, buf, 0);
4835 /* The maximum int x such that b**(x-1) is a representable float. */
4836 sprintf (name, "__%s_MAX_EXP__", name_prefix);
4837 builtin_define_with_int_value (name, fmt->emax);
4839 /* The maximum int x such that 10**x is in the range of representable
4840 finite floating-point numbers,
4842 floor (log10((1 - b**-p) * b**emax))
4843 = floor (log10(1 - b**-p) + log10(b**emax))
4844 = floor (log10(1 - b**-p) + log10(b)*emax)
4846 The safest thing to do here is to just compute this number. But since
4847 we don't link cc1 with libm, we cannot. We could implement log10 here
4848 a series expansion, but that seems too much effort because:
4850 Note that the first term, for all extant p, is a number exceedingly close
4851 to zero, but slightly negative. Note that the second term is an integer
4852 scaling an irrational number, and that because of the floor we are only
4853 interested in its integral portion.
4855 In order for the first term to have any effect on the integral portion
4856 of the second term, the second term has to be exceedingly close to an
4857 integer itself (e.g. 123.000000000001 or something). Getting a result
4858 that close to an integer requires that the irrational multiplicand have
4859 a long series of zeros in its expansion, which doesn't occur in the
4860 first 20 digits or so of log10(b).
4862 Hand-waving aside, crunching all of the sets of constants above by hand
4863 does not yield a case for which the first term is significant, which
4864 in the end is all that matters. */
4865 max_10_exp = fmt->emax * log10_b;
4866 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
4867 builtin_define_with_int_value (name, max_10_exp);
4869 /* The number of decimal digits, n, such that any floating-point number
4870 can be rounded to n decimal digits and back again without change to
4873 p * log10(b) if b is a power of 10
4874 ceil(1 + p * log10(b)) otherwise
4876 The only macro we care about is this number for the widest supported
4877 floating type, but we want this value for rendering constants below. */
4879 double d_decimal_dig = 1 + fmt->p * log10_b;
4880 decimal_dig = d_decimal_dig;
4881 if (decimal_dig < d_decimal_dig)
4884 if (type == long_double_type_node)
4885 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
4887 /* Since, for the supported formats, B is always a power of 2, we
4888 construct the following numbers directly as a hexadecimal
4891 /* The maximum representable finite floating-point number,
4892 (1 - b**-p) * b**emax */
4897 strcpy (buf, "0x0.");
4898 n = fmt->p * fmt->log2_b;
4899 for (i = 0, p = buf + 4; i + 3 < n; i += 4)
4902 *p++ = "08ce"[n - i];
4903 sprintf (p, "p%d", fmt->emax * fmt->log2_b);
4905 sprintf (name, "__%s_MAX__", name_prefix);
4906 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
4908 /* The minimum normalized positive floating-point number,
4910 sprintf (name, "__%s_MIN__", name_prefix);
4911 sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
4912 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
4914 /* The difference between 1 and the least value greater than 1 that is
4915 representable in the given floating point type, b**(1-p). */
4916 sprintf (name, "__%s_EPSILON__", name_prefix);
4917 sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
4918 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
4920 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
4921 positive floating-point number, b**(emin-p). Zero for formats that
4922 don't support denormals. */
4923 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
4924 if (fmt->has_denorm)
4926 sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
4927 builtin_define_with_hex_fp_value (name, type, decimal_dig,
4932 sprintf (buf, "0.0%s", fp_suffix);
4933 builtin_define_with_value (name, buf, 0);
4936 /* For C++ std::numeric_limits<T>::has_infinity. */
4937 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
4938 builtin_define_with_int_value (name,
4939 MODE_HAS_INFINITIES (TYPE_MODE (type)));
4940 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
4941 predicate to distinguish a target that has both quiet and
4942 signalling NaNs from a target that has only quiet NaNs or only
4943 signalling NaNs, so we assume that a target that has any kind of
4944 NaN has quiet NaNs. */
4945 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
4946 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
4949 /* Hook that registers front end and target-specific built-ins. */
4951 cb_register_builtins (pfile)
4954 /* -undef turns off target-specific built-ins. */
4958 if (c_language == clk_cplusplus)
4960 if (SUPPORTS_ONE_ONLY)
4961 cpp_define (pfile, "__GXX_WEAK__=1");
4963 cpp_define (pfile, "__GXX_WEAK__=0");
4964 if (flag_exceptions)
4965 cpp_define (pfile, "__EXCEPTIONS");
4966 if (warn_deprecated)
4967 cpp_define (pfile, "__DEPRECATED");
4970 /* represents the C++ ABI version, always defined so it can be used while
4971 preprocessing C and assembler. */
4972 cpp_define (pfile, "__GXX_ABI_VERSION=102");
4974 /* libgcc needs to know this. */
4975 if (USING_SJLJ_EXCEPTIONS)
4976 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
4978 /* stddef.h needs to know these. */
4979 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4980 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4981 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4982 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4984 /* limits.h needs to know these. */
4985 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
4986 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
4987 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
4988 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
4989 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
4990 builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
4992 builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
4994 /* float.h needs to know these. */
4996 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
4997 TARGET_FLT_EVAL_METHOD);
4999 builtin_define_float_constants ("FLT", "F", float_type_node);
5000 builtin_define_float_constants ("DBL", "", double_type_node);
5001 builtin_define_float_constants ("LDBL", "L", long_double_type_node);
5003 /* For use in assembly language. */
5004 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
5005 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
5008 builtin_define_with_value ("__VERSION__", version_string, 1);
5010 /* Other target-independent built-ins determined by command-line
5013 cpp_define (pfile, "__OPTIMIZE_SIZE__");
5015 cpp_define (pfile, "__OPTIMIZE__");
5018 cpp_define (pfile, "__STDC_HOSTED__=1");
5020 cpp_define (pfile, "__STDC_HOSTED__=0");
5022 if (fast_math_flags_set_p ())
5023 cpp_define (pfile, "__FAST_MATH__");
5024 if (flag_really_no_inline)
5025 cpp_define (pfile, "__NO_INLINE__");
5026 if (flag_signaling_nans)
5027 cpp_define (pfile, "__SUPPORT_SNAN__");
5028 if (flag_finite_math_only)
5029 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
5031 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
5034 cpp_define (pfile, "__STRICT_ANSI__");
5036 if (!flag_signed_char)
5037 cpp_define (pfile, "__CHAR_UNSIGNED__");
5039 if (c_language == clk_cplusplus && TREE_UNSIGNED (wchar_type_node))
5040 cpp_define (pfile, "__WCHAR_UNSIGNED__");
5042 /* Make the choice of ObjC runtime visible to source code. */
5043 if (flag_objc && flag_next_runtime)
5044 cpp_define (pfile, "__NEXT_RUNTIME__");
5046 /* A straightforward target hook doesn't work, because of problems
5047 linking that hook's body when part of non-C front ends. */
5048 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
5049 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
5050 # define builtin_define(TXT) cpp_define (pfile, TXT)
5051 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
5052 TARGET_CPU_CPP_BUILTINS ();
5053 TARGET_OS_CPP_BUILTINS ();
5056 /* Pass an object-like macro. If it doesn't lie in the user's
5057 namespace, defines it unconditionally. Otherwise define a version
5058 with two leading underscores, and another version with two leading
5059 and trailing underscores, and define the original only if an ISO
5060 standard was not nominated.
5062 e.g. passing "unix" defines "__unix", "__unix__" and possibly
5063 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
5066 builtin_define_std (macro)
5069 size_t len = strlen (macro);
5070 char *buff = alloca (len + 5);
5074 /* prepend __ (or maybe just _) if in user's namespace. */
5075 memcpy (p, macro, len + 1);
5076 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
5083 cpp_define (parse_in, p);
5085 /* If it was in user's namespace... */
5088 /* Define the macro with leading and following __. */
5094 cpp_define (parse_in, p);
5096 /* Finally, define the original macro if permitted. */
5098 cpp_define (parse_in, macro);
5102 /* Pass an object-like macro and a value to define it to. The third
5103 parameter says whether or not to turn the value into a string
5106 builtin_define_with_value (macro, expansion, is_str)
5108 const char *expansion;
5112 size_t mlen = strlen (macro);
5113 size_t elen = strlen (expansion);
5114 size_t extra = 2; /* space for an = and a NUL */
5117 extra += 2; /* space for two quote marks */
5119 buf = alloca (mlen + elen + extra);
5121 sprintf (buf, "%s=\"%s\"", macro, expansion);
5123 sprintf (buf, "%s=%s", macro, expansion);
5125 cpp_define (parse_in, buf);
5128 /* Pass an object-like macro and an integer value to define it to. */
5130 builtin_define_with_int_value (macro, value)
5132 HOST_WIDE_INT value;
5135 size_t mlen = strlen (macro);
5137 size_t extra = 2; /* space for = and NUL. */
5139 buf = alloca (mlen + vlen + extra);
5140 memcpy (buf, macro, mlen);
5142 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
5144 cpp_define (parse_in, buf);
5147 /* Pass an object-like macro a hexadecimal floating-point value. */
5149 builtin_define_with_hex_fp_value (macro, type, digits, hex_str, fp_suffix)
5151 tree type ATTRIBUTE_UNUSED;
5153 const char *hex_str;
5154 const char *fp_suffix;
5156 REAL_VALUE_TYPE real;
5157 char dec_str[64], buf[256];
5159 /* Hex values are really cool and convenient, except that they're
5160 not supported in strict ISO C90 mode. First, the "p-" sequence
5161 is not valid as part of a preprocessor number. Second, we get a
5162 pedwarn from the preprocessor, which has no context, so we can't
5163 suppress the warning with __extension__.
5165 So instead what we do is construct the number in hex (because
5166 it's easy to get the exact correct value), parse it as a real,
5167 then print it back out as decimal. */
5169 real_from_string (&real, hex_str);
5170 real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
5172 sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
5173 cpp_define (parse_in, buf);
5176 /* Define MAX for TYPE based on the precision of the type. IS_LONG is
5177 1 for type "long" and 2 for "long long". We have to handle
5178 unsigned types, since wchar_t might be unsigned. */
5181 builtin_define_type_max (macro, type, is_long)
5186 static const char *const values[]
5189 "2147483647", "4294967295",
5190 "9223372036854775807", "18446744073709551615",
5191 "170141183460469231731687303715884105727",
5192 "340282366920938463463374607431768211455" };
5193 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
5195 const char *value, *suffix;
5199 /* Pre-rendering the values mean we don't have to futz with printing a
5200 multi-word decimal value. There are also a very limited number of
5201 precisions that we support, so it's really a waste of time. */
5202 switch (TYPE_PRECISION (type))
5204 case 8: idx = 0; break;
5205 case 16: idx = 2; break;
5206 case 32: idx = 4; break;
5207 case 64: idx = 6; break;
5208 case 128: idx = 8; break;
5212 value = values[idx + TREE_UNSIGNED (type)];
5213 suffix = suffixes[is_long * 2 + TREE_UNSIGNED (type)];
5215 buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1);
5216 sprintf (buf, "%s=%s%s", macro, value, suffix);
5218 cpp_define (parse_in, buf);
5222 c_init_attributes ()
5224 /* Fill in the built_in_attributes array. */
5225 #define DEF_ATTR_NULL_TREE(ENUM) \
5226 built_in_attributes[(int) ENUM] = NULL_TREE;
5227 #define DEF_ATTR_INT(ENUM, VALUE) \
5228 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
5229 #define DEF_ATTR_IDENT(ENUM, STRING) \
5230 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5231 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5232 built_in_attributes[(int) ENUM] \
5233 = tree_cons (built_in_attributes[(int) PURPOSE], \
5234 built_in_attributes[(int) VALUE], \
5235 built_in_attributes[(int) CHAIN]);
5236 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
5237 #include "builtin-attrs.def"
5238 #undef DEF_ATTR_NULL_TREE
5240 #undef DEF_ATTR_IDENT
5241 #undef DEF_ATTR_TREE_LIST
5243 c_attrs_initialized = true;
5246 /* Depending on the name of DECL, apply default attributes to it. */
5249 c_common_insert_default_attributes (decl)
5252 tree name = DECL_NAME (decl);
5254 if (!c_attrs_initialized)
5255 c_init_attributes ();
5257 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
5258 #define DEF_ATTR_INT(ENUM, VALUE)
5259 #define DEF_ATTR_IDENT(ENUM, STRING)
5260 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
5261 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
5262 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
5263 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
5264 ATTR_FLAG_BUILT_IN);
5265 #include "builtin-attrs.def"
5266 #undef DEF_ATTR_NULL_TREE
5268 #undef DEF_ATTR_IDENT
5269 #undef DEF_ATTR_TREE_LIST
5273 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
5274 additionally give the location of the previous declaration DECL. */
5276 shadow_warning (msgid, name, decl)
5280 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
5281 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
5282 DECL_SOURCE_LINE (decl),
5283 "shadowed declaration is here");
5286 /* Attribute handlers common to C front ends. */
5288 /* Handle a "packed" attribute; arguments as in
5289 struct attribute_spec.handler. */
5292 handle_packed_attribute (node, name, args, flags, no_add_attrs)
5295 tree args ATTRIBUTE_UNUSED;
5302 if (TREE_CODE (*node) == TYPE_DECL)
5303 type = &TREE_TYPE (*node);
5310 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5311 *type = build_type_copy (*type);
5312 TYPE_PACKED (*type) = 1;
5314 else if (TREE_CODE (*node) == FIELD_DECL)
5315 DECL_PACKED (*node) = 1;
5316 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5317 used for DECL_REGISTER. It wouldn't mean anything anyway. */
5320 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5321 *no_add_attrs = true;
5327 /* Handle a "nocommon" attribute; arguments as in
5328 struct attribute_spec.handler. */
5331 handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
5334 tree args ATTRIBUTE_UNUSED;
5335 int flags ATTRIBUTE_UNUSED;
5338 if (TREE_CODE (*node) == VAR_DECL)
5339 DECL_COMMON (*node) = 0;
5342 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5343 *no_add_attrs = true;
5349 /* Handle a "common" attribute; arguments as in
5350 struct attribute_spec.handler. */
5353 handle_common_attribute (node, name, args, flags, no_add_attrs)
5356 tree args ATTRIBUTE_UNUSED;
5357 int flags ATTRIBUTE_UNUSED;
5360 if (TREE_CODE (*node) == VAR_DECL)
5361 DECL_COMMON (*node) = 1;
5364 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5365 *no_add_attrs = true;
5371 /* Handle a "noreturn" attribute; arguments as in
5372 struct attribute_spec.handler. */
5375 handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
5378 tree args ATTRIBUTE_UNUSED;
5379 int flags ATTRIBUTE_UNUSED;
5382 tree type = TREE_TYPE (*node);
5384 /* See FIXME comment in c_common_attribute_table. */
5385 if (TREE_CODE (*node) == FUNCTION_DECL)
5386 TREE_THIS_VOLATILE (*node) = 1;
5387 else if (TREE_CODE (type) == POINTER_TYPE
5388 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5390 = build_pointer_type
5391 (build_type_variant (TREE_TYPE (type),
5392 TREE_READONLY (TREE_TYPE (type)), 1));
5395 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5396 *no_add_attrs = true;
5402 /* Handle a "noinline" attribute; arguments as in
5403 struct attribute_spec.handler. */
5406 handle_noinline_attribute (node, name, args, flags, no_add_attrs)
5409 tree args ATTRIBUTE_UNUSED;
5410 int flags ATTRIBUTE_UNUSED;
5413 if (TREE_CODE (*node) == FUNCTION_DECL)
5414 DECL_UNINLINABLE (*node) = 1;
5417 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5418 *no_add_attrs = true;
5424 /* Handle a "always_inline" attribute; arguments as in
5425 struct attribute_spec.handler. */
5428 handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
5431 tree args ATTRIBUTE_UNUSED;
5432 int flags ATTRIBUTE_UNUSED;
5435 if (TREE_CODE (*node) == FUNCTION_DECL)
5437 /* Do nothing else, just set the attribute. We'll get at
5438 it later with lookup_attribute. */
5442 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5443 *no_add_attrs = true;
5449 /* Handle a "used" attribute; arguments as in
5450 struct attribute_spec.handler. */
5453 handle_used_attribute (pnode, name, args, flags, no_add_attrs)
5456 tree args ATTRIBUTE_UNUSED;
5457 int flags ATTRIBUTE_UNUSED;
5462 if (TREE_CODE (node) == FUNCTION_DECL
5463 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
5464 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (node))
5465 = TREE_USED (node) = 1;
5468 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5469 *no_add_attrs = true;
5475 /* Handle a "unused" attribute; arguments as in
5476 struct attribute_spec.handler. */
5479 handle_unused_attribute (node, name, args, flags, no_add_attrs)
5482 tree args ATTRIBUTE_UNUSED;
5490 if (TREE_CODE (decl) == PARM_DECL
5491 || TREE_CODE (decl) == VAR_DECL
5492 || TREE_CODE (decl) == FUNCTION_DECL
5493 || TREE_CODE (decl) == LABEL_DECL
5494 || TREE_CODE (decl) == TYPE_DECL)
5495 TREE_USED (decl) = 1;
5498 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5499 *no_add_attrs = true;
5504 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5505 *node = build_type_copy (*node);
5506 TREE_USED (*node) = 1;
5512 /* Handle a "const" attribute; arguments as in
5513 struct attribute_spec.handler. */
5516 handle_const_attribute (node, name, args, flags, no_add_attrs)
5519 tree args ATTRIBUTE_UNUSED;
5520 int flags ATTRIBUTE_UNUSED;
5523 tree type = TREE_TYPE (*node);
5525 /* See FIXME comment on noreturn in c_common_attribute_table. */
5526 if (TREE_CODE (*node) == FUNCTION_DECL)
5527 TREE_READONLY (*node) = 1;
5528 else if (TREE_CODE (type) == POINTER_TYPE
5529 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5531 = build_pointer_type
5532 (build_type_variant (TREE_TYPE (type), 1,
5533 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5536 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5537 *no_add_attrs = true;
5543 /* Handle a "transparent_union" attribute; arguments as in
5544 struct attribute_spec.handler. */
5547 handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
5550 tree args ATTRIBUTE_UNUSED;
5554 tree decl = NULL_TREE;
5561 type = &TREE_TYPE (decl);
5562 is_type = TREE_CODE (*node) == TYPE_DECL;
5564 else if (TYPE_P (*node))
5565 type = node, is_type = 1;
5568 && TREE_CODE (*type) == UNION_TYPE
5570 || (TYPE_FIELDS (*type) != 0
5571 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
5573 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5574 *type = build_type_copy (*type);
5575 TYPE_TRANSPARENT_UNION (*type) = 1;
5577 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
5578 && TREE_CODE (*type) == UNION_TYPE
5579 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
5580 DECL_TRANSPARENT_UNION (decl) = 1;
5583 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5584 *no_add_attrs = true;
5590 /* Handle a "constructor" attribute; arguments as in
5591 struct attribute_spec.handler. */
5594 handle_constructor_attribute (node, name, args, flags, no_add_attrs)
5597 tree args ATTRIBUTE_UNUSED;
5598 int flags ATTRIBUTE_UNUSED;
5602 tree type = TREE_TYPE (decl);
5604 if (TREE_CODE (decl) == FUNCTION_DECL
5605 && TREE_CODE (type) == FUNCTION_TYPE
5606 && decl_function_context (decl) == 0)
5608 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5609 TREE_USED (decl) = 1;
5613 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5614 *no_add_attrs = true;
5620 /* Handle a "destructor" attribute; arguments as in
5621 struct attribute_spec.handler. */
5624 handle_destructor_attribute (node, name, args, flags, no_add_attrs)
5627 tree args ATTRIBUTE_UNUSED;
5628 int flags ATTRIBUTE_UNUSED;
5632 tree type = TREE_TYPE (decl);
5634 if (TREE_CODE (decl) == FUNCTION_DECL
5635 && TREE_CODE (type) == FUNCTION_TYPE
5636 && decl_function_context (decl) == 0)
5638 DECL_STATIC_DESTRUCTOR (decl) = 1;
5639 TREE_USED (decl) = 1;
5643 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5644 *no_add_attrs = true;
5650 /* Handle a "mode" attribute; arguments as in
5651 struct attribute_spec.handler. */
5654 handle_mode_attribute (node, name, args, flags, no_add_attrs)
5658 int flags ATTRIBUTE_UNUSED;
5663 *no_add_attrs = true;
5665 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5666 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5670 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5671 int len = strlen (p);
5672 enum machine_mode mode = VOIDmode;
5676 if (len > 4 && p[0] == '_' && p[1] == '_'
5677 && p[len - 1] == '_' && p[len - 2] == '_')
5679 char *newp = (char *) alloca (len - 1);
5681 strcpy (newp, &p[2]);
5682 newp[len - 4] = '\0';
5686 /* Change this type to have a type with the specified mode.
5687 First check for the special modes. */
5688 if (! strcmp (p, "byte"))
5690 else if (!strcmp (p, "word"))
5692 else if (! strcmp (p, "pointer"))
5695 for (j = 0; j < NUM_MACHINE_MODES; j++)
5696 if (!strcmp (p, GET_MODE_NAME (j)))
5697 mode = (enum machine_mode) j;
5699 if (mode == VOIDmode)
5700 error ("unknown machine mode `%s'", p);
5701 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
5702 (mode, TREE_UNSIGNED (type))))
5703 error ("no data type for mode `%s'", p);
5704 else if ((TREE_CODE (type) == POINTER_TYPE
5705 || TREE_CODE (type) == REFERENCE_TYPE)
5706 && !(*targetm.valid_pointer_mode) (mode))
5707 error ("invalid pointer mode `%s'", p);
5710 /* If this is a vector, make sure we either have hardware
5711 support, or we can emulate it. */
5712 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5713 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5714 && !vector_mode_valid_p (mode))
5716 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5720 if (TREE_CODE (type) == POINTER_TYPE)
5722 ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
5726 else if (TREE_CODE (type) == REFERENCE_TYPE)
5728 ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
5734 /* No need to layout the type here. The caller should do this. */
5741 /* Handle a "section" attribute; arguments as in
5742 struct attribute_spec.handler. */
5745 handle_section_attribute (node, name, args, flags, no_add_attrs)
5747 tree name ATTRIBUTE_UNUSED;
5749 int flags ATTRIBUTE_UNUSED;
5754 if (targetm.have_named_sections)
5756 if ((TREE_CODE (decl) == FUNCTION_DECL
5757 || TREE_CODE (decl) == VAR_DECL)
5758 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5760 if (TREE_CODE (decl) == VAR_DECL
5761 && current_function_decl != NULL_TREE
5762 && ! TREE_STATIC (decl))
5764 error_with_decl (decl,
5765 "section attribute cannot be specified for local variables");
5766 *no_add_attrs = true;
5769 /* The decl may have already been given a section attribute
5770 from a previous declaration. Ensure they match. */
5771 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5772 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5773 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5775 error_with_decl (*node,
5776 "section of `%s' conflicts with previous declaration");
5777 *no_add_attrs = true;
5780 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5784 error_with_decl (*node,
5785 "section attribute not allowed for `%s'");
5786 *no_add_attrs = true;
5791 error_with_decl (*node,
5792 "section attributes are not supported for this target");
5793 *no_add_attrs = true;
5799 /* Handle a "aligned" attribute; arguments as in
5800 struct attribute_spec.handler. */
5803 handle_aligned_attribute (node, name, args, flags, no_add_attrs)
5805 tree name ATTRIBUTE_UNUSED;
5810 tree decl = NULL_TREE;
5813 tree align_expr = (args ? TREE_VALUE (args)
5814 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5820 type = &TREE_TYPE (decl);
5821 is_type = TREE_CODE (*node) == TYPE_DECL;
5823 else if (TYPE_P (*node))
5824 type = node, is_type = 1;
5826 /* Strip any NOPs of any kind. */
5827 while (TREE_CODE (align_expr) == NOP_EXPR
5828 || TREE_CODE (align_expr) == CONVERT_EXPR
5829 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
5830 align_expr = TREE_OPERAND (align_expr, 0);
5832 if (TREE_CODE (align_expr) != INTEGER_CST)
5834 error ("requested alignment is not a constant");
5835 *no_add_attrs = true;
5837 else if ((i = tree_log2 (align_expr)) == -1)
5839 error ("requested alignment is not a power of 2");
5840 *no_add_attrs = true;
5842 else if (i > HOST_BITS_PER_INT - 2)
5844 error ("requested alignment is too large");
5845 *no_add_attrs = true;
5849 /* If we have a TYPE_DECL, then copy the type, so that we
5850 don't accidentally modify a builtin type. See pushdecl. */
5851 if (decl && TREE_TYPE (decl) != error_mark_node
5852 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5854 tree tt = TREE_TYPE (decl);
5855 *type = build_type_copy (*type);
5856 DECL_ORIGINAL_TYPE (decl) = tt;
5857 TYPE_NAME (*type) = decl;
5858 TREE_USED (*type) = TREE_USED (decl);
5859 TREE_TYPE (decl) = *type;
5861 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5862 *type = build_type_copy (*type);
5864 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5865 TYPE_USER_ALIGN (*type) = 1;
5867 else if (TREE_CODE (decl) != VAR_DECL
5868 && TREE_CODE (decl) != FIELD_DECL)
5870 error_with_decl (decl,
5871 "alignment may not be specified for `%s'");
5872 *no_add_attrs = true;
5876 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5877 DECL_USER_ALIGN (decl) = 1;
5883 /* Handle a "weak" attribute; arguments as in
5884 struct attribute_spec.handler. */
5887 handle_weak_attribute (node, name, args, flags, no_add_attrs)
5889 tree name ATTRIBUTE_UNUSED;
5890 tree args ATTRIBUTE_UNUSED;
5891 int flags ATTRIBUTE_UNUSED;
5892 bool *no_add_attrs ATTRIBUTE_UNUSED;
5894 declare_weak (*node);
5899 /* Handle an "alias" attribute; arguments as in
5900 struct attribute_spec.handler. */
5903 handle_alias_attribute (node, name, args, flags, no_add_attrs)
5907 int flags ATTRIBUTE_UNUSED;
5912 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5913 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
5915 error_with_decl (decl,
5916 "`%s' defined both normally and as an alias");
5917 *no_add_attrs = true;
5919 else if (decl_function_context (decl) == 0)
5923 id = TREE_VALUE (args);
5924 if (TREE_CODE (id) != STRING_CST)
5926 error ("alias arg not a string");
5927 *no_add_attrs = true;
5930 id = get_identifier (TREE_STRING_POINTER (id));
5931 /* This counts as a use of the object pointed to. */
5934 if (TREE_CODE (decl) == FUNCTION_DECL)
5935 DECL_INITIAL (decl) = error_mark_node;
5937 DECL_EXTERNAL (decl) = 0;
5941 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5942 *no_add_attrs = true;
5948 /* Handle an "visibility" attribute; arguments as in
5949 struct attribute_spec.handler. */
5952 handle_visibility_attribute (node, name, args, flags, no_add_attrs)
5956 int flags ATTRIBUTE_UNUSED;
5961 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
5963 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5964 *no_add_attrs = true;
5970 id = TREE_VALUE (args);
5971 if (TREE_CODE (id) != STRING_CST)
5973 error ("visibility arg not a string");
5974 *no_add_attrs = true;
5977 if (strcmp (TREE_STRING_POINTER (id), "hidden")
5978 && strcmp (TREE_STRING_POINTER (id), "protected")
5979 && strcmp (TREE_STRING_POINTER (id), "internal")
5980 && strcmp (TREE_STRING_POINTER (id), "default"))
5982 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5983 *no_add_attrs = true;
5991 /* Handle an "tls_model" attribute; arguments as in
5992 struct attribute_spec.handler. */
5995 handle_tls_model_attribute (node, name, args, flags, no_add_attrs)
5999 int flags ATTRIBUTE_UNUSED;
6004 if (! DECL_THREAD_LOCAL (decl))
6006 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6007 *no_add_attrs = true;
6013 id = TREE_VALUE (args);
6014 if (TREE_CODE (id) != STRING_CST)
6016 error ("tls_model arg not a string");
6017 *no_add_attrs = true;
6020 if (strcmp (TREE_STRING_POINTER (id), "local-exec")
6021 && strcmp (TREE_STRING_POINTER (id), "initial-exec")
6022 && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
6023 && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
6025 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6026 *no_add_attrs = true;
6034 /* Handle a "no_instrument_function" attribute; arguments as in
6035 struct attribute_spec.handler. */
6038 handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
6041 tree args ATTRIBUTE_UNUSED;
6042 int flags ATTRIBUTE_UNUSED;
6047 if (TREE_CODE (decl) != FUNCTION_DECL)
6049 error_with_decl (decl,
6050 "`%s' attribute applies only to functions",
6051 IDENTIFIER_POINTER (name));
6052 *no_add_attrs = true;
6054 else if (DECL_INITIAL (decl))
6056 error_with_decl (decl,
6057 "can't set `%s' attribute after definition",
6058 IDENTIFIER_POINTER (name));
6059 *no_add_attrs = true;
6062 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6067 /* Handle a "malloc" attribute; arguments as in
6068 struct attribute_spec.handler. */
6071 handle_malloc_attribute (node, name, args, flags, no_add_attrs)
6074 tree args ATTRIBUTE_UNUSED;
6075 int flags ATTRIBUTE_UNUSED;
6078 if (TREE_CODE (*node) == FUNCTION_DECL)
6079 DECL_IS_MALLOC (*node) = 1;
6080 /* ??? TODO: Support types. */
6083 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6084 *no_add_attrs = true;
6090 /* Handle a "no_limit_stack" attribute; arguments as in
6091 struct attribute_spec.handler. */
6094 handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
6097 tree args ATTRIBUTE_UNUSED;
6098 int flags ATTRIBUTE_UNUSED;
6103 if (TREE_CODE (decl) != FUNCTION_DECL)
6105 error_with_decl (decl,
6106 "`%s' attribute applies only to functions",
6107 IDENTIFIER_POINTER (name));
6108 *no_add_attrs = true;
6110 else if (DECL_INITIAL (decl))
6112 error_with_decl (decl,
6113 "can't set `%s' attribute after definition",
6114 IDENTIFIER_POINTER (name));
6115 *no_add_attrs = true;
6118 DECL_NO_LIMIT_STACK (decl) = 1;
6123 /* Handle a "pure" attribute; arguments as in
6124 struct attribute_spec.handler. */
6127 handle_pure_attribute (node, name, args, flags, no_add_attrs)
6130 tree args ATTRIBUTE_UNUSED;
6131 int flags ATTRIBUTE_UNUSED;
6134 if (TREE_CODE (*node) == FUNCTION_DECL)
6135 DECL_IS_PURE (*node) = 1;
6136 /* ??? TODO: Support types. */
6139 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6140 *no_add_attrs = true;
6146 /* Handle a "deprecated" attribute; arguments as in
6147 struct attribute_spec.handler. */
6150 handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
6153 tree args ATTRIBUTE_UNUSED;
6157 tree type = NULL_TREE;
6159 const char *what = NULL;
6164 type = TREE_TYPE (decl);
6166 if (TREE_CODE (decl) == TYPE_DECL
6167 || TREE_CODE (decl) == PARM_DECL
6168 || TREE_CODE (decl) == VAR_DECL
6169 || TREE_CODE (decl) == FUNCTION_DECL
6170 || TREE_CODE (decl) == FIELD_DECL)
6171 TREE_DEPRECATED (decl) = 1;
6175 else if (TYPE_P (*node))
6177 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6178 *node = build_type_copy (*node);
6179 TREE_DEPRECATED (*node) = 1;
6187 *no_add_attrs = true;
6188 if (type && TYPE_NAME (type))
6190 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6191 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
6192 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6193 && DECL_NAME (TYPE_NAME (type)))
6194 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
6197 warning ("`%s' attribute ignored for `%s'",
6198 IDENTIFIER_POINTER (name), what);
6200 warning ("`%s' attribute ignored",
6201 IDENTIFIER_POINTER (name));
6207 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
6208 to prevent us from duplicating type nodes unnecessarily.
6209 The normal mechanism to prevent duplicates is to use type_hash_canon, but
6210 since we want to distinguish types that are essentially identical (except
6211 for their debug representation), we use a local list here. */
6212 static GTY(()) tree vector_type_node_list = 0;
6214 /* Handle a "vector_size" attribute; arguments as in
6215 struct attribute_spec.handler. */
6218 handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
6222 int flags ATTRIBUTE_UNUSED;
6225 unsigned HOST_WIDE_INT vecsize, nunits;
6226 enum machine_mode mode, orig_mode, new_mode;
6227 tree type = *node, new_type = NULL_TREE;
6228 tree type_list_node;
6230 *no_add_attrs = true;
6232 if (! host_integerp (TREE_VALUE (args), 1))
6234 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6238 /* Get the vector size (in bytes). */
6239 vecsize = tree_low_cst (TREE_VALUE (args), 1);
6241 /* We need to provide for vector pointers, vector arrays, and
6242 functions returning vectors. For example:
6244 __attribute__((vector_size(16))) short *foo;
6246 In this case, the mode is SI, but the type being modified is
6247 HI, so we need to look further. */
6249 while (POINTER_TYPE_P (type)
6250 || TREE_CODE (type) == FUNCTION_TYPE
6251 || TREE_CODE (type) == ARRAY_TYPE)
6252 type = TREE_TYPE (type);
6254 /* Get the mode of the type being modified. */
6255 orig_mode = TYPE_MODE (type);
6257 if (TREE_CODE (type) == RECORD_TYPE
6258 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
6259 && GET_MODE_CLASS (orig_mode) != MODE_INT)
6260 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
6262 error ("invalid vector type for attribute `%s'",
6263 IDENTIFIER_POINTER (name));
6267 /* Calculate how many units fit in the vector. */
6268 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6270 /* Find a suitably sized vector. */
6271 new_mode = VOIDmode;
6272 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
6274 : MODE_VECTOR_FLOAT);
6276 mode = GET_MODE_WIDER_MODE (mode))
6277 if (vecsize == GET_MODE_SIZE (mode)
6278 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
6284 if (new_mode == VOIDmode)
6286 error ("no vector mode with the size and type specified could be found");
6290 for (type_list_node = vector_type_node_list; type_list_node;
6291 type_list_node = TREE_CHAIN (type_list_node))
6293 tree other_type = TREE_VALUE (type_list_node);
6294 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
6295 tree fields = TYPE_FIELDS (record);
6296 tree field_type = TREE_TYPE (fields);
6297 tree array_type = TREE_TYPE (field_type);
6298 if (TREE_CODE (fields) != FIELD_DECL
6299 || TREE_CODE (field_type) != ARRAY_TYPE)
6302 if (TYPE_MODE (other_type) == mode && type == array_type)
6304 new_type = other_type;
6309 if (new_type == NULL_TREE)
6311 tree index, array, rt, list_node;
6313 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
6314 TREE_UNSIGNED (type));
6318 error ("no vector mode with the size and type specified could be found");
6322 new_type = build_type_copy (new_type);
6324 /* If this is a vector, make sure we either have hardware
6325 support, or we can emulate it. */
6326 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
6327 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
6328 && !vector_mode_valid_p (mode))
6330 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
6334 /* Set the debug information here, because this is the only
6335 place where we know the underlying type for a vector made
6336 with vector_size. For debugging purposes we pretend a vector
6337 is an array within a structure. */
6338 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
6339 array = build_array_type (type, build_index_type (index));
6340 rt = make_node (RECORD_TYPE);
6342 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
6343 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
6345 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
6347 list_node = build_tree_list (NULL, new_type);
6348 TREE_CHAIN (list_node) = vector_type_node_list;
6349 vector_type_node_list = list_node;
6352 /* Build back pointers if needed. */
6353 *node = vector_size_helper (*node, new_type);
6358 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
6361 If we requested a pointer to a vector, build up the pointers that
6362 we stripped off while looking for the inner type. Similarly for
6363 return values from functions.
6365 The argument "type" is the top of the chain, and "bottom" is the
6366 new type which we will point to. */
6369 vector_size_helper (type, bottom)
6374 if (POINTER_TYPE_P (type))
6376 inner = vector_size_helper (TREE_TYPE (type), bottom);
6377 outer = build_pointer_type (inner);
6379 else if (TREE_CODE (type) == ARRAY_TYPE)
6381 inner = vector_size_helper (TREE_TYPE (type), bottom);
6382 outer = build_array_type (inner, TYPE_VALUES (type));
6384 else if (TREE_CODE (type) == FUNCTION_TYPE)
6386 inner = vector_size_helper (TREE_TYPE (type), bottom);
6387 outer = build_function_type (inner, TYPE_VALUES (type));
6392 TREE_READONLY (outer) = TREE_READONLY (type);
6393 TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
6398 /* Handle the "nonnull" attribute. */
6400 handle_nonnull_attribute (node, name, args, flags, no_add_attrs)
6402 tree name ATTRIBUTE_UNUSED;
6404 int flags ATTRIBUTE_UNUSED;
6408 unsigned HOST_WIDE_INT attr_arg_num;
6410 /* If no arguments are specified, all pointer arguments should be
6411 non-null. Verify a full prototype is given so that the arguments
6412 will have the correct types when we actually check them later. */
6415 if (! TYPE_ARG_TYPES (type))
6417 error ("nonnull attribute without arguments on a non-prototype");
6418 *no_add_attrs = true;
6423 /* Argument list specified. Verify that each argument number references
6424 a pointer argument. */
6425 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6428 unsigned HOST_WIDE_INT arg_num, ck_num;
6430 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6432 error ("nonnull argument has invalid operand number (arg %lu)",
6433 (unsigned long) attr_arg_num);
6434 *no_add_attrs = true;
6438 argument = TYPE_ARG_TYPES (type);
6441 for (ck_num = 1; ; ck_num++)
6443 if (! argument || ck_num == arg_num)
6445 argument = TREE_CHAIN (argument);
6449 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6451 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
6452 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6453 *no_add_attrs = true;
6457 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6459 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
6460 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6461 *no_add_attrs = true;
6470 /* Check the argument list of a function call for null in argument slots
6471 that are marked as requiring a non-null pointer argument. */
6474 check_function_nonnull (attrs, params)
6478 tree a, args, param;
6481 for (a = attrs; a; a = TREE_CHAIN (a))
6483 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6485 args = TREE_VALUE (a);
6487 /* Walk the argument list. If we encounter an argument number we
6488 should check for non-null, do it. If the attribute has no args,
6489 then every pointer argument is checked (in which case the check
6490 for pointer type is done in check_nonnull_arg). */
6491 for (param = params, param_num = 1; ;
6492 param_num++, param = TREE_CHAIN (param))
6496 if (! args || nonnull_check_p (args, param_num))
6497 check_function_arguments_recurse (check_nonnull_arg, NULL,
6505 /* Helper for check_function_nonnull; given a list of operands which
6506 must be non-null in ARGS, determine if operand PARAM_NUM should be
6510 nonnull_check_p (args, param_num)
6512 unsigned HOST_WIDE_INT param_num;
6514 unsigned HOST_WIDE_INT arg_num;
6516 for (; args; args = TREE_CHAIN (args))
6518 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6521 if (arg_num == param_num)
6527 /* Check that the function argument PARAM (which is operand number
6528 PARAM_NUM) is non-null. This is called by check_function_nonnull
6529 via check_function_arguments_recurse. */
6532 check_nonnull_arg (ctx, param, param_num)
6533 void *ctx ATTRIBUTE_UNUSED;
6535 unsigned HOST_WIDE_INT param_num;
6537 /* Just skip checking the argument if it's not a pointer. This can
6538 happen if the "nonnull" attribute was given without an operand
6539 list (which means to check every pointer argument). */
6541 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6544 if (integer_zerop (param))
6545 warning ("null argument where non-null required (arg %lu)",
6546 (unsigned long) param_num);
6549 /* Helper for nonnull attribute handling; fetch the operand number
6550 from the attribute argument list. */
6553 get_nonnull_operand (arg_num_expr, valp)
6555 unsigned HOST_WIDE_INT *valp;
6557 /* Strip any conversions from the arg number and verify they
6559 while (TREE_CODE (arg_num_expr) == NOP_EXPR
6560 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
6561 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
6562 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
6564 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6565 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6568 *valp = TREE_INT_CST_LOW (arg_num_expr);
6572 /* Handle a "nothrow" attribute; arguments as in
6573 struct attribute_spec.handler. */
6576 handle_nothrow_attribute (node, name, args, flags, no_add_attrs)
6579 tree args ATTRIBUTE_UNUSED;
6580 int flags ATTRIBUTE_UNUSED;
6583 if (TREE_CODE (*node) == FUNCTION_DECL)
6584 TREE_NOTHROW (*node) = 1;
6585 /* ??? TODO: Support types. */
6588 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6589 *no_add_attrs = true;
6595 /* Check for valid arguments being passed to a function. */
6597 check_function_arguments (attrs, params)
6601 /* Check for null being passed in a pointer argument that must be
6602 non-null. We also need to do this if format checking is enabled. */
6605 check_function_nonnull (attrs, params);
6607 /* Check for errors in format strings. */
6610 check_function_format (NULL, attrs, params);
6613 /* Generic argument checking recursion routine. PARAM is the argument to
6614 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6615 once the argument is resolved. CTX is context for the callback. */
6617 check_function_arguments_recurse (callback, ctx, param, param_num)
6618 void (*callback) PARAMS ((void *, tree, unsigned HOST_WIDE_INT));
6621 unsigned HOST_WIDE_INT param_num;
6623 if (TREE_CODE (param) == NOP_EXPR)
6625 /* Strip coercion. */
6626 check_function_arguments_recurse (callback, ctx,
6627 TREE_OPERAND (param, 0), param_num);
6631 if (TREE_CODE (param) == CALL_EXPR)
6633 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
6635 bool found_format_arg = false;
6637 /* See if this is a call to a known internationalization function
6638 that modifies a format arg. Such a function may have multiple
6639 format_arg attributes (for example, ngettext). */
6641 for (attrs = TYPE_ATTRIBUTES (type);
6643 attrs = TREE_CHAIN (attrs))
6644 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6647 tree format_num_expr;
6651 /* Extract the argument number, which was previously checked
6653 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6654 while (TREE_CODE (format_num_expr) == NOP_EXPR
6655 || TREE_CODE (format_num_expr) == CONVERT_EXPR
6656 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
6657 format_num_expr = TREE_OPERAND (format_num_expr, 0);
6659 if (TREE_CODE (format_num_expr) != INTEGER_CST
6660 || TREE_INT_CST_HIGH (format_num_expr) != 0)
6663 format_num = TREE_INT_CST_LOW (format_num_expr);
6665 for (inner_args = TREE_OPERAND (param, 1), i = 1;
6667 inner_args = TREE_CHAIN (inner_args), i++)
6668 if (i == format_num)
6670 check_function_arguments_recurse (callback, ctx,
6671 TREE_VALUE (inner_args),
6673 found_format_arg = true;
6678 /* If we found a format_arg attribute and did a recursive check,
6679 we are done with checking this argument. Otherwise, we continue
6680 and this will be considered a non-literal. */
6681 if (found_format_arg)
6685 if (TREE_CODE (param) == COND_EXPR)
6687 /* Check both halves of the conditional expression. */
6688 check_function_arguments_recurse (callback, ctx,
6689 TREE_OPERAND (param, 1), param_num);
6690 check_function_arguments_recurse (callback, ctx,
6691 TREE_OPERAND (param, 2), param_num);
6695 (*callback) (ctx, param, param_num);
6698 #include "gt-c-common.h"