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, 2003, 2004 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"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #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 /* The following symbols are subsumed in the c_global_trees array, and
91 listed here individually for documentation purposes.
93 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
95 tree short_integer_type_node;
96 tree long_integer_type_node;
97 tree long_long_integer_type_node;
99 tree short_unsigned_type_node;
100 tree long_unsigned_type_node;
101 tree long_long_unsigned_type_node;
103 tree truthvalue_type_node;
104 tree truthvalue_false_node;
105 tree truthvalue_true_node;
107 tree ptrdiff_type_node;
109 tree unsigned_char_type_node;
110 tree signed_char_type_node;
111 tree wchar_type_node;
112 tree signed_wchar_type_node;
113 tree unsigned_wchar_type_node;
115 tree float_type_node;
116 tree double_type_node;
117 tree long_double_type_node;
119 tree complex_integer_type_node;
120 tree complex_float_type_node;
121 tree complex_double_type_node;
122 tree complex_long_double_type_node;
124 tree intQI_type_node;
125 tree intHI_type_node;
126 tree intSI_type_node;
127 tree intDI_type_node;
128 tree intTI_type_node;
130 tree unsigned_intQI_type_node;
131 tree unsigned_intHI_type_node;
132 tree unsigned_intSI_type_node;
133 tree unsigned_intDI_type_node;
134 tree unsigned_intTI_type_node;
136 tree widest_integer_literal_type_node;
137 tree widest_unsigned_literal_type_node;
139 Nodes for types `void *' and `const void *'.
141 tree ptr_type_node, const_ptr_type_node;
143 Nodes for types `char *' and `const char *'.
145 tree string_type_node, const_string_type_node;
147 Type `char[SOMENUMBER]'.
148 Used when an array of char is needed and the size is irrelevant.
150 tree char_array_type_node;
152 Type `int[SOMENUMBER]' or something like it.
153 Used when an array of int needed and the size is irrelevant.
155 tree int_array_type_node;
157 Type `wchar_t[SOMENUMBER]' or something like it.
158 Used when a wide string literal is created.
160 tree wchar_array_type_node;
162 Type `int ()' -- used for implicit declaration of functions.
164 tree default_function_type;
166 A VOID_TYPE node, packaged in a TREE_LIST.
170 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
171 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
172 VAR_DECLS, but C++ does.)
174 tree function_name_decl_node;
175 tree pretty_function_name_decl_node;
176 tree c99_function_name_decl_node;
178 Stack of nested function name VAR_DECLs.
180 tree saved_function_name_decls;
184 tree c_global_trees[CTI_MAX];
186 /* TRUE if a code represents a statement. The front end init
187 langhook should take care of initialization of this array. */
189 bool statement_code_p[MAX_TREE_CODES];
191 /* Switches common to the C front ends. */
193 /* Nonzero if prepreprocessing only. */
195 int flag_preprocess_only;
197 /* Nonzero means don't output line number information. */
199 char flag_no_line_commands;
201 /* Nonzero causes -E output not to be done, but directives such as
202 #define that have side effects are still obeyed. */
206 /* Nonzero means dump macros in some fashion. */
208 char flag_dump_macros;
210 /* Nonzero means pass #include lines through to the output. */
212 char flag_dump_includes;
214 /* The file name to which we should write a precompiled header, or
215 NULL if no header will be written in this compile. */
217 const char *pch_file;
219 /* Nonzero if an ISO standard was selected. It rejects macros in the
223 /* Nonzero if -undef was given. It suppresses target built-in macros
227 /* Nonzero means don't recognize the non-ANSI builtin functions. */
231 /* Nonzero means don't recognize the non-ANSI builtin functions.
234 int flag_no_nonansi_builtin;
236 /* Nonzero means give `double' the same size as `float'. */
238 int flag_short_double;
240 /* Nonzero means give `wchar_t' the same size as `short'. */
242 int flag_short_wchar;
244 /* Nonzero means allow Microsoft extensions without warnings or errors. */
245 int flag_ms_extensions;
247 /* Nonzero means don't recognize the keyword `asm'. */
251 /* Nonzero means give string constants the type `const char *', as mandated
254 int flag_const_strings;
256 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
258 int flag_signed_bitfields = 1;
259 int explicit_flag_signed_bitfields;
261 /* Nonzero means warn about pointer casts that can drop a type qualifier
262 from the pointer target type. */
266 /* Warn about functions which might be candidates for format attributes. */
268 int warn_missing_format_attribute;
270 /* Nonzero means warn about sizeof(function) or addition/subtraction
271 of function pointers. */
273 int warn_pointer_arith;
275 /* Nonzero means warn for any global function def
276 without separate previous prototype decl. */
278 int warn_missing_prototypes;
280 /* Warn if adding () is suggested. */
282 int warn_parentheses;
284 /* Warn if initializer is not completely bracketed. */
286 int warn_missing_braces;
288 /* Warn about comparison of signed and unsigned values.
289 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified
290 (in which case -Wextra gets to decide). */
292 int warn_sign_compare = -1;
294 /* Nonzero means warn about usage of long long when `-pedantic'. */
296 int warn_long_long = 1;
298 /* Nonzero means warn about deprecated conversion from string constant to
301 int warn_write_strings;
303 /* Nonzero means warn about multiple (redundant) decls for the same single
304 variable or function. */
306 int warn_redundant_decls;
308 /* Warn about testing equality of floating point numbers. */
310 int warn_float_equal;
312 /* Warn about a subscript that has type char. */
314 int warn_char_subscripts;
316 /* Warn if a type conversion is done that might have confusing results. */
320 /* Warn about #pragma directives that are not recognized. */
322 int warn_unknown_pragmas; /* Tri state variable. */
324 /* Warn about format/argument anomalies in calls to formatted I/O functions
325 (*printf, *scanf, strftime, strfmon, etc.). */
329 /* Warn about Y2K problems with strftime formats. */
333 /* Warn about excess arguments to formats. */
335 int warn_format_extra_args;
337 /* Warn about zero-length formats. */
339 int warn_format_zero_length;
341 /* Warn about non-literal format arguments. */
343 int warn_format_nonliteral;
345 /* Warn about possible security problems with calls to format functions. */
347 int warn_format_security;
349 /* Zero means that faster, ...NonNil variants of objc_msgSend...
350 calls will be used in ObjC; passing nil receivers to such calls
351 will most likely result in crashes. */
352 int flag_nil_receivers = 1;
354 /* Nonzero means that we will allow new ObjC exception syntax (@throw,
355 @try, etc.) in source code. */
356 int flag_objc_exceptions = 0;
358 /* Nonzero means that code generation will be altered to support
359 "zero-link" execution. This currently affects ObjC only, but may
360 affect other languages in the future. */
361 int flag_zero_link = 0;
363 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
364 unit. It will inform the ObjC runtime that class definition(s) herein
365 contained are to replace one(s) previously loaded. */
366 int flag_replace_objc_classes = 0;
368 /* C/ObjC language option variables. */
371 /* Nonzero means message about use of implicit function declarations;
372 1 means warning; 2 means error. */
374 int mesg_implicit_function_declaration = -1;
376 /* Nonzero means allow type mismatches in conditional expressions;
377 just make their values `void'. */
379 int flag_cond_mismatch;
381 /* Nonzero means enable C89 Amendment 1 features. */
385 /* Nonzero means use the ISO C99 dialect of C. */
389 /* Nonzero means that we have builtin functions, and main is an int. */
393 /* Nonzero means warn when casting a function call to a type that does
394 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
395 when there is no previous declaration of sqrt or malloc. */
397 int warn_bad_function_cast;
399 /* Warn about traditional constructs whose meanings changed in ANSI C. */
401 int warn_traditional;
403 /* Nonzero means warn for a declaration found after a statement. */
405 int warn_declaration_after_statement;
407 /* Nonzero means warn for non-prototype function decls
408 or non-prototyped defs without previous prototype. */
410 int warn_strict_prototypes;
412 /* Nonzero means warn for any global function def
413 without separate previous decl. */
415 int warn_missing_declarations;
417 /* Nonzero means warn about declarations of objects not at
418 file-scope level and about *all* declarations of functions (whether
419 or static) not at file-scope level. Note that we exclude
420 implicit function declarations. To get warnings about those, use
423 int warn_nested_externs;
425 /* Warn if main is suspicious. */
429 /* Nonzero means warn about possible violations of sequence point rules. */
431 int warn_sequence_point;
433 /* Nonzero means warn about uninitialized variable when it is initialized with itself.
434 For example: int i = i;, GCC will not warn about this when warn_init_self is nonzero. */
438 /* Nonzero means to warn about compile-time division by zero. */
439 int warn_div_by_zero = 1;
441 /* Nonzero means warn about use of implicit int. */
443 int warn_implicit_int;
445 /* Warn about NULL being passed to argument slots marked as requiring
450 /* Warn about old-style parameter declaration. */
452 int warn_old_style_definition;
455 /* ObjC language option variables. */
458 /* Open and close the file for outputting class declarations, if
461 int flag_gen_declaration;
463 /* Generate code for GNU or NeXT runtime environment. */
465 #ifdef NEXT_OBJC_RUNTIME
466 int flag_next_runtime = 1;
468 int flag_next_runtime = 0;
471 /* Tells the compiler that this is a special run. Do not perform any
472 compiling, instead we are to test some platform dependent features
473 and output a C header file with appropriate definitions. */
475 int print_struct_values;
477 /* ???. Undocumented. */
479 const char *constant_string_class_name;
481 /* Warn if multiple methods are seen for the same selector, but with
482 different argument types. Performs the check on the whole selector
483 table at the end of compilation. */
487 /* Warn if a @selector() is found, and no method with that selector
488 has been previously declared. The check is done on each
489 @selector() as soon as it is found - so it warns about forward
492 int warn_undeclared_selector;
494 /* Warn if methods required by a protocol are not implemented in the
495 class adopting it. When turned off, methods inherited to that
496 class are also considered implemented. */
498 int warn_protocol = 1;
501 /* C++ language option variables. */
504 /* Nonzero means don't recognize any extension keywords. */
506 int flag_no_gnu_keywords;
508 /* Nonzero means do emit exported implementations of functions even if
509 they can be inlined. */
511 int flag_implement_inlines = 1;
513 /* Nonzero means that implicit instantiations will be emitted if needed. */
515 int flag_implicit_templates = 1;
517 /* Nonzero means that implicit instantiations of inline templates will be
518 emitted if needed, even if instantiations of non-inline templates
521 int flag_implicit_inline_templates = 1;
523 /* Nonzero means generate separate instantiation control files and
524 juggle them at link time. */
526 int flag_use_repository;
528 /* Nonzero if we want to issue diagnostics that the standard says are not
531 int flag_optional_diags = 1;
533 /* Nonzero means we should attempt to elide constructors when possible. */
535 int flag_elide_constructors = 1;
537 /* Nonzero means that member functions defined in class scope are
538 inline by default. */
540 int flag_default_inline = 1;
542 /* Controls whether compiler generates 'type descriptor' that give
543 run-time type information. */
547 /* Nonzero if we want to conserve space in the .o files. We do this
548 by putting uninitialized data and runtime initialized data into
549 .common instead of .data at the expense of not flagging multiple
552 int flag_conserve_space;
554 /* Nonzero if we want to obey access control semantics. */
556 int flag_access_control = 1;
558 /* Nonzero if we want to check the return value of new and avoid calling
559 constructors if it is a null pointer. */
563 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
564 initialization variables.
565 0: Old rules, set by -fno-for-scope.
566 2: New ISO rules, set by -ffor-scope.
567 1: Try to implement new ISO rules, but with backup compatibility
568 (and warnings). This is the default, for now. */
570 int flag_new_for_scope = 1;
572 /* Nonzero if we want to emit defined symbols with common-like linkage as
573 weak symbols where possible, in order to conform to C++ semantics.
574 Otherwise, emit them as local symbols. */
578 /* 0 means we want the preprocessor to not emit line directives for
579 the current working directory. 1 means we want it to do it. -1
580 means we should decide depending on whether debugging information
581 is being emitted or not. */
583 int flag_working_directory = -1;
585 /* Nonzero to use __cxa_atexit, rather than atexit, to register
586 destructors for local statics and global objects. */
588 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
590 /* Nonzero means make the default pedwarns warnings instead of errors.
591 The value of this flag is ignored if -pedantic is specified. */
595 /* Nonzero means to implement standard semantics for exception
596 specifications, calling unexpected if an exception is thrown that
597 doesn't match the specification. Zero means to treat them as
598 assertions and optimize accordingly, but not check them. */
600 int flag_enforce_eh_specs = 1;
602 /* Nonzero means warn about things that will change when compiling
603 with an ABI-compliant compiler. */
607 /* Nonzero means warn about invalid uses of offsetof. */
609 int warn_invalid_offsetof = 1;
611 /* Nonzero means warn about implicit declarations. */
613 int warn_implicit = 1;
615 /* Nonzero means warn when all ctors or dtors are private, and the class
618 int warn_ctor_dtor_privacy = 0;
620 /* Nonzero means warn in function declared in derived class has the
621 same name as a virtual in the base class, but fails to match the
622 type signature of any virtual function in the base class. */
624 int warn_overloaded_virtual;
626 /* Nonzero means warn when declaring a class that has a non virtual
627 destructor, when it really ought to have a virtual one. */
631 /* Nonzero means warn when the compiler will reorder code. */
635 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
639 /* Nonzero means warn when we convert a pointer to member function
640 into a pointer to (void or function). */
642 int warn_pmf2ptr = 1;
644 /* Nonzero means warn about violation of some Effective C++ style rules. */
648 /* Nonzero means warn where overload resolution chooses a promotion from
649 unsigned to signed over a conversion to an unsigned of the same size. */
653 /* Nonzero means warn when an old-style cast is used. */
655 int warn_old_style_cast;
657 /* Nonzero means warn when non-templatized friend functions are
658 declared within a template */
660 int warn_nontemplate_friend = 1;
662 /* Nonzero means complain about deprecated features. */
664 int warn_deprecated = 1;
666 /* Maximum template instantiation depth. This limit is rather
667 arbitrary, but it exists to limit the time it takes to notice
668 infinite template instantiations. */
670 int max_tinst_depth = 500;
674 /* The elements of `ridpointers' are identifier nodes for the reserved
675 type names and storage classes. It is indexed by a RID_... value. */
678 tree (*make_fname_decl) (tree, int);
680 /* If non-NULL, the address of a language-specific function that takes
681 any action required right before expand_function_end is called. */
682 void (*lang_expand_function_end) (void);
684 /* Nonzero means the expression being parsed will never be evaluated.
685 This is a count, since unevaluated expressions can nest. */
688 /* Information about how a function name is generated. */
691 tree *const decl; /* pointer to the VAR_DECL. */
692 const unsigned rid; /* RID number for the identifier. */
693 const int pretty; /* How pretty is it? */
696 /* The three ways of getting then name of the current function. */
698 const struct fname_var_t fname_vars[] =
700 /* C99 compliant __func__, must be first. */
701 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
702 /* GCC __FUNCTION__ compliant. */
703 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
704 /* GCC __PRETTY_FUNCTION__ compliant. */
705 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
709 static int constant_fits_type_p (tree, tree);
711 /* Keep a stack of if statements. We record the number of compound
712 statements seen up to the if keyword, as well as the line number
713 and file of the if. If a potentially ambiguous else is seen, that
714 fact is recorded; the warning is issued when we can be sure that
715 the enclosing if statement does not have an else branch. */
724 static if_elt *if_stack;
726 /* Amount of space in the if statement stack. */
727 static int if_stack_space = 0;
730 static int if_stack_pointer = 0;
732 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
733 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
734 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
735 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
736 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
737 static tree handle_always_inline_attribute (tree *, tree, tree, int,
739 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
740 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
741 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
742 static tree handle_transparent_union_attribute (tree *, tree, tree,
744 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
745 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
746 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
747 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
748 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
749 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
750 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
751 static tree handle_visibility_attribute (tree *, tree, tree, int,
753 static tree handle_tls_model_attribute (tree *, tree, tree, int,
755 static tree handle_no_instrument_function_attribute (tree *, tree,
757 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
758 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
760 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
761 static tree handle_deprecated_attribute (tree *, tree, tree, int,
763 static tree handle_vector_size_attribute (tree *, tree, tree, int,
765 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
766 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
767 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
768 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
771 static void check_function_nonnull (tree, tree);
772 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
773 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
774 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
775 static int resort_field_decl_cmp (const void *, const void *);
777 /* Table of machine-independent attributes common to all C-like languages. */
778 const struct attribute_spec c_common_attribute_table[] =
780 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
781 { "packed", 0, 0, false, false, false,
782 handle_packed_attribute },
783 { "nocommon", 0, 0, true, false, false,
784 handle_nocommon_attribute },
785 { "common", 0, 0, true, false, false,
786 handle_common_attribute },
787 /* FIXME: logically, noreturn attributes should be listed as
788 "false, true, true" and apply to function types. But implementing this
789 would require all the places in the compiler that use TREE_THIS_VOLATILE
790 on a decl to identify non-returning functions to be located and fixed
791 to check the function type instead. */
792 { "noreturn", 0, 0, true, false, false,
793 handle_noreturn_attribute },
794 { "volatile", 0, 0, true, false, false,
795 handle_noreturn_attribute },
796 { "noinline", 0, 0, true, false, false,
797 handle_noinline_attribute },
798 { "always_inline", 0, 0, true, false, false,
799 handle_always_inline_attribute },
800 { "used", 0, 0, true, false, false,
801 handle_used_attribute },
802 { "unused", 0, 0, false, false, false,
803 handle_unused_attribute },
804 /* The same comments as for noreturn attributes apply to const ones. */
805 { "const", 0, 0, true, false, false,
806 handle_const_attribute },
807 { "transparent_union", 0, 0, false, false, false,
808 handle_transparent_union_attribute },
809 { "constructor", 0, 0, true, false, false,
810 handle_constructor_attribute },
811 { "destructor", 0, 0, true, false, false,
812 handle_destructor_attribute },
813 { "mode", 1, 1, false, true, false,
814 handle_mode_attribute },
815 { "section", 1, 1, true, false, false,
816 handle_section_attribute },
817 { "aligned", 0, 1, false, false, false,
818 handle_aligned_attribute },
819 { "weak", 0, 0, true, false, false,
820 handle_weak_attribute },
821 { "alias", 1, 1, true, false, false,
822 handle_alias_attribute },
823 { "no_instrument_function", 0, 0, true, false, false,
824 handle_no_instrument_function_attribute },
825 { "malloc", 0, 0, true, false, false,
826 handle_malloc_attribute },
827 { "no_stack_limit", 0, 0, true, false, false,
828 handle_no_limit_stack_attribute },
829 { "pure", 0, 0, true, false, false,
830 handle_pure_attribute },
831 { "deprecated", 0, 0, false, false, false,
832 handle_deprecated_attribute },
833 { "vector_size", 1, 1, false, true, false,
834 handle_vector_size_attribute },
835 { "visibility", 1, 1, true, false, false,
836 handle_visibility_attribute },
837 { "tls_model", 1, 1, true, false, false,
838 handle_tls_model_attribute },
839 { "nonnull", 0, -1, false, true, true,
840 handle_nonnull_attribute },
841 { "nothrow", 0, 0, true, false, false,
842 handle_nothrow_attribute },
843 { "may_alias", 0, 0, false, true, false, NULL },
844 { "cleanup", 1, 1, true, false, false,
845 handle_cleanup_attribute },
846 { "warn_unused_result", 0, 0, false, true, true,
847 handle_warn_unused_result_attribute },
848 { NULL, 0, 0, false, false, false, NULL }
851 /* Give the specifications for the format attributes, used by C and all
854 const struct attribute_spec c_common_format_attribute_table[] =
856 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
857 { "format", 3, 3, false, true, true,
858 handle_format_attribute },
859 { "format_arg", 1, 1, false, true, true,
860 handle_format_arg_attribute },
861 { NULL, 0, 0, false, false, false, NULL }
864 /* Record the start of an if-then, and record the start of it
865 for ambiguous else detection.
867 COND is the condition for the if-then statement.
869 IF_STMT is the statement node that has already been created for
870 this if-then statement. It is created before parsing the
871 condition to keep line number information accurate. */
874 c_expand_start_cond (tree cond, int compstmt_count, tree if_stmt)
876 /* Make sure there is enough space on the stack. */
877 if (if_stack_space == 0)
880 if_stack = xmalloc (10 * sizeof (if_elt));
882 else if (if_stack_space == if_stack_pointer)
884 if_stack_space += 10;
885 if_stack = xrealloc (if_stack, if_stack_space * sizeof (if_elt));
888 IF_COND (if_stmt) = cond;
891 /* Record this if statement. */
892 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
893 if_stack[if_stack_pointer].locus = input_location;
894 if_stack[if_stack_pointer].needs_warning = 0;
895 if_stack[if_stack_pointer].if_stmt = if_stmt;
899 /* Called after the then-clause for an if-statement is processed. */
904 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
905 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
908 /* Record the end of an if-then. Optionally warn if a nested
909 if statement had an ambiguous else clause. */
912 c_expand_end_cond (void)
915 if (if_stack[if_stack_pointer].needs_warning)
916 warning ("%Hsuggest explicit braces to avoid ambiguous `else'",
917 &if_stack[if_stack_pointer].locus);
918 last_expr_type = NULL_TREE;
921 /* Called between the then-clause and the else-clause
922 of an if-then-else. */
925 c_expand_start_else (void)
927 /* An ambiguous else warning must be generated for the enclosing if
928 statement, unless we see an else branch for that one, too. */
930 && if_stack_pointer > 1
931 && (if_stack[if_stack_pointer - 1].compstmt_count
932 == if_stack[if_stack_pointer - 2].compstmt_count))
933 if_stack[if_stack_pointer - 2].needs_warning = 1;
935 /* Even if a nested if statement had an else branch, it can't be
936 ambiguous if this one also has an else. So don't warn in that
937 case. Also don't warn for any if statements nested in this else. */
938 if_stack[if_stack_pointer - 1].needs_warning = 0;
939 if_stack[if_stack_pointer - 1].compstmt_count--;
942 /* Called after the else-clause for an if-statement is processed. */
947 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
948 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
951 /* Begin an if-statement. Returns a newly created IF_STMT if
954 Unlike the C++ front-end, we do not call add_stmt here; it is
955 probably safe to do so, but I am not very familiar with this
956 code so I am being extra careful not to change its behavior
957 beyond what is strictly necessary for correctness. */
960 c_begin_if_stmt (void)
963 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
967 /* Begin a while statement. Returns a newly created WHILE_STMT if
970 Unlike the C++ front-end, we do not call add_stmt here; it is
971 probably safe to do so, but I am not very familiar with this
972 code so I am being extra careful not to change its behavior
973 beyond what is strictly necessary for correctness. */
976 c_begin_while_stmt (void)
979 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
984 c_finish_while_stmt_cond (tree cond, tree while_stmt)
986 WHILE_COND (while_stmt) = cond;
989 /* Push current bindings for the function name VAR_DECLS. */
992 start_fname_decls (void)
995 tree saved = NULL_TREE;
997 for (ix = 0; fname_vars[ix].decl; ix++)
999 tree decl = *fname_vars[ix].decl;
1003 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
1004 *fname_vars[ix].decl = NULL_TREE;
1007 if (saved || saved_function_name_decls)
1008 /* Normally they'll have been NULL, so only push if we've got a
1009 stack, or they are non-NULL. */
1010 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1011 saved_function_name_decls);
1014 /* Finish up the current bindings, adding them into the
1015 current function's statement tree. This is done by wrapping the
1016 function's body in a COMPOUND_STMT containing these decls too. This
1017 must be done _before_ finish_stmt_tree is called. If there is no
1018 current function, we must be at file scope and no statements are
1019 involved. Pop the previous bindings. */
1022 finish_fname_decls (void)
1025 tree body = NULL_TREE;
1026 tree stack = saved_function_name_decls;
1028 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1029 body = chainon (TREE_VALUE (stack), body);
1033 /* They were called into existence, so add to statement tree. Add
1034 the DECL_STMTs inside the outermost scope. */
1035 tree *p = &DECL_SAVED_TREE (current_function_decl);
1036 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1037 while (TREE_CODE (*p) != COMPOUND_STMT)
1039 if (TREE_CODE (*p) == EXPR_STMT)
1040 p = &TREE_CHAIN (*p);
1042 p = &TREE_OPERAND(*p, 0);
1045 p = &COMPOUND_BODY (*p);
1046 if (TREE_CODE (*p) == SCOPE_STMT)
1047 p = &TREE_CHAIN (*p);
1049 body = chainon (body, *p);
1053 for (ix = 0; fname_vars[ix].decl; ix++)
1054 *fname_vars[ix].decl = NULL_TREE;
1058 /* We had saved values, restore them. */
1061 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1063 tree decl = TREE_PURPOSE (saved);
1064 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1066 *fname_vars[ix].decl = decl;
1068 stack = TREE_CHAIN (stack);
1070 saved_function_name_decls = stack;
1073 /* Return the text name of the current function, suitably prettified
1077 fname_as_string (int pretty_p)
1079 const char *name = "top level";
1088 if (current_function_decl)
1089 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
1094 /* Return the VAR_DECL for a const char array naming the current
1095 function. If the VAR_DECL has not yet been created, create it
1096 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1097 ID is its name (unfortunately C and C++ hold the RID values of
1098 keywords in different places, so we can't derive RID from ID in
1099 this language independent code. */
1102 fname_decl (unsigned int rid, tree id)
1105 tree decl = NULL_TREE;
1107 for (ix = 0; fname_vars[ix].decl; ix++)
1108 if (fname_vars[ix].rid == rid)
1111 decl = *fname_vars[ix].decl;
1114 tree saved_last_tree = last_tree;
1115 /* If a tree is built here, it would normally have the lineno of
1116 the current statement. Later this tree will be moved to the
1117 beginning of the function and this line number will be wrong.
1118 To avoid this problem set the lineno to 0 here; that prevents
1119 it from appearing in the RTL. */
1120 int saved_lineno = input_line;
1123 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1124 if (last_tree != saved_last_tree)
1126 /* We created some statement tree for the decl. This belongs
1127 at the start of the function, so remove it now and reinsert
1128 it after the function is complete. */
1129 tree stmts = TREE_CHAIN (saved_last_tree);
1131 TREE_CHAIN (saved_last_tree) = NULL_TREE;
1132 last_tree = saved_last_tree;
1133 saved_function_name_decls = tree_cons (decl, stmts,
1134 saved_function_name_decls);
1136 *fname_vars[ix].decl = decl;
1137 input_line = saved_lineno;
1139 if (!ix && !current_function_decl)
1140 pedwarn ("%J'%D' is not defined outside of function scope", decl, decl);
1145 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1148 fix_string_type (tree value)
1150 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1151 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1152 const int nchars_max = flag_isoc99 ? 4095 : 509;
1153 int length = TREE_STRING_LENGTH (value);
1156 /* Compute the number of elements, for the array type. */
1157 nchars = wide_flag ? length / wchar_bytes : length;
1159 if (pedantic && nchars - 1 > nchars_max && !c_dialect_cxx ())
1160 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1161 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1163 /* Create the array type for the string constant.
1164 -Wwrite-strings says make the string constant an array of const char
1165 so that copying it to a non-const pointer will get a warning.
1166 For C++, this is the standard behavior. */
1167 if (flag_const_strings)
1170 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1173 = build_array_type (elements,
1174 build_index_type (build_int_2 (nchars - 1, 0)));
1178 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1179 build_index_type (build_int_2 (nchars - 1, 0)));
1181 TREE_CONSTANT (value) = 1;
1182 TREE_READONLY (value) = 1;
1183 TREE_STATIC (value) = 1;
1187 /* Print a warning if a constant expression had overflow in folding.
1188 Invoke this function on every expression that the language
1189 requires to be a constant expression.
1190 Note the ANSI C standard says it is erroneous for a
1191 constant expression to overflow. */
1194 constant_expression_warning (tree value)
1196 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1197 || TREE_CODE (value) == VECTOR_CST
1198 || TREE_CODE (value) == COMPLEX_CST)
1199 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1200 pedwarn ("overflow in constant expression");
1203 /* Print a warning if an expression had overflow in folding.
1204 Invoke this function on every expression that
1205 (1) appears in the source code, and
1206 (2) might be a constant expression that overflowed, and
1207 (3) is not already checked by convert_and_check;
1208 however, do not invoke this function on operands of explicit casts. */
1211 overflow_warning (tree value)
1213 if ((TREE_CODE (value) == INTEGER_CST
1214 || (TREE_CODE (value) == COMPLEX_CST
1215 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1216 && TREE_OVERFLOW (value))
1218 TREE_OVERFLOW (value) = 0;
1219 if (skip_evaluation == 0)
1220 warning ("integer overflow in expression");
1222 else if ((TREE_CODE (value) == REAL_CST
1223 || (TREE_CODE (value) == COMPLEX_CST
1224 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1225 && TREE_OVERFLOW (value))
1227 TREE_OVERFLOW (value) = 0;
1228 if (skip_evaluation == 0)
1229 warning ("floating point overflow in expression");
1231 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1233 TREE_OVERFLOW (value) = 0;
1234 if (skip_evaluation == 0)
1235 warning ("vector overflow in expression");
1239 /* Print a warning if a large constant is truncated to unsigned,
1240 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1241 Invoke this function on every expression that might be implicitly
1242 converted to an unsigned type. */
1245 unsigned_conversion_warning (tree result, tree operand)
1247 tree type = TREE_TYPE (result);
1249 if (TREE_CODE (operand) == INTEGER_CST
1250 && TREE_CODE (type) == INTEGER_TYPE
1251 && TREE_UNSIGNED (type)
1252 && skip_evaluation == 0
1253 && !int_fits_type_p (operand, type))
1255 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1256 /* This detects cases like converting -129 or 256 to unsigned char. */
1257 warning ("large integer implicitly truncated to unsigned type");
1258 else if (warn_conversion)
1259 warning ("negative integer implicitly converted to unsigned type");
1263 /* Nonzero if constant C has a value that is permissible
1264 for type TYPE (an INTEGER_TYPE). */
1267 constant_fits_type_p (tree c, tree type)
1269 if (TREE_CODE (c) == INTEGER_CST)
1270 return int_fits_type_p (c, type);
1272 c = convert (type, c);
1273 return !TREE_OVERFLOW (c);
1276 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1277 Invoke this function on every expression that is converted implicitly,
1278 i.e. because of language rules and not because of an explicit cast. */
1281 convert_and_check (tree type, tree expr)
1283 tree t = convert (type, expr);
1284 if (TREE_CODE (t) == INTEGER_CST)
1286 if (TREE_OVERFLOW (t))
1288 TREE_OVERFLOW (t) = 0;
1290 /* Do not diagnose overflow in a constant expression merely
1291 because a conversion overflowed. */
1292 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1294 /* No warning for converting 0x80000000 to int. */
1295 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1296 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1297 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1298 /* If EXPR fits in the unsigned version of TYPE,
1299 don't warn unless pedantic. */
1301 || TREE_UNSIGNED (type)
1302 || ! constant_fits_type_p (expr,
1303 c_common_unsigned_type (type)))
1304 && skip_evaluation == 0)
1305 warning ("overflow in implicit constant conversion");
1308 unsigned_conversion_warning (t, expr);
1313 /* A node in a list that describes references to variables (EXPR), which are
1314 either read accesses if WRITER is zero, or write accesses, in which case
1315 WRITER is the parent of EXPR. */
1322 /* Used to implement a cache the results of a call to verify_tree. We only
1323 use this for SAVE_EXPRs. */
1326 struct tlist_cache *next;
1327 struct tlist *cache_before_sp;
1328 struct tlist *cache_after_sp;
1332 /* Obstack to use when allocating tlist structures, and corresponding
1334 static struct obstack tlist_obstack;
1335 static char *tlist_firstobj = 0;
1337 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1339 static struct tlist *warned_ids;
1340 /* SAVE_EXPRs need special treatment. We process them only once and then
1341 cache the results. */
1342 static struct tlist_cache *save_expr_cache;
1344 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1345 static void merge_tlist (struct tlist **, struct tlist *, int);
1346 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1347 static int warning_candidate_p (tree);
1348 static void warn_for_collisions (struct tlist *);
1349 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1350 static struct tlist *new_tlist (struct tlist *, tree, tree);
1351 static void verify_sequence_points (tree);
1353 /* Create a new struct tlist and fill in its fields. */
1354 static struct tlist *
1355 new_tlist (struct tlist *next, tree t, tree writer)
1358 l = obstack_alloc (&tlist_obstack, sizeof *l);
1365 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1366 is nonnull, we ignore any node we find which has a writer equal to it. */
1369 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1373 struct tlist *next = add->next;
1376 if (! exclude_writer || add->writer != exclude_writer)
1377 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1382 /* Merge the nodes of ADD into TO. This merging process is done so that for
1383 each variable that already exists in TO, no new node is added; however if
1384 there is a write access recorded in ADD, and an occurrence on TO is only
1385 a read access, then the occurrence in TO will be modified to record the
1389 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1391 struct tlist **end = to;
1394 end = &(*end)->next;
1400 struct tlist *next = add->next;
1402 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1403 if (tmp2->expr == add->expr)
1407 tmp2->writer = add->writer;
1411 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1412 end = &(*end)->next;
1419 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1420 references in list LIST conflict with it, excluding reads if ONLY writers
1424 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1429 /* Avoid duplicate warnings. */
1430 for (tmp = warned_ids; tmp; tmp = tmp->next)
1431 if (tmp->expr == written)
1436 if (list->expr == written
1437 && list->writer != writer
1438 && (! only_writes || list->writer))
1440 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1441 warning ("operation on `%s' may be undefined",
1442 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1448 /* Given a list LIST of references to variables, find whether any of these
1449 can cause conflicts due to missing sequence points. */
1452 warn_for_collisions (struct tlist *list)
1456 for (tmp = list; tmp; tmp = tmp->next)
1459 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1463 /* Return nonzero if X is a tree that can be verified by the sequence point
1466 warning_candidate_p (tree x)
1468 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1471 /* Walk the tree X, and record accesses to variables. If X is written by the
1472 parent tree, WRITER is the parent.
1473 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1474 expression or its only operand forces a sequence point, then everything up
1475 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1477 Once we return, we will have emitted warnings if any subexpression before
1478 such a sequence point could be undefined. On a higher level, however, the
1479 sequence point may not be relevant, and we'll merge the two lists.
1481 Example: (b++, a) + b;
1482 The call that processes the COMPOUND_EXPR will store the increment of B
1483 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1484 processes the PLUS_EXPR will need to merge the two lists so that
1485 eventually, all accesses end up on the same list (and we'll warn about the
1486 unordered subexpressions b++ and b.
1488 A note on merging. If we modify the former example so that our expression
1491 care must be taken not simply to add all three expressions into the final
1492 PNO_SP list. The function merge_tlist takes care of that by merging the
1493 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1494 way, so that no more than one access to B is recorded. */
1497 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1500 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1501 enum tree_code code;
1504 /* X may be NULL if it is the operand of an empty statement expression
1510 code = TREE_CODE (x);
1511 class = TREE_CODE_CLASS (code);
1513 if (warning_candidate_p (x))
1515 *pno_sp = new_tlist (*pno_sp, x, writer);
1525 case TRUTH_ANDIF_EXPR:
1526 case TRUTH_ORIF_EXPR:
1527 tmp_before = tmp_nosp = tmp_list3 = 0;
1528 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1529 warn_for_collisions (tmp_nosp);
1530 merge_tlist (pbefore_sp, tmp_before, 0);
1531 merge_tlist (pbefore_sp, tmp_nosp, 0);
1532 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1533 merge_tlist (pbefore_sp, tmp_list3, 0);
1537 tmp_before = tmp_list2 = 0;
1538 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1539 warn_for_collisions (tmp_list2);
1540 merge_tlist (pbefore_sp, tmp_before, 0);
1541 merge_tlist (pbefore_sp, tmp_list2, 1);
1543 tmp_list3 = tmp_nosp = 0;
1544 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1545 warn_for_collisions (tmp_nosp);
1546 merge_tlist (pbefore_sp, tmp_list3, 0);
1548 tmp_list3 = tmp_list2 = 0;
1549 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1550 warn_for_collisions (tmp_list2);
1551 merge_tlist (pbefore_sp, tmp_list3, 0);
1552 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1553 two first, to avoid warning for (a ? b++ : b++). */
1554 merge_tlist (&tmp_nosp, tmp_list2, 0);
1555 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1558 case PREDECREMENT_EXPR:
1559 case PREINCREMENT_EXPR:
1560 case POSTDECREMENT_EXPR:
1561 case POSTINCREMENT_EXPR:
1562 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1566 tmp_before = tmp_nosp = tmp_list3 = 0;
1567 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1568 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1569 /* Expressions inside the LHS are not ordered wrt. the sequence points
1570 in the RHS. Example:
1572 Despite the fact that the modification of "a" is in the before_sp
1573 list (tmp_before), it conflicts with the use of "a" in the LHS.
1574 We can handle this by adding the contents of tmp_list3
1575 to those of tmp_before, and redoing the collision warnings for that
1577 add_tlist (&tmp_before, tmp_list3, x, 1);
1578 warn_for_collisions (tmp_before);
1579 /* Exclude the LHS itself here; we first have to merge it into the
1580 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1581 didn't exclude the LHS, we'd get it twice, once as a read and once
1583 add_tlist (pno_sp, tmp_list3, x, 0);
1584 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1586 merge_tlist (pbefore_sp, tmp_before, 0);
1587 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1588 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1589 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1593 /* We need to warn about conflicts among arguments and conflicts between
1594 args and the function address. Side effects of the function address,
1595 however, are not ordered by the sequence point of the call. */
1596 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1597 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1598 if (TREE_OPERAND (x, 1))
1599 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1600 merge_tlist (&tmp_list3, tmp_list2, 0);
1601 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1602 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1603 warn_for_collisions (tmp_before);
1604 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1608 /* Scan all the list, e.g. indices of multi dimensional array. */
1611 tmp_before = tmp_nosp = 0;
1612 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1613 merge_tlist (&tmp_nosp, tmp_before, 0);
1614 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1621 struct tlist_cache *t;
1622 for (t = save_expr_cache; t; t = t->next)
1628 t = obstack_alloc (&tlist_obstack, sizeof *t);
1629 t->next = save_expr_cache;
1631 save_expr_cache = t;
1633 tmp_before = tmp_nosp = 0;
1634 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1635 warn_for_collisions (tmp_nosp);
1640 struct tlist *t = tmp_nosp;
1642 merge_tlist (&tmp_list3, t, 0);
1644 t->cache_before_sp = tmp_before;
1645 t->cache_after_sp = tmp_list3;
1647 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1648 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1657 if (first_rtl_op (code) == 0)
1659 x = TREE_OPERAND (x, 0);
1675 int max = first_rtl_op (TREE_CODE (x));
1676 for (lp = 0; lp < max; lp++)
1678 tmp_before = tmp_nosp = 0;
1679 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1680 merge_tlist (&tmp_nosp, tmp_before, 0);
1681 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1688 /* Try to warn for undefined behavior in EXPR due to missing sequence
1692 verify_sequence_points (tree expr)
1694 struct tlist *before_sp = 0, *after_sp = 0;
1697 save_expr_cache = 0;
1698 if (tlist_firstobj == 0)
1700 gcc_obstack_init (&tlist_obstack);
1701 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1704 verify_tree (expr, &before_sp, &after_sp, 0);
1705 warn_for_collisions (after_sp);
1706 obstack_free (&tlist_obstack, tlist_firstobj);
1710 c_expand_expr_stmt (tree expr)
1712 /* Do default conversion if safe and possibly important,
1713 in case within ({...}). */
1714 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1715 && (flag_isoc99 || lvalue_p (expr)))
1716 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1717 expr = default_conversion (expr);
1719 if (warn_sequence_point)
1720 verify_sequence_points (expr);
1722 if (TREE_TYPE (expr) != error_mark_node
1723 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1724 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1725 error ("expression statement has incomplete type");
1727 last_expr_type = TREE_TYPE (expr);
1728 return add_stmt (build_stmt (EXPR_STMT, expr));
1731 /* Validate the expression after `case' and apply default promotions. */
1734 check_case_value (tree value)
1736 if (value == NULL_TREE)
1739 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1740 STRIP_TYPE_NOPS (value);
1741 /* In C++, the following is allowed:
1744 switch (...) { case i: ... }
1746 So, we try to reduce the VALUE to a constant that way. */
1747 if (c_dialect_cxx ())
1749 value = decl_constant_value (value);
1750 STRIP_TYPE_NOPS (value);
1751 value = fold (value);
1754 if (TREE_CODE (value) != INTEGER_CST
1755 && value != error_mark_node)
1757 error ("case label does not reduce to an integer constant");
1758 value = error_mark_node;
1761 /* Promote char or short to int. */
1762 value = default_conversion (value);
1764 constant_expression_warning (value);
1769 /* Return an integer type with BITS bits of precision,
1770 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1773 c_common_type_for_size (unsigned int bits, int unsignedp)
1775 if (bits == TYPE_PRECISION (integer_type_node))
1776 return unsignedp ? unsigned_type_node : integer_type_node;
1778 if (bits == TYPE_PRECISION (signed_char_type_node))
1779 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1781 if (bits == TYPE_PRECISION (short_integer_type_node))
1782 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1784 if (bits == TYPE_PRECISION (long_integer_type_node))
1785 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1787 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1788 return (unsignedp ? long_long_unsigned_type_node
1789 : long_long_integer_type_node);
1791 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1792 return (unsignedp ? widest_unsigned_literal_type_node
1793 : widest_integer_literal_type_node);
1795 if (bits <= TYPE_PRECISION (intQI_type_node))
1796 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1798 if (bits <= TYPE_PRECISION (intHI_type_node))
1799 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1801 if (bits <= TYPE_PRECISION (intSI_type_node))
1802 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1804 if (bits <= TYPE_PRECISION (intDI_type_node))
1805 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1810 /* Used for communication between c_common_type_for_mode and
1811 c_register_builtin_type. */
1812 static GTY(()) tree registered_builtin_types;
1814 /* Return a data type that has machine mode MODE.
1815 If the mode is an integer,
1816 then UNSIGNEDP selects between signed and unsigned types. */
1819 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1823 if (mode == TYPE_MODE (integer_type_node))
1824 return unsignedp ? unsigned_type_node : integer_type_node;
1826 if (mode == TYPE_MODE (signed_char_type_node))
1827 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1829 if (mode == TYPE_MODE (short_integer_type_node))
1830 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1832 if (mode == TYPE_MODE (long_integer_type_node))
1833 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1835 if (mode == TYPE_MODE (long_long_integer_type_node))
1836 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1838 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1839 return unsignedp ? widest_unsigned_literal_type_node
1840 : widest_integer_literal_type_node;
1843 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1846 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1849 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1852 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1854 #if HOST_BITS_PER_WIDE_INT >= 64
1855 if (mode == TYPE_MODE (intTI_type_node))
1856 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1859 if (mode == TYPE_MODE (float_type_node))
1860 return float_type_node;
1862 if (mode == TYPE_MODE (double_type_node))
1863 return double_type_node;
1865 if (mode == TYPE_MODE (long_double_type_node))
1866 return long_double_type_node;
1868 if (mode == TYPE_MODE (void_type_node))
1869 return void_type_node;
1871 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1872 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1874 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1875 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1877 if (VECTOR_MODE_P (mode))
1879 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1880 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1881 if (inner_type != NULL_TREE)
1882 return build_vector_type_for_mode (inner_type, mode);
1885 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1886 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1887 return TREE_VALUE (t);
1892 /* Return an unsigned type the same as TYPE in other respects. */
1894 c_common_unsigned_type (tree type)
1896 tree type1 = TYPE_MAIN_VARIANT (type);
1897 if (type1 == signed_char_type_node || type1 == char_type_node)
1898 return unsigned_char_type_node;
1899 if (type1 == integer_type_node)
1900 return unsigned_type_node;
1901 if (type1 == short_integer_type_node)
1902 return short_unsigned_type_node;
1903 if (type1 == long_integer_type_node)
1904 return long_unsigned_type_node;
1905 if (type1 == long_long_integer_type_node)
1906 return long_long_unsigned_type_node;
1907 if (type1 == widest_integer_literal_type_node)
1908 return widest_unsigned_literal_type_node;
1909 #if HOST_BITS_PER_WIDE_INT >= 64
1910 if (type1 == intTI_type_node)
1911 return unsigned_intTI_type_node;
1913 if (type1 == intDI_type_node)
1914 return unsigned_intDI_type_node;
1915 if (type1 == intSI_type_node)
1916 return unsigned_intSI_type_node;
1917 if (type1 == intHI_type_node)
1918 return unsigned_intHI_type_node;
1919 if (type1 == intQI_type_node)
1920 return unsigned_intQI_type_node;
1922 return c_common_signed_or_unsigned_type (1, type);
1925 /* Return a signed type the same as TYPE in other respects. */
1928 c_common_signed_type (tree type)
1930 tree type1 = TYPE_MAIN_VARIANT (type);
1931 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1932 return signed_char_type_node;
1933 if (type1 == unsigned_type_node)
1934 return integer_type_node;
1935 if (type1 == short_unsigned_type_node)
1936 return short_integer_type_node;
1937 if (type1 == long_unsigned_type_node)
1938 return long_integer_type_node;
1939 if (type1 == long_long_unsigned_type_node)
1940 return long_long_integer_type_node;
1941 if (type1 == widest_unsigned_literal_type_node)
1942 return widest_integer_literal_type_node;
1943 #if HOST_BITS_PER_WIDE_INT >= 64
1944 if (type1 == unsigned_intTI_type_node)
1945 return intTI_type_node;
1947 if (type1 == unsigned_intDI_type_node)
1948 return intDI_type_node;
1949 if (type1 == unsigned_intSI_type_node)
1950 return intSI_type_node;
1951 if (type1 == unsigned_intHI_type_node)
1952 return intHI_type_node;
1953 if (type1 == unsigned_intQI_type_node)
1954 return intQI_type_node;
1956 return c_common_signed_or_unsigned_type (0, type);
1959 /* Return a type the same as TYPE except unsigned or
1960 signed according to UNSIGNEDP. */
1963 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1965 if (! INTEGRAL_TYPE_P (type)
1966 || TREE_UNSIGNED (type) == unsignedp)
1969 /* Must check the mode of the types, not the precision. Enumeral types
1970 in C++ have precision set to match their range, but may use a wider
1971 mode to match an ABI. If we change modes, we may wind up with bad
1974 if (TYPE_MODE (type) == TYPE_MODE (signed_char_type_node))
1975 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1976 if (TYPE_MODE (type) == TYPE_MODE (integer_type_node))
1977 return unsignedp ? unsigned_type_node : integer_type_node;
1978 if (TYPE_MODE (type) == TYPE_MODE (short_integer_type_node))
1979 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1980 if (TYPE_MODE (type) == TYPE_MODE (long_integer_type_node))
1981 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1982 if (TYPE_MODE (type) == TYPE_MODE (long_long_integer_type_node))
1983 return (unsignedp ? long_long_unsigned_type_node
1984 : long_long_integer_type_node);
1985 if (TYPE_MODE (type) == TYPE_MODE (widest_integer_literal_type_node))
1986 return (unsignedp ? widest_unsigned_literal_type_node
1987 : widest_integer_literal_type_node);
1989 #if HOST_BITS_PER_WIDE_INT >= 64
1990 if (TYPE_MODE (type) == TYPE_MODE (intTI_type_node))
1991 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1993 if (TYPE_MODE (type) == TYPE_MODE (intDI_type_node))
1994 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1995 if (TYPE_MODE (type) == TYPE_MODE (intSI_type_node))
1996 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1997 if (TYPE_MODE (type) == TYPE_MODE (intHI_type_node))
1998 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1999 if (TYPE_MODE (type) == TYPE_MODE (intQI_type_node))
2000 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2005 /* The C version of the register_builtin_type langhook. */
2008 c_register_builtin_type (tree type, const char* name)
2012 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2013 DECL_ARTIFICIAL (decl) = 1;
2014 if (!TYPE_NAME (type))
2015 TYPE_NAME (type) = decl;
2018 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2022 /* Return the minimum number of bits needed to represent VALUE in a
2023 signed or unsigned type, UNSIGNEDP says which. */
2026 min_precision (tree value, int unsignedp)
2030 /* If the value is negative, compute its negative minus 1. The latter
2031 adjustment is because the absolute value of the largest negative value
2032 is one larger than the largest positive value. This is equivalent to
2033 a bit-wise negation, so use that operation instead. */
2035 if (tree_int_cst_sgn (value) < 0)
2036 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2038 /* Return the number of bits needed, taking into account the fact
2039 that we need one more bit for a signed than unsigned type. */
2041 if (integer_zerop (value))
2044 log = tree_floor_log2 (value);
2046 return log + 1 + ! unsignedp;
2049 /* Print an error message for invalid operands to arith operation
2050 CODE. NOP_EXPR is used as a special case (see
2051 c_common_truthvalue_conversion). */
2054 binary_op_error (enum tree_code code)
2061 error ("invalid truth-value expression");
2065 opname = "+"; break;
2067 opname = "-"; break;
2069 opname = "*"; break;
2071 opname = "max"; break;
2073 opname = "min"; break;
2075 opname = "=="; break;
2077 opname = "!="; break;
2079 opname = "<="; break;
2081 opname = ">="; break;
2083 opname = "<"; break;
2085 opname = ">"; break;
2087 opname = "<<"; break;
2089 opname = ">>"; break;
2090 case TRUNC_MOD_EXPR:
2091 case FLOOR_MOD_EXPR:
2092 opname = "%"; break;
2093 case TRUNC_DIV_EXPR:
2094 case FLOOR_DIV_EXPR:
2095 opname = "/"; break;
2097 opname = "&"; break;
2099 opname = "|"; break;
2100 case TRUTH_ANDIF_EXPR:
2101 opname = "&&"; break;
2102 case TRUTH_ORIF_EXPR:
2103 opname = "||"; break;
2105 opname = "^"; break;
2108 opname = "rotate"; break;
2110 opname = "unknown"; break;
2112 error ("invalid operands to binary %s", opname);
2115 /* Subroutine of build_binary_op, used for comparison operations.
2116 See if the operands have both been converted from subword integer types
2117 and, if so, perhaps change them both back to their original type.
2118 This function is also responsible for converting the two operands
2119 to the proper common type for comparison.
2121 The arguments of this function are all pointers to local variables
2122 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2123 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2125 If this function returns nonzero, it means that the comparison has
2126 a constant value. What this function returns is an expression for
2130 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2131 enum tree_code *rescode_ptr)
2134 tree op0 = *op0_ptr;
2135 tree op1 = *op1_ptr;
2136 int unsignedp0, unsignedp1;
2138 tree primop0, primop1;
2139 enum tree_code code = *rescode_ptr;
2141 /* Throw away any conversions to wider types
2142 already present in the operands. */
2144 primop0 = get_narrower (op0, &unsignedp0);
2145 primop1 = get_narrower (op1, &unsignedp1);
2147 /* Handle the case that OP0 does not *contain* a conversion
2148 but it *requires* conversion to FINAL_TYPE. */
2150 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2151 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2152 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2153 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2155 /* If one of the operands must be floated, we cannot optimize. */
2156 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2157 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2159 /* If first arg is constant, swap the args (changing operation
2160 so value is preserved), for canonicalization. Don't do this if
2161 the second arg is 0. */
2163 if (TREE_CONSTANT (primop0)
2164 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2167 int temi = unsignedp0;
2175 unsignedp0 = unsignedp1;
2198 *rescode_ptr = code;
2201 /* If comparing an integer against a constant more bits wide,
2202 maybe we can deduce a value of 1 or 0 independent of the data.
2203 Or else truncate the constant now
2204 rather than extend the variable at run time.
2206 This is only interesting if the constant is the wider arg.
2207 Also, it is not safe if the constant is unsigned and the
2208 variable arg is signed, since in this case the variable
2209 would be sign-extended and then regarded as unsigned.
2210 Our technique fails in this case because the lowest/highest
2211 possible unsigned results don't follow naturally from the
2212 lowest/highest possible values of the variable operand.
2213 For just EQ_EXPR and NE_EXPR there is another technique that
2214 could be used: see if the constant can be faithfully represented
2215 in the other operand's type, by truncating it and reextending it
2216 and see if that preserves the constant's value. */
2218 if (!real1 && !real2
2219 && TREE_CODE (primop1) == INTEGER_CST
2220 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2222 int min_gt, max_gt, min_lt, max_lt;
2223 tree maxval, minval;
2224 /* 1 if comparison is nominally unsigned. */
2225 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2228 type = c_common_signed_or_unsigned_type (unsignedp0,
2229 TREE_TYPE (primop0));
2231 /* In C, if TYPE is an enumeration, then we need to get its
2232 min/max values from it's underlying integral type, not the
2233 enumerated type itself. In C++, TYPE_MAX_VALUE and
2234 TYPE_MIN_VALUE have already been set correctly on the
2235 enumeration type. */
2236 if (!c_dialect_cxx() && TREE_CODE (type) == ENUMERAL_TYPE)
2237 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2239 maxval = TYPE_MAX_VALUE (type);
2240 minval = TYPE_MIN_VALUE (type);
2242 if (unsignedp && !unsignedp0)
2243 *restype_ptr = c_common_signed_type (*restype_ptr);
2245 if (TREE_TYPE (primop1) != *restype_ptr)
2246 primop1 = convert (*restype_ptr, primop1);
2247 if (type != *restype_ptr)
2249 minval = convert (*restype_ptr, minval);
2250 maxval = convert (*restype_ptr, maxval);
2253 if (unsignedp && unsignedp0)
2255 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2256 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2257 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2258 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2262 min_gt = INT_CST_LT (primop1, minval);
2263 max_gt = INT_CST_LT (primop1, maxval);
2264 min_lt = INT_CST_LT (minval, primop1);
2265 max_lt = INT_CST_LT (maxval, primop1);
2269 /* This used to be a switch, but Genix compiler can't handle that. */
2270 if (code == NE_EXPR)
2272 if (max_lt || min_gt)
2273 val = truthvalue_true_node;
2275 else if (code == EQ_EXPR)
2277 if (max_lt || min_gt)
2278 val = truthvalue_false_node;
2280 else if (code == LT_EXPR)
2283 val = truthvalue_true_node;
2285 val = truthvalue_false_node;
2287 else if (code == GT_EXPR)
2290 val = truthvalue_true_node;
2292 val = truthvalue_false_node;
2294 else if (code == LE_EXPR)
2297 val = truthvalue_true_node;
2299 val = truthvalue_false_node;
2301 else if (code == GE_EXPR)
2304 val = truthvalue_true_node;
2306 val = truthvalue_false_node;
2309 /* If primop0 was sign-extended and unsigned comparison specd,
2310 we did a signed comparison above using the signed type bounds.
2311 But the comparison we output must be unsigned.
2313 Also, for inequalities, VAL is no good; but if the signed
2314 comparison had *any* fixed result, it follows that the
2315 unsigned comparison just tests the sign in reverse
2316 (positive values are LE, negative ones GE).
2317 So we can generate an unsigned comparison
2318 against an extreme value of the signed type. */
2320 if (unsignedp && !unsignedp0)
2327 primop1 = TYPE_MIN_VALUE (type);
2333 primop1 = TYPE_MAX_VALUE (type);
2340 type = c_common_unsigned_type (type);
2343 if (TREE_CODE (primop0) != INTEGER_CST)
2345 if (val == truthvalue_false_node)
2346 warning ("comparison is always false due to limited range of data type");
2347 if (val == truthvalue_true_node)
2348 warning ("comparison is always true due to limited range of data type");
2353 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2354 if (TREE_SIDE_EFFECTS (primop0))
2355 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2359 /* Value is not predetermined, but do the comparison
2360 in the type of the operand that is not constant.
2361 TYPE is already properly set. */
2363 else if (real1 && real2
2364 && (TYPE_PRECISION (TREE_TYPE (primop0))
2365 == TYPE_PRECISION (TREE_TYPE (primop1))))
2366 type = TREE_TYPE (primop0);
2368 /* If args' natural types are both narrower than nominal type
2369 and both extend in the same manner, compare them
2370 in the type of the wider arg.
2371 Otherwise must actually extend both to the nominal
2372 common type lest different ways of extending
2374 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2376 else if (unsignedp0 == unsignedp1 && real1 == real2
2377 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2378 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2380 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2381 type = c_common_signed_or_unsigned_type (unsignedp0
2382 || TREE_UNSIGNED (*restype_ptr),
2384 /* Make sure shorter operand is extended the right way
2385 to match the longer operand. */
2387 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2388 TREE_TYPE (primop0)),
2391 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2392 TREE_TYPE (primop1)),
2397 /* Here we must do the comparison on the nominal type
2398 using the args exactly as we received them. */
2399 type = *restype_ptr;
2403 if (!real1 && !real2 && integer_zerop (primop1)
2404 && TREE_UNSIGNED (*restype_ptr))
2410 /* All unsigned values are >= 0, so we warn if extra warnings
2411 are requested. However, if OP0 is a constant that is
2412 >= 0, the signedness of the comparison isn't an issue,
2413 so suppress the warning. */
2414 if (extra_warnings && !in_system_header
2415 && ! (TREE_CODE (primop0) == INTEGER_CST
2416 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2418 warning ("comparison of unsigned expression >= 0 is always true");
2419 value = truthvalue_true_node;
2423 if (extra_warnings && !in_system_header
2424 && ! (TREE_CODE (primop0) == INTEGER_CST
2425 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2427 warning ("comparison of unsigned expression < 0 is always false");
2428 value = truthvalue_false_node;
2437 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2438 if (TREE_SIDE_EFFECTS (primop0))
2439 return build (COMPOUND_EXPR, TREE_TYPE (value),
2446 *op0_ptr = convert (type, primop0);
2447 *op1_ptr = convert (type, primop1);
2449 *restype_ptr = truthvalue_type_node;
2454 /* Return a tree for the sum or difference (RESULTCODE says which)
2455 of pointer PTROP and integer INTOP. */
2458 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2465 /* The result is a pointer of the same type that is being added. */
2467 tree result_type = TREE_TYPE (ptrop);
2469 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2471 if (pedantic || warn_pointer_arith)
2472 pedwarn ("pointer of type `void *' used in arithmetic");
2473 size_exp = integer_one_node;
2475 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2477 if (pedantic || warn_pointer_arith)
2478 pedwarn ("pointer to a function used in arithmetic");
2479 size_exp = integer_one_node;
2481 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2483 if (pedantic || warn_pointer_arith)
2484 pedwarn ("pointer to member function used in arithmetic");
2485 size_exp = integer_one_node;
2487 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2489 if (pedantic || warn_pointer_arith)
2490 pedwarn ("pointer to a member used in arithmetic");
2491 size_exp = integer_one_node;
2494 size_exp = size_in_bytes (TREE_TYPE (result_type));
2496 /* If what we are about to multiply by the size of the elements
2497 contains a constant term, apply distributive law
2498 and multiply that constant term separately.
2499 This helps produce common subexpressions. */
2501 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2502 && ! TREE_CONSTANT (intop)
2503 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2504 && TREE_CONSTANT (size_exp)
2505 /* If the constant comes from pointer subtraction,
2506 skip this optimization--it would cause an error. */
2507 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2508 /* If the constant is unsigned, and smaller than the pointer size,
2509 then we must skip this optimization. This is because it could cause
2510 an overflow error if the constant is negative but INTOP is not. */
2511 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2512 || (TYPE_PRECISION (TREE_TYPE (intop))
2513 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2515 enum tree_code subcode = resultcode;
2516 tree int_type = TREE_TYPE (intop);
2517 if (TREE_CODE (intop) == MINUS_EXPR)
2518 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2519 /* Convert both subexpression types to the type of intop,
2520 because weird cases involving pointer arithmetic
2521 can result in a sum or difference with different type args. */
2522 ptrop = build_binary_op (subcode, ptrop,
2523 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2524 intop = convert (int_type, TREE_OPERAND (intop, 0));
2527 /* Convert the integer argument to a type the same size as sizetype
2528 so the multiply won't overflow spuriously. */
2530 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2531 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2532 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2533 TREE_UNSIGNED (sizetype)), intop);
2535 /* Replace the integer argument with a suitable product by the object size.
2536 Do this multiplication as signed, then convert to the appropriate
2537 pointer type (actually unsigned integral). */
2539 intop = convert (result_type,
2540 build_binary_op (MULT_EXPR, intop,
2541 convert (TREE_TYPE (intop), size_exp), 1));
2543 /* Create the sum or difference. */
2545 result = build (resultcode, result_type, ptrop, intop);
2547 folded = fold (result);
2548 if (folded == result)
2549 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2553 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2554 or validate its data type for an `if' or `while' statement or ?..: exp.
2556 This preparation consists of taking the ordinary
2557 representation of an expression expr and producing a valid tree
2558 boolean expression describing whether expr is nonzero. We could
2559 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2560 but we optimize comparisons, &&, ||, and !.
2562 The resulting type should always be `truthvalue_type_node'. */
2565 c_common_truthvalue_conversion (tree expr)
2567 if (TREE_CODE (expr) == ERROR_MARK)
2570 if (TREE_CODE (expr) == FUNCTION_DECL)
2571 expr = build_unary_op (ADDR_EXPR, expr, 0);
2573 switch (TREE_CODE (expr))
2576 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2577 case TRUTH_ANDIF_EXPR:
2578 case TRUTH_ORIF_EXPR:
2579 case TRUTH_AND_EXPR:
2581 case TRUTH_XOR_EXPR:
2582 case TRUTH_NOT_EXPR:
2583 TREE_TYPE (expr) = truthvalue_type_node;
2590 return integer_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2593 return real_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2597 if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2598 && ! DECL_WEAK (TREE_OPERAND (expr, 0)))
2600 /* Common Ada/Pascal programmer's mistake. We always warn
2601 about this since it is so bad. */
2602 warning ("the address of `%D', will always evaluate as `true'",
2603 TREE_OPERAND (expr, 0));
2604 return truthvalue_true_node;
2607 /* If we are taking the address of an external decl, it might be
2608 zero if it is weak, so we cannot optimize. */
2609 if (DECL_P (TREE_OPERAND (expr, 0))
2610 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2613 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2614 return build (COMPOUND_EXPR, truthvalue_type_node,
2615 TREE_OPERAND (expr, 0), truthvalue_true_node);
2617 return truthvalue_true_node;
2621 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2622 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2623 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)),
2624 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2630 /* These don't change whether an object is nonzero or zero. */
2631 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2635 /* These don't change whether an object is zero or nonzero, but
2636 we can't ignore them if their second arg has side-effects. */
2637 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2638 return build (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1),
2639 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)));
2641 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2644 /* Distribute the conversion into the arms of a COND_EXPR. */
2645 return fold (build (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0),
2646 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2647 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 2))));
2650 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2651 since that affects how `default_conversion' will behave. */
2652 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2653 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2655 /* Fall through.... */
2657 /* If this is widening the argument, we can ignore it. */
2658 if (TYPE_PRECISION (TREE_TYPE (expr))
2659 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2660 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2664 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2665 aren't guaranteed to the be same for modes that can represent
2666 infinity, since if x and y are both +infinity, or both
2667 -infinity, then x - y is not a number.
2669 Note that this transformation is safe when x or y is NaN.
2670 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2672 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2674 /* Fall through.... */
2676 /* This and MINUS_EXPR can be changed into a comparison of the
2678 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2679 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2680 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2681 TREE_OPERAND (expr, 1), 1);
2682 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2683 fold (build1 (NOP_EXPR,
2684 TREE_TYPE (TREE_OPERAND (expr, 0)),
2685 TREE_OPERAND (expr, 1))), 1);
2688 if (integer_onep (TREE_OPERAND (expr, 1))
2689 && TREE_TYPE (expr) != truthvalue_type_node)
2690 /* Using convert here would cause infinite recursion. */
2691 return build1 (NOP_EXPR, truthvalue_type_node, expr);
2695 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2696 warning ("suggest parentheses around assignment used as truth value");
2703 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2705 tree t = save_expr (expr);
2706 return (build_binary_op
2707 ((TREE_SIDE_EFFECTS (expr)
2708 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2709 lang_hooks.truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2710 lang_hooks.truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2714 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2717 static tree builtin_function_2 (const char *, const char *, tree, tree,
2718 int, enum built_in_class, int, int,
2721 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2722 down to the element type of an array. */
2725 c_build_qualified_type (tree type, int type_quals)
2727 if (type == error_mark_node)
2730 if (TREE_CODE (type) == ARRAY_TYPE)
2731 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2733 TYPE_DOMAIN (type));
2735 /* A restrict-qualified pointer type must be a pointer to object or
2736 incomplete type. Note that the use of POINTER_TYPE_P also allows
2737 REFERENCE_TYPEs, which is appropriate for C++. */
2738 if ((type_quals & TYPE_QUAL_RESTRICT)
2739 && (!POINTER_TYPE_P (type)
2740 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2742 error ("invalid use of `restrict'");
2743 type_quals &= ~TYPE_QUAL_RESTRICT;
2746 return build_qualified_type (type, type_quals);
2749 /* Apply the TYPE_QUALS to the new DECL. */
2752 c_apply_type_quals_to_decl (int type_quals, tree decl)
2754 tree type = TREE_TYPE (decl);
2756 if (type == error_mark_node)
2759 if (((type_quals & TYPE_QUAL_CONST)
2760 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2761 /* An object declared 'const' is only readonly after it is
2762 initialized. We don't have any way of expressing this currently,
2763 so we need to be conservative and unset TREE_READONLY for types
2764 with constructors. Otherwise aliasing code will ignore stores in
2765 an inline constructor. */
2766 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2767 TREE_READONLY (decl) = 1;
2768 if (type_quals & TYPE_QUAL_VOLATILE)
2770 TREE_SIDE_EFFECTS (decl) = 1;
2771 TREE_THIS_VOLATILE (decl) = 1;
2773 if (type_quals & TYPE_QUAL_RESTRICT)
2775 while (type && TREE_CODE (type) == ARRAY_TYPE)
2776 /* Allow 'restrict' on arrays of pointers.
2777 FIXME currently we just ignore it. */
2778 type = TREE_TYPE (type);
2780 || !POINTER_TYPE_P (type)
2781 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2782 error ("invalid use of `restrict'");
2783 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2784 /* Indicate we need to make a unique alias set for this pointer.
2785 We can't do it here because it might be pointing to an
2787 DECL_POINTER_ALIAS_SET (decl) = -2;
2791 /* Return the typed-based alias set for T, which may be an expression
2792 or a type. Return -1 if we don't do anything special. */
2795 c_common_get_alias_set (tree t)
2799 /* Permit type-punning when accessing a union, provided the access
2800 is directly through the union. For example, this code does not
2801 permit taking the address of a union member and then storing
2802 through it. Even the type-punning allowed here is a GCC
2803 extension, albeit a common and useful one; the C standard says
2804 that such accesses have implementation-defined behavior. */
2806 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2807 u = TREE_OPERAND (u, 0))
2808 if (TREE_CODE (u) == COMPONENT_REF
2809 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2812 /* That's all the expressions we handle specially. */
2816 /* The C standard guarantees that any object may be accessed via an
2817 lvalue that has character type. */
2818 if (t == char_type_node
2819 || t == signed_char_type_node
2820 || t == unsigned_char_type_node)
2823 /* If it has the may_alias attribute, it can alias anything. */
2824 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2827 /* The C standard specifically allows aliasing between signed and
2828 unsigned variants of the same type. We treat the signed
2829 variant as canonical. */
2830 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2832 tree t1 = c_common_signed_type (t);
2834 /* t1 == t can happen for boolean nodes which are always unsigned. */
2836 return get_alias_set (t1);
2838 else if (POINTER_TYPE_P (t))
2842 /* Unfortunately, there is no canonical form of a pointer type.
2843 In particular, if we have `typedef int I', then `int *', and
2844 `I *' are different types. So, we have to pick a canonical
2845 representative. We do this below.
2847 Technically, this approach is actually more conservative that
2848 it needs to be. In particular, `const int *' and `int *'
2849 should be in different alias sets, according to the C and C++
2850 standard, since their types are not the same, and so,
2851 technically, an `int **' and `const int **' cannot point at
2854 But, the standard is wrong. In particular, this code is
2859 const int* const* cipp = ipp;
2861 And, it doesn't make sense for that to be legal unless you
2862 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2863 the pointed-to types. This issue has been reported to the
2865 t1 = build_type_no_quals (t);
2867 return get_alias_set (t1);
2873 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2874 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2875 flag controls whether we should diagnose possibly ill-formed
2876 constructs or not. */
2878 c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
2880 const char *op_name;
2882 enum tree_code type_code = TREE_CODE (type);
2884 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
2885 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
2887 if (type_code == FUNCTION_TYPE)
2889 if (op == SIZEOF_EXPR)
2891 if (complain && (pedantic || warn_pointer_arith))
2892 pedwarn ("invalid application of `sizeof' to a function type");
2893 value = size_one_node;
2896 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2898 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2900 if (type_code == VOID_TYPE
2901 && complain && (pedantic || warn_pointer_arith))
2902 pedwarn ("invalid application of `%s' to a void type", op_name);
2903 value = size_one_node;
2905 else if (!COMPLETE_TYPE_P (type))
2908 error ("invalid application of `%s' to an incomplete type", op_name);
2909 value = size_zero_node;
2913 if (op == SIZEOF_EXPR)
2914 /* Convert in case a char is more than one unit. */
2915 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2916 size_int (TYPE_PRECISION (char_type_node)
2919 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2922 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2923 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2924 never happen. However, this node should really have type
2925 `size_t', which is just a typedef for an ordinary integer type. */
2926 value = fold (build1 (NOP_EXPR, size_type_node, value));
2927 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
2932 /* Implement the __alignof keyword: Return the minimum required
2933 alignment of EXPR, measured in bytes. For VAR_DECL's and
2934 FIELD_DECL's return DECL_ALIGN (which can be set from an
2935 "aligned" __attribute__ specification). */
2938 c_alignof_expr (tree expr)
2942 if (TREE_CODE (expr) == VAR_DECL)
2943 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2945 else if (TREE_CODE (expr) == COMPONENT_REF
2946 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2948 error ("`__alignof' applied to a bit-field");
2951 else if (TREE_CODE (expr) == COMPONENT_REF
2952 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2953 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2955 else if (TREE_CODE (expr) == INDIRECT_REF)
2957 tree t = TREE_OPERAND (expr, 0);
2959 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2961 while (TREE_CODE (t) == NOP_EXPR
2962 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2966 t = TREE_OPERAND (t, 0);
2967 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2968 if (thisalign > bestalign)
2969 best = t, bestalign = thisalign;
2971 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2974 return c_alignof (TREE_TYPE (expr));
2976 return fold (build1 (NOP_EXPR, size_type_node, t));
2979 /* Handle C and C++ default attributes. */
2981 enum built_in_attribute
2983 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2984 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2985 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2986 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2987 #include "builtin-attrs.def"
2988 #undef DEF_ATTR_NULL_TREE
2990 #undef DEF_ATTR_IDENT
2991 #undef DEF_ATTR_TREE_LIST
2995 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
2997 static void c_init_attributes (void);
2999 /* Build tree nodes and builtin functions common to both C and C++ language
3003 c_common_nodes_and_builtins (void)
3007 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3008 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3009 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3010 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3011 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3012 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3013 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3014 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3015 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3016 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3017 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3018 #include "builtin-types.def"
3019 #undef DEF_PRIMITIVE_TYPE
3020 #undef DEF_FUNCTION_TYPE_0
3021 #undef DEF_FUNCTION_TYPE_1
3022 #undef DEF_FUNCTION_TYPE_2
3023 #undef DEF_FUNCTION_TYPE_3
3024 #undef DEF_FUNCTION_TYPE_4
3025 #undef DEF_FUNCTION_TYPE_VAR_0
3026 #undef DEF_FUNCTION_TYPE_VAR_1
3027 #undef DEF_FUNCTION_TYPE_VAR_2
3028 #undef DEF_FUNCTION_TYPE_VAR_3
3029 #undef DEF_POINTER_TYPE
3033 typedef enum builtin_type builtin_type;
3035 tree builtin_types[(int) BT_LAST];
3036 int wchar_type_size;
3037 tree array_domain_type;
3038 tree va_list_ref_type_node;
3039 tree va_list_arg_type_node;
3041 /* Define `int' and `char' first so that dbx will output them first. */
3042 record_builtin_type (RID_INT, NULL, integer_type_node);
3043 record_builtin_type (RID_CHAR, "char", char_type_node);
3045 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3046 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3047 but not C. Are the conditionals here needed? */
3048 if (c_dialect_cxx ())
3049 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3050 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3051 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3052 record_builtin_type (RID_MAX, "long unsigned int",
3053 long_unsigned_type_node);
3054 if (c_dialect_cxx ())
3055 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3056 record_builtin_type (RID_MAX, "long long int",
3057 long_long_integer_type_node);
3058 record_builtin_type (RID_MAX, "long long unsigned int",
3059 long_long_unsigned_type_node);
3060 if (c_dialect_cxx ())
3061 record_builtin_type (RID_MAX, "long long unsigned",
3062 long_long_unsigned_type_node);
3063 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3064 record_builtin_type (RID_MAX, "short unsigned int",
3065 short_unsigned_type_node);
3066 if (c_dialect_cxx ())
3067 record_builtin_type (RID_MAX, "unsigned short",
3068 short_unsigned_type_node);
3070 /* Define both `signed char' and `unsigned char'. */
3071 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3072 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3074 /* These are types that c_common_type_for_size and
3075 c_common_type_for_mode use. */
3076 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3078 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3080 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3082 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3084 #if HOST_BITS_PER_WIDE_INT >= 64
3085 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3086 get_identifier ("__int128_t"),
3089 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3090 unsigned_intQI_type_node));
3091 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3092 unsigned_intHI_type_node));
3093 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3094 unsigned_intSI_type_node));
3095 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3096 unsigned_intDI_type_node));
3097 #if HOST_BITS_PER_WIDE_INT >= 64
3098 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3099 get_identifier ("__uint128_t"),
3100 unsigned_intTI_type_node));
3103 /* Create the widest literal types. */
3104 widest_integer_literal_type_node
3105 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3106 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3107 widest_integer_literal_type_node));
3109 widest_unsigned_literal_type_node
3110 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3111 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3112 widest_unsigned_literal_type_node));
3114 /* `unsigned long' is the standard type for sizeof.
3115 Note that stddef.h uses `unsigned long',
3116 and this must agree, even if long and int are the same size. */
3118 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3119 signed_size_type_node = c_common_signed_type (size_type_node);
3120 set_sizetype (size_type_node);
3122 build_common_tree_nodes_2 (flag_short_double);
3124 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3125 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3126 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3128 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3129 get_identifier ("complex int"),
3130 complex_integer_type_node));
3131 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3132 get_identifier ("complex float"),
3133 complex_float_type_node));
3134 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3135 get_identifier ("complex double"),
3136 complex_double_type_node));
3137 lang_hooks.decls.pushdecl
3138 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3139 complex_long_double_type_node));
3141 /* Types which are common to the fortran compiler and libf2c. When
3142 changing these, you also need to be concerned with f/com.h. */
3144 if (TYPE_PRECISION (float_type_node)
3145 == TYPE_PRECISION (long_integer_type_node))
3147 g77_integer_type_node = long_integer_type_node;
3148 g77_uinteger_type_node = long_unsigned_type_node;
3150 else if (TYPE_PRECISION (float_type_node)
3151 == TYPE_PRECISION (integer_type_node))
3153 g77_integer_type_node = integer_type_node;
3154 g77_uinteger_type_node = unsigned_type_node;
3157 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3159 if (g77_integer_type_node != NULL_TREE)
3161 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3162 get_identifier ("__g77_integer"),
3163 g77_integer_type_node));
3164 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3165 get_identifier ("__g77_uinteger"),
3166 g77_uinteger_type_node));
3169 if (TYPE_PRECISION (float_type_node) * 2
3170 == TYPE_PRECISION (long_integer_type_node))
3172 g77_longint_type_node = long_integer_type_node;
3173 g77_ulongint_type_node = long_unsigned_type_node;
3175 else if (TYPE_PRECISION (float_type_node) * 2
3176 == TYPE_PRECISION (long_long_integer_type_node))
3178 g77_longint_type_node = long_long_integer_type_node;
3179 g77_ulongint_type_node = long_long_unsigned_type_node;
3182 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3184 if (g77_longint_type_node != NULL_TREE)
3186 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3187 get_identifier ("__g77_longint"),
3188 g77_longint_type_node));
3189 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3190 get_identifier ("__g77_ulongint"),
3191 g77_ulongint_type_node));
3194 record_builtin_type (RID_VOID, NULL, void_type_node);
3196 void_zero_node = build_int_2 (0, 0);
3197 TREE_TYPE (void_zero_node) = void_type_node;
3199 void_list_node = build_void_list_node ();
3201 /* Make a type to be the domain of a few array types
3202 whose domains don't really matter.
3203 200 is small enough that it always fits in size_t
3204 and large enough that it can hold most function names for the
3205 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3206 array_domain_type = build_index_type (size_int (200));
3208 /* Make a type for arrays of characters.
3209 With luck nothing will ever really depend on the length of this
3211 char_array_type_node
3212 = build_array_type (char_type_node, array_domain_type);
3214 /* Likewise for arrays of ints. */
3216 = build_array_type (integer_type_node, array_domain_type);
3218 string_type_node = build_pointer_type (char_type_node);
3219 const_string_type_node
3220 = build_pointer_type (build_qualified_type
3221 (char_type_node, TYPE_QUAL_CONST));
3223 /* This is special for C++ so functions can be overloaded. */
3224 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3225 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3226 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3227 if (c_dialect_cxx ())
3229 if (TREE_UNSIGNED (wchar_type_node))
3230 wchar_type_node = make_unsigned_type (wchar_type_size);
3232 wchar_type_node = make_signed_type (wchar_type_size);
3233 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3237 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3238 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3241 /* This is for wide string constants. */
3242 wchar_array_type_node
3243 = build_array_type (wchar_type_node, array_domain_type);
3246 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3249 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3251 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3253 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3255 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3256 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3258 lang_hooks.decls.pushdecl
3259 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3260 va_list_type_node));
3262 lang_hooks.decls.pushdecl
3263 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3264 ptrdiff_type_node));
3266 lang_hooks.decls.pushdecl
3267 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3270 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3272 va_list_arg_type_node = va_list_ref_type_node =
3273 build_pointer_type (TREE_TYPE (va_list_type_node));
3277 va_list_arg_type_node = va_list_type_node;
3278 va_list_ref_type_node = build_reference_type (va_list_type_node);
3281 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3282 builtin_types[(int) ENUM] = VALUE;
3283 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3284 builtin_types[(int) ENUM] \
3285 = build_function_type (builtin_types[(int) RETURN], \
3287 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3288 builtin_types[(int) ENUM] \
3289 = build_function_type (builtin_types[(int) RETURN], \
3290 tree_cons (NULL_TREE, \
3291 builtin_types[(int) ARG1], \
3293 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3294 builtin_types[(int) ENUM] \
3295 = build_function_type \
3296 (builtin_types[(int) RETURN], \
3297 tree_cons (NULL_TREE, \
3298 builtin_types[(int) ARG1], \
3299 tree_cons (NULL_TREE, \
3300 builtin_types[(int) ARG2], \
3302 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3303 builtin_types[(int) ENUM] \
3304 = build_function_type \
3305 (builtin_types[(int) RETURN], \
3306 tree_cons (NULL_TREE, \
3307 builtin_types[(int) ARG1], \
3308 tree_cons (NULL_TREE, \
3309 builtin_types[(int) ARG2], \
3310 tree_cons (NULL_TREE, \
3311 builtin_types[(int) ARG3], \
3313 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3314 builtin_types[(int) ENUM] \
3315 = build_function_type \
3316 (builtin_types[(int) RETURN], \
3317 tree_cons (NULL_TREE, \
3318 builtin_types[(int) ARG1], \
3319 tree_cons (NULL_TREE, \
3320 builtin_types[(int) ARG2], \
3323 builtin_types[(int) ARG3], \
3324 tree_cons (NULL_TREE, \
3325 builtin_types[(int) ARG4], \
3326 void_list_node)))));
3327 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3328 builtin_types[(int) ENUM] \
3329 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3330 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3331 builtin_types[(int) ENUM] \
3332 = build_function_type (builtin_types[(int) RETURN], \
3333 tree_cons (NULL_TREE, \
3334 builtin_types[(int) ARG1], \
3337 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3338 builtin_types[(int) ENUM] \
3339 = build_function_type \
3340 (builtin_types[(int) RETURN], \
3341 tree_cons (NULL_TREE, \
3342 builtin_types[(int) ARG1], \
3343 tree_cons (NULL_TREE, \
3344 builtin_types[(int) ARG2], \
3347 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3348 builtin_types[(int) ENUM] \
3349 = build_function_type \
3350 (builtin_types[(int) RETURN], \
3351 tree_cons (NULL_TREE, \
3352 builtin_types[(int) ARG1], \
3353 tree_cons (NULL_TREE, \
3354 builtin_types[(int) ARG2], \
3355 tree_cons (NULL_TREE, \
3356 builtin_types[(int) ARG3], \
3359 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3360 builtin_types[(int) ENUM] \
3361 = build_pointer_type (builtin_types[(int) TYPE]);
3362 #include "builtin-types.def"
3363 #undef DEF_PRIMITIVE_TYPE
3364 #undef DEF_FUNCTION_TYPE_1
3365 #undef DEF_FUNCTION_TYPE_2
3366 #undef DEF_FUNCTION_TYPE_3
3367 #undef DEF_FUNCTION_TYPE_4
3368 #undef DEF_FUNCTION_TYPE_VAR_0
3369 #undef DEF_FUNCTION_TYPE_VAR_1
3370 #undef DEF_FUNCTION_TYPE_VAR_2
3371 #undef DEF_FUNCTION_TYPE_VAR_3
3372 #undef DEF_POINTER_TYPE
3374 c_init_attributes ();
3376 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3377 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3382 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3386 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3389 ? (NAME + strlen ("__builtin_")) \
3391 built_in_attributes[(int) ATTRS]); \
3393 decl = builtin_function_2 (NAME, \
3394 NAME + strlen ("__builtin_"), \
3395 builtin_types[TYPE], \
3396 builtin_types[LIBTYPE], \
3401 built_in_attributes[(int) ATTRS]); \
3403 built_in_decls[(int) ENUM] = decl; \
3405 implicit_built_in_decls[(int) ENUM] = decl; \
3407 #include "builtins.def"
3410 (*targetm.init_builtins) ();
3412 main_identifier_node = get_identifier ("main");
3416 build_va_arg (tree expr, tree type)
3418 return build1 (VA_ARG_EXPR, type, expr);
3422 /* Linked list of disabled built-in functions. */
3424 typedef struct disabled_builtin
3427 struct disabled_builtin *next;
3429 static disabled_builtin *disabled_builtins = NULL;
3431 static bool builtin_function_disabled_p (const char *);
3433 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3434 begins with "__builtin_", give an error. */
3437 disable_builtin_function (const char *name)
3439 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3440 error ("cannot disable built-in function `%s'", name);
3443 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3445 new->next = disabled_builtins;
3446 disabled_builtins = new;
3451 /* Return true if the built-in function NAME has been disabled, false
3455 builtin_function_disabled_p (const char *name)
3457 disabled_builtin *p;
3458 for (p = disabled_builtins; p != NULL; p = p->next)
3460 if (strcmp (name, p->name) == 0)
3467 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3468 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3469 of these may be NULL (though both being NULL is useless).
3470 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3471 TYPE is the type of the function with the ordinary name. These
3472 may differ if the ordinary name is declared with a looser type to avoid
3473 conflicts with headers. FUNCTION_CODE and CLASS are as for
3474 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3475 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3476 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3477 ATTRS is the tree list representing the builtin's function attributes.
3478 Returns the declaration of BUILTIN_NAME, if any, otherwise
3479 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3480 or if NONANSI_P and flag_no_nonansi_builtin. */
3483 builtin_function_2 (const char *builtin_name, const char *name,
3484 tree builtin_type, tree type, int function_code,
3485 enum built_in_class class, int library_name_p,
3486 int nonansi_p, tree attrs)
3488 tree bdecl = NULL_TREE;
3489 tree decl = NULL_TREE;
3491 if (builtin_name != 0)
3492 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3493 class, library_name_p ? name : NULL, attrs);
3495 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3496 && !(nonansi_p && flag_no_nonansi_builtin))
3497 decl = builtin_function (name, type, function_code, class, NULL, attrs);
3499 return (bdecl != 0 ? bdecl : decl);
3502 /* Nonzero if the type T promotes to int. This is (nearly) the
3503 integral promotions defined in ISO C99 6.3.1.1/2. */
3506 c_promoting_integer_type_p (tree t)
3508 switch (TREE_CODE (t))
3511 return (TYPE_MAIN_VARIANT (t) == char_type_node
3512 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3513 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3514 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3515 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3516 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3519 /* ??? Technically all enumerations not larger than an int
3520 promote to an int. But this is used along code paths
3521 that only want to notice a size change. */
3522 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3532 /* Return 1 if PARMS specifies a fixed number of parameters
3533 and none of their types is affected by default promotions. */
3536 self_promoting_args_p (tree parms)
3539 for (t = parms; t; t = TREE_CHAIN (t))
3541 tree type = TREE_VALUE (t);
3543 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3549 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3552 if (c_promoting_integer_type_p (type))
3558 /* Recursively examines the array elements of TYPE, until a non-array
3559 element type is found. */
3562 strip_array_types (tree type)
3564 while (TREE_CODE (type) == ARRAY_TYPE)
3565 type = TREE_TYPE (type);
3570 /* Recursively remove any '*' or '&' operator from TYPE. */
3572 strip_pointer_operator (tree t)
3574 while (POINTER_TYPE_P (t))
3579 static tree expand_unordered_cmp (tree, tree, enum tree_code, enum tree_code);
3581 /* Expand a call to an unordered comparison function such as
3582 __builtin_isgreater(). FUNCTION is the function's declaration and
3583 PARAMS a list of the values passed. For __builtin_isunordered(),
3584 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3585 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3586 that give the opposite of the desired result. UNORDERED_CODE is
3587 used for modes that can hold NaNs and ORDERED_CODE is used for the
3591 expand_unordered_cmp (tree function, tree params,
3592 enum tree_code unordered_code,
3593 enum tree_code ordered_code)
3595 tree arg0, arg1, type;
3596 enum tree_code code0, code1;
3598 /* Check that we have exactly two arguments. */
3599 if (params == 0 || TREE_CHAIN (params) == 0)
3601 error ("too few arguments to function `%s'",
3602 IDENTIFIER_POINTER (DECL_NAME (function)));
3603 return error_mark_node;
3605 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3607 error ("too many arguments to function `%s'",
3608 IDENTIFIER_POINTER (DECL_NAME (function)));
3609 return error_mark_node;
3612 arg0 = TREE_VALUE (params);
3613 arg1 = TREE_VALUE (TREE_CHAIN (params));
3615 code0 = TREE_CODE (TREE_TYPE (arg0));
3616 code1 = TREE_CODE (TREE_TYPE (arg1));
3618 /* Make sure that the arguments have a common type of REAL. */
3620 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3621 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3622 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3624 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3626 error ("non-floating-point argument to function `%s'",
3627 IDENTIFIER_POINTER (DECL_NAME (function)));
3628 return error_mark_node;
3631 if (unordered_code == UNORDERED_EXPR)
3633 if (MODE_HAS_NANS (TYPE_MODE (type)))
3634 return build_binary_op (unordered_code,
3635 convert (type, arg0),
3636 convert (type, arg1),
3639 return integer_zero_node;
3642 return build_unary_op (TRUTH_NOT_EXPR,
3643 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3646 convert (type, arg0),
3647 convert (type, arg1),
3653 /* Recognize certain built-in functions so we can make tree-codes
3654 other than CALL_EXPR. We do this when it enables fold-const.c
3655 to do something useful. */
3656 /* ??? By rights this should go in builtins.c, but only C and C++
3657 implement build_{binary,unary}_op. Not exactly sure what bits
3658 of functionality are actually needed from those functions, or
3659 where the similar functionality exists in the other front ends. */
3662 expand_tree_builtin (tree function, tree params, tree coerced_params)
3664 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3667 switch (DECL_FUNCTION_CODE (function))
3671 case BUILT_IN_LLABS:
3672 case BUILT_IN_IMAXABS:
3674 case BUILT_IN_FABSL:
3675 case BUILT_IN_FABSF:
3676 if (coerced_params == 0)
3677 return integer_zero_node;
3678 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3681 case BUILT_IN_CONJF:
3682 case BUILT_IN_CONJL:
3683 if (coerced_params == 0)
3684 return integer_zero_node;
3685 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3687 case BUILT_IN_CREAL:
3688 case BUILT_IN_CREALF:
3689 case BUILT_IN_CREALL:
3690 if (coerced_params == 0)
3691 return integer_zero_node;
3692 return non_lvalue (build_unary_op (REALPART_EXPR,
3693 TREE_VALUE (coerced_params), 0));
3695 case BUILT_IN_CIMAG:
3696 case BUILT_IN_CIMAGF:
3697 case BUILT_IN_CIMAGL:
3698 if (coerced_params == 0)
3699 return integer_zero_node;
3700 return non_lvalue (build_unary_op (IMAGPART_EXPR,
3701 TREE_VALUE (coerced_params), 0));
3703 case BUILT_IN_ISGREATER:
3704 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3706 case BUILT_IN_ISGREATEREQUAL:
3707 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3709 case BUILT_IN_ISLESS:
3710 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3712 case BUILT_IN_ISLESSEQUAL:
3713 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3715 case BUILT_IN_ISLESSGREATER:
3716 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3718 case BUILT_IN_ISUNORDERED:
3719 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3728 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3729 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3730 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3731 value, the traversal is aborted, and the value returned by FUNC is
3732 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3733 the node being visited are not walked.
3735 We don't need a without_duplicates variant of this one because the
3736 statement tree is a tree, not a graph. */
3739 walk_stmt_tree (tree *tp, walk_tree_fn func, void *data)
3741 enum tree_code code;
3746 #define WALK_SUBTREE(NODE) \
3749 result = walk_stmt_tree (&(NODE), func, data); \
3755 /* Skip empty subtrees. */
3759 /* Skip subtrees below non-statement nodes. */
3760 if (!STATEMENT_CODE_P (TREE_CODE (*tp)))
3763 /* Call the function. */
3765 result = (*func) (tp, &walk_subtrees, data);
3767 /* If we found something, return it. */
3771 /* FUNC may have modified the tree, recheck that we're looking at a
3773 code = TREE_CODE (*tp);
3774 if (!STATEMENT_CODE_P (code))
3777 /* Visit the subtrees unless FUNC decided that there was nothing
3778 interesting below this point in the tree. */
3781 /* Walk over all the sub-trees of this operand. Statement nodes
3782 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3783 len = TREE_CODE_LENGTH (code);
3785 /* Go through the subtrees. We need to do this in forward order so
3786 that the scope of a FOR_EXPR is handled properly. */
3787 for (i = 0; i < len; ++i)
3788 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3791 /* Finally visit the chain. This can be tail-recursion optimized if
3792 we write it this way. */
3793 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3798 /* Used to compare case labels. K1 and K2 are actually tree nodes
3799 representing case labels, or NULL_TREE for a `default' label.
3800 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3801 K2, and 0 if K1 and K2 are equal. */
3804 case_compare (splay_tree_key k1, splay_tree_key k2)
3806 /* Consider a NULL key (such as arises with a `default' label) to be
3807 smaller than anything else. */
3813 return tree_int_cst_compare ((tree) k1, (tree) k2);
3816 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3817 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3818 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3819 case label was declared using the usual C/C++ syntax, rather than
3820 the GNU case range extension. CASES is a tree containing all the
3821 case ranges processed so far; COND is the condition for the
3822 switch-statement itself. Returns the CASE_LABEL created, or
3823 ERROR_MARK_NODE if no CASE_LABEL is created. */
3826 c_add_case_label (splay_tree cases, tree cond, tree low_value,
3832 splay_tree_node node;
3834 /* Create the LABEL_DECL itself. */
3835 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3836 DECL_CONTEXT (label) = current_function_decl;
3838 /* If there was an error processing the switch condition, bail now
3839 before we get more confused. */
3840 if (!cond || cond == error_mark_node)
3842 /* Add a label anyhow so that the back-end doesn't think that
3843 the beginning of the switch is unreachable. */
3845 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3846 return error_mark_node;
3849 if ((low_value && TREE_TYPE (low_value)
3850 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3851 || (high_value && TREE_TYPE (high_value)
3852 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3853 error ("pointers are not permitted as case values");
3855 /* Case ranges are a GNU extension. */
3856 if (high_value && pedantic)
3857 pedwarn ("range expressions in switch statements are non-standard");
3859 type = TREE_TYPE (cond);
3862 low_value = check_case_value (low_value);
3863 low_value = convert_and_check (type, low_value);
3867 high_value = check_case_value (high_value);
3868 high_value = convert_and_check (type, high_value);
3871 /* If an error has occurred, bail out now. */
3872 if (low_value == error_mark_node || high_value == error_mark_node)
3875 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3876 return error_mark_node;
3879 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3880 really a case range, even though it was written that way. Remove
3881 the HIGH_VALUE to simplify later processing. */
3882 if (tree_int_cst_equal (low_value, high_value))
3883 high_value = NULL_TREE;
3884 if (low_value && high_value
3885 && !tree_int_cst_lt (low_value, high_value))
3886 warning ("empty range specified");
3888 /* Look up the LOW_VALUE in the table of case labels we already
3890 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3891 /* If there was not an exact match, check for overlapping ranges.
3892 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3893 that's a `default' label and the only overlap is an exact match. */
3894 if (!node && (low_value || high_value))
3896 splay_tree_node low_bound;
3897 splay_tree_node high_bound;
3899 /* Even though there wasn't an exact match, there might be an
3900 overlap between this case range and another case range.
3901 Since we've (inductively) not allowed any overlapping case
3902 ranges, we simply need to find the greatest low case label
3903 that is smaller that LOW_VALUE, and the smallest low case
3904 label that is greater than LOW_VALUE. If there is an overlap
3905 it will occur in one of these two ranges. */
3906 low_bound = splay_tree_predecessor (cases,
3907 (splay_tree_key) low_value);
3908 high_bound = splay_tree_successor (cases,
3909 (splay_tree_key) low_value);
3911 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3912 the LOW_VALUE, so there is no need to check unless the
3913 LOW_BOUND is in fact itself a case range. */
3915 && CASE_HIGH ((tree) low_bound->value)
3916 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3919 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3920 range is bigger than the low end of the current range, so we
3921 are only interested if the current range is a real range, and
3922 not an ordinary case label. */
3925 && (tree_int_cst_compare ((tree) high_bound->key,
3930 /* If there was an overlap, issue an error. */
3933 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3937 error ("duplicate (or overlapping) case value");
3938 error ("%Jthis is the first entry overlapping that value", duplicate);
3942 error ("duplicate case value") ;
3943 error ("%Jpreviously used here", duplicate);
3947 error ("multiple default labels in one switch");
3948 error ("%Jthis is the first default label", duplicate);
3951 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3954 /* Add a CASE_LABEL to the statement-tree. */
3955 case_label = add_stmt (build_case_label (low_value, high_value, label));
3956 /* Register this case label in the splay tree. */
3957 splay_tree_insert (cases,
3958 (splay_tree_key) low_value,
3959 (splay_tree_value) case_label);
3964 /* Finish an expression taking the address of LABEL (an
3965 IDENTIFIER_NODE). Returns an expression for the address. */
3968 finish_label_address_expr (tree label)
3973 pedwarn ("taking the address of a label is non-standard");
3975 if (label == error_mark_node)
3976 return error_mark_node;
3978 label = lookup_label (label);
3979 if (label == NULL_TREE)
3980 result = null_pointer_node;
3983 TREE_USED (label) = 1;
3984 result = build1 (ADDR_EXPR, ptr_type_node, label);
3985 TREE_CONSTANT (result) = 1;
3986 /* The current function in not necessarily uninlinable.
3987 Computed gotos are incompatible with inlining, but the value
3988 here could be used only in a diagnostic, for example. */
3994 /* Hook used by expand_expr to expand language-specific tree codes. */
3997 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
3998 int modifier /* Actually enum_modifier. */,
4001 switch (TREE_CODE (exp))
4007 bool preserve_result = false;
4009 if (STMT_EXPR_WARN_UNUSED_RESULT (exp) && target == const0_rtx)
4011 tree stmt = STMT_EXPR_STMT (exp);
4014 for (scope = COMPOUND_BODY (stmt);
4015 scope && TREE_CODE (scope) != SCOPE_STMT;
4016 scope = TREE_CHAIN (scope));
4018 if (scope && SCOPE_STMT_BLOCK (scope))
4019 warning ("%Hignoring return value of `%D', "
4020 "declared with attribute warn_unused_result",
4021 &expr_wfl_stack->location,
4022 BLOCK_ABSTRACT_ORIGIN (SCOPE_STMT_BLOCK (scope)));
4024 warning ("%Hignoring return value of function "
4025 "declared with attribute warn_unused_result",
4026 &expr_wfl_stack->location);
4029 /* Since expand_expr_stmt calls free_temp_slots after every
4030 expression statement, we must call push_temp_slots here.
4031 Otherwise, any temporaries in use now would be considered
4032 out-of-scope after the first EXPR_STMT from within the
4035 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4037 /* If we want the result of this expression, find the last
4038 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4039 if (target != const0_rtx
4040 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4041 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4043 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4044 tree last = TREE_CHAIN (expr);
4046 while (TREE_CHAIN (last))
4049 last = TREE_CHAIN (last);
4052 if (TREE_CODE (last) == SCOPE_STMT
4053 && TREE_CODE (expr) == EXPR_STMT)
4055 /* Otherwise, note that we want the value from the last
4057 TREE_ADDRESSABLE (expr) = 1;
4058 preserve_result = true;
4062 expand_stmt (STMT_EXPR_STMT (exp));
4063 expand_end_stmt_expr (rtl_expr);
4065 result = expand_expr_real (rtl_expr, target, tmode, modifier, alt_rtl);
4066 if (preserve_result && GET_CODE (result) == MEM)
4068 if (GET_MODE (result) != BLKmode)
4069 result = copy_to_reg (result);
4071 preserve_temp_slots (result);
4074 /* If the statment-expression does not have a scope, then the
4075 new temporaries we created within it must live beyond the
4076 statement-expression. */
4077 if (STMT_EXPR_NO_SCOPE (exp))
4078 preserve_temp_slots (NULL_RTX);
4085 case COMPOUND_LITERAL_EXPR:
4087 /* Initialize the anonymous variable declared in the compound
4088 literal, then return the variable. */
4089 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4090 emit_local_var (decl);
4091 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4102 /* Hook used by safe_from_p to handle language-specific tree codes. */
4105 c_safe_from_p (rtx target, tree exp)
4107 /* We can see statements here when processing the body of a
4108 statement-expression. For a declaration statement declaring a
4109 variable, look at the variable's initializer. */
4110 if (TREE_CODE (exp) == DECL_STMT)
4112 tree decl = DECL_STMT_DECL (exp);
4114 if (TREE_CODE (decl) == VAR_DECL
4115 && DECL_INITIAL (decl)
4116 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4120 /* For any statement, we must follow the statement-chain. */
4121 if (STATEMENT_CODE_P (TREE_CODE (exp)) && TREE_CHAIN (exp))
4122 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4124 /* Assume everything else is safe. */
4128 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4131 c_common_unsafe_for_reeval (tree exp)
4133 /* Statement expressions may not be reevaluated, likewise compound
4135 if (TREE_CODE (exp) == STMT_EXPR
4136 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4139 /* Walk all other expressions. */
4143 /* Hook used by staticp to handle language-specific tree codes. */
4146 c_staticp (tree exp)
4148 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4149 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4155 /* Given a boolean expression ARG, return a tree representing an increment
4156 or decrement (as indicated by CODE) of ARG. The front end must check for
4157 invalid cases (e.g., decrement in C++). */
4159 boolean_increment (enum tree_code code, tree arg)
4162 tree true_res = boolean_true_node;
4164 arg = stabilize_reference (arg);
4167 case PREINCREMENT_EXPR:
4168 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4170 case POSTINCREMENT_EXPR:
4171 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4172 arg = save_expr (arg);
4173 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4174 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4176 case PREDECREMENT_EXPR:
4177 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4179 case POSTDECREMENT_EXPR:
4180 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4181 arg = save_expr (arg);
4182 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4183 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4188 TREE_SIDE_EFFECTS (val) = 1;
4192 /* Built-in macros for stddef.h, that require macros defined in this
4195 c_stddef_cpp_builtins(void)
4197 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4198 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4199 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4200 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4204 c_init_attributes (void)
4206 /* Fill in the built_in_attributes array. */
4207 #define DEF_ATTR_NULL_TREE(ENUM) \
4208 built_in_attributes[(int) ENUM] = NULL_TREE;
4209 #define DEF_ATTR_INT(ENUM, VALUE) \
4210 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4211 #define DEF_ATTR_IDENT(ENUM, STRING) \
4212 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4213 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4214 built_in_attributes[(int) ENUM] \
4215 = tree_cons (built_in_attributes[(int) PURPOSE], \
4216 built_in_attributes[(int) VALUE], \
4217 built_in_attributes[(int) CHAIN]);
4218 #include "builtin-attrs.def"
4219 #undef DEF_ATTR_NULL_TREE
4221 #undef DEF_ATTR_IDENT
4222 #undef DEF_ATTR_TREE_LIST
4225 /* Attribute handlers common to C front ends. */
4227 /* Handle a "packed" attribute; arguments as in
4228 struct attribute_spec.handler. */
4231 handle_packed_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4232 int flags, bool *no_add_attrs)
4236 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4237 *node = build_type_copy (*node);
4238 TYPE_PACKED (*node) = 1;
4239 if (TYPE_MAIN_VARIANT (*node) == *node)
4241 /* If it is the main variant, then pack the other variants
4242 too. This happens in,
4245 struct Foo const *ptr; // creates a variant w/o packed flag
4246 } __ attribute__((packed)); // packs it now.
4250 for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
4251 TYPE_PACKED (probe) = 1;
4255 else if (TREE_CODE (*node) == FIELD_DECL)
4256 DECL_PACKED (*node) = 1;
4257 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4258 used for DECL_REGISTER. It wouldn't mean anything anyway.
4259 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4260 that changes what the typedef is typing. */
4263 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4264 *no_add_attrs = true;
4270 /* Handle a "nocommon" attribute; arguments as in
4271 struct attribute_spec.handler. */
4274 handle_nocommon_attribute (tree *node, tree name,
4275 tree args ATTRIBUTE_UNUSED,
4276 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4278 if (TREE_CODE (*node) == VAR_DECL)
4279 DECL_COMMON (*node) = 0;
4282 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4283 *no_add_attrs = true;
4289 /* Handle a "common" attribute; arguments as in
4290 struct attribute_spec.handler. */
4293 handle_common_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4294 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4296 if (TREE_CODE (*node) == VAR_DECL)
4297 DECL_COMMON (*node) = 1;
4300 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4301 *no_add_attrs = true;
4307 /* Handle a "noreturn" attribute; arguments as in
4308 struct attribute_spec.handler. */
4311 handle_noreturn_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4312 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4314 tree type = TREE_TYPE (*node);
4316 /* See FIXME comment in c_common_attribute_table. */
4317 if (TREE_CODE (*node) == FUNCTION_DECL)
4318 TREE_THIS_VOLATILE (*node) = 1;
4319 else if (TREE_CODE (type) == POINTER_TYPE
4320 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4322 = build_pointer_type
4323 (build_type_variant (TREE_TYPE (type),
4324 TREE_READONLY (TREE_TYPE (type)), 1));
4327 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4328 *no_add_attrs = true;
4334 /* Handle a "noinline" attribute; arguments as in
4335 struct attribute_spec.handler. */
4338 handle_noinline_attribute (tree *node, tree name,
4339 tree args ATTRIBUTE_UNUSED,
4340 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4342 if (TREE_CODE (*node) == FUNCTION_DECL)
4343 DECL_UNINLINABLE (*node) = 1;
4346 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4347 *no_add_attrs = true;
4353 /* Handle a "always_inline" attribute; arguments as in
4354 struct attribute_spec.handler. */
4357 handle_always_inline_attribute (tree *node, tree name,
4358 tree args ATTRIBUTE_UNUSED,
4359 int flags ATTRIBUTE_UNUSED,
4362 if (TREE_CODE (*node) == FUNCTION_DECL)
4364 /* Do nothing else, just set the attribute. We'll get at
4365 it later with lookup_attribute. */
4369 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4370 *no_add_attrs = true;
4376 /* Handle a "used" attribute; arguments as in
4377 struct attribute_spec.handler. */
4380 handle_used_attribute (tree *pnode, tree name, tree args ATTRIBUTE_UNUSED,
4381 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4385 if (TREE_CODE (node) == FUNCTION_DECL
4386 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4388 TREE_USED (node) = 1;
4392 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4393 *no_add_attrs = true;
4399 /* Handle a "unused" attribute; arguments as in
4400 struct attribute_spec.handler. */
4403 handle_unused_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4404 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4410 if (TREE_CODE (decl) == PARM_DECL
4411 || TREE_CODE (decl) == VAR_DECL
4412 || TREE_CODE (decl) == FUNCTION_DECL
4413 || TREE_CODE (decl) == LABEL_DECL
4414 || TREE_CODE (decl) == TYPE_DECL)
4415 TREE_USED (decl) = 1;
4418 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4419 *no_add_attrs = true;
4424 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4425 *node = build_type_copy (*node);
4426 TREE_USED (*node) = 1;
4432 /* Handle a "const" attribute; arguments as in
4433 struct attribute_spec.handler. */
4436 handle_const_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4437 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4439 tree type = TREE_TYPE (*node);
4441 /* See FIXME comment on noreturn in c_common_attribute_table. */
4442 if (TREE_CODE (*node) == FUNCTION_DECL)
4443 TREE_READONLY (*node) = 1;
4444 else if (TREE_CODE (type) == POINTER_TYPE
4445 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4447 = build_pointer_type
4448 (build_type_variant (TREE_TYPE (type), 1,
4449 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4452 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4453 *no_add_attrs = true;
4459 /* Handle a "transparent_union" attribute; arguments as in
4460 struct attribute_spec.handler. */
4463 handle_transparent_union_attribute (tree *node, tree name,
4464 tree args ATTRIBUTE_UNUSED, int flags,
4467 tree decl = NULL_TREE;
4474 type = &TREE_TYPE (decl);
4475 is_type = TREE_CODE (*node) == TYPE_DECL;
4477 else if (TYPE_P (*node))
4478 type = node, is_type = 1;
4481 && TREE_CODE (*type) == UNION_TYPE
4483 || (TYPE_FIELDS (*type) != 0
4484 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4486 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4487 *type = build_type_copy (*type);
4488 TYPE_TRANSPARENT_UNION (*type) = 1;
4490 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4491 && TREE_CODE (*type) == UNION_TYPE
4492 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4493 DECL_TRANSPARENT_UNION (decl) = 1;
4496 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4497 *no_add_attrs = true;
4503 /* Handle a "constructor" attribute; arguments as in
4504 struct attribute_spec.handler. */
4507 handle_constructor_attribute (tree *node, tree name,
4508 tree args ATTRIBUTE_UNUSED,
4509 int flags ATTRIBUTE_UNUSED,
4513 tree type = TREE_TYPE (decl);
4515 if (TREE_CODE (decl) == FUNCTION_DECL
4516 && TREE_CODE (type) == FUNCTION_TYPE
4517 && decl_function_context (decl) == 0)
4519 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4520 TREE_USED (decl) = 1;
4524 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4525 *no_add_attrs = true;
4531 /* Handle a "destructor" attribute; arguments as in
4532 struct attribute_spec.handler. */
4535 handle_destructor_attribute (tree *node, tree name,
4536 tree args ATTRIBUTE_UNUSED,
4537 int flags ATTRIBUTE_UNUSED,
4541 tree type = TREE_TYPE (decl);
4543 if (TREE_CODE (decl) == FUNCTION_DECL
4544 && TREE_CODE (type) == FUNCTION_TYPE
4545 && decl_function_context (decl) == 0)
4547 DECL_STATIC_DESTRUCTOR (decl) = 1;
4548 TREE_USED (decl) = 1;
4552 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4553 *no_add_attrs = true;
4559 /* Handle a "mode" attribute; arguments as in
4560 struct attribute_spec.handler. */
4563 handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4564 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4568 *no_add_attrs = true;
4570 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4571 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4575 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4576 int len = strlen (p);
4577 enum machine_mode mode = VOIDmode;
4581 if (len > 4 && p[0] == '_' && p[1] == '_'
4582 && p[len - 1] == '_' && p[len - 2] == '_')
4584 char *newp = alloca (len - 1);
4586 strcpy (newp, &p[2]);
4587 newp[len - 4] = '\0';
4591 /* Change this type to have a type with the specified mode.
4592 First check for the special modes. */
4593 if (! strcmp (p, "byte"))
4595 else if (!strcmp (p, "word"))
4597 else if (! strcmp (p, "pointer"))
4600 for (j = 0; j < NUM_MACHINE_MODES; j++)
4601 if (!strcmp (p, GET_MODE_NAME (j)))
4602 mode = (enum machine_mode) j;
4604 if (mode == VOIDmode)
4606 error ("unknown machine mode `%s'", p);
4610 if (VECTOR_MODE_P (mode))
4612 warning ("specifying vector types with __attribute__ ((mode)) "
4614 warning ("use __attribute__ ((vector_size)) instead");
4617 typefm = lang_hooks.types.type_for_mode (mode, TREE_UNSIGNED (type));
4618 if (typefm == NULL_TREE)
4619 error ("no data type for mode `%s'", p);
4621 else if ((TREE_CODE (type) == POINTER_TYPE
4622 || TREE_CODE (type) == REFERENCE_TYPE)
4623 && !(*targetm.valid_pointer_mode) (mode))
4624 error ("invalid pointer mode `%s'", p);
4627 /* If this is a vector, make sure we either have hardware
4628 support, or we can emulate it. */
4629 if (VECTOR_MODE_P (mode) && !vector_mode_valid_p (mode))
4631 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
4635 if (TREE_CODE (type) == POINTER_TYPE)
4637 ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
4641 else if (TREE_CODE (type) == REFERENCE_TYPE)
4643 ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
4649 /* No need to layout the type here. The caller should do this. */
4656 /* Handle a "section" attribute; arguments as in
4657 struct attribute_spec.handler. */
4660 handle_section_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4661 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4665 if (targetm.have_named_sections)
4667 if ((TREE_CODE (decl) == FUNCTION_DECL
4668 || TREE_CODE (decl) == VAR_DECL)
4669 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4671 if (TREE_CODE (decl) == VAR_DECL
4672 && current_function_decl != NULL_TREE
4673 && ! TREE_STATIC (decl))
4675 error ("%Jsection attribute cannot be specified for "
4676 "local variables", decl);
4677 *no_add_attrs = true;
4680 /* The decl may have already been given a section attribute
4681 from a previous declaration. Ensure they match. */
4682 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4683 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4684 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4686 error ("%Jsection of '%D' conflicts with previous declaration",
4688 *no_add_attrs = true;
4691 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4695 error ("%Jsection attribute not allowed for '%D'", *node, *node);
4696 *no_add_attrs = true;
4701 error ("%Jsection attributes are not supported for this target", *node);
4702 *no_add_attrs = true;
4708 /* Handle a "aligned" attribute; arguments as in
4709 struct attribute_spec.handler. */
4712 handle_aligned_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4713 int flags, bool *no_add_attrs)
4715 tree decl = NULL_TREE;
4718 tree align_expr = (args ? TREE_VALUE (args)
4719 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4725 type = &TREE_TYPE (decl);
4726 is_type = TREE_CODE (*node) == TYPE_DECL;
4728 else if (TYPE_P (*node))
4729 type = node, is_type = 1;
4731 /* Strip any NOPs of any kind. */
4732 while (TREE_CODE (align_expr) == NOP_EXPR
4733 || TREE_CODE (align_expr) == CONVERT_EXPR
4734 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
4735 align_expr = TREE_OPERAND (align_expr, 0);
4737 if (TREE_CODE (align_expr) != INTEGER_CST)
4739 error ("requested alignment is not a constant");
4740 *no_add_attrs = true;
4742 else if ((i = tree_log2 (align_expr)) == -1)
4744 error ("requested alignment is not a power of 2");
4745 *no_add_attrs = true;
4747 else if (i > HOST_BITS_PER_INT - 2)
4749 error ("requested alignment is too large");
4750 *no_add_attrs = true;
4754 /* If we have a TYPE_DECL, then copy the type, so that we
4755 don't accidentally modify a builtin type. See pushdecl. */
4756 if (decl && TREE_TYPE (decl) != error_mark_node
4757 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4759 tree tt = TREE_TYPE (decl);
4760 *type = build_type_copy (*type);
4761 DECL_ORIGINAL_TYPE (decl) = tt;
4762 TYPE_NAME (*type) = decl;
4763 TREE_USED (*type) = TREE_USED (decl);
4764 TREE_TYPE (decl) = *type;
4766 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4767 *type = build_type_copy (*type);
4769 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4770 TYPE_USER_ALIGN (*type) = 1;
4772 else if (TREE_CODE (decl) != VAR_DECL
4773 && TREE_CODE (decl) != FIELD_DECL)
4775 error ("%Jalignment may not be specified for '%D'", decl, decl);
4776 *no_add_attrs = true;
4780 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4781 DECL_USER_ALIGN (decl) = 1;
4787 /* Handle a "weak" attribute; arguments as in
4788 struct attribute_spec.handler. */
4791 handle_weak_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
4792 tree args ATTRIBUTE_UNUSED,
4793 int flags ATTRIBUTE_UNUSED,
4794 bool *no_add_attrs ATTRIBUTE_UNUSED)
4796 declare_weak (*node);
4801 /* Handle an "alias" attribute; arguments as in
4802 struct attribute_spec.handler. */
4805 handle_alias_attribute (tree *node, tree name, tree args,
4806 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4810 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4811 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
4813 error ("%J'%D' defined both normally and as an alias", decl, decl);
4814 *no_add_attrs = true;
4817 /* Note that the very first time we process a nested declaration,
4818 decl_function_context will not be set. Indeed, *would* never
4819 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4820 we do below. After such frobbery, pushdecl would set the context.
4821 In any case, this is never what we want. */
4822 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4826 id = TREE_VALUE (args);
4827 if (TREE_CODE (id) != STRING_CST)
4829 error ("alias arg not a string");
4830 *no_add_attrs = true;
4833 id = get_identifier (TREE_STRING_POINTER (id));
4834 /* This counts as a use of the object pointed to. */
4837 if (TREE_CODE (decl) == FUNCTION_DECL)
4838 DECL_INITIAL (decl) = error_mark_node;
4840 DECL_EXTERNAL (decl) = 0;
4844 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4845 *no_add_attrs = true;
4851 /* Handle an "visibility" attribute; arguments as in
4852 struct attribute_spec.handler. */
4855 handle_visibility_attribute (tree *node, tree name, tree args,
4856 int flags ATTRIBUTE_UNUSED,
4860 tree id = TREE_VALUE (args);
4862 *no_add_attrs = true;
4864 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
4866 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4870 if (TREE_CODE (id) != STRING_CST)
4872 error ("visibility arg not a string");
4876 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4877 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4878 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4879 DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4880 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4881 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4882 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4883 DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4885 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4890 /* Handle an "tls_model" attribute; arguments as in
4891 struct attribute_spec.handler. */
4894 handle_tls_model_attribute (tree *node, tree name, tree args,
4895 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4899 if (! DECL_THREAD_LOCAL (decl))
4901 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4902 *no_add_attrs = true;
4908 id = TREE_VALUE (args);
4909 if (TREE_CODE (id) != STRING_CST)
4911 error ("tls_model arg not a string");
4912 *no_add_attrs = true;
4915 if (strcmp (TREE_STRING_POINTER (id), "local-exec")
4916 && strcmp (TREE_STRING_POINTER (id), "initial-exec")
4917 && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
4918 && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
4920 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4921 *no_add_attrs = true;
4929 /* Handle a "no_instrument_function" attribute; arguments as in
4930 struct attribute_spec.handler. */
4933 handle_no_instrument_function_attribute (tree *node, tree name,
4934 tree args ATTRIBUTE_UNUSED,
4935 int flags ATTRIBUTE_UNUSED,
4940 if (TREE_CODE (decl) != FUNCTION_DECL)
4942 error ("%J'%E' attribute applies only to functions", decl, name);
4943 *no_add_attrs = true;
4945 else if (DECL_INITIAL (decl))
4947 error ("%Jcan't set '%E' attribute after definition", decl, name);
4948 *no_add_attrs = true;
4951 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
4956 /* Handle a "malloc" attribute; arguments as in
4957 struct attribute_spec.handler. */
4960 handle_malloc_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4961 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4963 if (TREE_CODE (*node) == FUNCTION_DECL)
4964 DECL_IS_MALLOC (*node) = 1;
4965 /* ??? TODO: Support types. */
4968 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4969 *no_add_attrs = true;
4975 /* Handle a "no_limit_stack" attribute; arguments as in
4976 struct attribute_spec.handler. */
4979 handle_no_limit_stack_attribute (tree *node, tree name,
4980 tree args ATTRIBUTE_UNUSED,
4981 int flags ATTRIBUTE_UNUSED,
4986 if (TREE_CODE (decl) != FUNCTION_DECL)
4988 error ("%J'%E' attribute applies only to functions", decl, name);
4989 *no_add_attrs = true;
4991 else if (DECL_INITIAL (decl))
4993 error ("%Jcan't set '%E' attribute after definition", decl, name);
4994 *no_add_attrs = true;
4997 DECL_NO_LIMIT_STACK (decl) = 1;
5002 /* Handle a "pure" attribute; arguments as in
5003 struct attribute_spec.handler. */
5006 handle_pure_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5007 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5009 if (TREE_CODE (*node) == FUNCTION_DECL)
5010 DECL_IS_PURE (*node) = 1;
5011 /* ??? TODO: Support types. */
5014 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5015 *no_add_attrs = true;
5021 /* Handle a "deprecated" attribute; arguments as in
5022 struct attribute_spec.handler. */
5025 handle_deprecated_attribute (tree *node, tree name,
5026 tree args ATTRIBUTE_UNUSED, int flags,
5029 tree type = NULL_TREE;
5031 const char *what = NULL;
5036 type = TREE_TYPE (decl);
5038 if (TREE_CODE (decl) == TYPE_DECL
5039 || TREE_CODE (decl) == PARM_DECL
5040 || TREE_CODE (decl) == VAR_DECL
5041 || TREE_CODE (decl) == FUNCTION_DECL
5042 || TREE_CODE (decl) == FIELD_DECL)
5043 TREE_DEPRECATED (decl) = 1;
5047 else if (TYPE_P (*node))
5049 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5050 *node = build_type_copy (*node);
5051 TREE_DEPRECATED (*node) = 1;
5059 *no_add_attrs = true;
5060 if (type && TYPE_NAME (type))
5062 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5063 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5064 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5065 && DECL_NAME (TYPE_NAME (type)))
5066 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5069 warning ("`%s' attribute ignored for `%s'",
5070 IDENTIFIER_POINTER (name), what);
5072 warning ("`%s' attribute ignored",
5073 IDENTIFIER_POINTER (name));
5079 /* Handle a "vector_size" attribute; arguments as in
5080 struct attribute_spec.handler. */
5083 handle_vector_size_attribute (tree *node, tree name, tree args,
5084 int flags ATTRIBUTE_UNUSED,
5087 unsigned HOST_WIDE_INT vecsize, nunits;
5088 enum machine_mode mode, orig_mode, new_mode;
5089 tree type = *node, new_type, size;
5091 *no_add_attrs = true;
5093 /* Stripping NON_LVALUE_EXPR allows declarations such as
5094 typedef short v4si __attribute__((vector_size (4 * sizeof(short)))). */
5095 size = TREE_VALUE (args);
5096 if (TREE_CODE (size) == NON_LVALUE_EXPR)
5097 size = TREE_OPERAND (size, 0);
5099 if (! host_integerp (size, 1))
5101 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5105 /* Get the vector size (in bytes). */
5106 vecsize = tree_low_cst (size, 1);
5108 /* We need to provide for vector pointers, vector arrays, and
5109 functions returning vectors. For example:
5111 __attribute__((vector_size(16))) short *foo;
5113 In this case, the mode is SI, but the type being modified is
5114 HI, so we need to look further. */
5116 while (POINTER_TYPE_P (type)
5117 || TREE_CODE (type) == FUNCTION_TYPE
5118 || TREE_CODE (type) == METHOD_TYPE
5119 || TREE_CODE (type) == ARRAY_TYPE)
5120 type = TREE_TYPE (type);
5122 /* Get the mode of the type being modified. */
5123 orig_mode = TYPE_MODE (type);
5125 if (TREE_CODE (type) == RECORD_TYPE
5126 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5127 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5128 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5130 error ("invalid vector type for attribute `%s'",
5131 IDENTIFIER_POINTER (name));
5135 /* Calculate how many units fit in the vector. */
5136 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5138 /* Find a suitably sized vector. */
5139 new_mode = VOIDmode;
5140 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5142 : MODE_VECTOR_FLOAT);
5144 mode = GET_MODE_WIDER_MODE (mode))
5145 if (vecsize == GET_MODE_SIZE (mode)
5146 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
5152 if (new_mode == VOIDmode)
5154 error ("no vector mode with the size and type specified could be found");
5158 new_type = build_vector_type_for_mode (type, new_mode);
5160 /* Build back pointers if needed. */
5161 *node = reconstruct_complex_type (*node, new_type);
5166 /* Handle the "nonnull" attribute. */
5168 handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
5169 tree args, int flags ATTRIBUTE_UNUSED,
5173 unsigned HOST_WIDE_INT attr_arg_num;
5175 /* If no arguments are specified, all pointer arguments should be
5176 non-null. Verify a full prototype is given so that the arguments
5177 will have the correct types when we actually check them later. */
5180 if (! TYPE_ARG_TYPES (type))
5182 error ("nonnull attribute without arguments on a non-prototype");
5183 *no_add_attrs = true;
5188 /* Argument list specified. Verify that each argument number references
5189 a pointer argument. */
5190 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5193 unsigned HOST_WIDE_INT arg_num, ck_num;
5195 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5197 error ("nonnull argument has invalid operand number (arg %lu)",
5198 (unsigned long) attr_arg_num);
5199 *no_add_attrs = true;
5203 argument = TYPE_ARG_TYPES (type);
5206 for (ck_num = 1; ; ck_num++)
5208 if (! argument || ck_num == arg_num)
5210 argument = TREE_CHAIN (argument);
5214 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5216 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5217 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5218 *no_add_attrs = true;
5222 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5224 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5225 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5226 *no_add_attrs = true;
5235 /* Check the argument list of a function call for null in argument slots
5236 that are marked as requiring a non-null pointer argument. */
5239 check_function_nonnull (tree attrs, tree params)
5241 tree a, args, param;
5244 for (a = attrs; a; a = TREE_CHAIN (a))
5246 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5248 args = TREE_VALUE (a);
5250 /* Walk the argument list. If we encounter an argument number we
5251 should check for non-null, do it. If the attribute has no args,
5252 then every pointer argument is checked (in which case the check
5253 for pointer type is done in check_nonnull_arg). */
5254 for (param = params, param_num = 1; ;
5255 param_num++, param = TREE_CHAIN (param))
5259 if (! args || nonnull_check_p (args, param_num))
5260 check_function_arguments_recurse (check_nonnull_arg, NULL,
5268 /* Helper for check_function_nonnull; given a list of operands which
5269 must be non-null in ARGS, determine if operand PARAM_NUM should be
5273 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5275 unsigned HOST_WIDE_INT arg_num;
5277 for (; args; args = TREE_CHAIN (args))
5279 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5282 if (arg_num == param_num)
5288 /* Check that the function argument PARAM (which is operand number
5289 PARAM_NUM) is non-null. This is called by check_function_nonnull
5290 via check_function_arguments_recurse. */
5293 check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED, tree param,
5294 unsigned HOST_WIDE_INT param_num)
5296 /* Just skip checking the argument if it's not a pointer. This can
5297 happen if the "nonnull" attribute was given without an operand
5298 list (which means to check every pointer argument). */
5300 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5303 if (integer_zerop (param))
5304 warning ("null argument where non-null required (arg %lu)",
5305 (unsigned long) param_num);
5308 /* Helper for nonnull attribute handling; fetch the operand number
5309 from the attribute argument list. */
5312 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5314 /* Strip any conversions from the arg number and verify they
5316 while (TREE_CODE (arg_num_expr) == NOP_EXPR
5317 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
5318 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
5319 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
5321 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5322 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5325 *valp = TREE_INT_CST_LOW (arg_num_expr);
5329 /* Handle a "nothrow" attribute; arguments as in
5330 struct attribute_spec.handler. */
5333 handle_nothrow_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5334 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5336 if (TREE_CODE (*node) == FUNCTION_DECL)
5337 TREE_NOTHROW (*node) = 1;
5338 /* ??? TODO: Support types. */
5341 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5342 *no_add_attrs = true;
5348 /* Handle a "cleanup" attribute; arguments as in
5349 struct attribute_spec.handler. */
5352 handle_cleanup_attribute (tree *node, tree name, tree args,
5353 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5356 tree cleanup_id, cleanup_decl;
5358 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5359 for global destructors in C++. This requires infrastructure that
5360 we don't have generically at the moment. It's also not a feature
5361 we'd be missing too much, since we do have attribute constructor. */
5362 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5364 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5365 *no_add_attrs = true;
5369 /* Verify that the argument is a function in scope. */
5370 /* ??? We could support pointers to functions here as well, if
5371 that was considered desirable. */
5372 cleanup_id = TREE_VALUE (args);
5373 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5375 error ("cleanup arg not an identifier");
5376 *no_add_attrs = true;
5379 cleanup_decl = lookup_name (cleanup_id);
5380 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5382 error ("cleanup arg not a function");
5383 *no_add_attrs = true;
5387 /* That the function has proper type is checked with the
5388 eventual call to build_function_call. */
5393 /* Handle a "warn_unused_result" attribute. No special handling. */
5396 handle_warn_unused_result_attribute (tree *node, tree name,
5397 tree args ATTRIBUTE_UNUSED,
5398 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5400 /* Ignore the attribute for functions not returning any value. */
5401 if (VOID_TYPE_P (TREE_TYPE (*node)))
5403 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5404 *no_add_attrs = true;
5410 /* Check for valid arguments being passed to a function. */
5412 check_function_arguments (tree attrs, tree params)
5414 /* Check for null being passed in a pointer argument that must be
5415 non-null. We also need to do this if format checking is enabled. */
5418 check_function_nonnull (attrs, params);
5420 /* Check for errors in format strings. */
5423 check_function_format (NULL, attrs, params);
5426 /* Generic argument checking recursion routine. PARAM is the argument to
5427 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5428 once the argument is resolved. CTX is context for the callback. */
5430 check_function_arguments_recurse (void (*callback)
5431 (void *, tree, unsigned HOST_WIDE_INT),
5432 void *ctx, tree param,
5433 unsigned HOST_WIDE_INT param_num)
5435 if (TREE_CODE (param) == NOP_EXPR)
5437 /* Strip coercion. */
5438 check_function_arguments_recurse (callback, ctx,
5439 TREE_OPERAND (param, 0), param_num);
5443 if (TREE_CODE (param) == CALL_EXPR)
5445 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5447 bool found_format_arg = false;
5449 /* See if this is a call to a known internationalization function
5450 that modifies a format arg. Such a function may have multiple
5451 format_arg attributes (for example, ngettext). */
5453 for (attrs = TYPE_ATTRIBUTES (type);
5455 attrs = TREE_CHAIN (attrs))
5456 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5459 tree format_num_expr;
5463 /* Extract the argument number, which was previously checked
5465 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5466 while (TREE_CODE (format_num_expr) == NOP_EXPR
5467 || TREE_CODE (format_num_expr) == CONVERT_EXPR
5468 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
5469 format_num_expr = TREE_OPERAND (format_num_expr, 0);
5471 if (TREE_CODE (format_num_expr) != INTEGER_CST
5472 || TREE_INT_CST_HIGH (format_num_expr) != 0)
5475 format_num = TREE_INT_CST_LOW (format_num_expr);
5477 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5479 inner_args = TREE_CHAIN (inner_args), i++)
5480 if (i == format_num)
5482 check_function_arguments_recurse (callback, ctx,
5483 TREE_VALUE (inner_args),
5485 found_format_arg = true;
5490 /* If we found a format_arg attribute and did a recursive check,
5491 we are done with checking this argument. Otherwise, we continue
5492 and this will be considered a non-literal. */
5493 if (found_format_arg)
5497 if (TREE_CODE (param) == COND_EXPR)
5499 /* Check both halves of the conditional expression. */
5500 check_function_arguments_recurse (callback, ctx,
5501 TREE_OPERAND (param, 1), param_num);
5502 check_function_arguments_recurse (callback, ctx,
5503 TREE_OPERAND (param, 2), param_num);
5507 (*callback) (ctx, param, param_num);
5510 /* Function to help qsort sort FIELD_DECLs by name order. */
5513 field_decl_cmp (const void *x_p, const void *y_p)
5515 const tree *const x = x_p;
5516 const tree *const y = y_p;
5517 if (DECL_NAME (*x) == DECL_NAME (*y))
5518 /* A nontype is "greater" than a type. */
5519 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5520 if (DECL_NAME (*x) == NULL_TREE)
5522 if (DECL_NAME (*y) == NULL_TREE)
5524 if (DECL_NAME (*x) < DECL_NAME (*y))
5530 gt_pointer_operator new_value;
5534 /* This routine compares two fields like field_decl_cmp but using the
5535 pointer operator in resort_data. */
5538 resort_field_decl_cmp (const void *x_p, const void *y_p)
5540 const tree *const x = x_p;
5541 const tree *const y = y_p;
5543 if (DECL_NAME (*x) == DECL_NAME (*y))
5544 /* A nontype is "greater" than a type. */
5545 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5546 if (DECL_NAME (*x) == NULL_TREE)
5548 if (DECL_NAME (*y) == NULL_TREE)
5551 tree d1 = DECL_NAME (*x);
5552 tree d2 = DECL_NAME (*y);
5553 resort_data.new_value (&d1, resort_data.cookie);
5554 resort_data.new_value (&d2, resort_data.cookie);
5561 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5564 resort_sorted_fields (void *obj,
5565 void *orig_obj ATTRIBUTE_UNUSED ,
5566 gt_pointer_operator new_value,
5569 struct sorted_fields_type *sf = obj;
5570 resort_data.new_value = new_value;
5571 resort_data.cookie = cookie;
5572 qsort (&sf->elts[0], sf->len, sizeof (tree),
5573 resort_field_decl_cmp);
5576 /* Used by estimate_num_insns. Estimate number of instructions seen
5577 by given statement. */
5579 c_estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
5584 if (TYPE_P (x) || DECL_P (x))
5589 /* Assume that constants and references counts nothing. These should
5590 be majorized by amount of operations among them we count later
5591 and are common target of CSE and similar optimizations. */
5592 if (TREE_CODE_CLASS (TREE_CODE (x)) == 'c'
5593 || TREE_CODE_CLASS (TREE_CODE (x)) == 'r')
5595 switch (TREE_CODE (x))
5597 /* Recognize assignments of large structures and constructors of
5604 size = int_size_in_bytes (TREE_TYPE (x));
5606 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
5609 *count += ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
5614 tree decl = get_callee_fndecl (x);
5616 if (decl && DECL_BUILT_IN (decl))
5617 switch (DECL_FUNCTION_CODE (decl))
5619 case BUILT_IN_CONSTANT_P:
5622 case BUILT_IN_EXPECT:
5630 /* Few special cases of expensive operations. This is useful
5631 to avoid inlining on functions having too many of these. */
5632 case TRUNC_DIV_EXPR:
5634 case FLOOR_DIV_EXPR:
5635 case ROUND_DIV_EXPR:
5636 case TRUNC_MOD_EXPR:
5638 case FLOOR_MOD_EXPR:
5639 case ROUND_MOD_EXPR:
5643 /* Various containers that will produce no code themselves. */
5650 case IDENTIFIER_NODE:
5651 case PLACEHOLDER_EXPR:
5652 case WITH_CLEANUP_EXPR:
5653 case CLEANUP_POINT_EXPR:
5655 case VIEW_CONVERT_EXPR:
5661 case TRY_CATCH_EXPR:
5662 case TRY_FINALLY_EXPR:
5665 case LABELED_BLOCK_EXPR:
5666 case EXIT_BLOCK_EXPR:
5667 case EXPR_WITH_FILE_LOCATION:
5684 /* Do not account static initializers. */
5685 if (TREE_STATIC (TREE_OPERAND (x, 0)))
5694 /* Estimate number of instructions that will be created by expanding the body. */
5696 c_estimate_num_insns (tree decl)
5699 walk_tree_without_duplicates (&DECL_SAVED_TREE (decl), c_estimate_num_insns_1, &num);
5703 /* Used by c_decl_uninit to find where expressions like x = x + 1; */
5706 c_decl_uninit_1 (tree *t, int *walk_sub_trees, void *x)
5708 /* If x = EXP(&x)EXP, then do not warn about the use of x. */
5709 if (TREE_CODE (*t) == ADDR_EXPR && TREE_OPERAND (*t, 0) == x)
5711 *walk_sub_trees = 0;
5719 /* Find out if a variable is uninitialized based on DECL_INITIAL. */
5722 c_decl_uninit (tree t)
5724 /* int x = x; is GCC extension to turn off this warning, only if warn_init_self is zero. */
5725 if (DECL_INITIAL (t) == t)
5726 return warn_init_self ? true : false;
5728 /* Walk the trees looking for the variable itself. */
5729 if (walk_tree_without_duplicates (&DECL_INITIAL (t), c_decl_uninit_1, t))
5734 /* Issue the error given by MSGID, indicating that it occurred before
5735 TOKEN, which had the associated VALUE. */
5738 c_parse_error (const char *msgid, enum cpp_ttype token, tree value)
5740 const char *string = _(msgid);
5742 if (token == CPP_EOF)
5743 error ("%s at end of input", string);
5744 else if (token == CPP_CHAR || token == CPP_WCHAR)
5746 unsigned int val = TREE_INT_CST_LOW (value);
5747 const char *const ell = (token == CPP_CHAR) ? "" : "L";
5748 if (val <= UCHAR_MAX && ISGRAPH (val))
5749 error ("%s before %s'%c'", string, ell, val);
5751 error ("%s before %s'\\x%x'", string, ell, val);
5753 else if (token == CPP_STRING
5754 || token == CPP_WSTRING)
5755 error ("%s before string constant", string);
5756 else if (token == CPP_NUMBER)
5757 error ("%s before numeric constant", string);
5758 else if (token == CPP_NAME)
5759 error ("%s before \"%s\"", string, IDENTIFIER_POINTER (value));
5760 else if (token < N_TTYPES)
5761 error ("%s before '%s' token", string, cpp_type2name (token));
5763 error ("%s", string);
5766 #include "gt-c-common.h"