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. */
201 int flag_preprocess_only;
203 /* The file name to which we should write a precompiled header, or
204 NULL if no header will be written in this compile. */
206 const char *pch_file;
208 /* Nonzero if an ISO standard was selected. It rejects macros in the
212 /* Nonzero whenever Objective-C functionality is being used. */
215 /* Nonzero if -undef was given. It suppresses target built-in macros
219 /* Nonzero means don't recognize the non-ANSI builtin functions. */
223 /* Nonzero means don't recognize the non-ANSI builtin functions.
226 int flag_no_nonansi_builtin;
228 /* Nonzero means give `double' the same size as `float'. */
230 int flag_short_double;
232 /* Nonzero means give `wchar_t' the same size as `short'. */
234 int flag_short_wchar;
236 /* Nonzero means allow Microsoft extensions without warnings or errors. */
237 int flag_ms_extensions;
239 /* Nonzero means don't recognize the keyword `asm'. */
243 /* Nonzero means give string constants the type `const char *', as mandated
246 int flag_const_strings;
248 /* Nonzero means `$' can be in an identifier. */
250 #ifndef DOLLARS_IN_IDENTIFIERS
251 #define DOLLARS_IN_IDENTIFIERS 1
253 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
255 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
257 int flag_signed_bitfields = 1;
258 int explicit_flag_signed_bitfields;
260 /* Nonzero means warn about pointer casts that can drop a type qualifier
261 from the pointer target type. */
265 /* Warn about functions which might be candidates for format attributes. */
267 int warn_missing_format_attribute;
269 /* Nonzero means warn about sizeof(function) or addition/subtraction
270 of function pointers. */
272 int warn_pointer_arith;
274 /* Nonzero means warn for any global function def
275 without separate previous prototype decl. */
277 int warn_missing_prototypes;
279 /* Warn if adding () is suggested. */
281 int warn_parentheses;
283 /* Warn if initializer is not completely bracketed. */
285 int warn_missing_braces;
287 /* Warn about comparison of signed and unsigned values.
288 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
290 int warn_sign_compare;
292 /* Nonzero means warn about usage of long long when `-pedantic'. */
294 int warn_long_long = 1;
296 /* Nonzero means warn about deprecated conversion from string constant to
299 int warn_write_strings;
301 /* Nonzero means warn about multiple (redundant) decls for the same single
302 variable or function. */
304 int warn_redundant_decls;
306 /* Warn about testing equality of floating point numbers. */
308 int warn_float_equal;
310 /* Warn about a subscript that has type char. */
312 int warn_char_subscripts;
314 /* Warn if a type conversion is done that might have confusing results. */
318 /* Warn about #pragma directives that are not recognized. */
320 int warn_unknown_pragmas; /* Tri state variable. */
322 /* Warn about format/argument anomalies in calls to formatted I/O functions
323 (*printf, *scanf, strftime, strfmon, etc.). */
327 /* Warn about Y2K problems with strftime formats. */
331 /* Warn about excess arguments to formats. */
333 int warn_format_extra_args;
335 /* Warn about zero-length formats. */
337 int warn_format_zero_length;
339 /* Warn about non-literal format arguments. */
341 int warn_format_nonliteral;
343 /* Warn about possible security problems with calls to format functions. */
345 int warn_format_security;
348 /* C/ObjC language option variables. */
351 /* Nonzero means message about use of implicit function declarations;
352 1 means warning; 2 means error. */
354 int mesg_implicit_function_declaration = -1;
356 /* Nonzero means allow type mismatches in conditional expressions;
357 just make their values `void'. */
359 int flag_cond_mismatch;
361 /* Nonzero means enable C89 Amendment 1 features. */
365 /* Nonzero means use the ISO C99 dialect of C. */
369 /* Nonzero means that we have builtin functions, and main is an int */
373 /* Nonzero means add default format_arg attributes for functions not
376 int flag_noniso_default_format_attributes = 1;
378 /* Nonzero means warn when casting a function call to a type that does
379 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
380 when there is no previous declaration of sqrt or malloc. */
382 int warn_bad_function_cast;
384 /* Warn about traditional constructs whose meanings changed in ANSI C. */
386 int warn_traditional;
388 /* Nonzero means warn for non-prototype function decls
389 or non-prototyped defs without previous prototype. */
391 int warn_strict_prototypes;
393 /* Nonzero means warn for any global function def
394 without separate previous decl. */
396 int warn_missing_declarations;
398 /* Nonzero means warn about declarations of objects not at
399 file-scope level and about *all* declarations of functions (whether
400 or static) not at file-scope level. Note that we exclude
401 implicit function declarations. To get warnings about those, use
404 int warn_nested_externs;
406 /* Warn if main is suspicious. */
410 /* Nonzero means warn about possible violations of sequence point rules. */
412 int warn_sequence_point;
414 /* Nonzero means to warn about compile-time division by zero. */
415 int warn_div_by_zero = 1;
417 /* Nonzero means warn about use of implicit int. */
419 int warn_implicit_int;
421 /* Warn about NULL being passed to argument slots marked as requiring
427 /* ObjC language option variables. */
430 /* Open and close the file for outputting class declarations, if
433 int flag_gen_declaration;
435 /* Generate code for GNU or NeXT runtime environment. */
437 #ifdef NEXT_OBJC_RUNTIME
438 int flag_next_runtime = 1;
440 int flag_next_runtime = 0;
443 /* Tells the compiler that this is a special run. Do not perform any
444 compiling, instead we are to test some platform dependent features
445 and output a C header file with appropriate definitions. */
447 int print_struct_values;
449 /* ???. Undocumented. */
451 const char *constant_string_class_name;
453 /* Warn if multiple methods are seen for the same selector, but with
454 different argument types. Performs the check on the whole selector
455 table at the end of compilation. */
459 /* Warn if a @selector() is found, and no method with that selector
460 has been previously declared. The check is done on each
461 @selector() as soon as it is found - so it warns about forward
464 int warn_undeclared_selector;
466 /* Warn if methods required by a protocol are not implemented in the
467 class adopting it. When turned off, methods inherited to that
468 class are also considered implemented. */
470 int warn_protocol = 1;
473 /* C++ language option variables. */
476 /* Nonzero means don't recognize any extension keywords. */
478 int flag_no_gnu_keywords;
480 /* Nonzero means do emit exported implementations of functions even if
481 they can be inlined. */
483 int flag_implement_inlines = 1;
485 /* Nonzero means do emit exported implementations of templates, instead of
486 multiple static copies in each file that needs a definition. */
488 int flag_external_templates;
490 /* Nonzero means that the decision to emit or not emit the implementation of a
491 template depends on where the template is instantiated, rather than where
494 int flag_alt_external_templates;
496 /* Nonzero means that implicit instantiations will be emitted if needed. */
498 int flag_implicit_templates = 1;
500 /* Nonzero means that implicit instantiations of inline templates will be
501 emitted if needed, even if instantiations of non-inline templates
504 int flag_implicit_inline_templates = 1;
506 /* Nonzero means generate separate instantiation control files and
507 juggle them at link time. */
509 int flag_use_repository;
511 /* Nonzero if we want to issue diagnostics that the standard says are not
514 int flag_optional_diags = 1;
516 /* Nonzero means we should attempt to elide constructors when possible. */
518 int flag_elide_constructors = 1;
520 /* Nonzero means that member functions defined in class scope are
521 inline by default. */
523 int flag_default_inline = 1;
525 /* Controls whether compiler generates 'type descriptor' that give
526 run-time type information. */
530 /* Nonzero if we want to conserve space in the .o files. We do this
531 by putting uninitialized data and runtime initialized data into
532 .common instead of .data at the expense of not flagging multiple
535 int flag_conserve_space;
537 /* Nonzero if we want to obey access control semantics. */
539 int flag_access_control = 1;
541 /* Nonzero if we want to check the return value of new and avoid calling
542 constructors if it is a null pointer. */
546 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
547 initialization variables.
548 0: Old rules, set by -fno-for-scope.
549 2: New ISO rules, set by -ffor-scope.
550 1: Try to implement new ISO rules, but with backup compatibility
551 (and warnings). This is the default, for now. */
553 int flag_new_for_scope = 1;
555 /* Nonzero if we want to emit defined symbols with common-like linkage as
556 weak symbols where possible, in order to conform to C++ semantics.
557 Otherwise, emit them as local symbols. */
561 /* Nonzero to use __cxa_atexit, rather than atexit, to register
562 destructors for local statics and global objects. */
564 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
566 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
570 /* Nonzero means make the default pedwarns warnings instead of errors.
571 The value of this flag is ignored if -pedantic is specified. */
575 /* Nonzero means to implement standard semantics for exception
576 specifications, calling unexpected if an exception is thrown that
577 doesn't match the specification. Zero means to treat them as
578 assertions and optimize accordingly, but not check them. */
580 int flag_enforce_eh_specs = 1;
582 /* The version of the C++ ABI in use. The following values are
585 0: The version of the ABI believed most conformant with the
586 C++ ABI specification. This ABI may change as bugs are
587 discovered and fixed. Therefore, 0 will not necessarily
588 indicate the same ABI in different versions of G++.
590 1: The version of the ABI first used in G++ 3.2.
592 Additional positive integers will be assigned as new versions of
593 the ABI become the default version of the ABI. */
595 int flag_abi_version = 1;
597 /* Nonzero means warn about things that will change when compiling
598 with an ABI-compliant compiler. */
602 /* Nonzero means warn about implicit declarations. */
604 int warn_implicit = 1;
606 /* Nonzero means warn when all ctors or dtors are private, and the class
609 int warn_ctor_dtor_privacy = 1;
611 /* Nonzero means warn in function declared in derived class has the
612 same name as a virtual in the base class, but fails to match the
613 type signature of any virtual function in the base class. */
615 int warn_overloaded_virtual;
617 /* Nonzero means warn when declaring a class that has a non virtual
618 destructor, when it really ought to have a virtual one. */
622 /* Nonzero means warn when the compiler will reorder code. */
626 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
630 /* Nonzero means warn when we convert a pointer to member function
631 into a pointer to (void or function). */
633 int warn_pmf2ptr = 1;
635 /* Nonzero means warn about violation of some Effective C++ style rules. */
639 /* Nonzero means warn where overload resolution chooses a promotion from
640 unsigned to signed over a conversion to an unsigned of the same size. */
644 /* Nonzero means warn when an old-style cast is used. */
646 int warn_old_style_cast;
648 /* Nonzero means warn when non-templatized friend functions are
649 declared within a template */
651 int warn_nontemplate_friend = 1;
653 /* Nonzero means complain about deprecated features. */
655 int warn_deprecated = 1;
657 /* Maximum template instantiation depth. This limit is rather
658 arbitrary, but it exists to limit the time it takes to notice
659 infinite template instantiations. */
661 int max_tinst_depth = 500;
665 /* The elements of `ridpointers' are identifier nodes for the reserved
666 type names and storage classes. It is indexed by a RID_... value. */
669 tree (*make_fname_decl) PARAMS ((tree, int));
671 /* If non-NULL, the address of a language-specific function that
672 returns 1 for language-specific statement codes. */
673 int (*lang_statement_code_p) PARAMS ((enum tree_code));
675 /* If non-NULL, the address of a language-specific function that takes
676 any action required right before expand_function_end is called. */
677 void (*lang_expand_function_end) PARAMS ((void));
679 /* Nonzero means the expression being parsed will never be evaluated.
680 This is a count, since unevaluated expressions can nest. */
683 /* Information about how a function name is generated. */
686 tree *const decl; /* pointer to the VAR_DECL. */
687 const unsigned rid; /* RID number for the identifier. */
688 const int pretty; /* How pretty is it? */
691 /* The three ways of getting then name of the current function. */
693 const struct fname_var_t fname_vars[] =
695 /* C99 compliant __func__, must be first. */
696 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
697 /* GCC __FUNCTION__ compliant. */
698 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
699 /* GCC __PRETTY_FUNCTION__ compliant. */
700 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
704 static int constant_fits_type_p PARAMS ((tree, tree));
706 /* Keep a stack of if statements. We record the number of compound
707 statements seen up to the if keyword, as well as the line number
708 and file of the if. If a potentially ambiguous else is seen, that
709 fact is recorded; the warning is issued when we can be sure that
710 the enclosing if statement does not have an else branch. */
720 static if_elt *if_stack;
722 /* Amount of space in the if statement stack. */
723 static int if_stack_space = 0;
726 static int if_stack_pointer = 0;
728 static tree handle_packed_attribute PARAMS ((tree *, tree, tree, int,
730 static tree handle_nocommon_attribute PARAMS ((tree *, tree, tree, int,
732 static tree handle_common_attribute PARAMS ((tree *, tree, tree, int,
734 static tree handle_noreturn_attribute PARAMS ((tree *, tree, tree, int,
736 static tree handle_noinline_attribute PARAMS ((tree *, tree, tree, int,
738 static tree handle_always_inline_attribute PARAMS ((tree *, tree, tree, int,
740 static tree handle_used_attribute PARAMS ((tree *, tree, tree, int,
742 static tree handle_unused_attribute PARAMS ((tree *, tree, tree, int,
744 static tree handle_const_attribute PARAMS ((tree *, tree, tree, int,
746 static tree handle_transparent_union_attribute PARAMS ((tree *, tree, tree,
748 static tree handle_constructor_attribute PARAMS ((tree *, tree, tree, int,
750 static tree handle_destructor_attribute PARAMS ((tree *, tree, tree, int,
752 static tree handle_mode_attribute PARAMS ((tree *, tree, tree, int,
754 static tree handle_section_attribute PARAMS ((tree *, tree, tree, int,
756 static tree handle_aligned_attribute PARAMS ((tree *, tree, tree, int,
758 static tree handle_weak_attribute PARAMS ((tree *, tree, tree, int,
760 static tree handle_alias_attribute PARAMS ((tree *, tree, tree, int,
762 static tree handle_visibility_attribute PARAMS ((tree *, tree, tree, int,
764 static tree handle_tls_model_attribute PARAMS ((tree *, tree, tree, int,
766 static tree handle_no_instrument_function_attribute PARAMS ((tree *, tree,
769 static tree handle_malloc_attribute PARAMS ((tree *, tree, tree, int,
771 static tree handle_no_limit_stack_attribute PARAMS ((tree *, tree, tree, int,
773 static tree handle_pure_attribute PARAMS ((tree *, tree, tree, int,
775 static tree handle_deprecated_attribute PARAMS ((tree *, tree, tree, int,
777 static tree handle_vector_size_attribute PARAMS ((tree *, tree, tree, int,
779 static tree handle_nonnull_attribute PARAMS ((tree *, tree, tree, int,
781 static tree handle_nothrow_attribute PARAMS ((tree *, tree, tree, int,
783 static tree vector_size_helper PARAMS ((tree, tree));
785 static void check_function_nonnull PARAMS ((tree, tree));
786 static void check_nonnull_arg PARAMS ((void *, tree,
787 unsigned HOST_WIDE_INT));
788 static bool nonnull_check_p PARAMS ((tree, unsigned HOST_WIDE_INT));
789 static bool get_nonnull_operand PARAMS ((tree,
790 unsigned HOST_WIDE_INT *));
791 void builtin_define_std PARAMS ((const char *));
792 static void builtin_define_with_value PARAMS ((const char *, const char *,
794 static void builtin_define_with_int_value PARAMS ((const char *,
796 static void builtin_define_with_hex_fp_value PARAMS ((const char *, tree,
799 static void builtin_define_type_max PARAMS ((const char *, tree, int));
800 static void builtin_define_type_precision PARAMS ((const char *, tree));
801 static void builtin_define_float_constants PARAMS ((const char *,
802 const char *, tree));
804 /* Table of machine-independent attributes common to all C-like languages. */
805 const struct attribute_spec c_common_attribute_table[] =
807 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
808 { "packed", 0, 0, false, false, false,
809 handle_packed_attribute },
810 { "nocommon", 0, 0, true, false, false,
811 handle_nocommon_attribute },
812 { "common", 0, 0, true, false, false,
813 handle_common_attribute },
814 /* FIXME: logically, noreturn attributes should be listed as
815 "false, true, true" and apply to function types. But implementing this
816 would require all the places in the compiler that use TREE_THIS_VOLATILE
817 on a decl to identify non-returning functions to be located and fixed
818 to check the function type instead. */
819 { "noreturn", 0, 0, true, false, false,
820 handle_noreturn_attribute },
821 { "volatile", 0, 0, true, false, false,
822 handle_noreturn_attribute },
823 { "noinline", 0, 0, true, false, false,
824 handle_noinline_attribute },
825 { "always_inline", 0, 0, true, false, false,
826 handle_always_inline_attribute },
827 { "used", 0, 0, true, false, false,
828 handle_used_attribute },
829 { "unused", 0, 0, false, false, false,
830 handle_unused_attribute },
831 /* The same comments as for noreturn attributes apply to const ones. */
832 { "const", 0, 0, true, false, false,
833 handle_const_attribute },
834 { "transparent_union", 0, 0, false, false, false,
835 handle_transparent_union_attribute },
836 { "constructor", 0, 0, true, false, false,
837 handle_constructor_attribute },
838 { "destructor", 0, 0, true, false, false,
839 handle_destructor_attribute },
840 { "mode", 1, 1, false, true, false,
841 handle_mode_attribute },
842 { "section", 1, 1, true, false, false,
843 handle_section_attribute },
844 { "aligned", 0, 1, false, false, false,
845 handle_aligned_attribute },
846 { "weak", 0, 0, true, false, false,
847 handle_weak_attribute },
848 { "alias", 1, 1, true, false, false,
849 handle_alias_attribute },
850 { "no_instrument_function", 0, 0, true, false, false,
851 handle_no_instrument_function_attribute },
852 { "malloc", 0, 0, true, false, false,
853 handle_malloc_attribute },
854 { "no_stack_limit", 0, 0, true, false, false,
855 handle_no_limit_stack_attribute },
856 { "pure", 0, 0, true, false, false,
857 handle_pure_attribute },
858 { "deprecated", 0, 0, false, false, false,
859 handle_deprecated_attribute },
860 { "vector_size", 1, 1, false, true, false,
861 handle_vector_size_attribute },
862 { "visibility", 1, 1, true, false, false,
863 handle_visibility_attribute },
864 { "tls_model", 1, 1, true, false, false,
865 handle_tls_model_attribute },
866 { "nonnull", 0, -1, false, true, true,
867 handle_nonnull_attribute },
868 { "nothrow", 0, 0, true, false, false,
869 handle_nothrow_attribute },
870 { "may_alias", 0, 0, false, true, false, NULL },
871 { NULL, 0, 0, false, false, false, NULL }
874 /* Give the specifications for the format attributes, used by C and all
877 const struct attribute_spec c_common_format_attribute_table[] =
879 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
880 { "format", 3, 3, false, true, true,
881 handle_format_attribute },
882 { "format_arg", 1, 1, false, true, true,
883 handle_format_arg_attribute },
884 { NULL, 0, 0, false, false, false, NULL }
887 /* Record the start of an if-then, and record the start of it
888 for ambiguous else detection.
890 COND is the condition for the if-then statement.
892 IF_STMT is the statement node that has already been created for
893 this if-then statement. It is created before parsing the
894 condition to keep line number information accurate. */
897 c_expand_start_cond (cond, compstmt_count, if_stmt)
902 /* Make sure there is enough space on the stack. */
903 if (if_stack_space == 0)
906 if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
908 else if (if_stack_space == if_stack_pointer)
910 if_stack_space += 10;
911 if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
914 IF_COND (if_stmt) = cond;
917 /* Record this if statement. */
918 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
919 if_stack[if_stack_pointer].file = input_filename;
920 if_stack[if_stack_pointer].line = lineno;
921 if_stack[if_stack_pointer].needs_warning = 0;
922 if_stack[if_stack_pointer].if_stmt = if_stmt;
926 /* Called after the then-clause for an if-statement is processed. */
931 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
932 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
935 /* Record the end of an if-then. Optionally warn if a nested
936 if statement had an ambiguous else clause. */
942 if (if_stack[if_stack_pointer].needs_warning)
943 warning_with_file_and_line (if_stack[if_stack_pointer].file,
944 if_stack[if_stack_pointer].line,
945 "suggest explicit braces to avoid ambiguous `else'");
946 last_expr_type = NULL_TREE;
949 /* Called between the then-clause and the else-clause
950 of an if-then-else. */
953 c_expand_start_else ()
955 /* An ambiguous else warning must be generated for the enclosing if
956 statement, unless we see an else branch for that one, too. */
958 && if_stack_pointer > 1
959 && (if_stack[if_stack_pointer - 1].compstmt_count
960 == if_stack[if_stack_pointer - 2].compstmt_count))
961 if_stack[if_stack_pointer - 2].needs_warning = 1;
963 /* Even if a nested if statement had an else branch, it can't be
964 ambiguous if this one also has an else. So don't warn in that
965 case. Also don't warn for any if statements nested in this else. */
966 if_stack[if_stack_pointer - 1].needs_warning = 0;
967 if_stack[if_stack_pointer - 1].compstmt_count--;
970 /* Called after the else-clause for an if-statement is processed. */
975 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
976 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
979 /* Begin an if-statement. Returns a newly created IF_STMT if
982 Unlike the C++ front-end, we do not call add_stmt here; it is
983 probably safe to do so, but I am not very familiar with this
984 code so I am being extra careful not to change its behavior
985 beyond what is strictly necessary for correctness. */
991 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
995 /* Begin a while statement. Returns a newly created WHILE_STMT if
998 Unlike the C++ front-end, we do not call add_stmt here; it is
999 probably safe to do so, but I am not very familiar with this
1000 code so I am being extra careful not to change its behavior
1001 beyond what is strictly necessary for correctness. */
1004 c_begin_while_stmt ()
1007 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
1012 c_finish_while_stmt_cond (cond, while_stmt)
1016 WHILE_COND (while_stmt) = cond;
1019 /* Push current bindings for the function name VAR_DECLS. */
1022 start_fname_decls ()
1025 tree saved = NULL_TREE;
1027 for (ix = 0; fname_vars[ix].decl; ix++)
1029 tree decl = *fname_vars[ix].decl;
1033 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
1034 *fname_vars[ix].decl = NULL_TREE;
1037 if (saved || saved_function_name_decls)
1038 /* Normally they'll have been NULL, so only push if we've got a
1039 stack, or they are non-NULL. */
1040 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1041 saved_function_name_decls);
1044 /* Finish up the current bindings, adding them into the
1045 current function's statement tree. This is done by wrapping the
1046 function's body in a COMPOUND_STMT containing these decls too. This
1047 must be done _before_ finish_stmt_tree is called. If there is no
1048 current function, we must be at file scope and no statements are
1049 involved. Pop the previous bindings. */
1052 finish_fname_decls ()
1055 tree body = NULL_TREE;
1056 tree stack = saved_function_name_decls;
1058 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1059 body = chainon (TREE_VALUE (stack), body);
1063 /* They were called into existence, so add to statement tree. Add
1064 the DECL_STMTs inside the outermost scope. */
1065 tree *p = &DECL_SAVED_TREE (current_function_decl);
1066 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1067 while (TREE_CODE (*p) != COMPOUND_STMT)
1068 p = &TREE_CHAIN (*p);
1069 p = &COMPOUND_BODY (*p);
1070 if (TREE_CODE (*p) == SCOPE_STMT)
1071 p = &TREE_CHAIN (*p);
1073 body = chainon (body, *p);
1077 for (ix = 0; fname_vars[ix].decl; ix++)
1078 *fname_vars[ix].decl = NULL_TREE;
1082 /* We had saved values, restore them. */
1085 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1087 tree decl = TREE_PURPOSE (saved);
1088 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1090 *fname_vars[ix].decl = decl;
1092 stack = TREE_CHAIN (stack);
1094 saved_function_name_decls = stack;
1097 /* Return the text name of the current function, suitably prettified
1101 fname_as_string (pretty_p)
1104 const char *name = NULL;
1107 name = (current_function_decl
1108 ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
1110 else if (current_function_decl && DECL_NAME (current_function_decl))
1111 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
1117 /* Return the text name of the current function, formatted as
1118 required by the supplied RID value. */
1126 for (ix = 0; fname_vars[ix].decl; ix++)
1127 if (fname_vars[ix].rid == rid)
1129 return fname_as_string (fname_vars[ix].pretty);
1132 /* Return the VAR_DECL for a const char array naming the current
1133 function. If the VAR_DECL has not yet been created, create it
1134 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1135 ID is its name (unfortunately C and C++ hold the RID values of
1136 keywords in different places, so we can't derive RID from ID in
1137 this language independent code. */
1140 fname_decl (rid, id)
1145 tree decl = NULL_TREE;
1147 for (ix = 0; fname_vars[ix].decl; ix++)
1148 if (fname_vars[ix].rid == rid)
1151 decl = *fname_vars[ix].decl;
1154 tree saved_last_tree = last_tree;
1155 /* If a tree is built here, it would normally have the lineno of
1156 the current statement. Later this tree will be moved to the
1157 beginning of the function and this line number will be wrong.
1158 To avoid this problem set the lineno to 0 here; that prevents
1159 it from appearing in the RTL. */
1160 int saved_lineno = lineno;
1163 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1164 if (last_tree != saved_last_tree)
1166 /* We created some statement tree for the decl. This belongs
1167 at the start of the function, so remove it now and reinsert
1168 it after the function is complete. */
1169 tree stmts = TREE_CHAIN (saved_last_tree);
1171 TREE_CHAIN (saved_last_tree) = NULL_TREE;
1172 last_tree = saved_last_tree;
1173 saved_function_name_decls = tree_cons (decl, stmts,
1174 saved_function_name_decls);
1176 *fname_vars[ix].decl = decl;
1177 lineno = saved_lineno;
1179 if (!ix && !current_function_decl)
1180 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
1185 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1188 fix_string_type (value)
1191 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1192 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1193 const int nchars_max = flag_isoc99 ? 4095 : 509;
1194 int length = TREE_STRING_LENGTH (value);
1197 /* Compute the number of elements, for the array type. */
1198 nchars = wide_flag ? length / wchar_bytes : length;
1200 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
1201 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1202 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1204 /* Create the array type for the string constant.
1205 -Wwrite-strings says make the string constant an array of const char
1206 so that copying it to a non-const pointer will get a warning.
1207 For C++, this is the standard behavior. */
1208 if (flag_const_strings && ! flag_writable_strings)
1211 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1214 = build_array_type (elements,
1215 build_index_type (build_int_2 (nchars - 1, 0)));
1219 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1220 build_index_type (build_int_2 (nchars - 1, 0)));
1222 TREE_CONSTANT (value) = 1;
1223 TREE_READONLY (value) = ! flag_writable_strings;
1224 TREE_STATIC (value) = 1;
1228 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1232 combine_strings (strings)
1233 varray_type strings;
1235 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1236 const int nstrings = VARRAY_ACTIVE_SIZE (strings);
1239 int wide_length = 0;
1244 /* Don't include the \0 at the end of each substring. Count wide
1245 strings and ordinary strings separately. */
1246 for (i = 0; i < nstrings; ++i)
1248 t = VARRAY_TREE (strings, i);
1250 if (TREE_TYPE (t) == wchar_array_type_node)
1252 wide_length += TREE_STRING_LENGTH (t) - wchar_bytes;
1257 length += (TREE_STRING_LENGTH (t) - 1);
1258 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
1259 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1263 /* If anything is wide, the non-wides will be converted,
1264 which makes them take more space. */
1266 length = length * wchar_bytes + wide_length;
1268 p = xmalloc (length);
1270 /* Copy the individual strings into the new combined string.
1271 If the combined string is wide, convert the chars to ints
1272 for any individual strings that are not wide. */
1275 for (i = 0; i < nstrings; ++i)
1279 t = VARRAY_TREE (strings, i);
1280 this_wide = TREE_TYPE (t) == wchar_array_type_node;
1281 len = TREE_STRING_LENGTH (t) - (this_wide ? wchar_bytes : 1);
1282 if (this_wide == wide_flag)
1284 memcpy (q, TREE_STRING_POINTER (t), len);
1289 const int nzeros = (TYPE_PRECISION (wchar_type_node)
1290 / BITS_PER_UNIT) - 1;
1293 if (BYTES_BIG_ENDIAN)
1295 for (k = 0; k < len; k++)
1297 for (j = 0; j < nzeros; j++)
1299 *q++ = TREE_STRING_POINTER (t)[k];
1304 for (k = 0; k < len; k++)
1306 *q++ = TREE_STRING_POINTER (t)[k];
1307 for (j = 0; j < nzeros; j++)
1314 /* Nul terminate the string. */
1317 for (i = 0; i < wchar_bytes; i++)
1323 value = build_string (length, p);
1327 TREE_TYPE (value) = wchar_array_type_node;
1329 TREE_TYPE (value) = char_array_type_node;
1334 static int is_valid_printf_arglist PARAMS ((tree));
1335 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1336 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1337 enum expand_modifier, int, int));
1338 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
1339 enum expand_modifier, int, int));
1341 /* Print a warning if a constant expression had overflow in folding.
1342 Invoke this function on every expression that the language
1343 requires to be a constant expression.
1344 Note the ANSI C standard says it is erroneous for a
1345 constant expression to overflow. */
1348 constant_expression_warning (value)
1351 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1352 || TREE_CODE (value) == VECTOR_CST
1353 || TREE_CODE (value) == COMPLEX_CST)
1354 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1355 pedwarn ("overflow in constant expression");
1358 /* Print a warning if an expression had overflow in folding.
1359 Invoke this function on every expression that
1360 (1) appears in the source code, and
1361 (2) might be a constant expression that overflowed, and
1362 (3) is not already checked by convert_and_check;
1363 however, do not invoke this function on operands of explicit casts. */
1366 overflow_warning (value)
1369 if ((TREE_CODE (value) == INTEGER_CST
1370 || (TREE_CODE (value) == COMPLEX_CST
1371 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1372 && TREE_OVERFLOW (value))
1374 TREE_OVERFLOW (value) = 0;
1375 if (skip_evaluation == 0)
1376 warning ("integer overflow in expression");
1378 else if ((TREE_CODE (value) == REAL_CST
1379 || (TREE_CODE (value) == COMPLEX_CST
1380 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1381 && TREE_OVERFLOW (value))
1383 TREE_OVERFLOW (value) = 0;
1384 if (skip_evaluation == 0)
1385 warning ("floating point overflow in expression");
1387 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1389 TREE_OVERFLOW (value) = 0;
1390 if (skip_evaluation == 0)
1391 warning ("vector overflow in expression");
1395 /* Print a warning if a large constant is truncated to unsigned,
1396 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1397 Invoke this function on every expression that might be implicitly
1398 converted to an unsigned type. */
1401 unsigned_conversion_warning (result, operand)
1402 tree result, operand;
1404 tree type = TREE_TYPE (result);
1406 if (TREE_CODE (operand) == INTEGER_CST
1407 && TREE_CODE (type) == INTEGER_TYPE
1408 && TREE_UNSIGNED (type)
1409 && skip_evaluation == 0
1410 && !int_fits_type_p (operand, type))
1412 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1413 /* This detects cases like converting -129 or 256 to unsigned char. */
1414 warning ("large integer implicitly truncated to unsigned type");
1415 else if (warn_conversion)
1416 warning ("negative integer implicitly converted to unsigned type");
1420 /* Nonzero if constant C has a value that is permissible
1421 for type TYPE (an INTEGER_TYPE). */
1424 constant_fits_type_p (c, type)
1427 if (TREE_CODE (c) == INTEGER_CST)
1428 return int_fits_type_p (c, type);
1430 c = convert (type, c);
1431 return !TREE_OVERFLOW (c);
1434 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1435 Invoke this function on every expression that is converted implicitly,
1436 i.e. because of language rules and not because of an explicit cast. */
1439 convert_and_check (type, expr)
1442 tree t = convert (type, expr);
1443 if (TREE_CODE (t) == INTEGER_CST)
1445 if (TREE_OVERFLOW (t))
1447 TREE_OVERFLOW (t) = 0;
1449 /* Do not diagnose overflow in a constant expression merely
1450 because a conversion overflowed. */
1451 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1453 /* No warning for converting 0x80000000 to int. */
1454 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1455 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1456 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1457 /* If EXPR fits in the unsigned version of TYPE,
1458 don't warn unless pedantic. */
1460 || TREE_UNSIGNED (type)
1461 || ! constant_fits_type_p (expr,
1462 c_common_unsigned_type (type)))
1463 && skip_evaluation == 0)
1464 warning ("overflow in implicit constant conversion");
1467 unsigned_conversion_warning (t, expr);
1472 /* A node in a list that describes references to variables (EXPR), which are
1473 either read accesses if WRITER is zero, or write accesses, in which case
1474 WRITER is the parent of EXPR. */
1481 /* Used to implement a cache the results of a call to verify_tree. We only
1482 use this for SAVE_EXPRs. */
1485 struct tlist_cache *next;
1486 struct tlist *cache_before_sp;
1487 struct tlist *cache_after_sp;
1491 /* Obstack to use when allocating tlist structures, and corresponding
1493 static struct obstack tlist_obstack;
1494 static char *tlist_firstobj = 0;
1496 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1498 static struct tlist *warned_ids;
1499 /* SAVE_EXPRs need special treatment. We process them only once and then
1500 cache the results. */
1501 static struct tlist_cache *save_expr_cache;
1503 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1504 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1505 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1506 static int warning_candidate_p PARAMS ((tree));
1507 static void warn_for_collisions PARAMS ((struct tlist *));
1508 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1509 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1510 static void verify_sequence_points PARAMS ((tree));
1512 /* Create a new struct tlist and fill in its fields. */
1513 static struct tlist *
1514 new_tlist (next, t, writer)
1520 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1527 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1528 is nonnull, we ignore any node we find which has a writer equal to it. */
1531 add_tlist (to, add, exclude_writer, copy)
1534 tree exclude_writer;
1539 struct tlist *next = add->next;
1542 if (! exclude_writer || add->writer != exclude_writer)
1543 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1548 /* Merge the nodes of ADD into TO. This merging process is done so that for
1549 each variable that already exists in TO, no new node is added; however if
1550 there is a write access recorded in ADD, and an occurrence on TO is only
1551 a read access, then the occurrence in TO will be modified to record the
1555 merge_tlist (to, add, copy)
1560 struct tlist **end = to;
1563 end = &(*end)->next;
1569 struct tlist *next = add->next;
1571 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1572 if (tmp2->expr == add->expr)
1576 tmp2->writer = add->writer;
1580 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1581 end = &(*end)->next;
1588 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1589 references in list LIST conflict with it, excluding reads if ONLY writers
1593 warn_for_collisions_1 (written, writer, list, only_writes)
1594 tree written, writer;
1600 /* Avoid duplicate warnings. */
1601 for (tmp = warned_ids; tmp; tmp = tmp->next)
1602 if (tmp->expr == written)
1607 if (list->expr == written
1608 && list->writer != writer
1609 && (! only_writes || list->writer))
1611 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1612 warning ("operation on `%s' may be undefined",
1613 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1619 /* Given a list LIST of references to variables, find whether any of these
1620 can cause conflicts due to missing sequence points. */
1623 warn_for_collisions (list)
1628 for (tmp = list; tmp; tmp = tmp->next)
1631 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1635 /* Return nonzero if X is a tree that can be verified by the sequence point
1638 warning_candidate_p (x)
1641 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1644 /* Walk the tree X, and record accesses to variables. If X is written by the
1645 parent tree, WRITER is the parent.
1646 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1647 expression or its only operand forces a sequence point, then everything up
1648 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1650 Once we return, we will have emitted warnings if any subexpression before
1651 such a sequence point could be undefined. On a higher level, however, the
1652 sequence point may not be relevant, and we'll merge the two lists.
1654 Example: (b++, a) + b;
1655 The call that processes the COMPOUND_EXPR will store the increment of B
1656 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1657 processes the PLUS_EXPR will need to merge the two lists so that
1658 eventually, all accesses end up on the same list (and we'll warn about the
1659 unordered subexpressions b++ and b.
1661 A note on merging. If we modify the former example so that our expression
1664 care must be taken not simply to add all three expressions into the final
1665 PNO_SP list. The function merge_tlist takes care of that by merging the
1666 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1667 way, so that no more than one access to B is recorded. */
1670 verify_tree (x, pbefore_sp, pno_sp, writer)
1672 struct tlist **pbefore_sp, **pno_sp;
1675 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1676 enum tree_code code;
1679 /* X may be NULL if it is the operand of an empty statement expression
1685 code = TREE_CODE (x);
1686 class = TREE_CODE_CLASS (code);
1688 if (warning_candidate_p (x))
1690 *pno_sp = new_tlist (*pno_sp, x, writer);
1700 case TRUTH_ANDIF_EXPR:
1701 case TRUTH_ORIF_EXPR:
1702 tmp_before = tmp_nosp = tmp_list3 = 0;
1703 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1704 warn_for_collisions (tmp_nosp);
1705 merge_tlist (pbefore_sp, tmp_before, 0);
1706 merge_tlist (pbefore_sp, tmp_nosp, 0);
1707 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1708 merge_tlist (pbefore_sp, tmp_list3, 0);
1712 tmp_before = tmp_list2 = 0;
1713 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1714 warn_for_collisions (tmp_list2);
1715 merge_tlist (pbefore_sp, tmp_before, 0);
1716 merge_tlist (pbefore_sp, tmp_list2, 1);
1718 tmp_list3 = tmp_nosp = 0;
1719 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1720 warn_for_collisions (tmp_nosp);
1721 merge_tlist (pbefore_sp, tmp_list3, 0);
1723 tmp_list3 = tmp_list2 = 0;
1724 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1725 warn_for_collisions (tmp_list2);
1726 merge_tlist (pbefore_sp, tmp_list3, 0);
1727 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1728 two first, to avoid warning for (a ? b++ : b++). */
1729 merge_tlist (&tmp_nosp, tmp_list2, 0);
1730 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1733 case PREDECREMENT_EXPR:
1734 case PREINCREMENT_EXPR:
1735 case POSTDECREMENT_EXPR:
1736 case POSTINCREMENT_EXPR:
1737 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1741 tmp_before = tmp_nosp = tmp_list3 = 0;
1742 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1743 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1744 /* Expressions inside the LHS are not ordered wrt. the sequence points
1745 in the RHS. Example:
1747 Despite the fact that the modification of "a" is in the before_sp
1748 list (tmp_before), it conflicts with the use of "a" in the LHS.
1749 We can handle this by adding the contents of tmp_list3
1750 to those of tmp_before, and redoing the collision warnings for that
1752 add_tlist (&tmp_before, tmp_list3, x, 1);
1753 warn_for_collisions (tmp_before);
1754 /* Exclude the LHS itself here; we first have to merge it into the
1755 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1756 didn't exclude the LHS, we'd get it twice, once as a read and once
1758 add_tlist (pno_sp, tmp_list3, x, 0);
1759 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1761 merge_tlist (pbefore_sp, tmp_before, 0);
1762 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1763 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1764 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1768 /* We need to warn about conflicts among arguments and conflicts between
1769 args and the function address. Side effects of the function address,
1770 however, are not ordered by the sequence point of the call. */
1771 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1772 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1773 if (TREE_OPERAND (x, 1))
1774 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1775 merge_tlist (&tmp_list3, tmp_list2, 0);
1776 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1777 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1778 warn_for_collisions (tmp_before);
1779 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1783 /* Scan all the list, e.g. indices of multi dimensional array. */
1786 tmp_before = tmp_nosp = 0;
1787 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1788 merge_tlist (&tmp_nosp, tmp_before, 0);
1789 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1796 struct tlist_cache *t;
1797 for (t = save_expr_cache; t; t = t->next)
1803 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1805 t->next = save_expr_cache;
1807 save_expr_cache = t;
1809 tmp_before = tmp_nosp = 0;
1810 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1811 warn_for_collisions (tmp_nosp);
1816 struct tlist *t = tmp_nosp;
1818 merge_tlist (&tmp_list3, t, 0);
1820 t->cache_before_sp = tmp_before;
1821 t->cache_after_sp = tmp_list3;
1823 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1824 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1833 if (first_rtl_op (code) == 0)
1835 x = TREE_OPERAND (x, 0);
1851 int max = first_rtl_op (TREE_CODE (x));
1852 for (lp = 0; lp < max; lp++)
1854 tmp_before = tmp_nosp = 0;
1855 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1856 merge_tlist (&tmp_nosp, tmp_before, 0);
1857 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1864 /* Try to warn for undefined behavior in EXPR due to missing sequence
1868 verify_sequence_points (expr)
1871 struct tlist *before_sp = 0, *after_sp = 0;
1874 save_expr_cache = 0;
1875 if (tlist_firstobj == 0)
1877 gcc_obstack_init (&tlist_obstack);
1878 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1881 verify_tree (expr, &before_sp, &after_sp, 0);
1882 warn_for_collisions (after_sp);
1883 obstack_free (&tlist_obstack, tlist_firstobj);
1887 c_expand_expr_stmt (expr)
1890 /* Do default conversion if safe and possibly important,
1891 in case within ({...}). */
1892 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1893 && (flag_isoc99 || lvalue_p (expr)))
1894 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1895 expr = default_conversion (expr);
1897 if (warn_sequence_point)
1898 verify_sequence_points (expr);
1900 if (TREE_TYPE (expr) != error_mark_node
1901 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1902 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1903 error ("expression statement has incomplete type");
1905 last_expr_type = TREE_TYPE (expr);
1906 return add_stmt (build_stmt (EXPR_STMT, expr));
1909 /* Validate the expression after `case' and apply default promotions. */
1912 check_case_value (value)
1915 if (value == NULL_TREE)
1918 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1919 STRIP_TYPE_NOPS (value);
1920 /* In C++, the following is allowed:
1923 switch (...) { case i: ... }
1925 So, we try to reduce the VALUE to a constant that way. */
1926 if (c_language == clk_cplusplus)
1928 value = decl_constant_value (value);
1929 STRIP_TYPE_NOPS (value);
1930 value = fold (value);
1933 if (TREE_CODE (value) != INTEGER_CST
1934 && value != error_mark_node)
1936 error ("case label does not reduce to an integer constant");
1937 value = error_mark_node;
1940 /* Promote char or short to int. */
1941 value = default_conversion (value);
1943 constant_expression_warning (value);
1948 /* Return an integer type with BITS bits of precision,
1949 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1952 c_common_type_for_size (bits, unsignedp)
1956 if (bits == TYPE_PRECISION (integer_type_node))
1957 return unsignedp ? unsigned_type_node : integer_type_node;
1959 if (bits == TYPE_PRECISION (signed_char_type_node))
1960 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1962 if (bits == TYPE_PRECISION (short_integer_type_node))
1963 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1965 if (bits == TYPE_PRECISION (long_integer_type_node))
1966 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1968 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1969 return (unsignedp ? long_long_unsigned_type_node
1970 : long_long_integer_type_node);
1972 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1973 return (unsignedp ? widest_unsigned_literal_type_node
1974 : widest_integer_literal_type_node);
1976 if (bits <= TYPE_PRECISION (intQI_type_node))
1977 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1979 if (bits <= TYPE_PRECISION (intHI_type_node))
1980 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1982 if (bits <= TYPE_PRECISION (intSI_type_node))
1983 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1985 if (bits <= TYPE_PRECISION (intDI_type_node))
1986 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1991 /* Return a data type that has machine mode MODE.
1992 If the mode is an integer,
1993 then UNSIGNEDP selects between signed and unsigned types. */
1996 c_common_type_for_mode (mode, unsignedp)
1997 enum machine_mode mode;
2000 if (mode == TYPE_MODE (integer_type_node))
2001 return unsignedp ? unsigned_type_node : integer_type_node;
2003 if (mode == TYPE_MODE (signed_char_type_node))
2004 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2006 if (mode == TYPE_MODE (short_integer_type_node))
2007 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2009 if (mode == TYPE_MODE (long_integer_type_node))
2010 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2012 if (mode == TYPE_MODE (long_long_integer_type_node))
2013 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2015 if (mode == TYPE_MODE (widest_integer_literal_type_node))
2016 return unsignedp ? widest_unsigned_literal_type_node
2017 : widest_integer_literal_type_node;
2020 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2023 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2026 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2029 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2031 #if HOST_BITS_PER_WIDE_INT >= 64
2032 if (mode == TYPE_MODE (intTI_type_node))
2033 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2036 if (mode == TYPE_MODE (float_type_node))
2037 return float_type_node;
2039 if (mode == TYPE_MODE (double_type_node))
2040 return double_type_node;
2042 if (mode == TYPE_MODE (long_double_type_node))
2043 return long_double_type_node;
2045 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2046 return build_pointer_type (char_type_node);
2048 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2049 return build_pointer_type (integer_type_node);
2054 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
2056 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
2058 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
2060 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
2062 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
2064 return unsignedp ? unsigned_V2HI_type_node : V2HI_type_node;
2066 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
2068 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
2070 return unsignedp ? unsigned_V1DI_type_node : V1DI_type_node;
2072 return V16SF_type_node;
2074 return V4SF_type_node;
2076 return V2SF_type_node;
2078 return V2DF_type_node;
2086 /* Return an unsigned type the same as TYPE in other respects. */
2088 c_common_unsigned_type (type)
2091 tree type1 = TYPE_MAIN_VARIANT (type);
2092 if (type1 == signed_char_type_node || type1 == char_type_node)
2093 return unsigned_char_type_node;
2094 if (type1 == integer_type_node)
2095 return unsigned_type_node;
2096 if (type1 == short_integer_type_node)
2097 return short_unsigned_type_node;
2098 if (type1 == long_integer_type_node)
2099 return long_unsigned_type_node;
2100 if (type1 == long_long_integer_type_node)
2101 return long_long_unsigned_type_node;
2102 if (type1 == widest_integer_literal_type_node)
2103 return widest_unsigned_literal_type_node;
2104 #if HOST_BITS_PER_WIDE_INT >= 64
2105 if (type1 == intTI_type_node)
2106 return unsigned_intTI_type_node;
2108 if (type1 == intDI_type_node)
2109 return unsigned_intDI_type_node;
2110 if (type1 == intSI_type_node)
2111 return unsigned_intSI_type_node;
2112 if (type1 == intHI_type_node)
2113 return unsigned_intHI_type_node;
2114 if (type1 == intQI_type_node)
2115 return unsigned_intQI_type_node;
2117 return c_common_signed_or_unsigned_type (1, type);
2120 /* Return a signed type the same as TYPE in other respects. */
2123 c_common_signed_type (type)
2126 tree type1 = TYPE_MAIN_VARIANT (type);
2127 if (type1 == unsigned_char_type_node || type1 == char_type_node)
2128 return signed_char_type_node;
2129 if (type1 == unsigned_type_node)
2130 return integer_type_node;
2131 if (type1 == short_unsigned_type_node)
2132 return short_integer_type_node;
2133 if (type1 == long_unsigned_type_node)
2134 return long_integer_type_node;
2135 if (type1 == long_long_unsigned_type_node)
2136 return long_long_integer_type_node;
2137 if (type1 == widest_unsigned_literal_type_node)
2138 return widest_integer_literal_type_node;
2139 #if HOST_BITS_PER_WIDE_INT >= 64
2140 if (type1 == unsigned_intTI_type_node)
2141 return intTI_type_node;
2143 if (type1 == unsigned_intDI_type_node)
2144 return intDI_type_node;
2145 if (type1 == unsigned_intSI_type_node)
2146 return intSI_type_node;
2147 if (type1 == unsigned_intHI_type_node)
2148 return intHI_type_node;
2149 if (type1 == unsigned_intQI_type_node)
2150 return intQI_type_node;
2152 return c_common_signed_or_unsigned_type (0, type);
2155 /* Return a type the same as TYPE except unsigned or
2156 signed according to UNSIGNEDP. */
2159 c_common_signed_or_unsigned_type (unsignedp, type)
2163 if (! INTEGRAL_TYPE_P (type)
2164 || TREE_UNSIGNED (type) == unsignedp)
2167 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2168 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2169 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2170 return unsignedp ? unsigned_type_node : integer_type_node;
2171 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2172 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2173 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2174 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2175 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2176 return (unsignedp ? long_long_unsigned_type_node
2177 : long_long_integer_type_node);
2178 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2179 return (unsignedp ? widest_unsigned_literal_type_node
2180 : widest_integer_literal_type_node);
2182 #if HOST_BITS_PER_WIDE_INT >= 64
2183 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
2184 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2186 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
2187 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2188 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
2189 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2190 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
2191 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2192 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
2193 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2198 /* Return the minimum number of bits needed to represent VALUE in a
2199 signed or unsigned type, UNSIGNEDP says which. */
2202 min_precision (value, unsignedp)
2208 /* If the value is negative, compute its negative minus 1. The latter
2209 adjustment is because the absolute value of the largest negative value
2210 is one larger than the largest positive value. This is equivalent to
2211 a bit-wise negation, so use that operation instead. */
2213 if (tree_int_cst_sgn (value) < 0)
2214 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2216 /* Return the number of bits needed, taking into account the fact
2217 that we need one more bit for a signed than unsigned type. */
2219 if (integer_zerop (value))
2222 log = tree_floor_log2 (value);
2224 return log + 1 + ! unsignedp;
2227 /* Print an error message for invalid operands to arith operation
2228 CODE. NOP_EXPR is used as a special case (see
2229 c_common_truthvalue_conversion). */
2232 binary_op_error (code)
2233 enum tree_code code;
2240 error ("invalid truth-value expression");
2244 opname = "+"; break;
2246 opname = "-"; break;
2248 opname = "*"; break;
2250 opname = "max"; break;
2252 opname = "min"; break;
2254 opname = "=="; break;
2256 opname = "!="; break;
2258 opname = "<="; break;
2260 opname = ">="; break;
2262 opname = "<"; break;
2264 opname = ">"; break;
2266 opname = "<<"; break;
2268 opname = ">>"; break;
2269 case TRUNC_MOD_EXPR:
2270 case FLOOR_MOD_EXPR:
2271 opname = "%"; break;
2272 case TRUNC_DIV_EXPR:
2273 case FLOOR_DIV_EXPR:
2274 opname = "/"; break;
2276 opname = "&"; break;
2278 opname = "|"; break;
2279 case TRUTH_ANDIF_EXPR:
2280 opname = "&&"; break;
2281 case TRUTH_ORIF_EXPR:
2282 opname = "||"; break;
2284 opname = "^"; break;
2287 opname = "rotate"; break;
2289 opname = "unknown"; break;
2291 error ("invalid operands to binary %s", opname);
2294 /* Subroutine of build_binary_op, used for comparison operations.
2295 See if the operands have both been converted from subword integer types
2296 and, if so, perhaps change them both back to their original type.
2297 This function is also responsible for converting the two operands
2298 to the proper common type for comparison.
2300 The arguments of this function are all pointers to local variables
2301 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2302 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2304 If this function returns nonzero, it means that the comparison has
2305 a constant value. What this function returns is an expression for
2309 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2310 tree *op0_ptr, *op1_ptr;
2312 enum tree_code *rescode_ptr;
2315 tree op0 = *op0_ptr;
2316 tree op1 = *op1_ptr;
2317 int unsignedp0, unsignedp1;
2319 tree primop0, primop1;
2320 enum tree_code code = *rescode_ptr;
2322 /* Throw away any conversions to wider types
2323 already present in the operands. */
2325 primop0 = get_narrower (op0, &unsignedp0);
2326 primop1 = get_narrower (op1, &unsignedp1);
2328 /* Handle the case that OP0 does not *contain* a conversion
2329 but it *requires* conversion to FINAL_TYPE. */
2331 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2332 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2333 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2334 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2336 /* If one of the operands must be floated, we cannot optimize. */
2337 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2338 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2340 /* If first arg is constant, swap the args (changing operation
2341 so value is preserved), for canonicalization. Don't do this if
2342 the second arg is 0. */
2344 if (TREE_CONSTANT (primop0)
2345 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2348 int temi = unsignedp0;
2356 unsignedp0 = unsignedp1;
2379 *rescode_ptr = code;
2382 /* If comparing an integer against a constant more bits wide,
2383 maybe we can deduce a value of 1 or 0 independent of the data.
2384 Or else truncate the constant now
2385 rather than extend the variable at run time.
2387 This is only interesting if the constant is the wider arg.
2388 Also, it is not safe if the constant is unsigned and the
2389 variable arg is signed, since in this case the variable
2390 would be sign-extended and then regarded as unsigned.
2391 Our technique fails in this case because the lowest/highest
2392 possible unsigned results don't follow naturally from the
2393 lowest/highest possible values of the variable operand.
2394 For just EQ_EXPR and NE_EXPR there is another technique that
2395 could be used: see if the constant can be faithfully represented
2396 in the other operand's type, by truncating it and reextending it
2397 and see if that preserves the constant's value. */
2399 if (!real1 && !real2
2400 && TREE_CODE (primop1) == INTEGER_CST
2401 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2403 int min_gt, max_gt, min_lt, max_lt;
2404 tree maxval, minval;
2405 /* 1 if comparison is nominally unsigned. */
2406 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2409 type = c_common_signed_or_unsigned_type (unsignedp0,
2410 TREE_TYPE (primop0));
2412 /* If TYPE is an enumeration, then we need to get its min/max
2413 values from it's underlying integral type, not the enumerated
2415 if (TREE_CODE (type) == ENUMERAL_TYPE)
2416 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2418 maxval = TYPE_MAX_VALUE (type);
2419 minval = TYPE_MIN_VALUE (type);
2421 if (unsignedp && !unsignedp0)
2422 *restype_ptr = c_common_signed_type (*restype_ptr);
2424 if (TREE_TYPE (primop1) != *restype_ptr)
2425 primop1 = convert (*restype_ptr, primop1);
2426 if (type != *restype_ptr)
2428 minval = convert (*restype_ptr, minval);
2429 maxval = convert (*restype_ptr, maxval);
2432 if (unsignedp && unsignedp0)
2434 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2435 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2436 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2437 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2441 min_gt = INT_CST_LT (primop1, minval);
2442 max_gt = INT_CST_LT (primop1, maxval);
2443 min_lt = INT_CST_LT (minval, primop1);
2444 max_lt = INT_CST_LT (maxval, primop1);
2448 /* This used to be a switch, but Genix compiler can't handle that. */
2449 if (code == NE_EXPR)
2451 if (max_lt || min_gt)
2452 val = boolean_true_node;
2454 else if (code == EQ_EXPR)
2456 if (max_lt || min_gt)
2457 val = boolean_false_node;
2459 else if (code == LT_EXPR)
2462 val = boolean_true_node;
2464 val = boolean_false_node;
2466 else if (code == GT_EXPR)
2469 val = boolean_true_node;
2471 val = boolean_false_node;
2473 else if (code == LE_EXPR)
2476 val = boolean_true_node;
2478 val = boolean_false_node;
2480 else if (code == GE_EXPR)
2483 val = boolean_true_node;
2485 val = boolean_false_node;
2488 /* If primop0 was sign-extended and unsigned comparison specd,
2489 we did a signed comparison above using the signed type bounds.
2490 But the comparison we output must be unsigned.
2492 Also, for inequalities, VAL is no good; but if the signed
2493 comparison had *any* fixed result, it follows that the
2494 unsigned comparison just tests the sign in reverse
2495 (positive values are LE, negative ones GE).
2496 So we can generate an unsigned comparison
2497 against an extreme value of the signed type. */
2499 if (unsignedp && !unsignedp0)
2506 primop1 = TYPE_MIN_VALUE (type);
2512 primop1 = TYPE_MAX_VALUE (type);
2519 type = c_common_unsigned_type (type);
2522 if (TREE_CODE (primop0) != INTEGER_CST)
2524 if (val == boolean_false_node)
2525 warning ("comparison is always false due to limited range of data type");
2526 if (val == boolean_true_node)
2527 warning ("comparison is always true due to limited range of data type");
2532 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2533 if (TREE_SIDE_EFFECTS (primop0))
2534 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2538 /* Value is not predetermined, but do the comparison
2539 in the type of the operand that is not constant.
2540 TYPE is already properly set. */
2542 else if (real1 && real2
2543 && (TYPE_PRECISION (TREE_TYPE (primop0))
2544 == TYPE_PRECISION (TREE_TYPE (primop1))))
2545 type = TREE_TYPE (primop0);
2547 /* If args' natural types are both narrower than nominal type
2548 and both extend in the same manner, compare them
2549 in the type of the wider arg.
2550 Otherwise must actually extend both to the nominal
2551 common type lest different ways of extending
2553 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2555 else if (unsignedp0 == unsignedp1 && real1 == real2
2556 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2557 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2559 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2560 type = c_common_signed_or_unsigned_type (unsignedp0
2561 || TREE_UNSIGNED (*restype_ptr),
2563 /* Make sure shorter operand is extended the right way
2564 to match the longer operand. */
2566 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2567 TREE_TYPE (primop0)),
2570 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2571 TREE_TYPE (primop1)),
2576 /* Here we must do the comparison on the nominal type
2577 using the args exactly as we received them. */
2578 type = *restype_ptr;
2582 if (!real1 && !real2 && integer_zerop (primop1)
2583 && TREE_UNSIGNED (*restype_ptr))
2589 /* All unsigned values are >= 0, so we warn if extra warnings
2590 are requested. However, if OP0 is a constant that is
2591 >= 0, the signedness of the comparison isn't an issue,
2592 so suppress the warning. */
2593 if (extra_warnings && !in_system_header
2594 && ! (TREE_CODE (primop0) == INTEGER_CST
2595 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2597 warning ("comparison of unsigned expression >= 0 is always true");
2598 value = boolean_true_node;
2602 if (extra_warnings && !in_system_header
2603 && ! (TREE_CODE (primop0) == INTEGER_CST
2604 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2606 warning ("comparison of unsigned expression < 0 is always false");
2607 value = boolean_false_node;
2616 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2617 if (TREE_SIDE_EFFECTS (primop0))
2618 return build (COMPOUND_EXPR, TREE_TYPE (value),
2625 *op0_ptr = convert (type, primop0);
2626 *op1_ptr = convert (type, primop1);
2628 *restype_ptr = boolean_type_node;
2633 /* Return a tree for the sum or difference (RESULTCODE says which)
2634 of pointer PTROP and integer INTOP. */
2637 pointer_int_sum (resultcode, ptrop, intop)
2638 enum tree_code resultcode;
2646 /* The result is a pointer of the same type that is being added. */
2648 tree result_type = TREE_TYPE (ptrop);
2650 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2652 if (pedantic || warn_pointer_arith)
2653 pedwarn ("pointer of type `void *' used in arithmetic");
2654 size_exp = integer_one_node;
2656 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2658 if (pedantic || warn_pointer_arith)
2659 pedwarn ("pointer to a function used in arithmetic");
2660 size_exp = integer_one_node;
2662 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2664 if (pedantic || warn_pointer_arith)
2665 pedwarn ("pointer to member function used in arithmetic");
2666 size_exp = integer_one_node;
2668 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2670 if (pedantic || warn_pointer_arith)
2671 pedwarn ("pointer to a member used in arithmetic");
2672 size_exp = integer_one_node;
2675 size_exp = size_in_bytes (TREE_TYPE (result_type));
2677 /* If what we are about to multiply by the size of the elements
2678 contains a constant term, apply distributive law
2679 and multiply that constant term separately.
2680 This helps produce common subexpressions. */
2682 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2683 && ! TREE_CONSTANT (intop)
2684 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2685 && TREE_CONSTANT (size_exp)
2686 /* If the constant comes from pointer subtraction,
2687 skip this optimization--it would cause an error. */
2688 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2689 /* If the constant is unsigned, and smaller than the pointer size,
2690 then we must skip this optimization. This is because it could cause
2691 an overflow error if the constant is negative but INTOP is not. */
2692 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2693 || (TYPE_PRECISION (TREE_TYPE (intop))
2694 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2696 enum tree_code subcode = resultcode;
2697 tree int_type = TREE_TYPE (intop);
2698 if (TREE_CODE (intop) == MINUS_EXPR)
2699 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2700 /* Convert both subexpression types to the type of intop,
2701 because weird cases involving pointer arithmetic
2702 can result in a sum or difference with different type args. */
2703 ptrop = build_binary_op (subcode, ptrop,
2704 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2705 intop = convert (int_type, TREE_OPERAND (intop, 0));
2708 /* Convert the integer argument to a type the same size as sizetype
2709 so the multiply won't overflow spuriously. */
2711 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2712 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2713 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2714 TREE_UNSIGNED (sizetype)), intop);
2716 /* Replace the integer argument with a suitable product by the object size.
2717 Do this multiplication as signed, then convert to the appropriate
2718 pointer type (actually unsigned integral). */
2720 intop = convert (result_type,
2721 build_binary_op (MULT_EXPR, intop,
2722 convert (TREE_TYPE (intop), size_exp), 1));
2724 /* Create the sum or difference. */
2726 result = build (resultcode, result_type, ptrop, intop);
2728 folded = fold (result);
2729 if (folded == result)
2730 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2734 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2735 or validate its data type for an `if' or `while' statement or ?..: exp.
2737 This preparation consists of taking the ordinary
2738 representation of an expression expr and producing a valid tree
2739 boolean expression describing whether expr is nonzero. We could
2740 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2741 but we optimize comparisons, &&, ||, and !.
2743 The resulting type should always be `boolean_type_node'. */
2746 c_common_truthvalue_conversion (expr)
2749 if (TREE_CODE (expr) == ERROR_MARK)
2752 #if 0 /* This appears to be wrong for C++. */
2753 /* These really should return error_mark_node after 2.4 is stable.
2754 But not all callers handle ERROR_MARK properly. */
2755 switch (TREE_CODE (TREE_TYPE (expr)))
2758 error ("struct type value used where scalar is required");
2759 return boolean_false_node;
2762 error ("union type value used where scalar is required");
2763 return boolean_false_node;
2766 error ("array type value used where scalar is required");
2767 return boolean_false_node;
2774 switch (TREE_CODE (expr))
2777 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2778 case TRUTH_ANDIF_EXPR:
2779 case TRUTH_ORIF_EXPR:
2780 case TRUTH_AND_EXPR:
2782 case TRUTH_XOR_EXPR:
2783 case TRUTH_NOT_EXPR:
2784 TREE_TYPE (expr) = boolean_type_node;
2791 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2794 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2797 /* If we are taking the address of an external decl, it might be zero
2798 if it is weak, so we cannot optimize. */
2799 if (DECL_P (TREE_OPERAND (expr, 0))
2800 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2803 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2804 return build (COMPOUND_EXPR, boolean_type_node,
2805 TREE_OPERAND (expr, 0), boolean_true_node);
2807 return boolean_true_node;
2810 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2811 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2812 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2813 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2820 /* These don't change whether an object is nonzero or zero. */
2821 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2825 /* These don't change whether an object is zero or nonzero, but
2826 we can't ignore them if their second arg has side-effects. */
2827 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2828 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2829 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2831 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2834 /* Distribute the conversion into the arms of a COND_EXPR. */
2835 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2836 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2837 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2840 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2841 since that affects how `default_conversion' will behave. */
2842 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2843 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2845 /* fall through... */
2847 /* If this is widening the argument, we can ignore it. */
2848 if (TYPE_PRECISION (TREE_TYPE (expr))
2849 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2850 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2854 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2855 aren't guaranteed to the be same for modes that can represent
2856 infinity, since if x and y are both +infinity, or both
2857 -infinity, then x - y is not a number.
2859 Note that this transformation is safe when x or y is NaN.
2860 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2862 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2864 /* fall through... */
2866 /* This and MINUS_EXPR can be changed into a comparison of the
2868 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2869 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2870 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2871 TREE_OPERAND (expr, 1), 1);
2872 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2873 fold (build1 (NOP_EXPR,
2874 TREE_TYPE (TREE_OPERAND (expr, 0)),
2875 TREE_OPERAND (expr, 1))), 1);
2878 if (integer_onep (TREE_OPERAND (expr, 1))
2879 && TREE_TYPE (expr) != boolean_type_node)
2880 /* Using convert here would cause infinite recursion. */
2881 return build1 (NOP_EXPR, boolean_type_node, expr);
2885 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2886 warning ("suggest parentheses around assignment used as truth value");
2893 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2895 tree t = save_expr (expr);
2896 return (build_binary_op
2897 ((TREE_SIDE_EFFECTS (expr)
2898 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2899 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2900 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2904 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2907 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2908 int, enum built_in_class, int, int,
2911 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2912 down to the element type of an array. */
2915 c_build_qualified_type (type, type_quals)
2919 /* A restrict-qualified pointer type must be a pointer to object or
2920 incomplete type. Note that the use of POINTER_TYPE_P also allows
2921 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2922 the C++ front-end also use POINTER_TYPE for pointer-to-member
2923 values, so even though it should be illegal to use `restrict'
2924 with such an entity we don't flag that here. Thus, special case
2925 code for that case is required in the C++ front-end. */
2926 if ((type_quals & TYPE_QUAL_RESTRICT)
2927 && (!POINTER_TYPE_P (type)
2928 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2930 error ("invalid use of `restrict'");
2931 type_quals &= ~TYPE_QUAL_RESTRICT;
2934 if (TREE_CODE (type) == ARRAY_TYPE)
2935 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2937 TYPE_DOMAIN (type));
2938 return build_qualified_type (type, type_quals);
2941 /* Apply the TYPE_QUALS to the new DECL. */
2944 c_apply_type_quals_to_decl (type_quals, decl)
2948 if ((type_quals & TYPE_QUAL_CONST)
2949 || (TREE_TYPE (decl)
2950 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2951 TREE_READONLY (decl) = 1;
2952 if (type_quals & TYPE_QUAL_VOLATILE)
2954 TREE_SIDE_EFFECTS (decl) = 1;
2955 TREE_THIS_VOLATILE (decl) = 1;
2957 if (type_quals & TYPE_QUAL_RESTRICT)
2959 if (!TREE_TYPE (decl)
2960 || !POINTER_TYPE_P (TREE_TYPE (decl))
2961 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2962 error ("invalid use of `restrict'");
2963 else if (flag_strict_aliasing)
2964 /* Indicate we need to make a unique alias set for this pointer.
2965 We can't do it here because it might be pointing to an
2967 DECL_POINTER_ALIAS_SET (decl) = -2;
2971 /* Return the typed-based alias set for T, which may be an expression
2972 or a type. Return -1 if we don't do anything special. */
2975 c_common_get_alias_set (t)
2980 /* Permit type-punning when accessing a union, provided the access
2981 is directly through the union. For example, this code does not
2982 permit taking the address of a union member and then storing
2983 through it. Even the type-punning allowed here is a GCC
2984 extension, albeit a common and useful one; the C standard says
2985 that such accesses have implementation-defined behavior. */
2987 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2988 u = TREE_OPERAND (u, 0))
2989 if (TREE_CODE (u) == COMPONENT_REF
2990 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2993 /* That's all the expressions we handle specially. */
2997 /* The C standard guarantees that any object may be accessed via an
2998 lvalue that has character type. */
2999 if (t == char_type_node
3000 || t == signed_char_type_node
3001 || t == unsigned_char_type_node)
3004 /* If it has the may_alias attribute, it can alias anything. */
3005 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
3008 /* The C standard specifically allows aliasing between signed and
3009 unsigned variants of the same type. We treat the signed
3010 variant as canonical. */
3011 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
3013 tree t1 = c_common_signed_type (t);
3015 /* t1 == t can happen for boolean nodes which are always unsigned. */
3017 return get_alias_set (t1);
3019 else if (POINTER_TYPE_P (t))
3023 /* Unfortunately, there is no canonical form of a pointer type.
3024 In particular, if we have `typedef int I', then `int *', and
3025 `I *' are different types. So, we have to pick a canonical
3026 representative. We do this below.
3028 Technically, this approach is actually more conservative that
3029 it needs to be. In particular, `const int *' and `int *'
3030 should be in different alias sets, according to the C and C++
3031 standard, since their types are not the same, and so,
3032 technically, an `int **' and `const int **' cannot point at
3035 But, the standard is wrong. In particular, this code is
3040 const int* const* cipp = &ipp;
3042 And, it doesn't make sense for that to be legal unless you
3043 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3044 the pointed-to types. This issue has been reported to the
3046 t1 = build_type_no_quals (t);
3048 return get_alias_set (t1);
3054 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3055 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3056 flag controls whether we should diagnose possibly ill-formed
3057 constructs or not. */
3059 c_sizeof_or_alignof_type (type, op, complain)
3064 const char *op_name;
3066 enum tree_code type_code = TREE_CODE (type);
3068 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
3069 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
3071 if (type_code == FUNCTION_TYPE)
3073 if (op == SIZEOF_EXPR)
3075 if (complain && (pedantic || warn_pointer_arith))
3076 pedwarn ("invalid application of `sizeof' to a function type");
3077 value = size_one_node;
3080 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3082 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3084 if (type_code == VOID_TYPE
3085 && complain && (pedantic || warn_pointer_arith))
3086 pedwarn ("invalid application of `%s' to a void type", op_name);
3087 value = size_one_node;
3089 else if (!COMPLETE_TYPE_P (type))
3092 error ("invalid application of `%s' to an incomplete type", op_name);
3093 value = size_zero_node;
3097 if (op == SIZEOF_EXPR)
3098 /* Convert in case a char is more than one unit. */
3099 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3100 size_int (TYPE_PRECISION (char_type_node)
3103 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
3106 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3107 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3108 never happen. However, this node should really have type
3109 `size_t', which is just a typedef for an ordinary integer type. */
3110 value = fold (build1 (NOP_EXPR, size_type_node, value));
3111 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
3116 /* Implement the __alignof keyword: Return the minimum required
3117 alignment of EXPR, measured in bytes. For VAR_DECL's and
3118 FIELD_DECL's return DECL_ALIGN (which can be set from an
3119 "aligned" __attribute__ specification). */
3122 c_alignof_expr (expr)
3127 if (TREE_CODE (expr) == VAR_DECL)
3128 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
3130 else if (TREE_CODE (expr) == COMPONENT_REF
3131 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3133 error ("`__alignof' applied to a bit-field");
3136 else if (TREE_CODE (expr) == COMPONENT_REF
3137 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3138 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
3140 else if (TREE_CODE (expr) == INDIRECT_REF)
3142 tree t = TREE_OPERAND (expr, 0);
3144 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3146 while (TREE_CODE (t) == NOP_EXPR
3147 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3151 t = TREE_OPERAND (t, 0);
3152 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3153 if (thisalign > bestalign)
3154 best = t, bestalign = thisalign;
3156 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3159 return c_alignof (TREE_TYPE (expr));
3161 return fold (build1 (NOP_EXPR, size_type_node, t));
3164 /* Handle C and C++ default attributes. */
3166 enum built_in_attribute
3168 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3169 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3170 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3171 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3172 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3173 #include "builtin-attrs.def"
3174 #undef DEF_ATTR_NULL_TREE
3176 #undef DEF_ATTR_IDENT
3177 #undef DEF_ATTR_TREE_LIST
3182 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3184 static bool c_attrs_initialized = false;
3186 static void c_init_attributes PARAMS ((void));
3188 /* Build tree nodes and builtin functions common to both C and C++ language
3192 c_common_nodes_and_builtins ()
3196 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3197 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3198 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3199 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3200 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3201 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3202 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3203 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3204 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3205 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3206 #include "builtin-types.def"
3207 #undef DEF_PRIMITIVE_TYPE
3208 #undef DEF_FUNCTION_TYPE_0
3209 #undef DEF_FUNCTION_TYPE_1
3210 #undef DEF_FUNCTION_TYPE_2
3211 #undef DEF_FUNCTION_TYPE_3
3212 #undef DEF_FUNCTION_TYPE_4
3213 #undef DEF_FUNCTION_TYPE_VAR_0
3214 #undef DEF_FUNCTION_TYPE_VAR_1
3215 #undef DEF_FUNCTION_TYPE_VAR_2
3216 #undef DEF_POINTER_TYPE
3220 typedef enum builtin_type builtin_type;
3222 tree builtin_types[(int) BT_LAST];
3223 int wchar_type_size;
3224 tree array_domain_type;
3225 tree va_list_ref_type_node;
3226 tree va_list_arg_type_node;
3228 /* Define `int' and `char' first so that dbx will output them first. */
3229 record_builtin_type (RID_INT, NULL, integer_type_node);
3230 record_builtin_type (RID_CHAR, "char", char_type_node);
3232 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3233 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3234 but not C. Are the conditionals here needed? */
3235 if (c_language == clk_cplusplus)
3236 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3237 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3238 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3239 record_builtin_type (RID_MAX, "long unsigned int",
3240 long_unsigned_type_node);
3241 if (c_language == clk_cplusplus)
3242 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3243 record_builtin_type (RID_MAX, "long long int",
3244 long_long_integer_type_node);
3245 record_builtin_type (RID_MAX, "long long unsigned int",
3246 long_long_unsigned_type_node);
3247 if (c_language == clk_cplusplus)
3248 record_builtin_type (RID_MAX, "long long unsigned",
3249 long_long_unsigned_type_node);
3250 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3251 record_builtin_type (RID_MAX, "short unsigned int",
3252 short_unsigned_type_node);
3253 if (c_language == clk_cplusplus)
3254 record_builtin_type (RID_MAX, "unsigned short",
3255 short_unsigned_type_node);
3257 /* Define both `signed char' and `unsigned char'. */
3258 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3259 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3261 /* These are types that c_common_type_for_size and
3262 c_common_type_for_mode use. */
3263 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3265 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3267 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3269 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3271 #if HOST_BITS_PER_WIDE_INT >= 64
3272 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3273 get_identifier ("__int128_t"),
3276 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3277 unsigned_intQI_type_node));
3278 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3279 unsigned_intHI_type_node));
3280 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3281 unsigned_intSI_type_node));
3282 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3283 unsigned_intDI_type_node));
3284 #if HOST_BITS_PER_WIDE_INT >= 64
3285 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3286 get_identifier ("__uint128_t"),
3287 unsigned_intTI_type_node));
3290 /* Create the widest literal types. */
3291 widest_integer_literal_type_node
3292 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3293 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3294 widest_integer_literal_type_node));
3296 widest_unsigned_literal_type_node
3297 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3298 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3299 widest_unsigned_literal_type_node));
3301 /* `unsigned long' is the standard type for sizeof.
3302 Note that stddef.h uses `unsigned long',
3303 and this must agree, even if long and int are the same size. */
3305 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3306 signed_size_type_node = c_common_signed_type (size_type_node);
3307 set_sizetype (size_type_node);
3309 build_common_tree_nodes_2 (flag_short_double);
3311 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3312 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3313 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3315 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3316 get_identifier ("complex int"),
3317 complex_integer_type_node));
3318 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3319 get_identifier ("complex float"),
3320 complex_float_type_node));
3321 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3322 get_identifier ("complex double"),
3323 complex_double_type_node));
3324 (*lang_hooks.decls.pushdecl)
3325 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3326 complex_long_double_type_node));
3328 /* Types which are common to the fortran compiler and libf2c. When
3329 changing these, you also need to be concerned with f/com.h. */
3331 if (TYPE_PRECISION (float_type_node)
3332 == TYPE_PRECISION (long_integer_type_node))
3334 g77_integer_type_node = long_integer_type_node;
3335 g77_uinteger_type_node = long_unsigned_type_node;
3337 else if (TYPE_PRECISION (float_type_node)
3338 == TYPE_PRECISION (integer_type_node))
3340 g77_integer_type_node = integer_type_node;
3341 g77_uinteger_type_node = unsigned_type_node;
3344 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3346 if (g77_integer_type_node != NULL_TREE)
3348 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3349 get_identifier ("__g77_integer"),
3350 g77_integer_type_node));
3351 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3352 get_identifier ("__g77_uinteger"),
3353 g77_uinteger_type_node));
3356 if (TYPE_PRECISION (float_type_node) * 2
3357 == TYPE_PRECISION (long_integer_type_node))
3359 g77_longint_type_node = long_integer_type_node;
3360 g77_ulongint_type_node = long_unsigned_type_node;
3362 else if (TYPE_PRECISION (float_type_node) * 2
3363 == TYPE_PRECISION (long_long_integer_type_node))
3365 g77_longint_type_node = long_long_integer_type_node;
3366 g77_ulongint_type_node = long_long_unsigned_type_node;
3369 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3371 if (g77_longint_type_node != NULL_TREE)
3373 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3374 get_identifier ("__g77_longint"),
3375 g77_longint_type_node));
3376 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3377 get_identifier ("__g77_ulongint"),
3378 g77_ulongint_type_node));
3381 record_builtin_type (RID_VOID, NULL, void_type_node);
3383 void_zero_node = build_int_2 (0, 0);
3384 TREE_TYPE (void_zero_node) = void_type_node;
3386 void_list_node = build_void_list_node ();
3388 /* Make a type to be the domain of a few array types
3389 whose domains don't really matter.
3390 200 is small enough that it always fits in size_t
3391 and large enough that it can hold most function names for the
3392 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3393 array_domain_type = build_index_type (size_int (200));
3395 /* Make a type for arrays of characters.
3396 With luck nothing will ever really depend on the length of this
3398 char_array_type_node
3399 = build_array_type (char_type_node, array_domain_type);
3401 /* Likewise for arrays of ints. */
3403 = build_array_type (integer_type_node, array_domain_type);
3405 string_type_node = build_pointer_type (char_type_node);
3406 const_string_type_node
3407 = build_pointer_type (build_qualified_type
3408 (char_type_node, TYPE_QUAL_CONST));
3410 (*targetm.init_builtins) ();
3412 /* This is special for C++ so functions can be overloaded. */
3413 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3414 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3415 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3416 if (c_language == clk_cplusplus)
3418 if (TREE_UNSIGNED (wchar_type_node))
3419 wchar_type_node = make_unsigned_type (wchar_type_size);
3421 wchar_type_node = make_signed_type (wchar_type_size);
3422 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3426 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3427 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3430 /* This is for wide string constants. */
3431 wchar_array_type_node
3432 = build_array_type (wchar_type_node, array_domain_type);
3435 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3438 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3440 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3442 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3444 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3445 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3447 (*lang_hooks.decls.pushdecl)
3448 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3449 va_list_type_node));
3451 (*lang_hooks.decls.pushdecl)
3452 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3453 ptrdiff_type_node));
3455 (*lang_hooks.decls.pushdecl)
3456 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3459 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3461 va_list_arg_type_node = va_list_ref_type_node =
3462 build_pointer_type (TREE_TYPE (va_list_type_node));
3466 va_list_arg_type_node = va_list_type_node;
3467 va_list_ref_type_node = build_reference_type (va_list_type_node);
3470 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3471 builtin_types[(int) ENUM] = VALUE;
3472 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3473 builtin_types[(int) ENUM] \
3474 = build_function_type (builtin_types[(int) RETURN], \
3476 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3477 builtin_types[(int) ENUM] \
3478 = build_function_type (builtin_types[(int) RETURN], \
3479 tree_cons (NULL_TREE, \
3480 builtin_types[(int) ARG1], \
3482 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3483 builtin_types[(int) ENUM] \
3484 = build_function_type \
3485 (builtin_types[(int) RETURN], \
3486 tree_cons (NULL_TREE, \
3487 builtin_types[(int) ARG1], \
3488 tree_cons (NULL_TREE, \
3489 builtin_types[(int) ARG2], \
3491 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3492 builtin_types[(int) ENUM] \
3493 = build_function_type \
3494 (builtin_types[(int) RETURN], \
3495 tree_cons (NULL_TREE, \
3496 builtin_types[(int) ARG1], \
3497 tree_cons (NULL_TREE, \
3498 builtin_types[(int) ARG2], \
3499 tree_cons (NULL_TREE, \
3500 builtin_types[(int) ARG3], \
3502 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3503 builtin_types[(int) ENUM] \
3504 = build_function_type \
3505 (builtin_types[(int) RETURN], \
3506 tree_cons (NULL_TREE, \
3507 builtin_types[(int) ARG1], \
3508 tree_cons (NULL_TREE, \
3509 builtin_types[(int) ARG2], \
3512 builtin_types[(int) ARG3], \
3513 tree_cons (NULL_TREE, \
3514 builtin_types[(int) ARG4], \
3515 void_list_node)))));
3516 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3517 builtin_types[(int) ENUM] \
3518 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3519 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3520 builtin_types[(int) ENUM] \
3521 = build_function_type (builtin_types[(int) RETURN], \
3522 tree_cons (NULL_TREE, \
3523 builtin_types[(int) ARG1], \
3526 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3527 builtin_types[(int) ENUM] \
3528 = build_function_type \
3529 (builtin_types[(int) RETURN], \
3530 tree_cons (NULL_TREE, \
3531 builtin_types[(int) ARG1], \
3532 tree_cons (NULL_TREE, \
3533 builtin_types[(int) ARG2], \
3535 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3536 builtin_types[(int) ENUM] \
3537 = build_pointer_type (builtin_types[(int) TYPE]);
3538 #include "builtin-types.def"
3539 #undef DEF_PRIMITIVE_TYPE
3540 #undef DEF_FUNCTION_TYPE_1
3541 #undef DEF_FUNCTION_TYPE_2
3542 #undef DEF_FUNCTION_TYPE_3
3543 #undef DEF_FUNCTION_TYPE_4
3544 #undef DEF_FUNCTION_TYPE_VAR_0
3545 #undef DEF_FUNCTION_TYPE_VAR_1
3546 #undef DEF_POINTER_TYPE
3548 if (!c_attrs_initialized)
3549 c_init_attributes ();
3551 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3552 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3557 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3561 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3564 ? (NAME + strlen ("__builtin_")) \
3566 built_in_attributes[(int) ATTRS]); \
3568 decl = builtin_function_2 (NAME, \
3569 NAME + strlen ("__builtin_"), \
3570 builtin_types[TYPE], \
3571 builtin_types[LIBTYPE], \
3576 built_in_attributes[(int) ATTRS]); \
3578 built_in_decls[(int) ENUM] = decl; \
3580 implicit_built_in_decls[(int) ENUM] = decl; \
3582 #include "builtins.def"
3585 main_identifier_node = get_identifier ("main");
3589 build_va_arg (expr, type)
3592 return build1 (VA_ARG_EXPR, type, expr);
3596 /* Linked list of disabled built-in functions. */
3598 typedef struct disabled_builtin
3601 struct disabled_builtin *next;
3603 static disabled_builtin *disabled_builtins = NULL;
3605 static bool builtin_function_disabled_p PARAMS ((const char *));
3607 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3608 begins with "__builtin_", give an error. */
3611 disable_builtin_function (name)
3614 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3615 error ("cannot disable built-in function `%s'", name);
3618 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3620 new->next = disabled_builtins;
3621 disabled_builtins = new;
3626 /* Return true if the built-in function NAME has been disabled, false
3630 builtin_function_disabled_p (name)
3633 disabled_builtin *p;
3634 for (p = disabled_builtins; p != NULL; p = p->next)
3636 if (strcmp (name, p->name) == 0)
3643 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3644 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3645 of these may be NULL (though both being NULL is useless).
3646 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3647 TYPE is the type of the function with the ordinary name. These
3648 may differ if the ordinary name is declared with a looser type to avoid
3649 conflicts with headers. FUNCTION_CODE and CLASS are as for
3650 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3651 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3652 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3653 ATTRS is the tree list representing the builtin's function attributes.
3654 Returns the declaration of BUILTIN_NAME, if any, otherwise
3655 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3656 or if NONANSI_P and flag_no_nonansi_builtin. */
3659 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3660 class, library_name_p, nonansi_p, attrs)
3661 const char *builtin_name;
3666 enum built_in_class class;
3671 tree bdecl = NULL_TREE;
3672 tree decl = NULL_TREE;
3673 if (builtin_name != 0)
3675 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3676 class, library_name_p ? name : NULL,
3679 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3680 && !(nonansi_p && flag_no_nonansi_builtin))
3682 decl = builtin_function (name, type, function_code, class, NULL,
3685 DECL_BUILT_IN_NONANSI (decl) = 1;
3687 return (bdecl != 0 ? bdecl : decl);
3690 /* Nonzero if the type T promotes to int. This is (nearly) the
3691 integral promotions defined in ISO C99 6.3.1.1/2. */
3694 c_promoting_integer_type_p (t)
3697 switch (TREE_CODE (t))
3700 return (TYPE_MAIN_VARIANT (t) == char_type_node
3701 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3702 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3703 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3704 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3705 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3708 /* ??? Technically all enumerations not larger than an int
3709 promote to an int. But this is used along code paths
3710 that only want to notice a size change. */
3711 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3721 /* Return 1 if PARMS specifies a fixed number of parameters
3722 and none of their types is affected by default promotions. */
3725 self_promoting_args_p (parms)
3729 for (t = parms; t; t = TREE_CHAIN (t))
3731 tree type = TREE_VALUE (t);
3733 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3739 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3742 if (c_promoting_integer_type_p (type))
3748 /* Recursively examines the array elements of TYPE, until a non-array
3749 element type is found. */
3752 strip_array_types (type)
3755 while (TREE_CODE (type) == ARRAY_TYPE)
3756 type = TREE_TYPE (type);
3761 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3764 /* Expand a call to an unordered comparison function such as
3765 __builtin_isgreater(). FUNCTION is the function's declaration and
3766 PARAMS a list of the values passed. For __builtin_isunordered(),
3767 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3768 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3769 that give the opposite of the desired result. UNORDERED_CODE is
3770 used for modes that can hold NaNs and ORDERED_CODE is used for the
3774 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3775 tree function, params;
3776 enum tree_code unordered_code, ordered_code;
3778 tree arg0, arg1, type;
3779 enum tree_code code0, code1;
3781 /* Check that we have exactly two arguments. */
3782 if (params == 0 || TREE_CHAIN (params) == 0)
3784 error ("too few arguments to function `%s'",
3785 IDENTIFIER_POINTER (DECL_NAME (function)));
3786 return error_mark_node;
3788 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3790 error ("too many arguments to function `%s'",
3791 IDENTIFIER_POINTER (DECL_NAME (function)));
3792 return error_mark_node;
3795 arg0 = TREE_VALUE (params);
3796 arg1 = TREE_VALUE (TREE_CHAIN (params));
3798 code0 = TREE_CODE (TREE_TYPE (arg0));
3799 code1 = TREE_CODE (TREE_TYPE (arg1));
3801 /* Make sure that the arguments have a common type of REAL. */
3803 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3804 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3805 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3807 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3809 error ("non-floating-point argument to function `%s'",
3810 IDENTIFIER_POINTER (DECL_NAME (function)));
3811 return error_mark_node;
3814 if (unordered_code == UNORDERED_EXPR)
3816 if (MODE_HAS_NANS (TYPE_MODE (type)))
3817 return build_binary_op (unordered_code,
3818 convert (type, arg0),
3819 convert (type, arg1),
3822 return integer_zero_node;
3825 return build_unary_op (TRUTH_NOT_EXPR,
3826 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3829 convert (type, arg0),
3830 convert (type, arg1),
3836 /* Recognize certain built-in functions so we can make tree-codes
3837 other than CALL_EXPR. We do this when it enables fold-const.c
3838 to do something useful. */
3839 /* ??? By rights this should go in builtins.c, but only C and C++
3840 implement build_{binary,unary}_op. Not exactly sure what bits
3841 of functionality are actually needed from those functions, or
3842 where the similar functionality exists in the other front ends. */
3845 expand_tree_builtin (function, params, coerced_params)
3846 tree function, params, coerced_params;
3848 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3851 switch (DECL_FUNCTION_CODE (function))
3855 case BUILT_IN_LLABS:
3856 case BUILT_IN_IMAXABS:
3858 case BUILT_IN_FABSL:
3859 case BUILT_IN_FABSF:
3860 if (coerced_params == 0)
3861 return integer_zero_node;
3862 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3865 case BUILT_IN_CONJF:
3866 case BUILT_IN_CONJL:
3867 if (coerced_params == 0)
3868 return integer_zero_node;
3869 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3871 case BUILT_IN_CREAL:
3872 case BUILT_IN_CREALF:
3873 case BUILT_IN_CREALL:
3874 if (coerced_params == 0)
3875 return integer_zero_node;
3876 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3878 case BUILT_IN_CIMAG:
3879 case BUILT_IN_CIMAGF:
3880 case BUILT_IN_CIMAGL:
3881 if (coerced_params == 0)
3882 return integer_zero_node;
3883 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3885 case BUILT_IN_ISGREATER:
3886 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3888 case BUILT_IN_ISGREATEREQUAL:
3889 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3891 case BUILT_IN_ISLESS:
3892 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3894 case BUILT_IN_ISLESSEQUAL:
3895 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3897 case BUILT_IN_ISLESSGREATER:
3898 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3900 case BUILT_IN_ISUNORDERED:
3901 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3910 /* Returns nonzero if CODE is the code for a statement. */
3913 statement_code_p (code)
3914 enum tree_code code;
3939 if (lang_statement_code_p)
3940 return (*lang_statement_code_p) (code);
3945 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3946 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3947 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3948 value, the traversal is aborted, and the value returned by FUNC is
3949 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3950 the node being visited are not walked.
3952 We don't need a without_duplicates variant of this one because the
3953 statement tree is a tree, not a graph. */
3956 walk_stmt_tree (tp, func, data)
3961 enum tree_code code;
3966 #define WALK_SUBTREE(NODE) \
3969 result = walk_stmt_tree (&(NODE), func, data); \
3975 /* Skip empty subtrees. */
3979 /* Skip subtrees below non-statement nodes. */
3980 if (!statement_code_p (TREE_CODE (*tp)))
3983 /* Call the function. */
3985 result = (*func) (tp, &walk_subtrees, data);
3987 /* If we found something, return it. */
3991 /* FUNC may have modified the tree, recheck that we're looking at a
3993 code = TREE_CODE (*tp);
3994 if (!statement_code_p (code))
3997 /* Visit the subtrees unless FUNC decided that there was nothing
3998 interesting below this point in the tree. */
4001 /* Walk over all the sub-trees of this operand. Statement nodes
4002 never contain RTL, and we needn't worry about TARGET_EXPRs. */
4003 len = TREE_CODE_LENGTH (code);
4005 /* Go through the subtrees. We need to do this in forward order so
4006 that the scope of a FOR_EXPR is handled properly. */
4007 for (i = 0; i < len; ++i)
4008 WALK_SUBTREE (TREE_OPERAND (*tp, i));
4011 /* Finally visit the chain. This can be tail-recursion optimized if
4012 we write it this way. */
4013 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
4018 /* Used to compare case labels. K1 and K2 are actually tree nodes
4019 representing case labels, or NULL_TREE for a `default' label.
4020 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4021 K2, and 0 if K1 and K2 are equal. */
4024 case_compare (k1, k2)
4028 /* Consider a NULL key (such as arises with a `default' label) to be
4029 smaller than anything else. */
4035 return tree_int_cst_compare ((tree) k1, (tree) k2);
4038 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4039 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4040 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4041 case label was declared using the usual C/C++ syntax, rather than
4042 the GNU case range extension. CASES is a tree containing all the
4043 case ranges processed so far; COND is the condition for the
4044 switch-statement itself. Returns the CASE_LABEL created, or
4045 ERROR_MARK_NODE if no CASE_LABEL is created. */
4048 c_add_case_label (cases, cond, low_value, high_value)
4057 splay_tree_node node;
4059 /* Create the LABEL_DECL itself. */
4060 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
4061 DECL_CONTEXT (label) = current_function_decl;
4063 /* If there was an error processing the switch condition, bail now
4064 before we get more confused. */
4065 if (!cond || cond == error_mark_node)
4067 /* Add a label anyhow so that the back-end doesn't think that
4068 the beginning of the switch is unreachable. */
4070 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4071 return error_mark_node;
4074 if ((low_value && TREE_TYPE (low_value)
4075 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4076 || (high_value && TREE_TYPE (high_value)
4077 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4078 error ("pointers are not permitted as case values");
4080 /* Case ranges are a GNU extension. */
4081 if (high_value && pedantic)
4083 if (c_language == clk_cplusplus)
4084 pedwarn ("ISO C++ forbids range expressions in switch statements");
4086 pedwarn ("ISO C forbids range expressions in switch statements");
4089 type = TREE_TYPE (cond);
4092 low_value = check_case_value (low_value);
4093 low_value = convert_and_check (type, low_value);
4097 high_value = check_case_value (high_value);
4098 high_value = convert_and_check (type, high_value);
4101 /* If an error has occurred, bail out now. */
4102 if (low_value == error_mark_node || high_value == error_mark_node)
4105 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4106 return error_mark_node;
4109 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4110 really a case range, even though it was written that way. Remove
4111 the HIGH_VALUE to simplify later processing. */
4112 if (tree_int_cst_equal (low_value, high_value))
4113 high_value = NULL_TREE;
4114 if (low_value && high_value
4115 && !tree_int_cst_lt (low_value, high_value))
4116 warning ("empty range specified");
4118 /* Look up the LOW_VALUE in the table of case labels we already
4120 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4121 /* If there was not an exact match, check for overlapping ranges.
4122 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4123 that's a `default' label and the only overlap is an exact match. */
4124 if (!node && (low_value || high_value))
4126 splay_tree_node low_bound;
4127 splay_tree_node high_bound;
4129 /* Even though there wasn't an exact match, there might be an
4130 overlap between this case range and another case range.
4131 Since we've (inductively) not allowed any overlapping case
4132 ranges, we simply need to find the greatest low case label
4133 that is smaller that LOW_VALUE, and the smallest low case
4134 label that is greater than LOW_VALUE. If there is an overlap
4135 it will occur in one of these two ranges. */
4136 low_bound = splay_tree_predecessor (cases,
4137 (splay_tree_key) low_value);
4138 high_bound = splay_tree_successor (cases,
4139 (splay_tree_key) low_value);
4141 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4142 the LOW_VALUE, so there is no need to check unless the
4143 LOW_BOUND is in fact itself a case range. */
4145 && CASE_HIGH ((tree) low_bound->value)
4146 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4149 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4150 range is bigger than the low end of the current range, so we
4151 are only interested if the current range is a real range, and
4152 not an ordinary case label. */
4155 && (tree_int_cst_compare ((tree) high_bound->key,
4160 /* If there was an overlap, issue an error. */
4163 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
4167 error ("duplicate (or overlapping) case value");
4168 error_with_decl (duplicate,
4169 "this is the first entry overlapping that value");
4173 error ("duplicate case value") ;
4174 error_with_decl (duplicate, "previously used here");
4178 error ("multiple default labels in one switch");
4179 error_with_decl (duplicate, "this is the first default label");
4182 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4185 /* Add a CASE_LABEL to the statement-tree. */
4186 case_label = add_stmt (build_case_label (low_value, high_value, label));
4187 /* Register this case label in the splay tree. */
4188 splay_tree_insert (cases,
4189 (splay_tree_key) low_value,
4190 (splay_tree_value) case_label);
4195 /* Finish an expression taking the address of LABEL. Returns an
4196 expression for the address. */
4199 finish_label_address_expr (label)
4206 if (c_language == clk_cplusplus)
4207 pedwarn ("ISO C++ forbids taking the address of a label");
4209 pedwarn ("ISO C forbids taking the address of a label");
4212 label = lookup_label (label);
4213 if (label == NULL_TREE)
4214 result = null_pointer_node;
4217 TREE_USED (label) = 1;
4218 result = build1 (ADDR_EXPR, ptr_type_node, label);
4219 TREE_CONSTANT (result) = 1;
4220 /* The current function in not necessarily uninlinable.
4221 Computed gotos are incompatible with inlining, but the value
4222 here could be used only in a diagnostic, for example. */
4228 /* Hook used by expand_expr to expand language-specific tree codes. */
4231 c_expand_expr (exp, target, tmode, modifier)
4234 enum machine_mode tmode;
4235 int modifier; /* Actually enum_modifier. */
4237 switch (TREE_CODE (exp))
4243 bool preserve_result = false;
4244 bool return_target = false;
4246 /* Since expand_expr_stmt calls free_temp_slots after every
4247 expression statement, we must call push_temp_slots here.
4248 Otherwise, any temporaries in use now would be considered
4249 out-of-scope after the first EXPR_STMT from within the
4252 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4254 /* If we want the result of this expression, find the last
4255 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4256 if (target != const0_rtx
4257 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4258 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4260 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4261 tree last = TREE_CHAIN (expr);
4263 while (TREE_CHAIN (last))
4266 last = TREE_CHAIN (last);
4269 if (TREE_CODE (last) == SCOPE_STMT
4270 && TREE_CODE (expr) == EXPR_STMT)
4272 if (target && TREE_CODE (EXPR_STMT_EXPR (expr)) == VAR_DECL
4273 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr)) == target)
4274 /* If the last expression is a variable whose RTL is the
4275 same as our target, just return the target; if it
4276 isn't valid expanding the decl would produce different
4277 RTL, and store_expr would try to do a copy. */
4278 return_target = true;
4281 /* Otherwise, note that we want the value from the last
4283 TREE_ADDRESSABLE (expr) = 1;
4284 preserve_result = true;
4289 expand_stmt (STMT_EXPR_STMT (exp));
4290 expand_end_stmt_expr (rtl_expr);
4292 result = expand_expr (rtl_expr, target, tmode, modifier);
4295 else if (preserve_result && GET_CODE (result) == MEM)
4297 if (GET_MODE (result) != BLKmode)
4298 result = copy_to_reg (result);
4300 preserve_temp_slots (result);
4303 /* If the statment-expression does not have a scope, then the
4304 new temporaries we created within it must live beyond the
4305 statement-expression. */
4306 if (STMT_EXPR_NO_SCOPE (exp))
4307 preserve_temp_slots (NULL_RTX);
4316 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
4317 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4319 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4320 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4321 == BUILT_IN_FRONTEND))
4322 return c_expand_builtin (exp, target, tmode, modifier);
4328 case COMPOUND_LITERAL_EXPR:
4330 /* Initialize the anonymous variable declared in the compound
4331 literal, then return the variable. */
4332 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4333 emit_local_var (decl);
4334 return expand_expr (decl, target, tmode, modifier);
4345 /* Hook used by safe_from_p to handle language-specific tree codes. */
4348 c_safe_from_p (target, exp)
4352 /* We can see statements here when processing the body of a
4353 statement-expression. For a declaration statement declaring a
4354 variable, look at the variable's initializer. */
4355 if (TREE_CODE (exp) == DECL_STMT)
4357 tree decl = DECL_STMT_DECL (exp);
4359 if (TREE_CODE (decl) == VAR_DECL
4360 && DECL_INITIAL (decl)
4361 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4365 /* For any statement, we must follow the statement-chain. */
4366 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
4367 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4369 /* Assume everything else is safe. */
4373 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4376 c_common_unsafe_for_reeval (exp)
4379 /* Statement expressions may not be reevaluated, likewise compound
4381 if (TREE_CODE (exp) == STMT_EXPR
4382 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4385 /* Walk all other expressions. */
4389 /* Hook used by staticp to handle language-specific tree codes. */
4395 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4396 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4401 #define CALLED_AS_BUILT_IN(NODE) \
4402 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4405 c_expand_builtin (exp, target, tmode, modifier)
4408 enum machine_mode tmode;
4409 enum expand_modifier modifier;
4411 tree type = TREE_TYPE (exp);
4412 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4413 tree arglist = TREE_OPERAND (exp, 1);
4414 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4415 enum tree_code code = TREE_CODE (exp);
4416 const int ignore = (target == const0_rtx
4417 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4418 || code == CONVERT_EXPR || code == REFERENCE_EXPR
4419 || code == COND_EXPR)
4420 && TREE_CODE (type) == VOID_TYPE));
4422 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4423 return expand_call (exp, target, ignore);
4427 case BUILT_IN_PRINTF:
4428 target = c_expand_builtin_printf (arglist, target, tmode,
4429 modifier, ignore, /*unlocked=*/ 0);
4434 case BUILT_IN_PRINTF_UNLOCKED:
4435 target = c_expand_builtin_printf (arglist, target, tmode,
4436 modifier, ignore, /*unlocked=*/ 1);
4441 case BUILT_IN_FPRINTF:
4442 target = c_expand_builtin_fprintf (arglist, target, tmode,
4443 modifier, ignore, /*unlocked=*/ 0);
4448 case BUILT_IN_FPRINTF_UNLOCKED:
4449 target = c_expand_builtin_fprintf (arglist, target, tmode,
4450 modifier, ignore, /*unlocked=*/ 1);
4455 default: /* just do library call, if unknown builtin */
4456 error ("built-in function `%s' not currently supported",
4457 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4460 /* The switch statement above can drop through to cause the function
4461 to be called normally. */
4462 return expand_call (exp, target, ignore);
4465 /* Check an arglist to *printf for problems. The arglist should start
4466 at the format specifier, with the remaining arguments immediately
4469 is_valid_printf_arglist (arglist)
4472 /* Save this value so we can restore it later. */
4473 const int SAVE_pedantic = pedantic;
4474 int diagnostic_occurred = 0;
4477 /* Set this to a known value so the user setting won't affect code
4480 /* Check to make sure there are no format specifier errors. */
4481 attrs = tree_cons (get_identifier ("format"),
4482 tree_cons (NULL_TREE,
4483 get_identifier ("printf"),
4484 tree_cons (NULL_TREE,
4486 tree_cons (NULL_TREE,
4490 check_function_format (&diagnostic_occurred, attrs, arglist);
4492 /* Restore the value of `pedantic'. */
4493 pedantic = SAVE_pedantic;
4495 /* If calling `check_function_format_ptr' produces a warning, we
4496 return false, otherwise we return true. */
4497 return ! diagnostic_occurred;
4500 /* If the arguments passed to printf are suitable for optimizations,
4501 we attempt to transform the call. */
4503 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
4506 enum machine_mode tmode;
4507 enum expand_modifier modifier;
4511 tree fn_putchar = unlocked ?
4512 implicit_built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : implicit_built_in_decls[BUILT_IN_PUTCHAR];
4513 tree fn_puts = unlocked ?
4514 implicit_built_in_decls[BUILT_IN_PUTS_UNLOCKED] : implicit_built_in_decls[BUILT_IN_PUTS];
4515 tree fn, format_arg, stripped_string;
4517 /* If the return value is used, or the replacement _DECL isn't
4518 initialized, don't do the transformation. */
4519 if (!ignore || !fn_putchar || !fn_puts)
4522 /* Verify the required arguments in the original call. */
4524 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4527 /* Check the specifier vs. the parameters. */
4528 if (!is_valid_printf_arglist (arglist))
4531 format_arg = TREE_VALUE (arglist);
4532 stripped_string = format_arg;
4533 STRIP_NOPS (stripped_string);
4534 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4535 stripped_string = TREE_OPERAND (stripped_string, 0);
4537 /* If the format specifier isn't a STRING_CST, punt. */
4538 if (TREE_CODE (stripped_string) != STRING_CST)
4541 /* OK! We can attempt optimization. */
4543 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4544 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4546 arglist = TREE_CHAIN (arglist);
4549 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4550 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4552 arglist = TREE_CHAIN (arglist);
4557 /* We can't handle anything else with % args or %% ... yet. */
4558 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4561 /* If the resulting constant string has a length of 1, call
4562 putchar. Note, TREE_STRING_LENGTH includes the terminating
4563 NULL in its count. */
4564 if (TREE_STRING_LENGTH (stripped_string) == 2)
4566 /* Given printf("c"), (where c is any one character,)
4567 convert "c"[0] to an int and pass that to the replacement
4569 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4570 arglist = build_tree_list (NULL_TREE, arglist);
4574 /* If the resulting constant was "string\n", call
4575 __builtin_puts("string"). Ensure "string" has at least one
4576 character besides the trailing \n. Note, TREE_STRING_LENGTH
4577 includes the terminating NULL in its count. */
4578 else if (TREE_STRING_LENGTH (stripped_string) > 2
4579 && TREE_STRING_POINTER (stripped_string)
4580 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4582 /* Create a NULL-terminated string that's one char shorter
4583 than the original, stripping off the trailing '\n'. */
4584 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4585 char *newstr = (char *) alloca (newlen);
4586 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4587 newstr[newlen - 1] = 0;
4589 arglist = fix_string_type (build_string (newlen, newstr));
4590 arglist = build_tree_list (NULL_TREE, arglist);
4594 /* We'd like to arrange to call fputs(string) here, but we
4595 need stdout and don't have a way to get it ... yet. */
4599 return expand_expr (build_function_call (fn, arglist),
4600 (ignore ? const0_rtx : target),
4604 /* If the arguments passed to fprintf are suitable for optimizations,
4605 we attempt to transform the call. */
4607 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4610 enum machine_mode tmode;
4611 enum expand_modifier modifier;
4615 tree fn_fputc = unlocked ?
4616 implicit_built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : implicit_built_in_decls[BUILT_IN_FPUTC];
4617 tree fn_fputs = unlocked ?
4618 implicit_built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : implicit_built_in_decls[BUILT_IN_FPUTS];
4619 tree fn, format_arg, stripped_string;
4621 /* If the return value is used, or the replacement _DECL isn't
4622 initialized, don't do the transformation. */
4623 if (!ignore || !fn_fputc || !fn_fputs)
4626 /* Verify the required arguments in the original call. */
4628 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4629 || (TREE_CHAIN (arglist) == 0)
4630 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4634 /* Check the specifier vs. the parameters. */
4635 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4638 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4639 stripped_string = format_arg;
4640 STRIP_NOPS (stripped_string);
4641 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4642 stripped_string = TREE_OPERAND (stripped_string, 0);
4644 /* If the format specifier isn't a STRING_CST, punt. */
4645 if (TREE_CODE (stripped_string) != STRING_CST)
4648 /* OK! We can attempt optimization. */
4650 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4651 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4653 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4654 arglist = tree_cons (NULL_TREE,
4655 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4659 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4660 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4662 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4663 arglist = tree_cons (NULL_TREE,
4664 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4670 /* We can't handle anything else with % args or %% ... yet. */
4671 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4674 /* When "string" doesn't contain %, replace all cases of
4675 fprintf(stream,string) with fputs(string,stream). The fputs
4676 builtin will take take of special cases like length==1. */
4677 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4678 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4682 return expand_expr (build_function_call (fn, arglist),
4683 (ignore ? const0_rtx : target),
4688 /* Given a boolean expression ARG, return a tree representing an increment
4689 or decrement (as indicated by CODE) of ARG. The front end must check for
4690 invalid cases (e.g., decrement in C++). */
4692 boolean_increment (code, arg)
4693 enum tree_code code;
4697 tree true_res = (c_language == clk_cplusplus
4699 : c_bool_true_node);
4700 arg = stabilize_reference (arg);
4703 case PREINCREMENT_EXPR:
4704 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4706 case POSTINCREMENT_EXPR:
4707 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4708 arg = save_expr (arg);
4709 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4710 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4712 case PREDECREMENT_EXPR:
4713 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4715 case POSTDECREMENT_EXPR:
4716 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4717 arg = save_expr (arg);
4718 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4719 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4724 TREE_SIDE_EFFECTS (val) = 1;
4728 /* Define NAME with value TYPE precision. */
4730 builtin_define_type_precision (name, type)
4734 builtin_define_with_int_value (name, TYPE_PRECISION (type));
4737 /* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
4739 builtin_define_float_constants (name_prefix, fp_suffix, type)
4740 const char *name_prefix;
4741 const char *fp_suffix;
4744 /* Used to convert radix-based values to base 10 values in several cases.
4746 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
4747 least 6 significant digits for correct results. Using the fraction
4748 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
4749 intermediate; perhaps someone can find a better approximation, in the
4750 mean time, I suspect using doubles won't harm the bootstrap here. */
4752 const double log10_2 = .30102999566398119521;
4754 const struct real_format *fmt;
4756 char name[64], buf[128];
4757 int dig, min_10_exp, max_10_exp;
4760 fmt = real_format_for_mode[TYPE_MODE (type) - QFmode];
4762 /* The radix of the exponent representation. */
4763 if (type == float_type_node)
4764 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
4765 log10_b = log10_2 * fmt->log2_b;
4767 /* The number of radix digits, p, in the floating-point significand. */
4768 sprintf (name, "__%s_MANT_DIG__", name_prefix);
4769 builtin_define_with_int_value (name, fmt->p);
4771 /* The number of decimal digits, q, such that any floating-point number
4772 with q decimal digits can be rounded into a floating-point number with
4773 p radix b digits and back again without change to the q decimal digits,
4775 p log10 b if b is a power of 10
4776 floor((p - 1) log10 b) otherwise
4778 dig = (fmt->p - 1) * log10_b;
4779 sprintf (name, "__%s_DIG__", name_prefix);
4780 builtin_define_with_int_value (name, dig);
4782 /* The minimum negative int x such that b**(x-1) is a normalized float. */
4783 sprintf (name, "__%s_MIN_EXP__", name_prefix);
4784 sprintf (buf, "(%d)", fmt->emin);
4785 builtin_define_with_value (name, buf, 0);
4787 /* The minimum negative int x such that 10**x is a normalized float,
4789 ceil (log10 (b ** (emin - 1)))
4790 = ceil (log10 (b) * (emin - 1))
4792 Recall that emin is negative, so the integer truncation calculates
4793 the ceiling, not the floor, in this case. */
4794 min_10_exp = (fmt->emin - 1) * log10_b;
4795 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
4796 sprintf (buf, "(%d)", min_10_exp);
4797 builtin_define_with_value (name, buf, 0);
4799 /* The maximum int x such that b**(x-1) is a representable float. */
4800 sprintf (name, "__%s_MAX_EXP__", name_prefix);
4801 builtin_define_with_int_value (name, fmt->emax);
4803 /* The maximum int x such that 10**x is in the range of representable
4804 finite floating-point numbers,
4806 floor (log10((1 - b**-p) * b**emax))
4807 = floor (log10(1 - b**-p) + log10(b**emax))
4808 = floor (log10(1 - b**-p) + log10(b)*emax)
4810 The safest thing to do here is to just compute this number. But since
4811 we don't link cc1 with libm, we cannot. We could implement log10 here
4812 a series expansion, but that seems too much effort because:
4814 Note that the first term, for all extant p, is a number exceedingly close
4815 to zero, but slightly negative. Note that the second term is an integer
4816 scaling an irrational number, and that because of the floor we are only
4817 interested in its integral portion.
4819 In order for the first term to have any effect on the integral portion
4820 of the second term, the second term has to be exceedingly close to an
4821 integer itself (e.g. 123.000000000001 or something). Getting a result
4822 that close to an integer requires that the irrational multiplicand have
4823 a long series of zeros in its expansion, which doesn't occur in the
4824 first 20 digits or so of log10(b).
4826 Hand-waving aside, crunching all of the sets of constants above by hand
4827 does not yield a case for which the first term is significant, which
4828 in the end is all that matters. */
4829 max_10_exp = fmt->emax * log10_b;
4830 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
4831 builtin_define_with_int_value (name, max_10_exp);
4833 /* The number of decimal digits, n, such that any floating-point number
4834 can be rounded to n decimal digits and back again without change to
4837 p * log10(b) if b is a power of 10
4838 ceil(1 + p * log10(b)) otherwise
4840 The only macro we care about is this number for the widest supported
4841 floating type, but we want this value for rendering constants below. */
4843 double d_decimal_dig = 1 + fmt->p * log10_b;
4844 decimal_dig = d_decimal_dig;
4845 if (decimal_dig < d_decimal_dig)
4848 if (type == long_double_type_node)
4849 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
4851 /* Since, for the supported formats, B is always a power of 2, we
4852 construct the following numbers directly as a hexadecimal
4855 /* The maximum representable finite floating-point number,
4856 (1 - b**-p) * b**emax */
4861 strcpy (buf, "0x0.");
4862 n = fmt->p * fmt->log2_b;
4863 for (i = 0, p = buf + 4; i + 3 < n; i += 4)
4866 *p++ = "08ce"[n - i];
4867 sprintf (p, "p%d", fmt->emax * fmt->log2_b);
4869 sprintf (name, "__%s_MAX__", name_prefix);
4870 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
4872 /* The minimum normalized positive floating-point number,
4874 sprintf (name, "__%s_MIN__", name_prefix);
4875 sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
4876 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
4878 /* The difference between 1 and the least value greater than 1 that is
4879 representable in the given floating point type, b**(1-p). */
4880 sprintf (name, "__%s_EPSILON__", name_prefix);
4881 sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
4882 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
4884 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
4885 positive floating-point number, b**(emin-p). Zero for formats that
4886 don't support denormals. */
4887 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
4888 if (fmt->has_denorm)
4890 sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
4891 builtin_define_with_hex_fp_value (name, type, decimal_dig,
4896 sprintf (buf, "0.0%s", fp_suffix);
4897 builtin_define_with_value (name, buf, 0);
4900 /* For C++ std::numeric_limits<T>::has_infinity. */
4901 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
4902 builtin_define_with_int_value (name,
4903 MODE_HAS_INFINITIES (TYPE_MODE (type)));
4904 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
4905 predicate to distinguish a target that has both quiet and
4906 signalling NaNs from a target that has only quiet NaNs or only
4907 signalling NaNs, so we assume that a target that has any kind of
4908 NaN has quiet NaNs. */
4909 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
4910 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
4913 /* Hook that registers front end and target-specific built-ins. */
4915 cb_register_builtins (pfile)
4918 /* -undef turns off target-specific built-ins. */
4922 if (c_language == clk_cplusplus)
4924 if (SUPPORTS_ONE_ONLY)
4925 cpp_define (pfile, "__GXX_WEAK__=1");
4927 cpp_define (pfile, "__GXX_WEAK__=0");
4928 if (flag_exceptions)
4929 cpp_define (pfile, "__EXCEPTIONS");
4930 if (warn_deprecated)
4931 cpp_define (pfile, "__DEPRECATED");
4934 /* represents the C++ ABI version, always defined so it can be used while
4935 preprocessing C and assembler. */
4936 cpp_define (pfile, "__GXX_ABI_VERSION=102");
4938 /* libgcc needs to know this. */
4939 if (USING_SJLJ_EXCEPTIONS)
4940 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
4942 /* stddef.h needs to know these. */
4943 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4944 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4945 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4946 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4948 /* limits.h needs to know these. */
4949 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
4950 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
4951 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
4952 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
4953 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
4954 builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
4956 builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
4958 /* float.h needs to know these. */
4960 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
4961 TARGET_FLT_EVAL_METHOD);
4963 builtin_define_float_constants ("FLT", "F", float_type_node);
4964 builtin_define_float_constants ("DBL", "", double_type_node);
4965 builtin_define_float_constants ("LDBL", "L", long_double_type_node);
4967 /* For use in assembly language. */
4968 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
4969 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
4972 builtin_define_with_value ("__VERSION__", version_string, 1);
4974 /* Other target-independent built-ins determined by command-line
4977 cpp_define (pfile, "__OPTIMIZE_SIZE__");
4979 cpp_define (pfile, "__OPTIMIZE__");
4982 cpp_define (pfile, "__STDC_HOSTED__=1");
4984 cpp_define (pfile, "__STDC_HOSTED__=0");
4986 if (fast_math_flags_set_p ())
4987 cpp_define (pfile, "__FAST_MATH__");
4988 if (flag_really_no_inline)
4989 cpp_define (pfile, "__NO_INLINE__");
4990 if (flag_signaling_nans)
4991 cpp_define (pfile, "__SUPPORT_SNAN__");
4992 if (flag_finite_math_only)
4993 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
4995 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
4998 cpp_define (pfile, "__STRICT_ANSI__");
5000 if (!flag_signed_char)
5001 cpp_define (pfile, "__CHAR_UNSIGNED__");
5003 if (c_language == clk_cplusplus && TREE_UNSIGNED (wchar_type_node))
5004 cpp_define (pfile, "__WCHAR_UNSIGNED__");
5006 /* Make the choice of ObjC runtime visible to source code. */
5007 if (flag_objc && flag_next_runtime)
5008 cpp_define (pfile, "__NEXT_RUNTIME__");
5010 /* A straightforward target hook doesn't work, because of problems
5011 linking that hook's body when part of non-C front ends. */
5012 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
5013 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
5014 # define builtin_define(TXT) cpp_define (pfile, TXT)
5015 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
5016 TARGET_CPU_CPP_BUILTINS ();
5017 TARGET_OS_CPP_BUILTINS ();
5020 /* Pass an object-like macro. If it doesn't lie in the user's
5021 namespace, defines it unconditionally. Otherwise define a version
5022 with two leading underscores, and another version with two leading
5023 and trailing underscores, and define the original only if an ISO
5024 standard was not nominated.
5026 e.g. passing "unix" defines "__unix", "__unix__" and possibly
5027 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
5030 builtin_define_std (macro)
5033 size_t len = strlen (macro);
5034 char *buff = alloca (len + 5);
5038 /* prepend __ (or maybe just _) if in user's namespace. */
5039 memcpy (p, macro, len + 1);
5040 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
5047 cpp_define (parse_in, p);
5049 /* If it was in user's namespace... */
5052 /* Define the macro with leading and following __. */
5058 cpp_define (parse_in, p);
5060 /* Finally, define the original macro if permitted. */
5062 cpp_define (parse_in, macro);
5066 /* Pass an object-like macro and a value to define it to. The third
5067 parameter says whether or not to turn the value into a string
5070 builtin_define_with_value (macro, expansion, is_str)
5072 const char *expansion;
5076 size_t mlen = strlen (macro);
5077 size_t elen = strlen (expansion);
5078 size_t extra = 2; /* space for an = and a NUL */
5081 extra += 2; /* space for two quote marks */
5083 buf = alloca (mlen + elen + extra);
5085 sprintf (buf, "%s=\"%s\"", macro, expansion);
5087 sprintf (buf, "%s=%s", macro, expansion);
5089 cpp_define (parse_in, buf);
5092 /* Pass an object-like macro and an integer value to define it to. */
5094 builtin_define_with_int_value (macro, value)
5096 HOST_WIDE_INT value;
5099 size_t mlen = strlen (macro);
5101 size_t extra = 2; /* space for = and NUL. */
5103 buf = alloca (mlen + vlen + extra);
5104 memcpy (buf, macro, mlen);
5106 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
5108 cpp_define (parse_in, buf);
5111 /* Pass an object-like macro a hexadecimal floating-point value. */
5113 builtin_define_with_hex_fp_value (macro, type, digits, hex_str, fp_suffix)
5115 tree type ATTRIBUTE_UNUSED;
5117 const char *hex_str;
5118 const char *fp_suffix;
5120 REAL_VALUE_TYPE real;
5121 char dec_str[64], buf[256];
5123 /* Hex values are really cool and convenient, except that they're
5124 not supported in strict ISO C90 mode. First, the "p-" sequence
5125 is not valid as part of a preprocessor number. Second, we get a
5126 pedwarn from the preprocessor, which has no context, so we can't
5127 suppress the warning with __extension__.
5129 So instead what we do is construct the number in hex (because
5130 it's easy to get the exact correct value), parse it as a real,
5131 then print it back out as decimal. */
5133 real_from_string (&real, hex_str);
5134 real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
5136 sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
5137 cpp_define (parse_in, buf);
5140 /* Define MAX for TYPE based on the precision of the type. IS_LONG is
5141 1 for type "long" and 2 for "long long". We have to handle
5142 unsigned types, since wchar_t might be unsigned. */
5145 builtin_define_type_max (macro, type, is_long)
5150 static const char *const values[]
5153 "2147483647", "4294967295",
5154 "9223372036854775807", "18446744073709551615",
5155 "170141183460469231731687303715884105727",
5156 "340282366920938463463374607431768211455" };
5157 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
5159 const char *value, *suffix;
5163 /* Pre-rendering the values mean we don't have to futz with printing a
5164 multi-word decimal value. There are also a very limited number of
5165 precisions that we support, so it's really a waste of time. */
5166 switch (TYPE_PRECISION (type))
5168 case 8: idx = 0; break;
5169 case 16: idx = 2; break;
5170 case 32: idx = 4; break;
5171 case 64: idx = 6; break;
5172 case 128: idx = 8; break;
5176 value = values[idx + TREE_UNSIGNED (type)];
5177 suffix = suffixes[is_long * 2 + TREE_UNSIGNED (type)];
5179 buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1);
5180 sprintf (buf, "%s=%s%s", macro, value, suffix);
5182 cpp_define (parse_in, buf);
5186 c_init_attributes ()
5188 /* Fill in the built_in_attributes array. */
5189 #define DEF_ATTR_NULL_TREE(ENUM) \
5190 built_in_attributes[(int) ENUM] = NULL_TREE;
5191 #define DEF_ATTR_INT(ENUM, VALUE) \
5192 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
5193 #define DEF_ATTR_IDENT(ENUM, STRING) \
5194 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5195 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5196 built_in_attributes[(int) ENUM] \
5197 = tree_cons (built_in_attributes[(int) PURPOSE], \
5198 built_in_attributes[(int) VALUE], \
5199 built_in_attributes[(int) CHAIN]);
5200 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
5201 #include "builtin-attrs.def"
5202 #undef DEF_ATTR_NULL_TREE
5204 #undef DEF_ATTR_IDENT
5205 #undef DEF_ATTR_TREE_LIST
5207 c_attrs_initialized = true;
5210 /* Depending on the name of DECL, apply default attributes to it. */
5213 c_common_insert_default_attributes (decl)
5216 tree name = DECL_NAME (decl);
5218 if (!c_attrs_initialized)
5219 c_init_attributes ();
5221 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
5222 #define DEF_ATTR_INT(ENUM, VALUE)
5223 #define DEF_ATTR_IDENT(ENUM, STRING)
5224 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
5225 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
5226 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
5227 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
5228 ATTR_FLAG_BUILT_IN);
5229 #include "builtin-attrs.def"
5230 #undef DEF_ATTR_NULL_TREE
5232 #undef DEF_ATTR_IDENT
5233 #undef DEF_ATTR_TREE_LIST
5237 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
5238 additionally give the location of the previous declaration DECL. */
5240 shadow_warning (msgid, name, decl)
5244 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
5245 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
5246 DECL_SOURCE_LINE (decl),
5247 "shadowed declaration is here");
5250 /* Attribute handlers common to C front ends. */
5252 /* Handle a "packed" attribute; arguments as in
5253 struct attribute_spec.handler. */
5256 handle_packed_attribute (node, name, args, flags, no_add_attrs)
5259 tree args ATTRIBUTE_UNUSED;
5266 if (TREE_CODE (*node) == TYPE_DECL)
5267 type = &TREE_TYPE (*node);
5274 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5275 *type = build_type_copy (*type);
5276 TYPE_PACKED (*type) = 1;
5278 else if (TREE_CODE (*node) == FIELD_DECL)
5279 DECL_PACKED (*node) = 1;
5280 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5281 used for DECL_REGISTER. It wouldn't mean anything anyway. */
5284 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5285 *no_add_attrs = true;
5291 /* Handle a "nocommon" attribute; arguments as in
5292 struct attribute_spec.handler. */
5295 handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
5298 tree args ATTRIBUTE_UNUSED;
5299 int flags ATTRIBUTE_UNUSED;
5302 if (TREE_CODE (*node) == VAR_DECL)
5303 DECL_COMMON (*node) = 0;
5306 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5307 *no_add_attrs = true;
5313 /* Handle a "common" attribute; arguments as in
5314 struct attribute_spec.handler. */
5317 handle_common_attribute (node, name, args, flags, no_add_attrs)
5320 tree args ATTRIBUTE_UNUSED;
5321 int flags ATTRIBUTE_UNUSED;
5324 if (TREE_CODE (*node) == VAR_DECL)
5325 DECL_COMMON (*node) = 1;
5328 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5329 *no_add_attrs = true;
5335 /* Handle a "noreturn" attribute; arguments as in
5336 struct attribute_spec.handler. */
5339 handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
5342 tree args ATTRIBUTE_UNUSED;
5343 int flags ATTRIBUTE_UNUSED;
5346 tree type = TREE_TYPE (*node);
5348 /* See FIXME comment in c_common_attribute_table. */
5349 if (TREE_CODE (*node) == FUNCTION_DECL)
5350 TREE_THIS_VOLATILE (*node) = 1;
5351 else if (TREE_CODE (type) == POINTER_TYPE
5352 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5354 = build_pointer_type
5355 (build_type_variant (TREE_TYPE (type),
5356 TREE_READONLY (TREE_TYPE (type)), 1));
5359 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5360 *no_add_attrs = true;
5366 /* Handle a "noinline" attribute; arguments as in
5367 struct attribute_spec.handler. */
5370 handle_noinline_attribute (node, name, args, flags, no_add_attrs)
5373 tree args ATTRIBUTE_UNUSED;
5374 int flags ATTRIBUTE_UNUSED;
5377 if (TREE_CODE (*node) == FUNCTION_DECL)
5378 DECL_UNINLINABLE (*node) = 1;
5381 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5382 *no_add_attrs = true;
5388 /* Handle a "always_inline" attribute; arguments as in
5389 struct attribute_spec.handler. */
5392 handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
5395 tree args ATTRIBUTE_UNUSED;
5396 int flags ATTRIBUTE_UNUSED;
5399 if (TREE_CODE (*node) == FUNCTION_DECL)
5401 /* Do nothing else, just set the attribute. We'll get at
5402 it later with lookup_attribute. */
5406 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5407 *no_add_attrs = true;
5413 /* Handle a "used" attribute; arguments as in
5414 struct attribute_spec.handler. */
5417 handle_used_attribute (node, name, args, flags, no_add_attrs)
5420 tree args ATTRIBUTE_UNUSED;
5421 int flags ATTRIBUTE_UNUSED;
5424 if (TREE_CODE (*node) == FUNCTION_DECL)
5425 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node))
5426 = TREE_USED (*node) = 1;
5429 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5430 *no_add_attrs = true;
5436 /* Handle a "unused" attribute; arguments as in
5437 struct attribute_spec.handler. */
5440 handle_unused_attribute (node, name, args, flags, no_add_attrs)
5443 tree args ATTRIBUTE_UNUSED;
5451 if (TREE_CODE (decl) == PARM_DECL
5452 || TREE_CODE (decl) == VAR_DECL
5453 || TREE_CODE (decl) == FUNCTION_DECL
5454 || TREE_CODE (decl) == LABEL_DECL
5455 || TREE_CODE (decl) == TYPE_DECL)
5456 TREE_USED (decl) = 1;
5459 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5460 *no_add_attrs = true;
5465 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5466 *node = build_type_copy (*node);
5467 TREE_USED (*node) = 1;
5473 /* Handle a "const" attribute; arguments as in
5474 struct attribute_spec.handler. */
5477 handle_const_attribute (node, name, args, flags, no_add_attrs)
5480 tree args ATTRIBUTE_UNUSED;
5481 int flags ATTRIBUTE_UNUSED;
5484 tree type = TREE_TYPE (*node);
5486 /* See FIXME comment on noreturn in c_common_attribute_table. */
5487 if (TREE_CODE (*node) == FUNCTION_DECL)
5488 TREE_READONLY (*node) = 1;
5489 else if (TREE_CODE (type) == POINTER_TYPE
5490 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5492 = build_pointer_type
5493 (build_type_variant (TREE_TYPE (type), 1,
5494 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5497 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5498 *no_add_attrs = true;
5504 /* Handle a "transparent_union" attribute; arguments as in
5505 struct attribute_spec.handler. */
5508 handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
5511 tree args ATTRIBUTE_UNUSED;
5515 tree decl = NULL_TREE;
5522 type = &TREE_TYPE (decl);
5523 is_type = TREE_CODE (*node) == TYPE_DECL;
5525 else if (TYPE_P (*node))
5526 type = node, is_type = 1;
5529 && TREE_CODE (*type) == UNION_TYPE
5531 || (TYPE_FIELDS (*type) != 0
5532 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
5534 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5535 *type = build_type_copy (*type);
5536 TYPE_TRANSPARENT_UNION (*type) = 1;
5538 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
5539 && TREE_CODE (*type) == UNION_TYPE
5540 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
5541 DECL_TRANSPARENT_UNION (decl) = 1;
5544 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5545 *no_add_attrs = true;
5551 /* Handle a "constructor" attribute; arguments as in
5552 struct attribute_spec.handler. */
5555 handle_constructor_attribute (node, name, args, flags, no_add_attrs)
5558 tree args ATTRIBUTE_UNUSED;
5559 int flags ATTRIBUTE_UNUSED;
5563 tree type = TREE_TYPE (decl);
5565 if (TREE_CODE (decl) == FUNCTION_DECL
5566 && TREE_CODE (type) == FUNCTION_TYPE
5567 && decl_function_context (decl) == 0)
5569 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5570 TREE_USED (decl) = 1;
5574 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5575 *no_add_attrs = true;
5581 /* Handle a "destructor" attribute; arguments as in
5582 struct attribute_spec.handler. */
5585 handle_destructor_attribute (node, name, args, flags, no_add_attrs)
5588 tree args ATTRIBUTE_UNUSED;
5589 int flags ATTRIBUTE_UNUSED;
5593 tree type = TREE_TYPE (decl);
5595 if (TREE_CODE (decl) == FUNCTION_DECL
5596 && TREE_CODE (type) == FUNCTION_TYPE
5597 && decl_function_context (decl) == 0)
5599 DECL_STATIC_DESTRUCTOR (decl) = 1;
5600 TREE_USED (decl) = 1;
5604 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5605 *no_add_attrs = true;
5611 /* Handle a "mode" attribute; arguments as in
5612 struct attribute_spec.handler. */
5615 handle_mode_attribute (node, name, args, flags, no_add_attrs)
5619 int flags ATTRIBUTE_UNUSED;
5624 *no_add_attrs = true;
5626 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5627 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5631 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5632 int len = strlen (p);
5633 enum machine_mode mode = VOIDmode;
5637 if (len > 4 && p[0] == '_' && p[1] == '_'
5638 && p[len - 1] == '_' && p[len - 2] == '_')
5640 char *newp = (char *) alloca (len - 1);
5642 strcpy (newp, &p[2]);
5643 newp[len - 4] = '\0';
5647 /* Change this type to have a type with the specified mode.
5648 First check for the special modes. */
5649 if (! strcmp (p, "byte"))
5651 else if (!strcmp (p, "word"))
5653 else if (! strcmp (p, "pointer"))
5656 for (j = 0; j < NUM_MACHINE_MODES; j++)
5657 if (!strcmp (p, GET_MODE_NAME (j)))
5658 mode = (enum machine_mode) j;
5660 if (mode == VOIDmode)
5661 error ("unknown machine mode `%s'", p);
5662 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
5663 (mode, TREE_UNSIGNED (type))))
5664 error ("no data type for mode `%s'", p);
5665 else if ((TREE_CODE (type) == POINTER_TYPE
5666 || TREE_CODE (type) == REFERENCE_TYPE)
5667 && !(*targetm.valid_pointer_mode) (mode))
5668 error ("invalid pointer mode `%s'", p);
5671 /* If this is a vector, make sure we either have hardware
5672 support, or we can emulate it. */
5673 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5674 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5675 && !vector_mode_valid_p (mode))
5677 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5681 if (TREE_CODE (type) == POINTER_TYPE)
5683 ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
5687 else if (TREE_CODE (type) == REFERENCE_TYPE)
5689 ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
5695 /* No need to layout the type here. The caller should do this. */
5702 /* Handle a "section" attribute; arguments as in
5703 struct attribute_spec.handler. */
5706 handle_section_attribute (node, name, args, flags, no_add_attrs)
5708 tree name ATTRIBUTE_UNUSED;
5710 int flags ATTRIBUTE_UNUSED;
5715 if (targetm.have_named_sections)
5717 if ((TREE_CODE (decl) == FUNCTION_DECL
5718 || TREE_CODE (decl) == VAR_DECL)
5719 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5721 if (TREE_CODE (decl) == VAR_DECL
5722 && current_function_decl != NULL_TREE
5723 && ! TREE_STATIC (decl))
5725 error_with_decl (decl,
5726 "section attribute cannot be specified for local variables");
5727 *no_add_attrs = true;
5730 /* The decl may have already been given a section attribute
5731 from a previous declaration. Ensure they match. */
5732 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5733 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5734 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5736 error_with_decl (*node,
5737 "section of `%s' conflicts with previous declaration");
5738 *no_add_attrs = true;
5741 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5745 error_with_decl (*node,
5746 "section attribute not allowed for `%s'");
5747 *no_add_attrs = true;
5752 error_with_decl (*node,
5753 "section attributes are not supported for this target");
5754 *no_add_attrs = true;
5760 /* Handle a "aligned" attribute; arguments as in
5761 struct attribute_spec.handler. */
5764 handle_aligned_attribute (node, name, args, flags, no_add_attrs)
5766 tree name ATTRIBUTE_UNUSED;
5771 tree decl = NULL_TREE;
5774 tree align_expr = (args ? TREE_VALUE (args)
5775 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5781 type = &TREE_TYPE (decl);
5782 is_type = TREE_CODE (*node) == TYPE_DECL;
5784 else if (TYPE_P (*node))
5785 type = node, is_type = 1;
5787 /* Strip any NOPs of any kind. */
5788 while (TREE_CODE (align_expr) == NOP_EXPR
5789 || TREE_CODE (align_expr) == CONVERT_EXPR
5790 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
5791 align_expr = TREE_OPERAND (align_expr, 0);
5793 if (TREE_CODE (align_expr) != INTEGER_CST)
5795 error ("requested alignment is not a constant");
5796 *no_add_attrs = true;
5798 else if ((i = tree_log2 (align_expr)) == -1)
5800 error ("requested alignment is not a power of 2");
5801 *no_add_attrs = true;
5803 else if (i > HOST_BITS_PER_INT - 2)
5805 error ("requested alignment is too large");
5806 *no_add_attrs = true;
5810 /* If we have a TYPE_DECL, then copy the type, so that we
5811 don't accidentally modify a builtin type. See pushdecl. */
5812 if (decl && TREE_TYPE (decl) != error_mark_node
5813 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5815 tree tt = TREE_TYPE (decl);
5816 *type = build_type_copy (*type);
5817 DECL_ORIGINAL_TYPE (decl) = tt;
5818 TYPE_NAME (*type) = decl;
5819 TREE_USED (*type) = TREE_USED (decl);
5820 TREE_TYPE (decl) = *type;
5822 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5823 *type = build_type_copy (*type);
5825 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5826 TYPE_USER_ALIGN (*type) = 1;
5828 else if (TREE_CODE (decl) != VAR_DECL
5829 && TREE_CODE (decl) != FIELD_DECL)
5831 error_with_decl (decl,
5832 "alignment may not be specified for `%s'");
5833 *no_add_attrs = true;
5837 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5838 DECL_USER_ALIGN (decl) = 1;
5844 /* Handle a "weak" attribute; arguments as in
5845 struct attribute_spec.handler. */
5848 handle_weak_attribute (node, name, args, flags, no_add_attrs)
5850 tree name ATTRIBUTE_UNUSED;
5851 tree args ATTRIBUTE_UNUSED;
5852 int flags ATTRIBUTE_UNUSED;
5853 bool *no_add_attrs ATTRIBUTE_UNUSED;
5855 declare_weak (*node);
5860 /* Handle an "alias" attribute; arguments as in
5861 struct attribute_spec.handler. */
5864 handle_alias_attribute (node, name, args, flags, no_add_attrs)
5868 int flags ATTRIBUTE_UNUSED;
5873 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5874 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
5876 error_with_decl (decl,
5877 "`%s' defined both normally and as an alias");
5878 *no_add_attrs = true;
5880 else if (decl_function_context (decl) == 0)
5884 id = TREE_VALUE (args);
5885 if (TREE_CODE (id) != STRING_CST)
5887 error ("alias arg not a string");
5888 *no_add_attrs = true;
5891 id = get_identifier (TREE_STRING_POINTER (id));
5892 /* This counts as a use of the object pointed to. */
5895 if (TREE_CODE (decl) == FUNCTION_DECL)
5896 DECL_INITIAL (decl) = error_mark_node;
5898 DECL_EXTERNAL (decl) = 0;
5902 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5903 *no_add_attrs = true;
5909 /* Handle an "visibility" attribute; arguments as in
5910 struct attribute_spec.handler. */
5913 handle_visibility_attribute (node, name, args, flags, no_add_attrs)
5917 int flags ATTRIBUTE_UNUSED;
5922 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
5924 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5925 *no_add_attrs = true;
5931 id = TREE_VALUE (args);
5932 if (TREE_CODE (id) != STRING_CST)
5934 error ("visibility arg not a string");
5935 *no_add_attrs = true;
5938 if (strcmp (TREE_STRING_POINTER (id), "hidden")
5939 && strcmp (TREE_STRING_POINTER (id), "protected")
5940 && strcmp (TREE_STRING_POINTER (id), "internal")
5941 && strcmp (TREE_STRING_POINTER (id), "default"))
5943 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5944 *no_add_attrs = true;
5952 /* Handle an "tls_model" attribute; arguments as in
5953 struct attribute_spec.handler. */
5956 handle_tls_model_attribute (node, name, args, flags, no_add_attrs)
5960 int flags ATTRIBUTE_UNUSED;
5965 if (! DECL_THREAD_LOCAL (decl))
5967 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5968 *no_add_attrs = true;
5974 id = TREE_VALUE (args);
5975 if (TREE_CODE (id) != STRING_CST)
5977 error ("tls_model arg not a string");
5978 *no_add_attrs = true;
5981 if (strcmp (TREE_STRING_POINTER (id), "local-exec")
5982 && strcmp (TREE_STRING_POINTER (id), "initial-exec")
5983 && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
5984 && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5986 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5987 *no_add_attrs = true;
5995 /* Handle a "no_instrument_function" attribute; arguments as in
5996 struct attribute_spec.handler. */
5999 handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
6002 tree args ATTRIBUTE_UNUSED;
6003 int flags ATTRIBUTE_UNUSED;
6008 if (TREE_CODE (decl) != FUNCTION_DECL)
6010 error_with_decl (decl,
6011 "`%s' attribute applies only to functions",
6012 IDENTIFIER_POINTER (name));
6013 *no_add_attrs = true;
6015 else if (DECL_INITIAL (decl))
6017 error_with_decl (decl,
6018 "can't set `%s' attribute after definition",
6019 IDENTIFIER_POINTER (name));
6020 *no_add_attrs = true;
6023 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6028 /* Handle a "malloc" attribute; arguments as in
6029 struct attribute_spec.handler. */
6032 handle_malloc_attribute (node, name, args, flags, no_add_attrs)
6035 tree args ATTRIBUTE_UNUSED;
6036 int flags ATTRIBUTE_UNUSED;
6039 if (TREE_CODE (*node) == FUNCTION_DECL)
6040 DECL_IS_MALLOC (*node) = 1;
6041 /* ??? TODO: Support types. */
6044 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6045 *no_add_attrs = true;
6051 /* Handle a "no_limit_stack" attribute; arguments as in
6052 struct attribute_spec.handler. */
6055 handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
6058 tree args ATTRIBUTE_UNUSED;
6059 int flags ATTRIBUTE_UNUSED;
6064 if (TREE_CODE (decl) != FUNCTION_DECL)
6066 error_with_decl (decl,
6067 "`%s' attribute applies only to functions",
6068 IDENTIFIER_POINTER (name));
6069 *no_add_attrs = true;
6071 else if (DECL_INITIAL (decl))
6073 error_with_decl (decl,
6074 "can't set `%s' attribute after definition",
6075 IDENTIFIER_POINTER (name));
6076 *no_add_attrs = true;
6079 DECL_NO_LIMIT_STACK (decl) = 1;
6084 /* Handle a "pure" attribute; arguments as in
6085 struct attribute_spec.handler. */
6088 handle_pure_attribute (node, name, args, flags, no_add_attrs)
6091 tree args ATTRIBUTE_UNUSED;
6092 int flags ATTRIBUTE_UNUSED;
6095 if (TREE_CODE (*node) == FUNCTION_DECL)
6096 DECL_IS_PURE (*node) = 1;
6097 /* ??? TODO: Support types. */
6100 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6101 *no_add_attrs = true;
6107 /* Handle a "deprecated" attribute; arguments as in
6108 struct attribute_spec.handler. */
6111 handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
6114 tree args ATTRIBUTE_UNUSED;
6118 tree type = NULL_TREE;
6120 const char *what = NULL;
6125 type = TREE_TYPE (decl);
6127 if (TREE_CODE (decl) == TYPE_DECL
6128 || TREE_CODE (decl) == PARM_DECL
6129 || TREE_CODE (decl) == VAR_DECL
6130 || TREE_CODE (decl) == FUNCTION_DECL
6131 || TREE_CODE (decl) == FIELD_DECL)
6132 TREE_DEPRECATED (decl) = 1;
6136 else if (TYPE_P (*node))
6138 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6139 *node = build_type_copy (*node);
6140 TREE_DEPRECATED (*node) = 1;
6148 *no_add_attrs = true;
6149 if (type && TYPE_NAME (type))
6151 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6152 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
6153 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6154 && DECL_NAME (TYPE_NAME (type)))
6155 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
6158 warning ("`%s' attribute ignored for `%s'",
6159 IDENTIFIER_POINTER (name), what);
6161 warning ("`%s' attribute ignored",
6162 IDENTIFIER_POINTER (name));
6168 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
6169 to prevent us from duplicating type nodes unnecessarily.
6170 The normal mechanism to prevent duplicates is to use type_hash_canon, but
6171 since we want to distinguish types that are essentially identical (except
6172 for their debug representation), we use a local list here. */
6173 static GTY(()) tree vector_type_node_list = 0;
6175 /* Handle a "vector_size" attribute; arguments as in
6176 struct attribute_spec.handler. */
6179 handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
6183 int flags ATTRIBUTE_UNUSED;
6186 unsigned HOST_WIDE_INT vecsize, nunits;
6187 enum machine_mode mode, orig_mode, new_mode;
6188 tree type = *node, new_type = NULL_TREE;
6189 tree type_list_node;
6191 *no_add_attrs = true;
6193 if (! host_integerp (TREE_VALUE (args), 1))
6195 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6199 /* Get the vector size (in bytes). */
6200 vecsize = tree_low_cst (TREE_VALUE (args), 1);
6202 /* We need to provide for vector pointers, vector arrays, and
6203 functions returning vectors. For example:
6205 __attribute__((vector_size(16))) short *foo;
6207 In this case, the mode is SI, but the type being modified is
6208 HI, so we need to look further. */
6210 while (POINTER_TYPE_P (type)
6211 || TREE_CODE (type) == FUNCTION_TYPE
6212 || TREE_CODE (type) == ARRAY_TYPE)
6213 type = TREE_TYPE (type);
6215 /* Get the mode of the type being modified. */
6216 orig_mode = TYPE_MODE (type);
6218 if (TREE_CODE (type) == RECORD_TYPE
6219 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
6220 && GET_MODE_CLASS (orig_mode) != MODE_INT)
6221 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
6223 error ("invalid vector type for attribute `%s'",
6224 IDENTIFIER_POINTER (name));
6228 /* Calculate how many units fit in the vector. */
6229 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6231 /* Find a suitably sized vector. */
6232 new_mode = VOIDmode;
6233 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
6235 : MODE_VECTOR_FLOAT);
6237 mode = GET_MODE_WIDER_MODE (mode))
6238 if (vecsize == GET_MODE_SIZE (mode)
6239 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
6245 if (new_mode == VOIDmode)
6247 error ("no vector mode with the size and type specified could be found");
6251 for (type_list_node = vector_type_node_list; type_list_node;
6252 type_list_node = TREE_CHAIN (type_list_node))
6254 tree other_type = TREE_VALUE (type_list_node);
6255 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
6256 tree fields = TYPE_FIELDS (record);
6257 tree field_type = TREE_TYPE (fields);
6258 tree array_type = TREE_TYPE (field_type);
6259 if (TREE_CODE (fields) != FIELD_DECL
6260 || TREE_CODE (field_type) != ARRAY_TYPE)
6263 if (TYPE_MODE (other_type) == mode && type == array_type)
6265 new_type = other_type;
6270 if (new_type == NULL_TREE)
6272 tree index, array, rt, list_node;
6274 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
6275 TREE_UNSIGNED (type));
6279 error ("no vector mode with the size and type specified could be found");
6283 new_type = build_type_copy (new_type);
6285 /* If this is a vector, make sure we either have hardware
6286 support, or we can emulate it. */
6287 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
6288 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
6289 && !vector_mode_valid_p (mode))
6291 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
6295 /* Set the debug information here, because this is the only
6296 place where we know the underlying type for a vector made
6297 with vector_size. For debugging purposes we pretend a vector
6298 is an array within a structure. */
6299 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
6300 array = build_array_type (type, build_index_type (index));
6301 rt = make_node (RECORD_TYPE);
6303 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
6304 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
6306 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
6308 list_node = build_tree_list (NULL, new_type);
6309 TREE_CHAIN (list_node) = vector_type_node_list;
6310 vector_type_node_list = list_node;
6313 /* Build back pointers if needed. */
6314 *node = vector_size_helper (*node, new_type);
6319 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
6322 If we requested a pointer to a vector, build up the pointers that
6323 we stripped off while looking for the inner type. Similarly for
6324 return values from functions.
6326 The argument "type" is the top of the chain, and "bottom" is the
6327 new type which we will point to. */
6330 vector_size_helper (type, bottom)
6335 if (POINTER_TYPE_P (type))
6337 inner = vector_size_helper (TREE_TYPE (type), bottom);
6338 outer = build_pointer_type (inner);
6340 else if (TREE_CODE (type) == ARRAY_TYPE)
6342 inner = vector_size_helper (TREE_TYPE (type), bottom);
6343 outer = build_array_type (inner, TYPE_VALUES (type));
6345 else if (TREE_CODE (type) == FUNCTION_TYPE)
6347 inner = vector_size_helper (TREE_TYPE (type), bottom);
6348 outer = build_function_type (inner, TYPE_VALUES (type));
6353 TREE_READONLY (outer) = TREE_READONLY (type);
6354 TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
6359 /* Handle the "nonnull" attribute. */
6361 handle_nonnull_attribute (node, name, args, flags, no_add_attrs)
6363 tree name ATTRIBUTE_UNUSED;
6365 int flags ATTRIBUTE_UNUSED;
6369 unsigned HOST_WIDE_INT attr_arg_num;
6371 /* If no arguments are specified, all pointer arguments should be
6372 non-null. Verify a full prototype is given so that the arguments
6373 will have the correct types when we actually check them later. */
6376 if (! TYPE_ARG_TYPES (type))
6378 error ("nonnull attribute without arguments on a non-prototype");
6379 *no_add_attrs = true;
6384 /* Argument list specified. Verify that each argument number references
6385 a pointer argument. */
6386 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6389 unsigned HOST_WIDE_INT arg_num, ck_num;
6391 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6393 error ("nonnull argument has invalid operand number (arg %lu)",
6394 (unsigned long) attr_arg_num);
6395 *no_add_attrs = true;
6399 argument = TYPE_ARG_TYPES (type);
6402 for (ck_num = 1; ; ck_num++)
6404 if (! argument || ck_num == arg_num)
6406 argument = TREE_CHAIN (argument);
6410 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6412 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
6413 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6414 *no_add_attrs = true;
6418 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6420 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
6421 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6422 *no_add_attrs = true;
6431 /* Check the argument list of a function call for null in argument slots
6432 that are marked as requiring a non-null pointer argument. */
6435 check_function_nonnull (attrs, params)
6439 tree a, args, param;
6442 for (a = attrs; a; a = TREE_CHAIN (a))
6444 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6446 args = TREE_VALUE (a);
6448 /* Walk the argument list. If we encounter an argument number we
6449 should check for non-null, do it. If the attribute has no args,
6450 then every pointer argument is checked (in which case the check
6451 for pointer type is done in check_nonnull_arg). */
6452 for (param = params, param_num = 1; ;
6453 param_num++, param = TREE_CHAIN (param))
6457 if (! args || nonnull_check_p (args, param_num))
6458 check_function_arguments_recurse (check_nonnull_arg, NULL,
6466 /* Helper for check_function_nonnull; given a list of operands which
6467 must be non-null in ARGS, determine if operand PARAM_NUM should be
6471 nonnull_check_p (args, param_num)
6473 unsigned HOST_WIDE_INT param_num;
6475 unsigned HOST_WIDE_INT arg_num;
6477 for (; args; args = TREE_CHAIN (args))
6479 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6482 if (arg_num == param_num)
6488 /* Check that the function argument PARAM (which is operand number
6489 PARAM_NUM) is non-null. This is called by check_function_nonnull
6490 via check_function_arguments_recurse. */
6493 check_nonnull_arg (ctx, param, param_num)
6494 void *ctx ATTRIBUTE_UNUSED;
6496 unsigned HOST_WIDE_INT param_num;
6498 /* Just skip checking the argument if it's not a pointer. This can
6499 happen if the "nonnull" attribute was given without an operand
6500 list (which means to check every pointer argument). */
6502 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6505 if (integer_zerop (param))
6506 warning ("null argument where non-null required (arg %lu)",
6507 (unsigned long) param_num);
6510 /* Helper for nonnull attribute handling; fetch the operand number
6511 from the attribute argument list. */
6514 get_nonnull_operand (arg_num_expr, valp)
6516 unsigned HOST_WIDE_INT *valp;
6518 /* Strip any conversions from the arg number and verify they
6520 while (TREE_CODE (arg_num_expr) == NOP_EXPR
6521 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
6522 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
6523 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
6525 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6526 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6529 *valp = TREE_INT_CST_LOW (arg_num_expr);
6533 /* Handle a "nothrow" attribute; arguments as in
6534 struct attribute_spec.handler. */
6537 handle_nothrow_attribute (node, name, args, flags, no_add_attrs)
6540 tree args ATTRIBUTE_UNUSED;
6541 int flags ATTRIBUTE_UNUSED;
6544 if (TREE_CODE (*node) == FUNCTION_DECL)
6545 TREE_NOTHROW (*node) = 1;
6546 /* ??? TODO: Support types. */
6549 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6550 *no_add_attrs = true;
6556 /* Check for valid arguments being passed to a function. */
6558 check_function_arguments (attrs, params)
6562 /* Check for null being passed in a pointer argument that must be
6563 non-null. We also need to do this if format checking is enabled. */
6566 check_function_nonnull (attrs, params);
6568 /* Check for errors in format strings. */
6571 check_function_format (NULL, attrs, params);
6574 /* Generic argument checking recursion routine. PARAM is the argument to
6575 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6576 once the argument is resolved. CTX is context for the callback. */
6578 check_function_arguments_recurse (callback, ctx, param, param_num)
6579 void (*callback) PARAMS ((void *, tree, unsigned HOST_WIDE_INT));
6582 unsigned HOST_WIDE_INT param_num;
6584 if (TREE_CODE (param) == NOP_EXPR)
6586 /* Strip coercion. */
6587 check_function_arguments_recurse (callback, ctx,
6588 TREE_OPERAND (param, 0), param_num);
6592 if (TREE_CODE (param) == CALL_EXPR)
6594 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
6596 bool found_format_arg = false;
6598 /* See if this is a call to a known internationalization function
6599 that modifies a format arg. Such a function may have multiple
6600 format_arg attributes (for example, ngettext). */
6602 for (attrs = TYPE_ATTRIBUTES (type);
6604 attrs = TREE_CHAIN (attrs))
6605 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6608 tree format_num_expr;
6612 /* Extract the argument number, which was previously checked
6614 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6615 while (TREE_CODE (format_num_expr) == NOP_EXPR
6616 || TREE_CODE (format_num_expr) == CONVERT_EXPR
6617 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
6618 format_num_expr = TREE_OPERAND (format_num_expr, 0);
6620 if (TREE_CODE (format_num_expr) != INTEGER_CST
6621 || TREE_INT_CST_HIGH (format_num_expr) != 0)
6624 format_num = TREE_INT_CST_LOW (format_num_expr);
6626 for (inner_args = TREE_OPERAND (param, 1), i = 1;
6628 inner_args = TREE_CHAIN (inner_args), i++)
6629 if (i == format_num)
6631 check_function_arguments_recurse (callback, ctx,
6632 TREE_VALUE (inner_args),
6634 found_format_arg = true;
6639 /* If we found a format_arg attribute and did a recursive check,
6640 we are done with checking this argument. Otherwise, we continue
6641 and this will be considered a non-literal. */
6642 if (found_format_arg)
6646 if (TREE_CODE (param) == COND_EXPR)
6648 /* Check both halves of the conditional expression. */
6649 check_function_arguments_recurse (callback, ctx,
6650 TREE_OPERAND (param, 1), param_num);
6651 check_function_arguments_recurse (callback, ctx,
6652 TREE_OPERAND (param, 2), param_num);
6656 (*callback) (ctx, param, param_num);
6659 #include "gt-c-common.h"